git-blame-ignore 1.0.0

package/dist/types.d.ts

@@ -0,0 +1,22 @@
+export interface BulkCommit {
+    sha: string;
+    message: string;
+    filesChanged: number;
+    linesChanged: number;
+    whitespaceRatio: number;
+    bulkScore: number;
+    date: string;
+}
+export interface IgnoreEntry {
+    sha: string;
+    message: string;
+    date: string;
+    comment?: string;
+}
+export interface GitBlameIgnoreConfig {
+    ignoreFile: string;
+    minFilesChanged: number;
+    minBulkScore: number;
+    whitespaceThreshold: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,UAAU;IACzB,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,eAAe,EAAE,MAAM,CAAC;IACxB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,WAAW;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,oBAAoB;IACnC,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB,YAAY,EAAE,MAAM,CAAC;IACrB,mBAAmB,EAAE,MAAM,CAAC;CAC7B"}

package/dist/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/jest.config.js

@@ -0,0 +1,16 @@
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  roots: ['<rootDir>/src', '<rootDir>/test'],
+  testMatch: ['**/*.test.ts'],
+  transform: {
+    '^.+\\.ts$': 'ts-jest',
+  },
+  collectCoverageFrom: [
+    'src/**/*.ts',
+    '!src/**/*.test.ts',
+    '!src/cli.ts',
+  ],
+  coverageDirectory: 'coverage',
+  coverageReporters: ['text', 'lcov', 'html'],
+};

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "git-blame-ignore",
+  "version": "1.0.0",
+  "description": "CLI that auto-detects bulk-change commits and manages .git-blame-ignore-revs file",
+  "main": "dist/index.js",
+  "bin": {
+    "git-blame-ignore": "dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "ts-node src/cli.ts",
+    "lint": "eslint src --ext .ts",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "prepublishOnly": "npm run lint && npm run build && npm test"
+  },
+  "keywords": [
+    "git",
+    "blame",
+    "prettier",
+    "eslint",
+    "format",
+    "development",
+    "cli",
+    "utility"
+  ],
+  "author": "Sulthonzh",
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "commander": "^11.0.0",
+    "inquirer": "^9.2.0",
+    "simple-git": "^3.20.0"
+  },
+  "devDependencies": {
+    "@types/inquirer": "^9.0.9",
+    "@types/jest": "^29.5.0",
+    "@types/node": "^20.0.0",
+    "@typescript-eslint/eslint-plugin": "^6.0.0",
+    "@typescript-eslint/parser": "^6.0.0",
+    "eslint": "^8.45.0",
+    "jest": "^29.6.0",
+    "ts-jest": "^29.1.0",
+    "ts-node": "^10.9.0",
+    "typescript": "^5.1.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/src/cli.ts

@@ -0,0 +1,198 @@
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { BulkCommitScanner } from './scanner';
+import { GitBlameIgnoreFileManager } from './file-manager';
+
+
+export class GitBlameIgnoreCLI {
+  private scanner: BulkCommitScanner;
+  private fileManager: GitBlameIgnoreFileManager;
+
+  constructor() {
+    this.scanner = new BulkCommitScanner();
+    this.fileManager = new GitBlameIgnoreFileManager();
+  }
+
+  async init(): Promise<void> {
+    console.log(chalk.blue('🔍 git-blame-ignore init - Interactive Setup Wizard'));
+    console.log(chalk.gray('Scanning for bulk-change commits...\n'));
+
+    try {
+      const commits = await this.scanner.scan();
+      
+      if (commits.length === 0) {
+        console.log(chalk.yellow('🤔 No bulk-change commits found that meet the criteria.'));
+        console.log(chalk.gray('Try running formatting tools like prettier or eslint --fix first.'));
+        return;
+      }
+
+      console.log(chalk.green(`✅ Found ${commits.length} bulk-change commits:\n`));
+
+      // Display commits
+      commits.forEach((commit, index) => {
+        const scoreColor = commit.bulkScore >= 70 ? chalk.green : commit.bulkScore >= 50 ? chalk.yellow : chalk.red;
+        console.log(`${index + 1}. ${commit.sha.substring(0, 7)} ${scoreColor(`[${commit.bulkScore}/100]`)} ${commit.message}`);
+        console.log(`   📁 ${commit.filesChanged} files changed, 📝 ${commit.linesChanged} lines changed`);
+        console.log(`   📅 ${commit.date}\n`);
+      });
+
+      // Ask user to select commits
+      const answers = await inquirer.prompt([
+        {
+          type: 'checkbox',
+          name: 'commits',
+          message: 'Which commits would you like to add to .git-blame-ignore-revs?',
+          choices: commits.map((commit) => ({
+            name: `${commit.sha.substring(0, 7)} - ${commit.message} (${commit.filesChanged} files)`,
+            value: commit.sha,
+            short: commit.sha.substring(0, 7)
+          })),
+          pageSize: 10
+        }
+      ]);
+
+      if (answers.commits.length === 0) {
+        console.log(chalk.yellow('❌ No commits selected. Exiting.'));
+        return;
+      }
+
+      // Add selected commits
+      for (const sha of answers.commits) {
+        await this.fileManager.add(sha);
+      }
+
+      console.log(chalk.green(`✅ Successfully added ${answers.commits.length} commits to .git-blame-ignore-revs`));
+      console.log(chalk.blue('💡 Now run `git blame` on affected files to see the improved output!'));
+
+    } catch (error) {
+      console.error(chalk.red('❌ Error during initialization:'), error);
+      process.exit(1);
+    }
+  }
+
+  async scan(limit: number = 20): Promise<void> {
+    console.log(chalk.blue('🔍 git-blame-ignore scan - Finding bulk-change commits'));
+    console.log(chalk.gray(`Analyzing last 100 commits...\n`));
+
+    try {
+      const commits = await this.scanner.scan();
+
+      if (commits.length === 0) {
+        console.log(chalk.yellow('🤔 No bulk-change commits found that meet the criteria.'));
+        console.log(chalk.gray('Try running formatting tools like prettier or eslint --fix first.'));
+        return;
+      }
+
+      const displayCommits = commits.slice(0, limit);
+      
+      console.log(chalk.green(`📋 Found ${commits.length} bulk-change commits (showing first ${Math.min(limit, commits.length)}):\n`));
+
+      displayCommits.forEach((commit, index) => {
+        const scoreColor = commit.bulkScore >= 70 ? chalk.green : commit.bulkScore >= 50 ? chalk.yellow : chalk.red;
+        console.log(`${index + 1}. ${commit.sha.substring(0, 7)} ${scoreColor(`[${commit.bulkScore}/100]`)} ${commit.message}`);
+        console.log(`   📁 ${commit.filesChanged} files changed, 📝 ${commit.linesChanged} lines changed`);
+        console.log(`   📅 ${commit.date} | Whitespace: ${Math.round(commit.whitespaceRatio * 100)}%\n`);
+      });
+
+      if (commits.length > limit) {
+        console.log(chalk.gray(`... and ${commits.length - limit} more commits`));
+      }
+
+    } catch (error) {
+      console.error(chalk.red('❌ Error during scan:'), error);
+      process.exit(1);
+    }
+  }
+
+  async add(sha: string): Promise<void> {
+    console.log(chalk.blue(`📝 git-blame-ignore add ${sha}`));
+
+    try {
+      await this.fileManager.add(sha);
+    } catch (error) {
+      console.error(chalk.red('❌ Error adding commit:'), error);
+      process.exit(1);
+    }
+  }
+
+  async list(): Promise<void> {
+    console.log(chalk.blue('📋 git-blame-ignore list - Current .git-blame-ignore-revs entries'));
+
+    try {
+      const entries = await this.fileManager.read();
+
+      if (entries.length === 0) {
+        console.log(chalk.yellow('🤔 No entries found in .git-blame-ignore-revs'));
+        console.log(chalk.gray('Run `git-blame-ignore init` to add some commits.'));
+        return;
+      }
+
+      console.log(chalk.green(`📋 .git-blame-ignore-revs (${entries.length} entries):\n`));
+
+      entries.forEach((entry, index) => {
+        console.log(`${index + 1}. ${entry.sha.substring(0, 7)} - ${entry.message}`);
+        console.log(`   📅 ${entry.date}`);
+        if (entry.comment) {
+          console.log(`   💬 ${entry.comment}`);
+        }
+        console.log('');
+      });
+
+    } catch (error) {
+      console.error(chalk.red('❌ Error listing entries:'), error);
+      process.exit(1);
+    }
+  }
+
+  async remove(sha: string): Promise<void> {
+    console.log(chalk.blue(`🗑️  git-blame-ignore remove ${sha}`));
+
+    try {
+      await this.fileManager.remove(sha);
+    } catch (error) {
+      console.error(chalk.red('❌ Error removing commit:'), error);
+      process.exit(1);
+    }
+  }
+
+  async check(): Promise<void> {
+    console.log(chalk.blue('✅ git-blame-ignore check - Validating entries'));
+
+    try {
+      const entries = await this.fileManager.read();
+      
+      if (entries.length === 0) {
+        console.log(chalk.yellow('🤔 No entries to check.'));
+        return;
+      }
+
+      const { valid, invalid } = await this.fileManager.validate(entries);
+
+      console.log(chalk.green(`✅ Valid entries: ${valid.length}`));
+      console.log(chalk.red(`❌ Invalid entries: ${invalid.length}\n`));
+
+      if (invalid.length > 0) {
+        console.log(chalk.red('Invalid entries (SHAs not found in repository):'));
+        invalid.forEach(entry => {
+          console.log(`  - ${entry.sha.substring(0, 7)} - ${entry.message}`);
+        });
+        console.log('');
+      }
+
+      if (valid.length > 0) {
+        console.log(chalk.green('Valid entries:'));
+        valid.forEach(entry => {
+          console.log(`  ✅ ${entry.sha.substring(0, 7)} - ${entry.message}`);
+        });
+      }
+
+      if (invalid.length > 0) {
+        console.log(chalk.yellow('\n💡 Tip: Remove invalid entries with `git-blame-ignore remove <sha>`'));
+      }
+
+    } catch (error) {
+      console.error(chalk.red('❌ Error during validation:'), error);
+      process.exit(1);
+    }
+  }
+}

package/src/file-manager.ts

@@ -0,0 +1,150 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { IgnoreEntry } from './types';
+
+export class GitBlameIgnoreFileManager {
+  private ignoreFilePath: string;
+
+  constructor(ignoreFilePath?: string) {
+    this.ignoreFilePath = ignoreFilePath || '.git-blame-ignore-revs';
+  }
+
+  async exists(): Promise<boolean> {
+    try {
+      await fs.access(this.ignoreFilePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async read(): Promise<IgnoreEntry[]> {
+    if (!(await this.exists())) {
+      return [];
+    }
+
+    try {
+      const content = await fs.readFile(this.ignoreFilePath, 'utf-8');
+      const entries: IgnoreEntry[] = [];
+      
+      const lines = content.split('\n').filter(line => line.trim() && !line.trim().startsWith('#'));
+      
+      for (const line of lines) {
+        const sha = line.trim();
+        if (sha && /^[a-f0-9]{40}$/i.test(sha)) {
+          const entry = await this.createIgnoreEntry(sha);
+          if (entry) {
+            entries.push(entry);
+          }
+        }
+      }
+
+      return entries;
+    } catch (error) {
+      throw new Error(`Failed to read ${this.ignoreFilePath}: ${error}`);
+    }
+  }
+
+  async add(sha: string, comment?: string): Promise<void> {
+    const entry = await this.createIgnoreEntry(sha);
+    if (!entry) {
+      throw new Error(`Invalid commit SHA: ${sha}`);
+    }
+
+    const entries = await this.read();
+    
+    // Check if already exists
+    if (entries.some(e => e.sha === sha)) {
+      console.log(`Entry ${sha.substring(0, 7)} already exists in ${this.ignoreFilePath}`);
+      return;
+    }
+
+    entries.push({
+      ...entry,
+      comment: comment || `Auto-added by git-blame-ignore`
+    });
+
+    await this.write(entries);
+    console.log(`Added ${sha.substring(0, 7)} to ${this.ignoreFilePath}`);
+  }
+
+  async remove(sha: string): Promise<void> {
+    const entries = await this.read();
+    const filtered = entries.filter(e => e.sha !== sha);
+    
+    if (filtered.length === entries.length) {
+      console.log(`Entry ${sha.substring(0, 7)} not found in ${this.ignoreFilePath}`);
+      return;
+    }
+
+    await this.write(filtered);
+    console.log(`Removed ${sha.substring(0, 7)} from ${this.ignoreFilePath}`);
+  }
+
+  async write(entries: IgnoreEntry[]): Promise<void> {
+    try {
+      // Create directory if it doesn't exist
+      const dir = path.dirname(this.ignoreFilePath);
+      await fs.mkdir(dir, { recursive: true });
+
+      let content = '# .git-blame-ignore-revs - managed by git-blame-ignore\n';
+      content += '# Format: SHA of commits to ignore for git blame\n\n';
+
+      for (const entry of entries) {
+        content += `# ${entry.sha.substring(0, 7)} - ${entry.message} (${entry.date})\n`;
+        content += `${entry.sha}\n\n`;
+      }
+
+      await fs.writeFile(this.ignoreFilePath, content);
+    } catch (error) {
+      throw new Error(`Failed to write ${this.ignoreFilePath}: ${error}`);
+    }
+  }
+
+  async validate(entries: IgnoreEntry[]): Promise<{ valid: IgnoreEntry[]; invalid: IgnoreEntry[] }> {
+    const valid: IgnoreEntry[] = [];
+    const invalid: IgnoreEntry[] = [];
+
+    for (const entry of entries) {
+      try {
+        // Check if SHA is a valid 40-character hex string
+        if (!/^[a-f0-9]{40}$/i.test(entry.sha)) {
+          invalid.push(entry);
+          continue;
+        }
+
+        // Try to get commit info to verify it exists
+        const git = require('simple-git')();
+        const result = await git.show([entry.sha, '--format=%H', '--no-patch']);
+        
+        if (result.trim() === entry.sha) {
+          valid.push(entry);
+        } else {
+          invalid.push(entry);
+        }
+      } catch {
+        invalid.push(entry);
+      }
+    }
+
+    return { valid, invalid };
+  }
+
+  private async createIgnoreEntry(sha: string): Promise<IgnoreEntry | null> {
+    try {
+      const git = require('simple-git')();
+      const [message, date] = await Promise.all([
+        git.show([sha, '--format=%s', '--no-patch']),
+        git.show([sha, '--format=%ai', '--no-patch'])
+      ]);
+
+      return {
+        sha,
+        message: message.trim(),
+        date: date.trim(),
+      };
+    } catch {
+      return null;
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,241 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import simpleGit from 'simple-git';
+import { readFile, writeFile } from 'fs/promises';
+import { join } from 'path';
+
+const program = new Command();
+
+program
+  .name('git-blame-ignore')
+  .description('Auto-detects bulk-change commits and manages .git-blame-ignore-revs file')
+  .version('1.0.0');
+
+program
+  .command('scan')
+  .description('Scan repository for bulk-change commits')
+  .option('-n, --number <number>', 'Number of commits to check (default: 50)', '50')
+  .option('-t, --threshold <threshold>', 'Threshold for bulk changes (default: 10)', '10')
+  .action(async (options) => {
+    try {
+      await scanBulkCommits(parseInt(options.number), parseInt(options.threshold));
+    } catch (error) {
+      console.error(chalk.red('Error:'), (error as Error).message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('ignore')
+  .description('Add bulk-change commits to .git-blame-ignore-revs')
+  .option('-c, --commits <commits>', 'Comma-separated list of commit hashes to ignore')
+  .option('-a, --auto', 'Auto-scan and add all detected bulk commits')
+  .action(async (options) => {
+    try {
+      if (options.auto) {
+        const bulkCommits = await scanBulkCommits(50, 10);
+        if (bulkCommits.length > 0) {
+          await addToIgnoreFile(bulkCommits.map(commit => commit.hash));
+        }
+      } else if (options.commits) {
+        const commitHashes = options.commits.split(',').map((hash: string) => hash.trim());
+        await addToIgnoreFile(commitHashes);
+      } else {
+        console.log(chalk.yellow('Please specify either --commits or --auto'));
+      }
+    } catch (error) {
+      console.error(chalk.red('Error:'), (error as Error).message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('list')
+  .description('List commits currently ignored in .git-blame-ignore-revs')
+  .action(async () => {
+    try {
+      await listIgnoredCommits();
+    } catch (error) {
+      console.error(chalk.red('Error:'), (error as Error).message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('remove')
+  .description('Remove commits from .git-blame-ignore-revs')
+  .option('-c, --commits <commits>', 'Comma-separated list of commit hashes to remove')
+  .option('-a, --all', 'Remove all ignored commits')
+  .action(async (options) => {
+    try {
+      if (options.all) {
+        await removeAllIgnoredCommits();
+      } else if (options.commits) {
+        const commitHashes = options.commits.split(',').map((hash: string) => hash.trim());
+        await removeFromIgnoreFile(commitHashes);
+      } else {
+        console.log(chalk.yellow('Please specify either --commits or --all'));
+      }
+    } catch (error) {
+      console.error(chalk.red('Error:'), (error as Error).message);
+      process.exit(1);
+    }
+  });
+
+async function scanBulkCommits(limit: number, threshold: number) {
+  const git = simpleGit();
+  
+  // Check if we're in a git repository
+  try {
+    await git.revparse(['--is-inside-work-tree']);
+  } catch (error) {
+    throw new Error('Not a git repository');
+  }
+
+  console.log(chalk.blue(`Scanning last ${limit} commits for bulk changes...`));
+
+  const logOutput = await git.log(['--pretty=format:%H %s %an %ad', `--max-count=${limit}`, '--date=short']);
+  const commits = logOutput.all;
+
+  const bulkCommits: Array<{ hash: string; subject: string; author: string; date: string; changes: number }> = [];
+
+  for (const commit of commits) {
+    try {
+      // Get number of changed files in this commit
+      const diffSummary = await git.diffSummary([`${commit.hash}^`, commit.hash]);
+      const changesCount = diffSummary.files.length;
+
+      if (changesCount >= threshold) {
+        bulkCommits.push({
+          hash: commit.hash,
+          subject: commit.message.split('\n')[0],
+          author: commit.author_name,
+          date: commit.date,
+          changes: changesCount
+        });
+      }
+    } catch (error) {
+      console.warn(chalk.yellow(`Warning: Could not analyze commit ${commit.hash}: ${(error as Error).message}`));
+    }
+  }
+
+  if (bulkCommits.length === 0) {
+    console.log(chalk.green('✅ No bulk-change commits found'));
+    return [];
+  }
+
+  console.log(chalk.blue('\n🔍 Bulk-change commits detected:'));
+  console.table(bulkCommits.map(commit => ({
+    Hash: commit.hash.substring(0, 8),
+    Subject: commit.subject,
+    Author: commit.author,
+    Date: commit.date,
+    Changes: commit.changes
+  })));
+
+  return bulkCommits;
+}
+
+async function addToIgnoreFile(commitHashes: string[]) {
+  const gitignorePath = join(process.cwd(), '.git-blame-ignore-revs');
+  let existingContent = '';
+
+  try {
+    existingContent = await readFile(gitignorePath, 'utf-8');
+  } catch (error) {
+    // File doesn't exist, that's okay
+  }
+
+  const newCommits = commitHashes.filter(hash => !existingContent.includes(hash));
+  
+  if (newCommits.length === 0) {
+    console.log(chalk.green('✅ All specified commits are already ignored'));
+    return;
+  }
+
+  const updatedContent = existingContent + (existingContent ? '\n' : '') + newCommits.join('\n') + '\n';
+  
+  try {
+    await writeFile(gitignorePath, updatedContent, 'utf-8');
+    console.log(chalk.green(`✅ Added ${newCommits.length} commit(s) to .git-blame-ignore-revs`));
+    console.log(chalk.blue('💡 Run `git blame --ignore-revs` to use the ignore file'));
+  } catch (error) {
+    throw new Error(`Failed to write .git-blame-ignore-revs: ${(error as Error).message}`);
+  }
+}
+
+async function listIgnoredCommits() {
+  const gitignorePath = join(process.cwd(), '.git-blame-ignore-revs');
+  
+  try {
+    const content = await readFile(gitignorePath, 'utf-8');
+    const commits = content.split('\n').filter(line => line.trim() && !line.startsWith('#'));
+    
+    if (commits.length === 0) {
+      console.log(chalk.yellow('No commits are currently ignored'));
+      return;
+    }
+
+    console.log(chalk.blue('📝 Currently ignored commits:'));
+    commits.forEach((commit, index) => {
+      console.log(`${index + 1}. ${commit}`);
+    });
+  } catch (error) {
+    throw new Error('.git-blame-ignore-revs file not found');
+  }
+}
+
+async function removeFromIgnoreFile(commitHashes: string[]) {
+  const gitignorePath = join(process.cwd(), '.git-blame-ignore-revs');
+  
+  try {
+    const content = await readFile(gitignorePath, 'utf-8');
+    const lines = content.split('\n');
+    
+    const filteredLines = lines.filter(line => {
+      return !commitHashes.includes(line.trim());
+    });
+    
+    const updatedContent = filteredLines.join('\n');
+    
+    if (updatedContent === content) {
+      console.log(chalk.yellow('None of the specified commits are currently ignored'));
+      return;
+    }
+    
+    await writeFile(gitignorePath, updatedContent, 'utf-8');
+    console.log(chalk.green(`✅ Removed ${commitHashes.length} commit(s) from .git-blame-ignore-revs`));
+  } catch (error) {
+    throw new Error('.git-blame-ignore-revs file not found');
+  }
+}
+
+async function removeAllIgnoredCommits() {
+  const gitignorePath = join(process.cwd(), '.git-blame-ignore-revs');
+  
+  try {
+    const content = await readFile(gitignorePath, 'utf-8');
+    const commits = content.split('\n').filter(line => line.trim() && !line.startsWith('#'));
+    
+    if (commits.length === 0) {
+      console.log(chalk.yellow('No commits are currently ignored'));
+      return;
+    }
+    
+    // Create a backup
+    const backupPath = gitignorePath + '.backup';
+    await writeFile(backupPath, content, 'utf-8');
+    
+    // Clear the file but keep the structure
+    await writeFile(gitignorePath, '# Git blame ignore file - auto-generated by git-blame-ignore\n', 'utf-8');
+    
+    console.log(chalk.green(`✅ Removed all ${commits.length} ignored commits`));
+    console.log(chalk.blue(`💡 Backup saved to: ${backupPath}`));
+  } catch (error) {
+    throw new Error('.git-blame-ignore-revs file not found');
+  }
+}
+
+program.parse();