gitsquash 0.0.1 → 0.1.0

package/bin/gitsquash.js

@@ -1,3 +1,29 @@
 #!/usr/bin/env node
 
-require('../src');
+import { program } from 'commander';
+import { main } from '../src/index.js';
+import chalk from 'chalk';
+
+program
+  .name('gitsquash')
+  .description('Interactive CLI tool to squash git commits')
+  .version('0.0.1')
+  .option('-n, --number <count>', 'number of recent commits to show', '10')
+  .option('-m, --message <message>', 'preset commit message (skips the prompt)')
+  .option('--dry-run', 'show what commits would be squashed without actually squashing')
+  .addHelpText('after', `
+Examples:
+  $ gitsquash                    # Interactive squash of last 10 commits
+  $ gitsquash -n 5              # Show only last 5 commits
+  $ gitsquash -m "feat: xyz"    # Squash with preset commit message
+  $ gitsquash --dry-run         # Preview squash operation
+  `);
+
+program.parse();
+
+const options = program.opts();
+
+main(options).catch(error => {
+  console.error(chalk.red('An unexpected error occurred:'), error.message);
+  process.exit(1);
+});

package/package.json

@@ -1,17 +1,27 @@
 {
   "name": "gitsquash",
-  "version": "0.0.1",
-  "description": "Squash your git history",
+  "version": "0.1.0",
+  "description": "Interactive CLI tool to squash git commits",
   "main": "src/index.js",
   "bin": {
     "gitsquash": "bin/gitsquash.js"
   },
+  "type": "module",
   "files": [
     "bin",
     "src",
     "license.md",
     "package.json"
   ],
+  "scripts": {
+    "start": "node bin/gitsquash.js"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "inquirer": "^9.2.12",
+    "simple-git": "^3.22.0",
+    "commander": "^11.1.0"
+  },
   "author": "Anoop M D",
   "license": "MIT"
 }

package/readme.md

@@ -0,0 +1,67 @@
+# gitsquash
+
+An interactive CLI tool that makes git commit squashing simple and intuitive. Select multiple commits using an interactive interface, provide a new commit message, and squash them into a single commit.
+
+## Features
+
+- 🔍 Interactive commit selection with checkboxes
+- 📝 Preview commit details (hash, date, message)
+- ⚡️ Simple keyboard-based navigation
+- 🔄 Automatic stashing of uncommitted changes
+- 🚀 Dry-run mode to preview changes
+- 💬 Optional preset commit messages
+
+## Installation
+
+```bash
+# Install globally
+npm install -g gitsquash
+
+# Or run directly with npx
+npx gitsquash
+```
+
+## Usage
+
+```bash
+# Basic interactive mode - shows last 10 commits
+gitsquash
+
+# Show only last 5 commits
+gitsquash -n 5
+
+# Squash with a preset commit message (skips the message prompt)
+gitsquash -m "feat: combine recent changes"
+
+# Preview what would happen without making changes
+gitsquash --dry-run
+```
+
+## Options
+
+| Option | Description |
+|--------|-------------|
+| `-n, --number <count>` | Number of recent commits to show (default: 10) |
+| `-m, --message <message>` | Preset commit message (skips the message prompt) |
+| `--dry-run` | Preview squash operation without making changes |
+| `--help` | Display help information |
+| `--version` | Display version number |
+
+## How It Works
+
+1. Shows you a list of recent commits
+2. Use space bar to select commits you want to squash
+3. Press enter to confirm selection
+4. Enter a new commit message (or use preset with `-m`)
+5. The selected commits will be squashed into a single commit
+
+## Notes
+
+- Requires git to be installed and available in PATH
+- Works on any git repository
+- Automatically handles uncommitted changes by stashing them
+- Minimum of 2 commits required for squashing
+
+## License
+
+MIT

package/src/index.js

@@ -1 +1,270 @@
-console.log('Hello World');
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import simpleGit from 'simple-git';
+
+const git = simpleGit();
+
+async function getRecentCommits(options) {
+  try {
+    const maxCount = parseInt(options.number) || 10;
+    const log = await git.log({ maxCount });
+    return log.all;
+  } catch (error) {
+    console.error(chalk.red('Error fetching git commits:'), error.message);
+    process.exit(1);
+  }
+}
+
+async function selectCommits(commits) {
+  const choices = commits.map(commit => ({
+    name: `${chalk.yellow(commit.hash.slice(0, 7))} - ${chalk.blue(commit.date)} - ${commit.message}`,
+    value: commit.hash,
+    short: commit.hash.slice(0, 7)
+  }));
+
+  const { selectedCommits } = await inquirer.prompt([
+    {
+      type: 'checkbox',
+      name: 'selectedCommits',
+      message: 'Select commits to squash (space to select, enter to confirm):',
+      choices,
+      pageSize: 10,
+      validate: input => {
+        if (input.length < 2) return 'Please select at least 2 commits to squash';
+        return true;
+      }
+    }
+  ]);
+
+  return selectedCommits;
+}
+
+async function getNewCommitMessage(presetMessage) {
+  if (presetMessage) {
+    return presetMessage;
+  }
+
+  const { message } = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'message',
+      message: 'Enter the new commit message:',
+      validate: input => {
+        if (!input.trim()) return 'Commit message cannot be empty';
+        return true;
+      }
+    }
+  ]);
+
+  return message;
+}
+
+async function squashLatestCommits(commits, message) {
+  const oldestCommit = commits[commits.length - 1];
+  
+  // Reset to the commit before the oldest commit we want to squash
+  await git.reset(['--soft', `${oldestCommit}~1`]);
+  // Create a new commit with all the changes
+  await git.commit(message);
+}
+
+async function squashNonConsecutiveCommits(commits, message) {
+  // Get the current branch name
+  const branchData = await git.branch();
+  const currentBranch = branchData.current;
+
+  // Create a temporary branch
+  const tempBranch = `temp-squash-${Date.now()}`;
+  
+  // Get all commits after our newest selected commit
+  console.log(chalk.yellow('\n🔍 Phase 1: Analyzing commits...'));
+  const newestSelectedCommit = commits[0];
+  const log = await git.log();
+  const laterCommits = [];
+  for (const commit of log.all) {
+    if (commit.hash === newestSelectedCommit) {
+      break;
+    }
+    laterCommits.push({ hash: commit.hash, message: commit.message.split('\n')[0] });
+  }
+  console.log(chalk.dim(`  Found ${laterCommits.length} newer commits to preserve`));
+
+  console.log(chalk.yellow('\n📦 Phase 2: Preparing workspace...'));
+  console.log(chalk.dim(`  Creating temporary branch: ${tempBranch}`));
+  await git.checkout(['-b', tempBranch]);
+
+  try {
+    console.log(chalk.yellow('\n🔄 Phase 3: Reconstructing history...'));
+    const oldestCommit = commits[commits.length - 1];
+    console.log(chalk.dim(`  Resetting to parent of ${oldestCommit.slice(0, 7)}`));
+    await git.reset(['--hard', `${oldestCommit}~1`]);
+
+    // Cherry pick all commits in order
+    console.log(chalk.magenta('\n  🍒 Cherry picking selected commits:'));
+    for (const commit of commits.reverse()) {
+      const shortHash = commit.slice(0, 7);
+      process.stdout.write(chalk.dim(`    Processing ${shortHash}... `));
+      await git.raw(['cherry-pick', commit]);
+      console.log(chalk.green('✓'));
+    }
+
+    // Now squash all the commits
+    console.log(chalk.magenta('\n  💼 Creating squashed commit:'));
+    console.log(chalk.dim(`    Resetting to parent of ${oldestCommit.slice(0, 7)}`));
+    await git.reset(['--soft', `${oldestCommit}~1`]);
+    process.stdout.write(chalk.dim('    Creating new commit... '));
+    await git.commit(message);
+    console.log(chalk.green('✓'));
+
+    // Get the new commit hash
+    const newCommit = await git.revparse(['HEAD']);
+    const shortNewCommit = newCommit.slice(0, 7);
+    console.log(chalk.dim(`    New commit hash: ${shortNewCommit}`));
+
+    console.log(chalk.yellow('\n🔄 Phase 4: Applying changes to main branch...'));
+    console.log(chalk.dim(`  Switching back to ${currentBranch}`));
+    await git.checkout([currentBranch]);
+
+    console.log(chalk.dim(`  Resetting to parent of ${oldestCommit.slice(0, 7)}`));
+    await git.reset(['--hard', `${oldestCommit}~1`]);
+
+    process.stdout.write(chalk.dim(`  Applying squashed commit ${shortNewCommit}... `));
+    await git.raw(['cherry-pick', newCommit]);
+    console.log(chalk.green('✓'));
+
+    // Now cherry pick all the later commits back on top
+    if (laterCommits.length > 0) {
+      console.log(chalk.magenta('\n  🔄 Restoring newer commits:'));
+      for (const commit of laterCommits.reverse()) {
+        const shortHash = commit.hash.slice(0, 7);
+        process.stdout.write(chalk.dim(`    ${shortHash} ${commit.message}... `));
+        await git.raw(['cherry-pick', commit.hash]);
+        console.log(chalk.green('✓'));
+      }
+    }
+
+    // Clean up: delete temporary branch
+    console.log(chalk.yellow('\n🧹 Phase 5: Cleanup'));
+    process.stdout.write(chalk.dim(`  Removing temporary branch ${tempBranch}... `));
+    await git.branch(['-D', tempBranch]);
+    console.log(chalk.green('✓'));
+
+  } catch (error) {
+    // If something goes wrong, try to cleanup
+    console.log(chalk.red('\n❌ Error: Squash failed!'));
+    console.log(chalk.yellow('🧹 Cleaning up...'));
+    console.log(chalk.dim(`  Switching back to ${currentBranch}`));
+    await git.checkout([currentBranch]);
+    process.stdout.write(chalk.dim(`  Removing temporary branch ${tempBranch}... `));
+    await git.branch(['-D', tempBranch]).catch(() => {});
+    console.log(chalk.green('✓'));
+    throw error;
+  }
+}
+
+async function areCommitsLatestAndConsecutive(commits) {
+  // Get recent commits - fetch at least the number of commits we're checking
+  const log = await git.log({ maxCount: commits.length });
+  const recentCommits = log.all.map(c => c.hash);
+
+  // Sort our selected commits by comparing their positions in the recent commits
+  const sortedSelectedCommits = [...commits].sort((a, b) => {
+    return recentCommits.indexOf(a) - recentCommits.indexOf(b);
+  });
+
+  // Check if they are the latest commits
+  for (let i = 0; i < commits.length; i++) {
+    if (sortedSelectedCommits[i] !== recentCommits[i]) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+async function squashCommits(commits, message, isDryRun) {
+  try {
+    const oldestCommit = commits[commits.length - 1];
+    const status = await git.status();
+    
+    if (isDryRun) {
+      // Get all commits to show context - fetch more than selected for better context
+      const log = await git.log({ maxCount: Math.max(10, commits.length + 3) });
+      
+      console.log(chalk.blue('\n📋 Dry Run - Squash Preview\n'));
+      
+      // Show current state
+      console.log(chalk.yellow('Current Commits:'));
+      log.all.forEach(commit => {
+        const isSelected = commits.includes(commit.hash);
+        const prefix = isSelected ? '🔷' : '⚪️';
+        const hash = commit.hash.slice(0, 7);
+        const message = commit.message.split('\n')[0];
+        console.log(`${prefix} ${chalk.dim(hash)} ${isSelected ? chalk.yellow(message) : message}`);
+      });
+
+      // Show future state
+      console.log(chalk.yellow('\nAfter Squash:'));
+      log.all.forEach(commit => {
+        const hash = commit.hash.slice(0, 7);
+        if (commits.includes(commit.hash)) {
+          if (commit.hash === oldestCommit) {
+            // Show the new squashed commit
+            console.log(`🔶 ${chalk.dim('NEW')} ${chalk.green(message)}`);
+          }
+          // Skip other commits that will be squashed
+          return;
+        }
+        // Show unaffected commits
+        console.log(`⚪️ ${chalk.dim(hash)} ${commit.message.split('\n')[0]}`);
+      });
+
+      console.log(chalk.blue('\nDetails:'));
+      console.log(`• ${commits.length} commits will be squashed into one`);
+      console.log(`• New commit message: "${message}"`);
+      if (status.files.length > 0) {
+        console.log(`• ${status.files.length} uncommitted changes will be preserved`);
+      }
+      return;
+    }
+
+    if (status.files.length > 0) {
+      console.log(chalk.yellow('Warning: You have uncommitted changes. Stashing them...'));
+      await git.stash(['save', 'temporary stash before squash']);
+    }
+
+    const useSimpleApproach = await areCommitsLatestAndConsecutive(commits);
+
+    if (useSimpleApproach) {
+      await squashLatestCommits(commits, message);
+    } else {
+      console.log(chalk.yellow('\n🔄 Using advanced squash approach (non-consecutive or non-latest commits)...'));
+      await squashNonConsecutiveCommits(commits, message);
+    }
+
+    if (status.files.length > 0) {
+      await git.stash(['pop']);
+    }
+
+    console.log(chalk.green('\n✨ Successfully squashed commits!'));
+  } catch (error) {
+    console.error(chalk.red('Error during squash:'), error.message);
+    process.exit(1);
+  }
+}
+
+export async function main(options = {}) {
+  console.log(chalk.blue('🔍 Fetching recent commits...'));
+  
+  const commits = await getRecentCommits(options);
+  if (commits.length < 2) {
+    console.log(chalk.yellow('Not enough commits to squash. Need at least 2 commits.'));
+    process.exit(0);
+  }
+
+  const selectedCommits = await selectCommits(commits);
+  const newMessage = await getNewCommitMessage(options.message);
+
+  console.log(chalk.blue('\n🔄 Squashing commits...'));
+  await squashCommits(selectedCommits, newMessage, options.dryRun);
+}