@harryisfish/gitt 1.4.0 → 1.5.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

@@ -16,7 +16,12 @@ const git = (0, simple_git_1.simpleGit)();
  */
 async function cleanDeletedBranches(options = {}) {
     try {
-        const tasks = new listr2_1.Listr([
+        const state = {
+            mainBranch: '',
+            deletedBranches: []
+        };
+        // Phase 1: Discovery
+        const discoveryTasks = new listr2_1.Listr([
             {
                 title: 'Fetch main from remote',
                 task: async (ctx) => {
@@ -28,100 +33,138 @@ async function cleanDeletedBranches(options = {}) {
             {
                 title: 'Switch to main branch',
                 task: async (ctx) => {
-                    await git.checkout(ctx.mainBranch);
+                    // Check if we are on a branch that will be deleted? 
+                    // For now, just try to switch to main to be safe.
+                    // But if main is checked out in another worktree, this might fail?
+                    // Let's just try.
+                    try {
+                        await git.checkout(ctx.mainBranch);
+                    }
+                    catch (e) {
+                        // If we can't checkout main (e.g. dirty state), warn but continue?
+                        // Ideally we should be on main to delete other branches safely.
+                    }
                 }
             },
             {
                 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;
-                }
-            },
-            {
-                title: 'Select branches to delete',
-                enabled: (ctx) => !!options.interactive && Array.isArray(ctx.deletedBranches) && ctx.deletedBranches.length > 0,
-                task: async (ctx, task) => {
-                    const branches = ctx.deletedBranches;
-                    // Pause the listr task to show prompt
-                    // We need to stop the spinner to show the prompt clearly
-                    // But listr2 doesn't make it easy to pause/resume in the middle of a task flow easily without custom renderers
-                    // So we will do the prompt and then update the context
-                    // Actually, listr2 supports prompts but it's complex. 
-                    // Let's try to use the prompt directly.
-                    // We might need to handle the UI interference.
-                    // For now, let's just run the prompt.
-                    // In a real TTY, listr2 might fight for control.
-                    // A common pattern is to run the prompt outside listr or use listr's prompt adapter.
-                    // But here we are inside a task.
-                    // Let's try to use the prompt.
-                    try {
-                        const selected = await (0, prompts_1.checkbox)({
-                            message: 'Select branches to delete:',
-                            choices: branches.map(b => ({ name: b, value: b, checked: true })),
-                        });
-                        ctx.deletedBranches = selected;
-                    }
-                    catch (e) {
-                        // If user cancels, we might want to abort or just delete nothing
-                        ctx.deletedBranches = [];
-                    }
-                }
-            },
-            {
-                title: 'Dry Run: List branches to be deleted',
-                enabled: (ctx) => !!options.dryRun && Array.isArray(ctx.deletedBranches) && ctx.deletedBranches.length > 0,
-                task: (ctx, task) => {
-                    const branches = ctx.deletedBranches;
-                    task.output = `The following branches would be deleted:\n${branches.map(b => `  - ${b}`).join('\n')}`;
-                    // We don't want to fail, just show info. 
-                    // But listr output is transient.
-                    // We will print it at the end or use a separate log.
-                    console.log('\nDry Run: The following branches would be deleted:');
-                    branches.forEach(b => console.log(`  - ${b}`));
-                    ctx.deletedBranches = []; // Clear so next step does nothing
+                    // 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');
+            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: choices,
+                });
+                state.deletedBranches = selected;
+            }
+            catch (e) {
+                // User cancelled
+                throw new Error('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');
+            return;
+        }
+        if (options.dryRun) {
+            console.log('\nDry Run: The following branches would be deleted:');
+            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',
-                enabled: (ctx) => Array.isArray(ctx.deletedBranches),
-                skip: (ctx) => {
-                    if (!ctx.deletedBranches || ctx.deletedBranches.length === 0) {
-                        return 'No branches need to be cleaned up';
-                    }
-                    return false;
-                },
+                title: 'Delete branches',
                 task: (ctx) => {
-                    return new listr2_1.Listr((ctx.deletedBranches || []).map(branch => ({
-                        title: `Delete ${branch}`,
+                    return new listr2_1.Listr(state.deletedBranches.map(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 tasks.run();
+        await deleteTasks.run(state);
         (0, errors_2.printSuccess)('Branch cleanup completed');
     }
     catch (error) {

package/dist/index.js

@@ -86,12 +86,16 @@ Commands:
 Options:
   -i, --interactive      Interactive mode: Select branches to delete
   -d, --dry-run          Dry run: Show what would be deleted without deleting
+  --stale [days]         Find stale branches (default: 90 days, use with a number for custom)
+  -v, --version          Show version number
   -h, --help             Show this help message
 
 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'
 `);
@@ -100,11 +104,27 @@ async function main() {
     try {
         const args = process.argv.slice(2);
         const command = args[0];
+        // Check for version command
+        if (args.includes('-v') || args.includes('--version')) {
+            const packageJson = require('../package.json');
+            console.log(`v${packageJson.version}`);
+            process.exit(0);
+        }
         // Check for help command
         if (args.includes('-h') || args.includes('--help')) {
             printHelp();
             process.exit(0);
         }
+        // Check for updates
+        try {
+            // Use eval to prevent TypeScript from transpiling dynamic import to require()
+            const { default: updateNotifier } = await eval('import("update-notifier")');
+            const pkg = require('../package.json');
+            updateNotifier({ pkg }).notify();
+        }
+        catch (e) {
+            // Ignore update check errors
+        }
         // 检查 Git 仓库
         await checkGitRepo();
         if (command === 'set-main') {
@@ -125,8 +145,25 @@ async function main() {
             // Parse options
             const isInteractive = args.includes('-i') || args.includes('--interactive');
             const isDryRun = args.includes('-d') || args.includes('--dry-run');
+            // Parse stale options
+            const staleIndex = args.indexOf('--stale');
+            const isStale = staleIndex !== -1;
+            let staleDays = 90; // Default 3 months
+            if (isStale) {
+                // Check if next arg is a number (days)
+                // Note: This is a simple check, ideally use a proper arg parser like commander or yargs
+                const nextArg = args[staleIndex + 1];
+                if (nextArg && !nextArg.startsWith('-') && !isNaN(Number(nextArg))) {
+                    staleDays = Number(nextArg);
+                }
+            }
             // 默认执行清理操作
-            await (0, clean_1.cleanDeletedBranches)({ interactive: isInteractive, dryRun: isDryRun });
+            await (0, clean_1.cleanDeletedBranches)({
+                interactive: isInteractive,
+                dryRun: isDryRun,
+                stale: isStale,
+                staleDays: staleDays
+            });
         }
         // 退出程序
         process.exit(0);

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.0",
+  "version": "1.5.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": {
@@ -39,9 +39,11 @@
   "dependencies": {
     "@inquirer/prompts": "^3.3.0",
     "@types/minimatch": "^6.0.0",
+    "@types/update-notifier": "^6.0.8",
     "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"