ccmanager 0.2.1 → 1.1.0

package/README.md

@@ -1,17 +1,23 @@
-# CCManager - Claude Code Session Manager
+# CCManager - AI Code Assistant Session Manager
+
+CCManager is a TUI application for managing multiple AI coding assistant sessions (Claude Code, Gemini CLI) across Git worktrees.
+
+
+
+https://github.com/user-attachments/assets/15914a88-e288-4ac9-94d5-8127f2e19dbf
 
-CCManager is a TUI application for managing multiple Claude Code sessions across Git worktrees.
 
-https://github.com/user-attachments/assets/a6d80e73-dc06-4ef8-849d-e3857f6c7024
 
 ## Features
 
-- Run multiple Claude Code sessions in parallel across different Git worktrees
+- Run multiple AI assistant sessions in parallel across different Git worktrees
+- Support for multiple AI coding assistants (Claude Code, Gemini CLI)
 - Switch between sessions seamlessly
 - Visual status indicators for session states (busy, waiting, idle)
 - Create, merge, and delete worktrees from within the app
 - Configurable keyboard shortcuts
-- Command configuration with automatic fallback support
+- Command presets with automatic fallback support
+- Configurable state detection strategies for different CLI tools
 - Status change hooks for automation and notifications
 
 ## Why CCManager over Claude Squad?
@@ -50,13 +56,6 @@ $ npm start
 $ npx ccmanager
 ```
 
-## Environment Variables
-
-### CCMANAGER_CLAUDE_ARGS
-
-⚠️ **Deprecated in v0.1.9**: `CCMANAGER_CLAUDE_ARGS` is no longer supported. Please use the [Command Configuration](#command-configuration) feature instead.
-
-
 ## Keyboard Shortcuts
 
 ### Default Shortcuts
@@ -69,7 +68,7 @@ $ npx ccmanager
 You can customize keyboard shortcuts in two ways:
 
 1. **Through the UI**: Select "Configuration" → "Configure Shortcuts" from the main menu
-2. **Configuration file**: Edit `~/.config/ccmanager/config.json` (or legacy `~/.config/ccmanager/shortcuts.json`)
+2. **Configuration file**: Edit `~/.config/ccmanager/config.json`
 
 Example configuration:
 ```json
@@ -85,17 +84,6 @@ Example configuration:
     }
   }
 }
-
-// shortcuts.json (legacy format, still supported)
-{
-  "returnToMenu": {
-    "ctrl": true,
-    "key": "r"
-  },
-  "cancel": {
-    "key": "escape"
-  }
-}
 ```
 
 Note: Shortcuts from `shortcuts.json` will be automatically migrated to `config.json` on first use.
@@ -108,6 +96,26 @@ Note: Shortcuts from `shortcuts.json` will be automatically migrated to `config.
   - Ctrl+D
   - Ctrl+[ (equivalent to Escape)
 
+## Supported AI Assistants
+
+CCManager now supports multiple AI coding assistants with tailored state detection:
+
+### Claude Code (Default)
+- Command: `claude`
+- State detection: Built-in patterns for Claude's prompts and status messages
+
+### Gemini CLI
+- Command: `gemini`
+- State detection: Custom patterns for Gemini's confirmation prompts
+- Installation: [google-gemini/gemini-cli](https://github.com/google-gemini/gemini-cli)
+
+Each assistant has its own state detection strategy to properly track:
+- **Idle**: Ready for new input
+- **Busy**: Processing a request
+- **Waiting**: Awaiting user confirmation
+
+See [Gemini Support Documentation](docs/gemini-support.md) for detailed configuration instructions.
+
 
 ## Command Configuration
 
@@ -145,7 +153,33 @@ Status hooks allow you to:
 - Trigger automations based on session activity
 - Integrate with notification systems like [noti](https://github.com/variadico/noti)
 
-For detailed setup instructions, see [docs/state-hooks.md](docs/state-hooks.md).
+For detailed setup instructions, see [docs/state-hooks.md](docs/status-hooks.md).
+
+## Automatic Worktree Directory Generation
+
+CCManager can automatically generate worktree directory paths based on branch names, streamlining the worktree creation process.
+
+- **Auto-generate paths**: No need to manually specify directories
+- **Customizable patterns**: Use placeholders like `{branch}` in your pattern
+- **Smart sanitization**: Branch names are automatically made filesystem-safe
+
+For detailed configuration and examples, see [docs/worktree-auto-directory.md](docs/worktree-auto-directory.md).
+
+## Git Worktree Configuration
+
+CCManager can display enhanced git status information for each worktree when Git's worktree configuration extension is enabled.
+
+```bash
+# Enable enhanced status tracking
+git config extensions.worktreeConfig true
+```
+
+With this enabled, you'll see:
+- **File changes**: `+10 -5` (additions/deletions)
+- **Commit tracking**: `↑3 ↓1` (ahead/behind parent branch)
+- **Parent branch context**: Shows which branch the worktree was created from
+
+For complete setup instructions and troubleshooting, see [docs/git-worktree-config.md](docs/git-worktree-config.md).
 
 ## Development
 

package/dist/components/ConfigureCommand.js

@@ -4,6 +4,17 @@ import TextInput from 'ink-text-input';
 import SelectInput from 'ink-select-input';
 import { configurationManager } from '../services/configurationManager.js';
 import { shortcutManager } from '../services/shortcutManager.js';
+const formatDetectionStrategy = (strategy) => {
+    const value = strategy || 'claude';
+    switch (value) {
+        case 'gemini':
+            return 'Gemini';
+        case 'codex':
+            return 'Codex';
+        default:
+            return 'Claude';
+    }
+};
 const ConfigureCommand = ({ onComplete }) => {
     const presetsConfig = configurationManager.getCommandPresets();
     const [presets, setPresets] = useState(presetsConfig.presets);
@@ -14,52 +25,52 @@ const ConfigureCommand = ({ onComplete }) => {
     const [selectedIndex, setSelectedIndex] = useState(0);
     const [editField, setEditField] = useState(null);
     const [inputValue, setInputValue] = useState('');
+    const [isSelectingStrategy, setIsSelectingStrategy] = useState(false);
+    const [isSelectingStrategyInAdd, setIsSelectingStrategyInAdd] = useState(false);
     const [newPreset, setNewPreset] = useState({});
     const [addStep, setAddStep] = useState('name');
     const [errorMessage, setErrorMessage] = useState(null);
     // Remove handleListNavigation as SelectInput handles navigation internally
     // Remove handleListSelection as we now use handleSelectItem
-    const handleEditNavigation = (key) => {
-        const menuItems = 7; // name, command, args, fallbackArgs, set default, delete, back
-        if (key.upArrow) {
-            setSelectedIndex(prev => (prev > 0 ? prev - 1 : menuItems - 1));
-        }
-        else if (key.downArrow) {
-            setSelectedIndex(prev => (prev < menuItems - 1 ? prev + 1 : 0));
+    const handleEditMenuSelect = (item) => {
+        // Ignore separator selections
+        if (item.value.startsWith('separator')) {
+            return;
         }
-    };
-    const handleEditSelection = () => {
         const preset = presets.find(p => p.id === selectedPresetId);
         if (!preset)
             return;
-        switch (selectedIndex) {
-            case 0: // Name
+        switch (item.value) {
+            case 'name':
                 setEditField('name');
                 setInputValue(preset.name);
                 break;
-            case 1: // Command
+            case 'command':
                 setEditField('command');
                 setInputValue(preset.command);
                 break;
-            case 2: // Args
+            case 'args':
                 setEditField('args');
                 setInputValue(preset.args?.join(' ') || '');
                 break;
-            case 3: // Fallback Args
+            case 'fallbackArgs':
                 setEditField('fallbackArgs');
                 setInputValue(preset.fallbackArgs?.join(' ') || '');
                 break;
-            case 4: // Set as Default
+            case 'detectionStrategy':
+                setIsSelectingStrategy(true);
+                break;
+            case 'setDefault':
                 setDefaultPresetId(preset.id);
                 configurationManager.setDefaultPreset(preset.id);
                 break;
-            case 5: // Delete
+            case 'delete':
                 if (presets.length > 1) {
                     setViewMode('delete-confirm');
                     setSelectedIndex(0);
                 }
                 break;
-            case 6: // Back
+            case 'back':
                 setViewMode('list');
                 setSelectedIndex(presets.findIndex(p => p.id === selectedPresetId));
                 break;
@@ -129,23 +140,45 @@ const ConfigureCommand = ({ onComplete }) => {
                 const fallbackArgs = value.trim()
                     ? value.trim().split(/\s+/)
                     : undefined;
-                const id = Date.now().toString();
-                const completePreset = {
-                    id,
-                    name: newPreset.name || 'New Preset',
-                    command: newPreset.command || 'claude',
-                    args: newPreset.args,
-                    fallbackArgs,
-                };
-                const updatedPresets = [...presets, completePreset];
-                setPresets(updatedPresets);
-                configurationManager.addPreset(completePreset);
-                setViewMode('list');
-                setSelectedIndex(updatedPresets.length - 1);
+                setNewPreset({ ...newPreset, fallbackArgs });
+                setAddStep('detectionStrategy');
+                setIsSelectingStrategyInAdd(true);
                 break;
             }
         }
     };
+    const handleStrategySelect = (item) => {
+        const preset = presets.find(p => p.id === selectedPresetId);
+        if (!preset)
+            return;
+        const updatedPreset = { ...preset };
+        updatedPreset.detectionStrategy = item.value;
+        const updatedPresets = presets.map(p => p.id === preset.id ? updatedPreset : p);
+        setPresets(updatedPresets);
+        configurationManager.addPreset(updatedPreset);
+        setIsSelectingStrategy(false);
+    };
+    const handleAddStrategySelect = (item) => {
+        const id = Date.now().toString();
+        const completePreset = {
+            id,
+            name: newPreset.name || 'New Preset',
+            command: newPreset.command || 'claude',
+            args: newPreset.args,
+            fallbackArgs: newPreset.fallbackArgs,
+            detectionStrategy: item.value,
+        };
+        const updatedPresets = [...presets, completePreset];
+        setPresets(updatedPresets);
+        configurationManager.addPreset(completePreset);
+        setViewMode('list');
+        setSelectedIndex(updatedPresets.length - 1);
+        setNewPreset({});
+        setAddStep('name');
+        setInputValue('');
+        setIsSelectingStrategyInAdd(false);
+        setErrorMessage(null);
+    };
     const handleDeleteConfirm = () => {
         if (selectedIndex === 0) {
             // Yes, delete
@@ -166,12 +199,21 @@ const ConfigureCommand = ({ onComplete }) => {
         else {
             // Cancel
             setViewMode('edit');
-            setSelectedIndex(5); // Back to delete option
+            setSelectedIndex(6); // Back to delete option (index updated for new field)
         }
     };
     useInput((input, key) => {
         if (shortcutManager.matchesShortcut('cancel', input, key)) {
-            if (editField) {
+            if (isSelectingStrategy) {
+                setIsSelectingStrategy(false);
+            }
+            else if (isSelectingStrategyInAdd) {
+                setIsSelectingStrategyInAdd(false);
+                setViewMode('list');
+                setAddStep('name');
+                setNewPreset({});
+            }
+            else if (editField) {
                 setEditField(null);
                 setInputValue('');
                 setErrorMessage(null);
@@ -188,27 +230,26 @@ const ConfigureCommand = ({ onComplete }) => {
             }
             else if (viewMode === 'delete-confirm') {
                 setViewMode('edit');
-                setSelectedIndex(5);
+                setSelectedIndex(6); // Updated index for delete option
             }
             else {
                 onComplete();
             }
             return;
         }
-        if (editField || (viewMode === 'add' && inputValue !== undefined)) {
-            // In input mode, let TextInput handle it
+        if (editField ||
+            (viewMode === 'add' &&
+                inputValue !== undefined &&
+                !isSelectingStrategyInAdd) ||
+            isSelectingStrategy ||
+            isSelectingStrategyInAdd) {
+            // In input mode, let TextInput or SelectInput handle it
             return;
         }
-        if (viewMode === 'list') {
+        if (viewMode === 'list' || viewMode === 'edit') {
             // SelectInput handles navigation and selection
             return;
         }
-        else if (viewMode === 'edit') {
-            handleEditNavigation(key);
-            if (key.return) {
-                handleEditSelection();
-            }
-        }
         else if (viewMode === 'delete-confirm') {
             if (key.upArrow || key.downArrow) {
                 setSelectedIndex(prev => (prev === 0 ? 1 : 0));
@@ -218,6 +259,31 @@ const ConfigureCommand = ({ onComplete }) => {
             }
         }
     });
+    // Render strategy selection
+    if (isSelectingStrategy) {
+        const preset = presets.find(p => p.id === selectedPresetId);
+        if (!preset)
+            return null;
+        const strategyItems = [
+            { label: 'Claude', value: 'claude' },
+            { label: 'Gemini', value: 'gemini' },
+            { label: 'Codex', value: 'codex' },
+        ];
+        const currentStrategy = preset.detectionStrategy || 'claude';
+        const initialIndex = strategyItems.findIndex(item => item.value === currentStrategy);
+        return (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { bold: true, color: "green" }, "Select Detection Strategy")),
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, null, "Choose the state detection strategy for this preset:")),
+            React.createElement(SelectInput, { items: strategyItems, onSelect: handleStrategySelect, initialIndex: initialIndex }),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true },
+                    "Press Enter to select,",
+                    ' ',
+                    shortcutManager.getShortcutDisplay('cancel'),
+                    " to cancel"))));
+    }
     // Render input field
     if (editField) {
         const titles = {
@@ -246,6 +312,25 @@ const ConfigureCommand = ({ onComplete }) => {
     }
     // Render add preset form
     if (viewMode === 'add') {
+        if (isSelectingStrategyInAdd) {
+            const strategyItems = [
+                { label: 'Claude', value: 'claude' },
+                { label: 'Gemini', value: 'gemini' },
+                { label: 'Codex', value: 'codex' },
+            ];
+            return (React.createElement(Box, { flexDirection: "column" },
+                React.createElement(Box, { marginBottom: 1 },
+                    React.createElement(Text, { bold: true, color: "green" }, "Add New Preset - Detection Strategy")),
+                React.createElement(Box, { marginBottom: 1 },
+                    React.createElement(Text, null, "Choose the state detection strategy for this preset:")),
+                React.createElement(SelectInput, { items: strategyItems, onSelect: handleAddStrategySelect, initialIndex: 0 }),
+                React.createElement(Box, { marginTop: 1 },
+                    React.createElement(Text, { dimColor: true },
+                        "Press Enter to select,",
+                        ' ',
+                        shortcutManager.getShortcutDisplay('cancel'),
+                        " to cancel"))));
+        }
         const titles = {
             name: 'Enter preset name:',
             command: 'Enter command (e.g., claude):',
@@ -302,30 +387,49 @@ const ConfigureCommand = ({ onComplete }) => {
             return null;
         const isDefault = preset.id === defaultPresetId;
         const canDelete = presets.length > 1;
-        const menuItems = [
-            { label: 'Name', value: preset.name },
-            { label: 'Command', value: preset.command },
-            { label: 'Arguments', value: preset.args?.join(' ') || '(none)' },
+        const editMenuItems = [
+            {
+                label: `Name: ${preset.name}`,
+                value: 'name',
+            },
+            {
+                label: `Command: ${preset.command}`,
+                value: 'command',
+            },
+            {
+                label: `Arguments: ${preset.args?.join(' ') || '(none)'}`,
+                value: 'args',
+            },
+            {
+                label: `Fallback Arguments: ${preset.fallbackArgs?.join(' ') || '(none)'}`,
+                value: 'fallbackArgs',
+            },
             {
-                label: 'Fallback Arguments',
-                value: preset.fallbackArgs?.join(' ') || '(none)',
+                label: `Detection Strategy: ${formatDetectionStrategy(preset.detectionStrategy)}`,
+                value: 'detectionStrategy',
             },
+            { label: '─────────────────────────', value: 'separator1' },
             {
-                label: isDefault ? 'Already Default' : 'Set as Default',
-                value: '',
-                isButton: true,
-                disabled: isDefault,
+                label: isDefault ? '⭐ Already Default' : 'Set as Default',
+                value: 'setDefault',
             },
             {
                 label: canDelete
                     ? 'Delete Preset'
                     : 'Delete Preset (cannot delete last preset)',
-                value: '',
-                isButton: true,
-                disabled: !canDelete,
+                value: 'delete',
             },
-            { label: 'Back to List', value: '', isButton: true, disabled: false },
+            { label: '─────────────────────────', value: 'separator2' },
+            { label: '← Back to List', value: 'back' },
         ];
+        // Filter out disabled items for SelectInput
+        const selectableItems = editMenuItems.filter(item => {
+            if (item.value === 'setDefault' && isDefault)
+                return false;
+            if (item.value === 'delete' && !canDelete)
+                return false;
+            return true;
+        });
         return (React.createElement(Box, { flexDirection: "column" },
             React.createElement(Box, { marginBottom: 1 },
                 React.createElement(Text, { bold: true, color: "green" },
@@ -333,18 +437,7 @@ const ConfigureCommand = ({ onComplete }) => {
                     preset.name)),
             isDefault && (React.createElement(Box, { marginBottom: 1 },
                 React.createElement(Text, { color: "yellow" }, "\u2B50 This is the default preset"))),
-            React.createElement(Box, { flexDirection: "column" }, menuItems.map((item, index) => {
-                const isSelected = selectedIndex === index;
-                const color = item.disabled
-                    ? 'gray'
-                    : isSelected
-                        ? 'cyan'
-                        : undefined;
-                return (React.createElement(Box, { key: index, marginTop: item.isButton && index > 0 ? 1 : 0 },
-                    React.createElement(Text, { color: color },
-                        isSelected ? '> ' : '  ',
-                        item.isButton ? (React.createElement(Text, { bold: isSelected && !item.disabled, dimColor: item.disabled }, item.label)) : (`${item.label}: ${item.value}`))));
-            })),
+            React.createElement(SelectInput, { items: selectableItems, onSelect: handleEditMenuSelect }),
             React.createElement(Box, { marginTop: 1 },
                 React.createElement(Text, { dimColor: true },
                     "Press \u2191\u2193 to navigate, Enter to edit/select,",
@@ -366,6 +459,7 @@ const ConfigureCommand = ({ onComplete }) => {
                 label += `\n    Args: ${args}`;
             if (fallback)
                 label += `\n    Fallback: ${fallback}`;
+            label += `\n    Detection: ${formatDetectionStrategy(preset.detectionStrategy)}`;
             return {
                 label,
                 value: preset.id,

package/dist/services/sessionManager.d.ts

@@ -1,13 +1,11 @@
 import { Session, SessionManager as ISessionManager, SessionState } from '../types/index.js';
 import { EventEmitter } from 'events';
-import pkg from '@xterm/headless';
-declare const Terminal: typeof pkg.Terminal;
 export declare class SessionManager extends EventEmitter implements ISessionManager {
     sessions: Map<string, Session>;
     private waitingWithBottomBorder;
     private busyTimers;
     private spawn;
-    detectTerminalState(terminal: InstanceType<typeof Terminal>): SessionState;
+    detectTerminalState(session: Session): SessionState;
     constructor();
     createSession(worktreePath: string): Promise<Session>;
     createSessionWithPreset(worktreePath: string, presetId?: string): Promise<Session>;
@@ -22,4 +20,3 @@ export declare class SessionManager extends EventEmitter implements ISessionMana
     private executeStatusHook;
     destroy(): void;
 }
-export {};

package/dist/services/sessionManager.js

@@ -4,6 +4,7 @@ import pkg from '@xterm/headless';
 import { exec } from 'child_process';
 import { configurationManager } from './configurationManager.js';
 import { WorktreeService } from './worktreeService.js';
+import { createStateDetector } from './stateDetector.js';
 const { Terminal } = pkg;
 export class SessionManager extends EventEmitter {
     async spawn(command, args, worktreePath) {
@@ -16,35 +17,11 @@ export class SessionManager extends EventEmitter {
         };
         return spawn(command, args, spawnOptions);
     }
-    detectTerminalState(terminal) {
-        // Get the last 30 lines from the terminal buffer
-        const buffer = terminal.buffer.active;
-        const lines = [];
-        // Start from the bottom and work our way up
-        for (let i = buffer.length - 1; i >= 0 && lines.length < 30; i--) {
-            const line = buffer.getLine(i);
-            if (line) {
-                const text = line.translateToString(true);
-                // Skip empty lines at the bottom
-                if (lines.length > 0 || text.trim() !== '') {
-                    lines.unshift(text);
-                }
-            }
-        }
-        // Join lines and check for patterns
-        const content = lines.join('\n');
-        const lowerContent = content.toLowerCase();
-        // Check for waiting prompts with box character
-        if (content.includes('│ Do you want') ||
-            content.includes('│ Would you like')) {
-            return 'waiting_input';
-        }
-        // Check for busy state
-        if (lowerContent.includes('esc to interrupt')) {
-            return 'busy';
-        }
-        // Otherwise idle
-        return 'idle';
+    detectTerminalState(session) {
+        // Create a detector based on the session's detection strategy
+        const strategy = session.detectionStrategy || 'claude';
+        const detector = createStateDetector(strategy);
+        return detector.detectState(session.terminal);
     }
     constructor() {
         super();
@@ -101,6 +78,7 @@ export class SessionManager extends EventEmitter {
             terminal,
             isPrimaryCommand: true,
             commandConfig,
+            detectionStrategy: 'claude', // Default to claude for legacy method
         };
         // Set up persistent background data handler for state detection
         this.setupBackgroundHandler(session);
@@ -170,6 +148,7 @@ export class SessionManager extends EventEmitter {
             terminal,
             isPrimaryCommand,
             commandConfig,
+            detectionStrategy: preset.detectionStrategy || 'claude',
         };
         // Set up persistent background data handler for state detection
         this.setupBackgroundHandler(session);
@@ -234,7 +213,7 @@ export class SessionManager extends EventEmitter {
         // Set up interval-based state detection
         session.stateCheckInterval = setInterval(() => {
             const oldState = session.state;
-            const newState = this.detectTerminalState(session.terminal);
+            const newState = this.detectTerminalState(session);
             if (newState !== oldState) {
                 session.state = newState;
                 this.executeStatusHook(oldState, newState, session);

package/dist/services/stateDetector.d.ts

@@ -0,0 +1,19 @@
+import { SessionState, Terminal, StateDetectionStrategy } from '../types/index.js';
+export interface StateDetector {
+    detectState(terminal: Terminal): SessionState;
+}
+export declare function createStateDetector(strategy?: StateDetectionStrategy): StateDetector;
+export declare abstract class BaseStateDetector implements StateDetector {
+    abstract detectState(terminal: Terminal): SessionState;
+    protected getTerminalLines(terminal: Terminal, maxLines?: number): string[];
+    protected getTerminalContent(terminal: Terminal, maxLines?: number): string;
+}
+export declare class ClaudeStateDetector extends BaseStateDetector {
+    detectState(terminal: Terminal): SessionState;
+}
+export declare class GeminiStateDetector extends BaseStateDetector {
+    detectState(terminal: Terminal): SessionState;
+}
+export declare class CodexStateDetector extends BaseStateDetector {
+    detectState(terminal: Terminal): SessionState;
+}

package/dist/services/stateDetector.js

@@ -0,0 +1,87 @@
+export function createStateDetector(strategy = 'claude') {
+    switch (strategy) {
+        case 'claude':
+            return new ClaudeStateDetector();
+        case 'gemini':
+            return new GeminiStateDetector();
+        case 'codex':
+            return new CodexStateDetector();
+        default:
+            return new ClaudeStateDetector();
+    }
+}
+export class BaseStateDetector {
+    getTerminalLines(terminal, maxLines = 30) {
+        const buffer = terminal.buffer.active;
+        const lines = [];
+        // Start from the bottom and work our way up
+        for (let i = buffer.length - 1; i >= 0 && lines.length < maxLines; i--) {
+            const line = buffer.getLine(i);
+            if (line) {
+                const text = line.translateToString(true);
+                // Skip empty lines at the bottom
+                if (lines.length > 0 || text.trim() !== '') {
+                    lines.unshift(text);
+                }
+            }
+        }
+        return lines;
+    }
+    getTerminalContent(terminal, maxLines = 30) {
+        return this.getTerminalLines(terminal, maxLines).join('\n');
+    }
+}
+export class ClaudeStateDetector extends BaseStateDetector {
+    detectState(terminal) {
+        const content = this.getTerminalContent(terminal);
+        const lowerContent = content.toLowerCase();
+        // Check for waiting prompts with box character
+        if (content.includes('│ Do you want') ||
+            content.includes('│ Would you like')) {
+            return 'waiting_input';
+        }
+        // Check for busy state
+        if (lowerContent.includes('esc to interrupt')) {
+            return 'busy';
+        }
+        // Otherwise idle
+        return 'idle';
+    }
+}
+// https://github.com/google-gemini/gemini-cli/blob/main/packages/cli/src/ui/components/messages/ToolConfirmationMessage.tsx
+export class GeminiStateDetector extends BaseStateDetector {
+    detectState(terminal) {
+        const content = this.getTerminalContent(terminal);
+        const lowerContent = content.toLowerCase();
+        // Check for waiting prompts with box character
+        if (content.includes('│ Apply this change?') ||
+            content.includes('│ Allow execution?') ||
+            content.includes('│ Do you want to proceed?')) {
+            return 'waiting_input';
+        }
+        // Check for busy state
+        if (lowerContent.includes('esc to cancel')) {
+            return 'busy';
+        }
+        // Otherwise idle
+        return 'idle';
+    }
+}
+export class CodexStateDetector extends BaseStateDetector {
+    detectState(terminal) {
+        const content = this.getTerminalContent(terminal);
+        const lowerContent = content.toLowerCase();
+        // Check for waiting prompts
+        if (content.includes('│Allow') ||
+            content.includes('[y/N]') ||
+            content.includes('Press any key')) {
+            return 'waiting_input';
+        }
+        // Check for busy state
+        if (lowerContent.includes('press esc')) {
+            return 'busy';
+        }
+        // Otherwise idle
+        return 'idle';
+    }
+}

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

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

package/dist/services/stateDetector.test.js

@@ -0,0 +1,333 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { ClaudeStateDetector, GeminiStateDetector, CodexStateDetector, } from './stateDetector.js';
+describe('ClaudeStateDetector', () => {
+    let detector;
+    let terminal;
+    const createMockTerminal = (lines) => {
+        const buffer = {
+            length: lines.length,
+            getLine: (index) => {
+                if (index >= 0 && index < lines.length) {
+                    return {
+                        translateToString: () => lines[index],
+                    };
+                }
+                return null;
+            },
+        };
+        return {
+            buffer: {
+                active: buffer,
+            },
+        };
+    };
+    beforeEach(() => {
+        detector = new ClaudeStateDetector();
+    });
+    describe('detectState', () => {
+        it('should detect waiting_input when "Do you want" prompt is present', () => {
+            // Arrange
+            terminal = createMockTerminal([
+                'Some previous output',
+                '│ Do you want to continue? (y/n)',
+                '│ > ',
+            ]);
+            // Act
+            const state = detector.detectState(terminal);
+            // Assert
+            expect(state).toBe('waiting_input');
+        });
+        it('should detect waiting_input when "Would you like" prompt is present', () => {
+            // Arrange
+            terminal = createMockTerminal([
+                'Some output',
+                '│ Would you like to save changes?',
+                '│ > ',
+            ]);
+            // Act
+            const state = detector.detectState(terminal);
+            // Assert
+            expect(state).toBe('waiting_input');
+        });
+        it('should detect busy when "ESC to interrupt" is present', () => {
+            // Arrange
+            terminal = createMockTerminal([
+                'Processing...',
+                'Press ESC to interrupt',
+            ]);
+            // Act
+            const state = detector.detectState(terminal);
+            // Assert
+            expect(state).toBe('busy');
+        });
+        it('should detect busy when "esc to interrupt" is present (case insensitive)', () => {
+            // Arrange
+            terminal = createMockTerminal([
+                'Running command...',
+                'press esc to interrupt the process',
+            ]);
+            // Act
+            const state = detector.detectState(terminal);
+            // Assert
+            expect(state).toBe('busy');
+        });
+        it('should detect idle when no specific patterns are found', () => {
+            // Arrange
+            terminal = createMockTerminal([
+                'Command completed successfully',
+                'Ready for next command',
+                '> ',
+            ]);
+            // Act
+            const state = detector.detectState(terminal);
+            // Assert
+            expect(state).toBe('idle');
+        });
+        it('should handle empty terminal', () => {
+            // Arrange
+            terminal = createMockTerminal([]);
+            // Act
+            const state = detector.detectState(terminal);
+            // Assert
+            expect(state).toBe('idle');
+        });
+        it('should only consider last 30 lines', () => {
+            // Arrange
+            const lines = [];
+            // Add more than 30 lines
+            for (let i = 0; i < 40; i++) {
+                lines.push(`Line ${i}`);
+            }
+            // The "Do you want" should be outside the 30 line window
+            lines.push('│ Do you want to continue?');
+            // Add 30 more lines to push it out
+            for (let i = 0; i < 30; i++) {
+                lines.push(`Recent line ${i}`);
+            }
+            terminal = createMockTerminal(lines);
+            // Act
+            const state = detector.detectState(terminal);
+            // Assert
+            expect(state).toBe('idle'); // Should not detect the old prompt
+        });
+        it('should prioritize waiting_input over busy state', () => {
+            // Arrange
+            terminal = createMockTerminal([
+                'Press ESC to interrupt',
+                '│ Do you want to continue?',
+                '│ > ',
+            ]);
+            // Act
+            const state = detector.detectState(terminal);
+            // Assert
+            expect(state).toBe('waiting_input'); // waiting_input should take precedence
+        });
+    });
+});
+describe('GeminiStateDetector', () => {
+    let detector;
+    let terminal;
+    const createMockTerminal = (lines) => {
+        const buffer = {
+            length: lines.length,
+            getLine: (index) => {
+                if (index >= 0 && index < lines.length) {
+                    return {
+                        translateToString: () => lines[index],
+                    };
+                }
+                return null;
+            },
+        };
+        return {
+            buffer: {
+                active: buffer,
+            },
+        };
+    };
+    beforeEach(() => {
+        detector = new GeminiStateDetector();
+    });
+    describe('detectState', () => {
+        it('should detect waiting_input when "Apply this change?" prompt is present', () => {
+            // Arrange
+            terminal = createMockTerminal([
+                'Some output from Gemini',
+                '│ Apply this change?',
+                '│ > ',
+            ]);
+            // Act
+            const state = detector.detectState(terminal);
+            // Assert
+            expect(state).toBe('waiting_input');
+        });
+        it('should detect waiting_input when "Allow execution?" prompt is present', () => {
+            // Arrange
+            terminal = createMockTerminal([
+                'Command found: npm install',
+                '│ Allow execution?',
+                '│ > ',
+            ]);
+            // Act
+            const state = detector.detectState(terminal);
+            // Assert
+            expect(state).toBe('waiting_input');
+        });
+        it('should detect waiting_input when "Do you want to proceed?" prompt is present', () => {
+            // Arrange
+            terminal = createMockTerminal([
+                'Changes detected',
+                '│ Do you want to proceed?',
+                '│ > ',
+            ]);
+            // Act
+            const state = detector.detectState(terminal);
+            // Assert
+            expect(state).toBe('waiting_input');
+        });
+        it('should detect busy when "esc to cancel" is present', () => {
+            // Arrange
+            terminal = createMockTerminal([
+                'Processing your request...',
+                'Press ESC to cancel',
+            ]);
+            // Act
+            const state = detector.detectState(terminal);
+            // Assert
+            expect(state).toBe('busy');
+        });
+        it('should detect busy when "ESC to cancel" is present (case insensitive)', () => {
+            // Arrange
+            terminal = createMockTerminal([
+                'Running command...',
+                'Press Esc to cancel the operation',
+            ]);
+            // Act
+            const state = detector.detectState(terminal);
+            // Assert
+            expect(state).toBe('busy');
+        });
+        it('should detect idle when no specific patterns are found', () => {
+            // Arrange
+            terminal = createMockTerminal([
+                'Welcome to Gemini CLI',
+                'Type your message below',
+            ]);
+            // Act
+            const state = detector.detectState(terminal);
+            // Assert
+            expect(state).toBe('idle');
+        });
+        it('should handle empty terminal', () => {
+            // Arrange
+            terminal = createMockTerminal([]);
+            // Act
+            const state = detector.detectState(terminal);
+            // Assert
+            expect(state).toBe('idle');
+        });
+        it('should prioritize waiting_input over busy state', () => {
+            // Arrange
+            terminal = createMockTerminal([
+                'Press ESC to cancel',
+                '│ Apply this change?',
+                '│ > ',
+            ]);
+            // Act
+            const state = detector.detectState(terminal);
+            // Assert
+            expect(state).toBe('waiting_input'); // waiting_input should take precedence
+        });
+    });
+});
+describe('CodexStateDetector', () => {
+    let detector;
+    let terminal;
+    const createMockTerminal = (lines) => {
+        const buffer = {
+            length: lines.length,
+            active: {
+                length: lines.length,
+                getLine: (index) => {
+                    if (index >= 0 && index < lines.length) {
+                        return {
+                            translateToString: () => lines[index],
+                        };
+                    }
+                    return null;
+                },
+            },
+        };
+        return { buffer };
+    };
+    beforeEach(() => {
+        detector = new CodexStateDetector();
+    });
+    it('should detect waiting_input state for │Allow pattern', () => {
+        // Arrange
+        terminal = createMockTerminal(['Some output', '│Allow execution?', '│ > ']);
+        // Act
+        const state = detector.detectState(terminal);
+        // Assert
+        expect(state).toBe('waiting_input');
+    });
+    it('should detect waiting_input state for [y/N] pattern', () => {
+        // Arrange
+        terminal = createMockTerminal(['Some output', 'Continue? [y/N]', '> ']);
+        // Act
+        const state = detector.detectState(terminal);
+        // Assert
+        expect(state).toBe('waiting_input');
+    });
+    it('should detect waiting_input state for Press any key pattern', () => {
+        // Arrange
+        terminal = createMockTerminal([
+            'Some output',
+            'Press any key to continue...',
+        ]);
+        // Act
+        const state = detector.detectState(terminal);
+        // Assert
+        expect(state).toBe('waiting_input');
+    });
+    it('should detect busy state for press esc pattern', () => {
+        // Arrange
+        terminal = createMockTerminal([
+            'Processing...',
+            'press esc to cancel',
+            'Working...',
+        ]);
+        // Act
+        const state = detector.detectState(terminal);
+        // Assert
+        expect(state).toBe('busy');
+    });
+    it('should detect busy state for PRESS ESC (uppercase)', () => {
+        // Arrange
+        terminal = createMockTerminal([
+            'Processing...',
+            'PRESS ESC to stop',
+            'Working...',
+        ]);
+        // Act
+        const state = detector.detectState(terminal);
+        // Assert
+        expect(state).toBe('busy');
+    });
+    it('should detect idle state when no patterns match', () => {
+        // Arrange
+        terminal = createMockTerminal(['Normal output', 'Some message', 'Ready']);
+        // Act
+        const state = detector.detectState(terminal);
+        // Assert
+        expect(state).toBe('idle');
+    });
+    it('should prioritize waiting_input over busy', () => {
+        // Arrange
+        terminal = createMockTerminal(['press esc to cancel', '[y/N]']);
+        // Act
+        const state = detector.detectState(terminal);
+        // Assert
+        expect(state).toBe('waiting_input');
+    });
+});

package/dist/types/index.d.ts

@@ -3,6 +3,7 @@ import type pkg from '@xterm/headless';
 import { GitStatus } from '../utils/gitStatus.js';
 export type Terminal = InstanceType<typeof pkg.Terminal>;
 export type SessionState = 'idle' | 'busy' | 'waiting_input';
+export type StateDetectionStrategy = 'claude' | 'gemini' | 'codex';
 export interface Worktree {
     path: string;
     branch?: string;
@@ -24,6 +25,7 @@ export interface Session {
     stateCheckInterval?: NodeJS.Timeout;
     isPrimaryCommand?: boolean;
     commandConfig?: CommandConfig;
+    detectionStrategy?: StateDetectionStrategy;
 }
 export interface SessionManager {
     sessions: Map<string, Session>;
@@ -67,6 +69,7 @@ export interface CommandPreset {
     command: string;
     args?: string[];
     fallbackArgs?: string[];
+    detectionStrategy?: StateDetectionStrategy;
 }
 export interface CommandPresetsConfig {
     presets: CommandPreset[];

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ccmanager",
-	"version": "0.2.1",
+	"version": "1.1.0",
 	"description": "TUI application for managing multiple Claude Code sessions across Git worktrees",
 	"license": "MIT",
 	"author": "Kodai Kabasawa",