☰

GitHub PR Squasher

One-click tool to squash GitHub Pull Requests. Creates a new PR with squashed commits and preserves the description.

  1. // ==UserScript==
  2. // @name         GitHub PR Squasher
  3. // @namespace    https://github.com/balakumardev/github-pr-squasher
  4. // @version      2.0
  5. // @description  One-click tool to squash GitHub Pull Requests. Creates a new PR with squashed commits and preserves the description.
  6. // @author       Bala Kumar
  7. // @license      MIT
  8. // @match        https://github.com/*
  9. // @match        https://*.github.com/*
  10. // @match        https://*.github.io/*
  11. // @match        https://*.githubusercontent.com/*
  12. // @icon         https://github.githubassets.com/favicons/favicon.svg
  13. // @grant        GM_xmlhttpRequest
  14. // @grant        GM_getValue
  15. // @grant        GM_setValue
  16. // @grant        GM_registerMenuCommand
  17. // @connect      api.github.com
  18. // @connect      *
  19. // @supportURL   https://github.com/balakumardev/github-pr-squasher/issues
  20. // @homepage     https://github.com/balakumardev/github-pr-squasher
  21. // ==/UserScript==
  22.  
  23. (function() {
  24.     'use strict';
  25.  
  26.     const DEBUG = true;
  27.  
  28.     // Add settings menu to Tampermonkey
  29.     GM_registerMenuCommand('Set GitHub Token', async () => {
  30.         const token = prompt('Enter your GitHub Personal Access Token (Classic):', GM_getValue('github_token', ''));
  31.         if (token !== null) {
  32.             if (token.startsWith('ghp_')) {
  33.                 await GM_setValue('github_token', token);
  34.                 alert('Token saved! Please refresh the page.');
  35.             } else {
  36.                 alert('Invalid token format. Token should start with "ghp_"');
  37.             }
  38.         }
  39.     });
  40.  
  41.     function debugLog(...args) {
  42.         if (DEBUG) console.log('[PR Squasher]', ...args);
  43.     }
  44.  
  45.     async function getGitHubToken() {
  46.         const token = GM_getValue('github_token');
  47.         if (!token) {
  48.             throw new Error('GitHub token not set. Click on the Tampermonkey icon and select "Set GitHub Token"');
  49.         }
  50.         return token;
  51.     }
  52.  
  53.     async function githubAPI(endpoint, method = 'GET', body = null) {
  54.         debugLog(`API Call: ${method} ${endpoint}`);
  55.         if (body) debugLog('Request Body:', body);
  56.  
  57.         const token = await getGitHubToken();
  58.  
  59.         return new Promise((resolve, reject) => {
  60.             GM_xmlhttpRequest({
  61.                 method: method,
  62.                 url: `https://api.github.com${endpoint}`,
  63.                 headers: {
  64.                     'Authorization': `Bearer ${token}`,
  65.                     'Accept': 'application/vnd.github.v3+json',
  66.                     'Content-Type': 'application/json',
  67.                 },
  68.                 data: body ? JSON.stringify(body) : null,
  69.                 onload: function(response) {
  70.                     debugLog(`Response ${endpoint}:`, {
  71.                         status: response.status,
  72.                         statusText: response.statusText,
  73.                         responseText: response.responseText.substring(0, 500) + (response.responseText.length > 500 ? '...' : '')
  74.                     });
  75.  
  76.                     if (response.status >= 200 && response.status < 300) {
  77.                         resolve(JSON.parse(response.responseText || '{}'));
  78.                     } else {
  79.                         reject(new Error(`GitHub API error: ${response.status} - ${response.responseText}`));
  80.                     }
  81.                 },
  82.                 onerror: function(error) {
  83.                     debugLog('Request failed:', error);
  84.                     reject(error);
  85.                 }
  86.             });
  87.         });
  88.     }
  89.  
  90.     async function handleSquash() {
  91.         const button = document.getElementById('squash-button');
  92.         button.disabled = true;
  93.         button.innerHTML = '⏳ Starting...';
  94.  
  95.         try {
  96.             await getGitHubToken();
  97.  
  98.             const prInfo = {
  99.                 owner: window.location.pathname.split('/')[1],
  100.                 repo: window.location.pathname.split('/')[2],
  101.                 prNumber: window.location.pathname.split('/')[4],
  102.                 branch: document.querySelector('.head-ref').innerText.trim(),
  103.                 title: document.querySelector('.js-issue-title').innerText.trim(),
  104.                 baseBranch: document.querySelector('.base-ref').innerText.trim()
  105.             };
  106.             debugLog('PR Info:', prInfo);
  107.  
  108.             button.innerHTML = '⏳ Getting PR details...';
  109.             const prDetails = await githubAPI(`/repos/${prInfo.owner}/${prInfo.repo}/pulls/${prInfo.prNumber}`);
  110.             debugLog('PR Details:', prDetails);
  111.             
  112.             // Get the exact PR description from the API to preserve formatting
  113.             prInfo.description = prDetails.body || '';
  114.  
  115.             // Get the latest base branch commit
  116.             button.innerHTML = '⏳ Getting latest base branch...';
  117.             const latestBaseRef = await githubAPI(`/repos/${prInfo.owner}/${prInfo.repo}/git/refs/heads/${prInfo.baseBranch}`);
  118.             const latestBaseSha = latestBaseRef.object.sha;
  119.             debugLog('Latest Base SHA:', latestBaseSha);
  120.  
  121.             // Get the comparison between base and head
  122.             button.innerHTML = '⏳ Comparing changes...';
  123.             const comparison = await githubAPI(`/repos/${prInfo.owner}/${prInfo.repo}/compare/${prDetails.base.sha}...${prDetails.head.sha}`);
  124.             debugLog('Comparison:', comparison);
  125.  
  126.             // Create new branch name
  127.             const timestamp = new Date().getTime();
  128.             const newBranchName = `squashed-pr-${prInfo.prNumber}-${timestamp}`;
  129.             debugLog('New Branch Name:', newBranchName);
  130.  
  131.             // Create new branch from the latest base
  132.             button.innerHTML = '⏳ Creating new branch...';
  133.             await githubAPI(`/repos/${prInfo.owner}/${prInfo.repo}/git/refs`, 'POST', {
  134.                 ref: `refs/heads/${newBranchName}`,
  135.                 sha: latestBaseSha
  136.             });
  137.  
  138.             // Get the PR commits to form a proper commit message
  139.             button.innerHTML = '⏳ Getting PR commits...';
  140.             const commits = await githubAPI(`/repos/${prInfo.owner}/${prInfo.repo}/pulls/${prInfo.prNumber}/commits`);
  141.             
  142.             // Create a combined commit message
  143.             let commitMessage = `${prInfo.title}\n\n`;
  144.             if (prInfo.description) {
  145.                 commitMessage += `${prInfo.description}\n\n`;
  146.             }
  147.             commitMessage += `Squashed commits from #${prInfo.prNumber}:\n\n`;
  148.             
  149.             commits.forEach(commit => {
  150.                 commitMessage += `* ${commit.commit.message.split('\n')[0]}\n`;
  151.             });
  152.  
  153.             // Get the PR files to apply changes
  154.             button.innerHTML = '⏳ Getting PR changes...';
  155.             const files = await githubAPI(`/repos/${prInfo.owner}/${prInfo.repo}/pulls/${prInfo.prNumber}/files`);
  156.             debugLog(`PR has ${files.length} changed files`);
  157.  
  158.             // Get the latest tree from the base branch
  159.             const baseTree = await githubAPI(`/repos/${prInfo.owner}/${prInfo.repo}/git/trees/${latestBaseSha}`);
  160.             
  161.             // Create a new tree with the changes
  162.             button.innerHTML = '⏳ Creating new tree with changes...';
  163.             
  164.             // For each changed file, we need to get its content
  165.             const treeItems = [];
  166.             for (const file of files) {
  167.                 if (file.status === 'removed') {
  168.                     // For deleted files, we don't include them in the new tree
  169.                     treeItems.push({
  170.                         path: file.filename,
  171.                         mode: '100644',
  172.                         type: 'blob',
  173.                         sha: null // null SHA means delete the file
  174.                     });
  175.                 } else {
  176.                     // For added or modified files, get the content from the head branch
  177.                     const fileContent = await githubAPI(`/repos/${prInfo.owner}/${prInfo.repo}/contents/${file.filename}?ref=${prDetails.head.ref}`);
  178.                     
  179.                     // If the file is binary or too large, use its SHA directly
  180.                     if (fileContent.encoding === 'base64') {
  181.                         treeItems.push({
  182.                             path: file.filename,
  183.                             mode: '100644',
  184.                             type: 'blob',
  185.                             content: atob(fileContent.content.replace(/\s/g, ''))
  186.                         });
  187.                     } else {
  188.                         // For other cases (like submodules or very large files), use the SHA
  189.                         treeItems.push({
  190.                             path: file.filename,
  191.                             mode: '100644',
  192.                             type: 'blob',
  193.                             sha: fileContent.sha
  194.                         });
  195.                     }
  196.                 }
  197.             }
  198.             
  199.             // Create a new tree
  200.             const newTree = await githubAPI(`/repos/${prInfo.owner}/${prInfo.repo}/git/trees`, 'POST', {
  201.                 base_tree: latestBaseSha,
  202.                 tree: treeItems
  203.             });
  204.             
  205.             // Create the squashed commit
  206.             button.innerHTML = '⏳ Creating squashed commit...';
  207.             const newCommit = await githubAPI(`/repos/${prInfo.owner}/${prInfo.repo}/git/commits`, 'POST', {
  208.                 message: commitMessage,
  209.                 tree: newTree.sha,
  210.                 parents: [latestBaseSha]
  211.             });
  212.             
  213.             // Update the new branch to point to the squashed commit
  214.             button.innerHTML = '⏳ Updating branch...';
  215.             await githubAPI(`/repos/${prInfo.owner}/${prInfo.repo}/git/refs/heads/${newBranchName}`, 'PATCH', {
  216.                 sha: newCommit.sha,
  217.                 force: true
  218.             });
  219.  
  220.             // Create new PR with the exact same description
  221.             button.innerHTML = '⏳ Creating new PR...';
  222.             const newPR = await githubAPI(`/repos/${prInfo.owner}/${prInfo.repo}/pulls`, 'POST', {
  223.                 title: `${prInfo.title} (Squashed)`,
  224.                 head: newBranchName,
  225.                 base: prInfo.baseBranch,
  226.                 body: `${prInfo.description}\n\n---\n_Squashed version of #${prInfo.prNumber}_`
  227.             });
  228.  
  229.             // Close original PR
  230.             button.innerHTML = '⏳ Closing original PR...';
  231.             await githubAPI(`/repos/${prInfo.owner}/${prInfo.repo}/pulls/${prInfo.prNumber}`, 'PATCH', {
  232.                 state: 'closed'
  233.             });
  234.  
  235.             // Redirect to the new PR
  236.             window.location.href = newPR.html_url;
  237.  
  238.         } catch (error) {
  239.             console.error('Failed to squash PR:', error);
  240.             debugLog('Error details:', error);
  241.             alert(`Failed to squash PR: ${error.message}\nCheck console for details`);
  242.             button.disabled = false;
  243.             button.innerHTML = '🔄 Squash & Recreate PR';
  244.         }
  245.     }
  246.  
  247.     function addSquashButton() {
  248.         if (window.location.href.includes('/pull/')) {
  249.             const actionBar = document.querySelector('.gh-header-actions');
  250.             if (actionBar && !document.getElementById('squash-button')) {
  251.                 const squashButton = document.createElement('button');
  252.                 squashButton.id = 'squash-button';
  253.                 squashButton.className = 'btn btn-sm btn-primary';
  254.                 squashButton.innerHTML = '🔄 Squash & Recreate PR';
  255.                 squashButton.onclick = handleSquash;
  256.                 actionBar.appendChild(squashButton);
  257.             }
  258.         }
  259.     }
  260.  
  261.     // Add button when page loads
  262.     addSquashButton();
  263.  
  264.     // Add button when navigation occurs
  265.     const observer = new MutationObserver(() => {
  266.         if (window.location.href.includes('/pull/')) {
  267.             addSquashButton();
  268.         }
  269.     });
  270.  
  271.     observer.observe(document.body, { childList: true, subtree: true });
  272. })();