ccmanager 3.7.0 → 3.7.2

package/README.md

@@ -2,7 +2,7 @@
 
 [![Mentioned in Awesome Gemini CLI](https://awesome.re/mentioned-badge.svg)](https://github.com/Piebald-AI/awesome-gemini-cli)
 
-CCManager is a CLI application for managing multiple AI coding assistant sessions (Claude Code, Gemini CLI, Codex CLI) across Git worktrees and projects.
+CCManager is a CLI application for managing multiple AI coding assistant sessions (Claude Code, Gemini CLI, Codex CLI, Cursor Agent, Copilot CLI, Cline CLI, OpenCode, Kimi CLI) across Git worktrees and projects.
 
 https://github.com/user-attachments/assets/15914a88-e288-4ac9-94d5-8127f2e19dbf
 
@@ -10,7 +10,7 @@ https://github.com/user-attachments/assets/15914a88-e288-4ac9-94d5-8127f2e19dbf
 
 - Run multiple AI assistant sessions in parallel across different Git worktrees
 - **Multi-project support**: Manage multiple git repositories from a single interface
-- Support for multiple AI coding assistants (Claude Code, Gemini CLI)
+- Support for multiple AI coding assistants (Claude Code, Gemini CLI, Codex CLI, Cursor Agent, Copilot CLI, Cline CLI, OpenCode, Kimi CLI)
 - Switch between sessions seamlessly
 - Visual status indicators for session states (busy, waiting, idle)
 - Create, merge, and delete worktrees from within the app
@@ -129,6 +129,7 @@ CCManager supports multiple AI coding assistants with tailored state detection f
 | Copilot CLI | `copilot` | [github.com/github/copilot-cli](https://github.com/github/copilot-cli) |
 | Cline CLI | `cline` | [github.com/cline/cline](https://github.com/cline/cline) |
 | OpenCode | `opencode` | [opencode.ai/docs](https://opencode.ai/docs) |
+| Kimi CLI | `kimi` | [kimi-cli.com](https://www.kimi-cli.com/en/) |
 
 Each assistant has its own state detection strategy to properly track:
 - **Idle**: Ready for new input

package/dist/components/App.test.js

@@ -172,7 +172,7 @@ describe('App component loading state machine', () => {
         resolveWorktree?.();
         await createPromise;
         await selectPromise;
-        await flush(20);
+        await waitForCondition(() => lastFrame()?.includes('Menu View') ?? false);
         expect(lastFrame()).toContain('Menu View');
         unmount();
     });
@@ -201,7 +201,7 @@ describe('App component loading state machine', () => {
         resolveDelete?.();
         await deletePromise;
         await selectPromise;
-        await flush(20);
+        await waitForCondition(() => lastFrame()?.includes('Menu View') ?? false);
         expect(lastFrame()).toContain('Menu View');
         unmount();
     });

package/dist/components/DeleteConfirmation.js

@@ -1,15 +1,34 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { useState } from 'react';
+import { useState, useEffect } from 'react';
 import { Box, Text, useInput } from 'ink';
 import SelectInput from 'ink-select-input';
 import { shortcutManager } from '../services/shortcutManager.js';
 import Confirmation from './Confirmation.js';
+import { hasUncommittedChanges } from '../utils/gitUtils.js';
 const DeleteConfirmation = ({ worktrees, onConfirm, onCancel, }) => {
     // Check if any worktrees have branches
     const hasAnyBranches = worktrees.some(wt => wt.branch);
     const [deleteBranch, setDeleteBranch] = useState(true);
-    const [view, setView] = useState(hasAnyBranches ? 'options' : 'confirm');
+    const [view, setView] = useState('checking-uncommitted');
     const [focusedOption, setFocusedOption] = useState(deleteBranch ? 'deleteBranch' : 'keepBranch');
+    const [worktreesWithChanges, setWorktreesWithChanges] = useState([]);
+    // Check for uncommitted changes on mount
+    useEffect(() => {
+        const checkUncommittedChanges = () => {
+            const withChanges = worktrees.filter(wt => hasUncommittedChanges(wt.path));
+            setWorktreesWithChanges(withChanges);
+            if (withChanges.length > 0) {
+                setView('uncommitted-warning');
+            }
+            else if (hasAnyBranches) {
+                setView('options');
+            }
+            else {
+                setView('confirm');
+            }
+        };
+        checkUncommittedChanges();
+    }, [worktrees, hasAnyBranches]);
     // Menu items for branch options
     const branchOptions = [
         {
@@ -53,7 +72,12 @@ const DeleteConfirmation = ({ worktrees, onConfirm, onCancel, }) => {
         return false;
     };
     useInput((input, key) => {
-        if (hasAnyBranches && view === 'options') {
+        if (view === 'uncommitted-warning') {
+            if (shortcutManager.matchesShortcut('cancel', input, key)) {
+                onCancel();
+            }
+        }
+        else if (hasAnyBranches && view === 'options') {
             if (handleBranchOptionsInput(input, key)) {
                 return;
             }
@@ -66,6 +90,33 @@ const DeleteConfirmation = ({ worktrees, onConfirm, onCancel, }) => {
     const title = (_jsx(Text, { bold: true, color: "red", children: "\u26A0\uFE0F Delete Confirmation" }));
     // Message component
     const message = (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: "You are about to delete the following worktrees:" }), worktrees.length <= 10 ? (worktrees.map(wt => (_jsxs(Text, { color: "red", children: ["\u2022 ", wt.branch ? wt.branch.replace('refs/heads/', '') : 'detached', " (", wt.path, ")"] }, wt.path)))) : (_jsxs(_Fragment, { children: [worktrees.slice(0, 8).map(wt => (_jsxs(Text, { color: "red", children: ["\u2022 ", wt.branch ? wt.branch.replace('refs/heads/', '') : 'detached', ' ', "(", wt.path, ")"] }, wt.path))), _jsxs(Text, { color: "red", dimColor: true, children: ["... and ", worktrees.length - 8, " more worktrees"] })] }))] }));
+    // Loading state while checking uncommitted changes
+    if (view === 'checking-uncommitted') {
+        return (_jsx(Box, { flexDirection: "column", children: _jsx(Text, { color: "cyan", children: "Checking for uncommitted changes..." }) }));
+    }
+    // Uncommitted changes warning view
+    if (view === 'uncommitted-warning') {
+        const warningTitle = (_jsx(Text, { bold: true, color: "yellow", children: "\u26A0\uFE0F Warning: Uncommitted Changes" }));
+        const warningMessage = (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: "The following worktrees have uncommitted changes that will be lost:" }), worktreesWithChanges.length <= 10 ? (worktreesWithChanges.map(wt => (_jsxs(Text, { color: "yellow", children: ["\u2022 ", wt.branch ? wt.branch.replace('refs/heads/', '') : 'detached', ' ', "(", wt.path, ")"] }, wt.path)))) : (_jsxs(_Fragment, { children: [worktreesWithChanges.slice(0, 8).map(wt => (_jsxs(Text, { color: "yellow", children: ["\u2022", ' ', wt.branch ? wt.branch.replace('refs/heads/', '') : 'detached', ' ', "(", wt.path, ")"] }, wt.path))), _jsxs(Text, { color: "yellow", dimColor: true, children: ["... and ", worktreesWithChanges.length - 8, " more worktrees"] })] })), _jsx(Box, { marginTop: 1, children: _jsx(Text, { children: "Do you want to continue?" }) })] }));
+        const warningHint = (_jsxs(Text, { dimColor: true, children: ["Use \u2191\u2193/j/k to navigate, Enter to select,", ' ', shortcutManager.getShortcutDisplay('cancel'), " to cancel"] }));
+        const handleWarningSelect = (value) => {
+            if (value === 'yes') {
+                if (hasAnyBranches) {
+                    setView('options');
+                }
+                else {
+                    setView('confirm');
+                }
+            }
+            else {
+                onCancel();
+            }
+        };
+        return (_jsx(Confirmation, { title: warningTitle, message: warningMessage, options: [
+                { label: 'Yes', value: 'yes', color: 'green' },
+                { label: 'No', value: 'no', color: 'red' },
+            ], onSelect: handleWarningSelect, initialIndex: 1, hint: warningHint, onCancel: onCancel }));
+    }
     if (hasAnyBranches && view === 'options') {
         return (_jsxs(Box, { flexDirection: "column", children: [title, _jsx(Box, { marginTop: 1, marginBottom: 1, children: message }), _jsxs(Box, { marginBottom: 1, flexDirection: "column", children: [_jsx(Text, { bold: true, children: "What do you want to do with the associated branches?" }), _jsx(Box, { marginTop: 1, children: _jsx(SelectInput, { items: branchOptions, onSelect: handleBranchSelect, onHighlight: (item) => {
                                     setFocusedOption(item.value);

package/dist/components/MergeWorktree.js

@@ -7,6 +7,7 @@ import { WorktreeService } from '../services/worktreeService.js';
 import Confirmation, { SimpleConfirmation } from './Confirmation.js';
 import { shortcutManager } from '../services/shortcutManager.js';
 import { GitError } from '../types/errors.js';
+import { hasUncommittedChanges } from '../utils/gitUtils.js';
 const MergeWorktree = ({ onComplete, onCancel, }) => {
     const [step, setStep] = useState('select-source');
     const [sourceBranch, setSourceBranch] = useState('');
@@ -83,8 +84,8 @@ const MergeWorktree = ({ onComplete, onCancel, }) => {
         const performMerge = async () => {
             try {
                 await Effect.runPromise(worktreeService.mergeWorktreeEffect(sourceBranch, targetBranch, useRebase));
-                // Merge successful, ask about deleting source branch
-                setStep('delete-confirm');
+                // Merge successful, check for uncommitted changes before asking about deletion
+                setStep('check-uncommitted');
             }
             catch (err) {
                 // Merge failed, show error
@@ -99,6 +100,29 @@ const MergeWorktree = ({ onComplete, onCancel, }) => {
         };
         performMerge();
     }, [step, sourceBranch, targetBranch, useRebase, worktreeService]);
+    // Check for uncommitted changes in source worktree when entering check-uncommitted step
+    useEffect(() => {
+        if (step !== 'check-uncommitted')
+            return;
+        const checkUncommitted = async () => {
+            try {
+                // Find the worktree path for the source branch
+                const worktrees = await Effect.runPromise(worktreeService.getWorktreesEffect());
+                const sourceWorktree = worktrees.find(wt => wt.branch && wt.branch.replace('refs/heads/', '') === sourceBranch);
+                if (sourceWorktree && hasUncommittedChanges(sourceWorktree.path)) {
+                    setStep('uncommitted-warning');
+                }
+                else {
+                    setStep('delete-confirm');
+                }
+            }
+            catch {
+                // On error, proceed to delete-confirm
+                setStep('delete-confirm');
+            }
+        };
+        checkUncommitted();
+    }, [step, sourceBranch, worktreeService]);
     if (isLoading) {
         return (_jsx(Box, { flexDirection: "column", children: _jsx(Text, { color: "cyan", children: "Loading worktrees..." }) }));
     }
@@ -134,6 +158,27 @@ const MergeWorktree = ({ onComplete, onCancel, }) => {
     if (step === 'merge-error') {
         return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { bold: true, color: "red", children: [useRebase ? 'Rebase' : 'Merge', " Failed"] }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: "red", children: mergeError }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Press any key to return to menu" }) })] }));
     }
+    if (step === 'check-uncommitted') {
+        return (_jsx(Box, { flexDirection: "column", children: _jsx(Text, { color: "cyan", children: "Checking for uncommitted changes..." }) }));
+    }
+    if (step === 'uncommitted-warning') {
+        const warningTitle = (_jsx(Text, { bold: true, color: "yellow", children: "Warning: Uncommitted Changes" }));
+        const warningMessage = (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: ["The source branch ", _jsx(Text, { color: "yellow", children: sourceBranch }), " has uncommitted changes that will be lost if you delete it."] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { children: "Do you still want to delete it?" }) })] }));
+        const warningHint = (_jsxs(Text, { dimColor: true, children: ["Use \u2191\u2193/j/k to navigate, Enter to select,", ' ', shortcutManager.getShortcutDisplay('cancel'), " to cancel"] }));
+        const handleWarningSelect = (value) => {
+            if (value === 'yes') {
+                setStep('delete-confirm');
+            }
+            else {
+                // User chose not to delete, complete without deletion
+                onComplete();
+            }
+        };
+        return (_jsx(Confirmation, { title: warningTitle, message: warningMessage, options: [
+                { label: 'Yes', value: 'yes', color: 'green' },
+                { label: 'No', value: 'no', color: 'red' },
+            ], onSelect: handleWarningSelect, initialIndex: 1, hint: warningHint, onCancel: onCancel }));
+    }
     if (step === 'delete-confirm') {
         const deleteMessage = (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "green", children: "Delete Source Branch?" }) }), _jsxs(Text, { children: ["Delete the merged branch ", _jsx(Text, { color: "yellow", children: sourceBranch }), ' ', "and its worktree?"] })] }));
         return (_jsx(SimpleConfirmation, { message: deleteMessage, onConfirm: async () => {

package/dist/services/stateDetector/base.d.ts

@@ -2,7 +2,7 @@ import { SessionState, Terminal } from '../../types/index.js';
 import { StateDetector } from './types.js';
 export declare abstract class BaseStateDetector implements StateDetector {
     abstract detectState(terminal: Terminal, currentState: SessionState): SessionState;
-    protected getTerminalLines(terminal: Terminal, maxLines?: number): string[];
-    protected getTerminalContent(terminal: Terminal, maxLines?: number): string;
+    protected getTerminalLines(terminal: Terminal, maxLines: number): string[];
+    protected getTerminalContent(terminal: Terminal, maxLines: number): string;
     abstract detectBackgroundTask(terminal: Terminal): number;
 }

package/dist/services/stateDetector/base.js

@@ -1,10 +1,10 @@
 import { getTerminalScreenContent } from '../../utils/screenCapture.js';
 export class BaseStateDetector {
-    getTerminalLines(terminal, maxLines = 30) {
+    getTerminalLines(terminal, maxLines) {
         const content = getTerminalScreenContent(terminal, maxLines);
         return content.split('\n');
     }
-    getTerminalContent(terminal, maxLines = 30) {
+    getTerminalContent(terminal, maxLines) {
         return getTerminalScreenContent(terminal, maxLines);
     }
 }

package/dist/services/stateDetector/kimi.js

@@ -7,7 +7,7 @@ import { BaseStateDetector } from './base.js';
  */
 export class KimiStateDetector extends BaseStateDetector {
     detectState(terminal, _currentState) {
-        const content = this.getTerminalContent(terminal);
+        const content = this.getTerminalContent(terminal, 30);
         const lowerContent = content.toLowerCase();
         // Check for permission/confirmation prompts - waiting_input state
         // Kimi CLI uses prompts like "Allow?", "Confirm?", "Yes/No" patterns

package/dist/utils/gitUtils.d.ts

@@ -1,3 +1,11 @@
+/**
+ * Check if a worktree or repository has uncommitted changes.
+ * This includes unstaged changes, staged changes, and untracked files.
+ *
+ * @param worktreePath - The path to the worktree or repository
+ * @returns true if there are uncommitted changes, false if clean
+ */
+export declare function hasUncommittedChanges(worktreePath: string): boolean;
 /**
  * Get the git repository root path from a given directory.
  * For worktrees, this returns the main repository root (parent of .git).

package/dist/utils/gitUtils.js

@@ -1,5 +1,26 @@
 import path from 'path';
 import { execSync } from 'child_process';
+/**
+ * Check if a worktree or repository has uncommitted changes.
+ * This includes unstaged changes, staged changes, and untracked files.
+ *
+ * @param worktreePath - The path to the worktree or repository
+ * @returns true if there are uncommitted changes, false if clean
+ */
+export function hasUncommittedChanges(worktreePath) {
+    try {
+        const output = execSync('git status --porcelain', {
+            cwd: worktreePath,
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+        return output.length > 0;
+    }
+    catch {
+        // Conservative default on error - treat as having changes
+        return true;
+    }
+}
 /**
  * Get the git repository root path from a given directory.
  * For worktrees, this returns the main repository root (parent of .git).

package/dist/utils/gitUtils.uncommitted.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/gitUtils.uncommitted.test.js

@@ -0,0 +1,92 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { execSync } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+import { hasUncommittedChanges } from './gitUtils.js';
+describe('hasUncommittedChanges', () => {
+    // Use os.tmpdir() and unique suffix to avoid conflicts with parallel tests
+    // Use realpathSync to resolve symlinks (e.g., /var -> /private/var on macOS)
+    const testDir = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'ccmanager-uncommitted-test-')));
+    const mainRepoDir = path.join(testDir, 'main-repo');
+    const worktreeDir = path.join(testDir, 'worktree-1');
+    beforeAll(() => {
+        // Clean up if exists
+        if (fs.existsSync(testDir)) {
+            fs.rmSync(testDir, { recursive: true, force: true });
+        }
+        // Create test directory structure
+        fs.mkdirSync(testDir, { recursive: true });
+        // Create main repository
+        fs.mkdirSync(mainRepoDir, { recursive: true });
+        execSync('git init', { cwd: mainRepoDir });
+        // Set git user for CI environment
+        execSync('git config user.email "test@test.com"', { cwd: mainRepoDir });
+        execSync('git config user.name "Test User"', { cwd: mainRepoDir });
+        fs.writeFileSync(path.join(mainRepoDir, 'README.md'), '# Main Repo');
+        execSync('git add README.md', { cwd: mainRepoDir });
+        execSync('git commit -m "Initial commit"', { cwd: mainRepoDir });
+        // Create a branch and worktree
+        execSync('git branch feature-branch', { cwd: mainRepoDir });
+        execSync(`git worktree add ${worktreeDir} feature-branch`, {
+            cwd: mainRepoDir,
+        });
+    });
+    afterAll(() => {
+        // Clean up worktree first
+        try {
+            execSync(`git worktree remove ${worktreeDir} --force`, {
+                cwd: mainRepoDir,
+            });
+        }
+        catch {
+            // Ignore errors
+        }
+        // Clean up
+        if (fs.existsSync(testDir)) {
+            fs.rmSync(testDir, { recursive: true, force: true });
+        }
+    });
+    it('should return false for a clean worktree', () => {
+        const result = hasUncommittedChanges(worktreeDir);
+        expect(result).toBe(false);
+    });
+    it('should return true for a worktree with unstaged changes', () => {
+        // Create an unstaged change
+        fs.writeFileSync(path.join(worktreeDir, 'README.md'), '# Modified');
+        const result = hasUncommittedChanges(worktreeDir);
+        expect(result).toBe(true);
+        // Restore the file
+        execSync('git checkout README.md', { cwd: worktreeDir });
+    });
+    it('should return true for a worktree with staged but uncommitted changes', () => {
+        // Create a staged change
+        fs.writeFileSync(path.join(worktreeDir, 'new-file.txt'), 'new content');
+        execSync('git add new-file.txt', { cwd: worktreeDir });
+        const result = hasUncommittedChanges(worktreeDir);
+        expect(result).toBe(true);
+        // Reset the change
+        execSync('git reset HEAD new-file.txt', { cwd: worktreeDir });
+        fs.unlinkSync(path.join(worktreeDir, 'new-file.txt'));
+    });
+    it('should return true for a worktree with untracked files', () => {
+        // Create an untracked file
+        fs.writeFileSync(path.join(worktreeDir, 'untracked.txt'), 'untracked');
+        const result = hasUncommittedChanges(worktreeDir);
+        expect(result).toBe(true);
+        // Clean up
+        fs.unlinkSync(path.join(worktreeDir, 'untracked.txt'));
+    });
+    it('should return false for a clean main repository', () => {
+        const result = hasUncommittedChanges(mainRepoDir);
+        expect(result).toBe(false);
+    });
+    it('should return true for a main repository with uncommitted changes', () => {
+        // Create an unstaged change
+        fs.writeFileSync(path.join(mainRepoDir, 'README.md'), '# Modified Main');
+        const result = hasUncommittedChanges(mainRepoDir);
+        expect(result).toBe(true);
+        // Restore the file
+        execSync('git checkout README.md', { cwd: mainRepoDir });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ccmanager",
-	"version": "3.7.0",
+	"version": "3.7.2",
 	"description": "TUI application for managing multiple Claude Code sessions across Git worktrees",
 	"license": "MIT",
 	"author": "Kodai Kabasawa",
@@ -41,11 +41,11 @@
 		"bin"
 	],
 	"optionalDependencies": {
-		"@kodaikabasawa/ccmanager-darwin-arm64": "3.7.0",
-		"@kodaikabasawa/ccmanager-darwin-x64": "3.7.0",
-		"@kodaikabasawa/ccmanager-linux-arm64": "3.7.0",
-		"@kodaikabasawa/ccmanager-linux-x64": "3.7.0",
-		"@kodaikabasawa/ccmanager-win32-x64": "3.7.0"
+		"@kodaikabasawa/ccmanager-darwin-arm64": "3.7.2",
+		"@kodaikabasawa/ccmanager-darwin-x64": "3.7.2",
+		"@kodaikabasawa/ccmanager-linux-arm64": "3.7.2",
+		"@kodaikabasawa/ccmanager-linux-x64": "3.7.2",
+		"@kodaikabasawa/ccmanager-win32-x64": "3.7.2"
 	},
 	"devDependencies": {
 		"@eslint/js": "^9.28.0",