@harryisfish/gitt 1.4.1 → 1.6.0

package/README.md

@@ -18,8 +18,10 @@ pnpm add -g @harryisfish/gitt
 
 ## Usage
 
+### Basic Commands
+
 ```bash
-# Default behavior (auto-clean)
+# Default behavior (auto-clean deleted branches)
 gitt
 
 # Interactive mode (select branches to delete)
@@ -31,8 +33,63 @@ gitt --interactive
 gitt -d
 # or
 gitt --dry-run
+
+# Check version
+gitt -v
+# or
+gitt --version
+
+# Show help
+gitt -h
+# or
+gitt --help
+```
+
+### Stale Branch Cleaning (NEW)
+
+Clean up branches that haven't been updated for a long time:
+
+```bash
+# Find branches inactive for 90+ days (default)
+gitt --stale
+
+# Custom threshold (e.g., 30 days)
+gitt --stale 30
+
+# Preview stale branches without deleting
+gitt --stale --dry-run
+
+# Interactively select stale branches to delete
+gitt --stale -i
 ```
 
+**Note:** Stale branch detection:
+- Checks the last commit date on each branch
+- Automatically excludes the main branch
+- Protects branches in use by Git worktrees
+- Can be combined with interactive (`-i`) and dry-run (`-d`) modes
+
+
+## Features
+
+### 🔄 Auto Update Notification
+Gitt automatically checks for updates on each run and notifies you when a new version is available.
+
+### 🌳 Worktree Protection
+Branches currently checked out in Git worktrees are automatically protected from deletion to prevent errors.
+
+### 🧹 Smart Branch Cleanup
+- **Remote-deleted branches**: Automatically detect and clean branches removed from remote
+- **Stale branches**: Find and remove branches inactive for X days
+- **Merge status check**: Safely handles both merged and unmerged branches
+- **Interactive mode**: Manual selection with clear indicators
+- **Dry-run mode**: Preview changes before applying
+
+### 🛡️ Branch Protection
+- Honors `.gitt` ignore patterns
+- Respects Git worktree usage
+- Never touches the main branch
+
 ## Configuration
 
 ### Main Branch Detection

package/dist/commands/clean.js

@@ -6,7 +6,6 @@ const listr2_1 = require("listr2");
 const prompts_1 = require("@inquirer/prompts");
 const minimatch_1 = require("minimatch");
 const errors_1 = require("../errors");
-const errors_2 = require("../errors");
 const git_1 = require("../utils/git");
 const config_1 = require("../utils/config");
 const git = (0, simple_git_1.simpleGit)();
@@ -33,81 +32,141 @@ async function cleanDeletedBranches(options = {}) {
             {
                 title: 'Switch to main branch',
                 task: async (ctx) => {
-                    await git.checkout(ctx.mainBranch);
+                    const currentBranch = (await git.branchLocal()).current;
+                    const willDeleteCurrent = state.deletedBranches.some(b => b.name === currentBranch);
+                    try {
+                        await git.checkout(ctx.mainBranch);
+                    }
+                    catch (e) {
+                        // If current branch will be deleted, we must switch - fail the operation
+                        if (willDeleteCurrent) {
+                            throw new errors_1.GitError(`Cannot switch to ${ctx.mainBranch}. Current branch "${currentBranch}" will be deleted but checkout failed.`);
+                        }
+                        // Otherwise, warn but continue (we can delete other branches)
+                        console.warn(`Warning: Could not switch to ${ctx.mainBranch}, but continuing as current branch is not being deleted.`);
+                    }
                 }
             },
             {
                 title: 'Sync main with remote',
                 task: async () => {
-                    await git.pull();
+                    try {
+                        await git.pull();
+                    }
+                    catch (e) {
+                        // Ignore pull errors (e.g. if not on branch)
+                    }
                 }
             },
             {
-                title: 'Fetch and prune remote branches',
+                title: 'Analyze branches',
                 task: async (ctx) => {
                     await git.fetch(['--prune']);
                     const branchSummary = await git.branch(['-vv']);
                     const config = await (0, config_1.readConfigFile)();
                     const ignorePatterns = config.ignoreBranches || [];
-                    let deletedBranches = branchSummary.all.filter(branch => {
-                        const branchInfo = branchSummary.branches[branch];
-                        return branchInfo.label && branchInfo.label.includes(': gone]');
-                    });
+                    const worktreeBranches = await (0, git_1.getWorktrees)();
+                    let candidates = [];
+                    if (options.stale) {
+                        // Stale mode: check all local branches
+                        const allBranches = branchSummary.all;
+                        for (const branch of allBranches) {
+                            if (branch === ctx.mainBranch)
+                                continue;
+                            const days = await (0, git_1.getBranchLastCommitTime)(branch);
+                            if (days > (options.staleDays || 90)) {
+                                candidates.push({
+                                    name: branch,
+                                    reason: `Stale (${days} days)`
+                                });
+                            }
+                        }
+                    }
+                    else {
+                        // Default mode: check "gone" branches
+                        const goneBranches = branchSummary.all.filter(branch => {
+                            const branchInfo = branchSummary.branches[branch];
+                            return branchInfo.label && branchInfo.label.includes(': gone]');
+                        });
+                        candidates = goneBranches.map(b => ({ name: b, reason: 'Remote deleted' }));
+                    }
                     // Filter out ignored branches
                     if (ignorePatterns.length > 0) {
-                        deletedBranches = deletedBranches.filter(branch => {
-                            const isIgnored = ignorePatterns.some(pattern => (0, minimatch_1.minimatch)(branch, pattern));
+                        candidates = candidates.filter(c => {
+                            const isIgnored = ignorePatterns.some(pattern => (0, minimatch_1.minimatch)(c.name, pattern));
                             return !isIgnored;
                         });
                     }
-                    ctx.deletedBranches = deletedBranches;
+                    // Filter out worktree branches
+                    candidates = candidates.filter(c => !worktreeBranches.includes(c.name));
+                    // Check merge status for each branch
+                    const branchesWithStatus = await Promise.all(candidates.map(async (c) => {
+                        const isMerged = await (0, git_1.isBranchMerged)(c.name, ctx.mainBranch);
+                        return { ...c, isMerged };
+                    }));
+                    ctx.deletedBranches = branchesWithStatus;
                 }
             }
         ]);
         await discoveryTasks.run(state);
         // Phase 2: Interaction / Filtering
         if (state.deletedBranches.length === 0) {
-            (0, errors_2.printSuccess)('No branches need to be cleaned up');
+            (0, errors_1.printSuccess)('No branches need to be cleaned up');
             return;
         }
         if (options.interactive) {
             try {
+                const choices = state.deletedBranches.map(b => ({
+                    name: `${b.name} (${b.reason}${b.isMerged ? '' : ', Unmerged'})`,
+                    value: b,
+                    checked: b.isMerged // Only check merged branches by default
+                }));
                 const selected = await (0, prompts_1.checkbox)({
                     message: 'Select branches to delete:',
-                    choices: state.deletedBranches.map(b => ({ name: b, value: b, checked: true })),
+                    choices: choices,
                 });
                 state.deletedBranches = selected;
             }
             catch (e) {
                 // User cancelled
-                throw new Error('Operation cancelled');
+                throw new errors_1.UserCancelError('Operation cancelled');
+            }
+        }
+        else {
+            // Auto mode: Filter out unmerged branches
+            const unmerged = state.deletedBranches.filter(b => !b.isMerged);
+            if (unmerged.length > 0) {
+                console.log('\nSkipping unmerged branches (use -i to force delete):');
+                unmerged.forEach(b => console.log(`  - ${b.name} (${b.reason})`));
             }
+            state.deletedBranches = state.deletedBranches.filter(b => b.isMerged);
         }
         if (state.deletedBranches.length === 0) {
-            (0, errors_2.printSuccess)('No branches selected for deletion');
+            (0, errors_1.printSuccess)('No branches selected for deletion');
             return;
         }
         if (options.dryRun) {
             console.log('\nDry Run: The following branches would be deleted:');
-            state.deletedBranches.forEach(b => console.log(`  - ${b}`));
+            state.deletedBranches.forEach(b => console.log(`  - ${b.name} (${b.reason})`));
             return;
         }
         // Phase 3: Execution
         const deleteTasks = new listr2_1.Listr([
             {
-                title: 'Delete branches removed on remote',
-                task: (ctx) => {
+                title: 'Delete branches',
+                task: (_ctx) => {
                     return new listr2_1.Listr(state.deletedBranches.map(branch => ({
-                        title: `Delete ${branch}`,
+                        title: `Delete ${branch.name}`,
                         task: async () => {
-                            await git.branch(['-D', branch]);
+                            // Always use -D to force delete if we are here (user confirmed or it's merged)
+                            await git.branch(['-D', branch.name]);
                         }
                     })), { concurrent: false });
                 }
             }
         ]);
         await deleteTasks.run(state);
-        (0, errors_2.printSuccess)('Branch cleanup completed');
+        (0, errors_1.printSuccess)('Branch cleanup completed');
     }
     catch (error) {
         throw new errors_1.GitError(error instanceof Error ? error.message : 'Unknown error occurred while cleaning branches');

package/dist/errors.js

@@ -1,9 +1,13 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UserCancelError = exports.GitError = void 0;
 exports.handleError = handleError;
 exports.printSuccess = printSuccess;
 exports.printError = printError;
+const chalk_1 = __importDefault(require("chalk"));
 // 自定义错误类型
 class GitError extends Error {
     constructor(message) {
@@ -19,10 +23,6 @@ class UserCancelError extends Error {
     }
 }
 exports.UserCancelError = UserCancelError;
-// 错误消息颜色
-const ERROR_COLOR = '\x1b[31m';
-const SUCCESS_COLOR = '\x1b[32m';
-const RESET_COLOR = '\x1b[0m';
 // 统一错误处理函数
 function handleError(error) {
     if (error instanceof UserCancelError) {
@@ -30,21 +30,21 @@ function handleError(error) {
         process.exit(0);
     }
     if (error instanceof GitError) {
-        console.error(`${ERROR_COLOR}Error: ${RESET_COLOR}${error.message}`);
+        console.error(chalk_1.default.red('Error:'), error.message);
         process.exit(1);
     }
     if (error instanceof Error) {
-        console.error(`${ERROR_COLOR}Program error: ${RESET_COLOR}${error.message}`);
+        console.error(chalk_1.default.red('Program error:'), error.message);
         process.exit(1);
     }
-    console.error(`${ERROR_COLOR}Unknown error occurred${RESET_COLOR}`);
+    console.error(chalk_1.default.red('Unknown error occurred'));
     process.exit(1);
 }
 // 成功消息处理
 function printSuccess(message) {
-    console.log(`${SUCCESS_COLOR}✓ ${message}${RESET_COLOR}`);
+    console.log(chalk_1.default.green('✓'), message);
 }
 // 错误消息处理
 function printError(message) {
-    console.error(`${ERROR_COLOR}${message}${RESET_COLOR}`);
+    console.error(chalk_1.default.red(message));
 }

package/dist/index.js

@@ -34,10 +34,12 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
 const simple_git_1 = require("simple-git");
 const errors_1 = require("./errors");
 const clean_1 = require("./commands/clean");
 const git = (0, simple_git_1.simpleGit)();
+const packageJson = require('../package.json');
 // 处理 Ctrl+C 和其他终止信号
 process.on('SIGINT', () => {
     throw new errors_1.UserCancelError('\nOperation cancelled');
@@ -45,16 +47,6 @@ process.on('SIGINT', () => {
 process.on('SIGTERM', () => {
     throw new errors_1.UserCancelError('\nProgram terminated');
 });
-// 初始化 Git 仓库
-async function initGitRepo() {
-    try {
-        await git.init();
-        (0, errors_1.printSuccess)('Git repository initialized successfully');
-    }
-    catch (error) {
-        throw new errors_1.GitError('Failed to initialize Git repository');
-    }
-}
 // 检查当前目录是否是 Git 仓库
 async function checkGitRepo() {
     const isRepo = await git.checkIsRepo();
@@ -74,67 +66,70 @@ async function checkGitRepo() {
         throw new errors_1.GitError('Cannot access remote repository, please check network connection or repository permissions');
     }
 }
-function printHelp() {
-    console.log(`
-Usage: gitt [command] [options]
-
-Commands:
-  (default)              Clean up local branches that have been deleted on remote
-  set-main <branch>      Set the main branch for the current project
-  ignore <pattern>       Add a branch pattern to the ignore list (e.g., "release/*")
-
-Options:
-  -i, --interactive      Interactive mode: Select branches to delete
-  -d, --dry-run          Dry run: Show what would be deleted without deleting
-  -h, --help             Show this help message
-
-Examples:
-  gitt                   # Auto-clean deleted branches
-  gitt -i                # Select branches to delete interactively
-  gitt -d                # Preview deletion
-  gitt ignore "temp/*"   # Ignore branches matching "temp/*"
-  gitt set-main master   # Set main branch to 'master'
-`);
-}
 async function main() {
     try {
-        const args = process.argv.slice(2);
-        const command = args[0];
-        // Check for help command
-        if (args.includes('-h') || args.includes('--help')) {
-            printHelp();
-            process.exit(0);
+        // Check for updates before parsing commands
+        try {
+            // Use eval to prevent TypeScript from transpiling dynamic import to require()
+            const { default: updateNotifier } = await eval('import("update-notifier")');
+            updateNotifier({ pkg: packageJson }).notify();
         }
-        // 检查 Git 仓库
-        await checkGitRepo();
-        if (command === 'set-main') {
-            const branch = args[1];
-            if (!branch) {
-                throw new Error('Please specify a branch name');
-            }
-            await Promise.resolve().then(() => __importStar(require('./commands/config'))).then(m => m.configMainBranch(branch));
+        catch (e) {
+            // Ignore update check errors
         }
-        else if (command === 'ignore') {
-            const pattern = args[1];
-            if (!pattern) {
-                throw new Error('Please specify a branch pattern to ignore');
-            }
+        const program = new commander_1.Command();
+        program
+            .name('gitt')
+            .description('A CLI tool for Git branch management')
+            .version(packageJson.version, '-v, --version', 'Show version number');
+        // Default command: clean deleted branches
+        program
+            .option('-i, --interactive', 'Interactive mode: Select branches to delete')
+            .option('-d, --dry-run', 'Dry run: Show what would be deleted without deleting')
+            .option('--stale [days]', 'Find stale branches (default: 90 days)', '90')
+            .action(async (options) => {
+            await checkGitRepo();
+            const staleDays = options.stale === true ? 90 : parseInt(options.stale, 10);
+            const isStale = options.stale !== undefined;
+            await (0, clean_1.cleanDeletedBranches)({
+                interactive: options.interactive || false,
+                dryRun: options.dryRun || false,
+                stale: isStale,
+                staleDays: staleDays
+            });
+        });
+        // set-main command
+        program
+            .command('set-main <branch>')
+            .description('Set the main branch for the current project')
+            .action(async (branch) => {
+            await checkGitRepo();
+            await Promise.resolve().then(() => __importStar(require('./commands/config'))).then(m => m.configMainBranch(branch));
+        });
+        // ignore command
+        program
+            .command('ignore <pattern>')
+            .description('Add a branch pattern to the ignore list (e.g., "release/*")')
+            .action(async (pattern) => {
+            await checkGitRepo();
             await Promise.resolve().then(() => __importStar(require('./commands/config'))).then(m => m.configIgnoreBranch(pattern));
-        }
-        else {
-            // Parse options
-            const isInteractive = args.includes('-i') || args.includes('--interactive');
-            const isDryRun = args.includes('-d') || args.includes('--dry-run');
-            // 默认执行清理操作
-            await (0, clean_1.cleanDeletedBranches)({ interactive: isInteractive, dryRun: isDryRun });
-        }
-        // 退出程序
-        process.exit(0);
+        });
+        // Add examples to help
+        program.addHelpText('after', `
+Examples:
+  $ gitt                   # Auto-clean deleted branches
+  $ gitt -i                # Select branches to delete interactively
+  $ gitt -d                # Preview deletion
+  $ gitt --stale           # Find branches inactive for 90+ days
+  $ gitt --stale 30        # Find branches inactive for 30+ days
+  $ gitt ignore "temp/*"   # Ignore branches matching "temp/*"
+  $ gitt set-main master   # Set main branch to 'master'
+`);
+        await program.parseAsync(process.argv);
     }
     catch (error) {
         (0, errors_1.handleError)(error);
-        process.exit(1);
     }
 }
 // 启动程序
-main().catch(errors_1.handleError);
+main();

package/dist/utils/config.js

@@ -39,7 +39,50 @@ exports.writeConfigFile = writeConfigFile;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const simple_git_1 = require("simple-git");
+const minimatch_1 = require("minimatch");
 const CONFIG_FILE_NAME = '.gitt';
+/**
+ * Validate configuration values.
+ */
+function validateConfig(config) {
+    const validated = {};
+    // Validate mainBranch
+    if (config.mainBranch !== undefined) {
+        if (typeof config.mainBranch !== 'string' || config.mainBranch.trim() === '') {
+            throw new Error('Invalid config: mainBranch must be a non-empty string');
+        }
+        validated.mainBranch = config.mainBranch.trim();
+    }
+    // Validate ignoreBranches
+    if (config.ignoreBranches !== undefined) {
+        if (!Array.isArray(config.ignoreBranches)) {
+            throw new Error('Invalid config: ignoreBranches must be an array');
+        }
+        const validPatterns = [];
+        for (const pattern of config.ignoreBranches) {
+            if (typeof pattern !== 'string' || pattern.trim() === '') {
+                throw new Error('Invalid config: ignoreBranches must contain non-empty strings');
+            }
+            // Test if it's a valid glob pattern by trying to use it
+            try {
+                (0, minimatch_1.minimatch)('test', pattern);
+                validPatterns.push(pattern);
+            }
+            catch (e) {
+                throw new Error(`Invalid config: "${pattern}" is not a valid glob pattern`);
+            }
+        }
+        validated.ignoreBranches = validPatterns;
+    }
+    // Validate staleDays
+    if (config.staleDays !== undefined) {
+        if (typeof config.staleDays !== 'number' || config.staleDays < 1 || config.staleDays > 365 || !Number.isInteger(config.staleDays)) {
+            throw new Error('Invalid config: staleDays must be an integer between 1 and 365');
+        }
+        validated.staleDays = config.staleDays;
+    }
+    return validated;
+}
 /**
  * Get the project root directory (where .git is located).
  */
@@ -64,9 +107,15 @@ async function readConfigFile() {
             return {};
         }
         const content = fs.readFileSync(configPath, 'utf-8');
-        return JSON.parse(content);
+        const parsedConfig = JSON.parse(content);
+        return validateConfig(parsedConfig);
     }
     catch (error) {
+        // If validation fails, throw the error instead of returning empty config
+        if (error instanceof Error && error.message.startsWith('Invalid config:')) {
+            throw error;
+        }
+        // For other errors (file read, JSON parse), return empty config
         return {};
     }
 }
@@ -74,10 +123,12 @@ async function readConfigFile() {
  * Write to the .gitt configuration file.
  */
 async function writeConfigFile(config) {
+    // Validate new config before writing
+    const validatedConfig = validateConfig(config);
     const root = await getProjectRoot();
     const configPath = path.join(root, CONFIG_FILE_NAME);
     // Read existing config to merge
     const currentConfig = await readConfigFile();
-    const newConfig = { ...currentConfig, ...config };
+    const newConfig = { ...currentConfig, ...validatedConfig };
     fs.writeFileSync(configPath, JSON.stringify(newConfig, null, 2));
 }

package/dist/utils/git.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getMainBranch = getMainBranch;
 exports.setMainBranch = setMainBranch;
+exports.isBranchMerged = isBranchMerged;
+exports.getWorktrees = getWorktrees;
+exports.getBranchLastCommitTime = getBranchLastCommitTime;
 const simple_git_1 = require("simple-git");
 const errors_1 = require("../errors");
 const config_1 = require("./config");
@@ -74,3 +77,59 @@ async function setMainBranch(branch) {
         throw new errors_1.GitError('Failed to set main branch configuration');
     }
 }
+/**
+ * Check if a branch is merged into the main branch.
+ */
+async function isBranchMerged(branch, mainBranch) {
+    try {
+        const mergedBranches = await git.branch(['--merged', mainBranch]);
+        return mergedBranches.all.includes(branch);
+    }
+    catch (error) {
+        return false;
+    }
+}
+/**
+ * Get a list of branches that are currently checked out in worktrees.
+ */
+async function getWorktrees() {
+    try {
+        // Output format:
+        // /path/to/repo    (HEAD detached at 123456)
+        // /path/to/worktree    [branch-name]
+        const worktrees = await git.raw(['worktree', 'list']);
+        const lines = worktrees.split('\n').filter(Boolean);
+        const branches = [];
+        for (const line of lines) {
+            // Extract branch name from [branch-name]
+            const match = line.match(/\[(.*?)\]/);
+            if (match && match[1]) {
+                branches.push(match[1]);
+            }
+        }
+        return branches;
+    }
+    catch (error) {
+        // If worktrees are not supported or error occurs, return empty list
+        return [];
+    }
+}
+/**
+ * Get the last commit time (in days) for a branch.
+ * Returns the number of days since the last commit.
+ */
+async function getBranchLastCommitTime(branch) {
+    try {
+        // Get unix timestamp of last commit
+        const timestamp = await git.raw(['log', '-1', '--format=%at', branch]);
+        const lastCommitDate = new Date(parseInt(timestamp.trim()) * 1000);
+        const now = new Date();
+        const diffTime = Math.abs(now.getTime() - lastCommitDate.getTime());
+        const diffDays = Math.ceil(diffTime / (1000 * 60 * 60 * 24));
+        return diffDays;
+    }
+    catch (error) {
+        // If branch doesn't exist or error, return 0 (treat as active/new to be safe)
+        return 0;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@harryisfish/gitt",
-  "version": "1.4.1",
+  "version": "1.6.0",
   "description": "A command-line tool to help you manage Git repositories and remote repositories, such as keeping in sync, pushing, pulling, etc.",
   "main": "dist/index.js",
   "bin": {
@@ -10,6 +10,9 @@
     "build": "tsc",
     "start": "tsx src/index.ts",
     "dev": "tsx watch src/index.ts",
+    "test": "vitest",
+    "test:ui": "vitest --ui",
+    "test:coverage": "vitest --coverage",
     "prepare": "pnpm run build",
     "dev:link": "pnpm build && pnpm link --global",
     "dev:unlink": "pnpm unlink --global"
@@ -32,16 +35,22 @@
   "homepage": "https://github.com/harryisfish/gitt#readme",
   "devDependencies": {
     "@types/node": "^20.11.24",
+    "@vitest/ui": "^4.0.14",
     "ts-node": "^10.9.2",
     "tsx": "^4.7.1",
-    "typescript": "^5.3.3"
+    "typescript": "^5.3.3",
+    "vitest": "^4.0.14"
   },
   "dependencies": {
     "@inquirer/prompts": "^3.3.0",
     "@types/minimatch": "^6.0.0",
+    "@types/update-notifier": "^6.0.8",
+    "chalk": "4",
+    "commander": "^14.0.2",
     "listr2": "^8.0.0",
     "minimatch": "^10.1.1",
-    "simple-git": "^3.22.0"
+    "simple-git": "^3.22.0",
+    "update-notifier": "^7.3.1"
   },
   "engines": {
     "node": ">=14.0.0"