ccmanager 3.2.10 → 3.3.1

package/README.md

@@ -112,23 +112,24 @@ Note: Shortcuts from `shortcuts.json` will be automatically migrated to `config.
 
 ## 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)
+CCManager supports multiple AI coding assistants with tailored state detection for each:
+
+| Assistant | Command | Installation |
+|-----------|---------|--------------|
+| Claude Code (Default) | `claude` | [code.claude.com](https://code.claude.com/docs/en/setup) |
+| Gemini CLI | `gemini` | [github.com/google-gemini/gemini-cli](https://github.com/google-gemini/gemini-cli) |
+| Codex CLI | `codex` | [github.com/openai/codex](https://github.com/openai/codex) |
+| Cursor Agent | `cursor-agent` | [cursor.com/cli](https://cursor.com/docs/cli/overview) |
+| 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) |
 
 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.
+See [Gemini Support Documentation](docs/gemini-support.md) for CCManager-specific configuration.
 
 
 ## Command Configuration

package/dist/components/ConfigureCommand.js

@@ -19,11 +19,22 @@ const createStrategyItems = () => {
             value: 'github-copilot',
         },
         cline: { label: 'Cline', value: 'cline' },
+        opencode: { label: 'OpenCode', value: 'opencode' },
     };
     return Object.values(strategies);
 };
 // Type-safe strategy items that ensures all StateDetectionStrategy values are included
 const ALL_STRATEGY_ITEMS = createStrategyItems();
+// Default command mapping for each strategy
+const DEFAULT_COMMANDS = {
+    claude: 'claude',
+    gemini: 'gemini',
+    codex: 'codex',
+    cursor: 'cursor',
+    'github-copilot': 'copilot',
+    cline: 'cline',
+    opencode: 'opencode',
+};
 const formatDetectionStrategy = (strategy) => {
     const value = strategy || 'claude';
     switch (value) {
@@ -35,6 +46,10 @@ const formatDetectionStrategy = (strategy) => {
             return 'Cursor';
         case 'github-copilot':
             return 'GitHub Copilot CLI';
+        case 'cline':
+            return 'Cline';
+        case 'opencode':
+            return 'OpenCode';
         default:
             return 'Claude';
     }
@@ -52,7 +67,7 @@ const ConfigureCommand = ({ onComplete }) => {
     const [isSelectingStrategy, setIsSelectingStrategy] = useState(false);
     const [isSelectingStrategyInAdd, setIsSelectingStrategyInAdd] = useState(false);
     const [newPreset, setNewPreset] = useState({});
-    const [addStep, setAddStep] = useState('name');
+    const [addStep, setAddStep] = useState('detectionStrategy');
     const [errorMessage, setErrorMessage] = useState(null);
     // Remove handleListNavigation as SelectInput handles navigation internally
     // Remove handleListSelection as we now use handleSelectItem
@@ -137,19 +152,8 @@ const ConfigureCommand = ({ onComplete }) => {
     };
     const handleAddPresetInput = (value) => {
         switch (addStep) {
-            case 'name':
-                // Prevent using "Default" as a name to avoid confusion
-                if (value.trim().toLowerCase() === 'default') {
-                    setErrorMessage('Cannot use "Default" as a preset name. Please choose a different name.');
-                    return;
-                }
-                setNewPreset({ ...newPreset, name: value });
-                setAddStep('command');
-                setInputValue('');
-                setErrorMessage(null);
-                break;
             case 'command':
-                setNewPreset({ ...newPreset, command: value || 'claude' });
+                setNewPreset({ ...newPreset, command: value });
                 setAddStep('args');
                 setInputValue('');
                 break;
@@ -165,8 +169,38 @@ const ConfigureCommand = ({ onComplete }) => {
                     ? value.trim().split(/\s+/)
                     : undefined;
                 setNewPreset({ ...newPreset, fallbackArgs });
+                setAddStep('name');
+                setInputValue('');
+                break;
+            }
+            case 'name': {
+                if (!value.trim()) {
+                    setErrorMessage('Preset name cannot be empty. Please enter a name.');
+                    return;
+                }
+                if (value.trim().toLowerCase() === 'default') {
+                    setErrorMessage('Cannot use "Default" as a preset name. Please choose a different name.');
+                    return;
+                }
+                const id = Date.now().toString();
+                const completePreset = {
+                    id,
+                    name: value,
+                    command: newPreset.command || 'claude',
+                    args: newPreset.args,
+                    fallbackArgs: newPreset.fallbackArgs,
+                    detectionStrategy: newPreset.detectionStrategy || 'claude',
+                };
+                const updatedPresets = [...presets, completePreset];
+                setPresets(updatedPresets);
+                configurationManager.addPreset(completePreset);
+                setViewMode('list');
+                setSelectedIndex(updatedPresets.length - 1);
+                setNewPreset({});
                 setAddStep('detectionStrategy');
-                setIsSelectingStrategyInAdd(true);
+                setInputValue('');
+                setIsSelectingStrategyInAdd(false);
+                setErrorMessage(null);
                 break;
             }
         }
@@ -183,25 +217,16 @@ const ConfigureCommand = ({ onComplete }) => {
         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('');
+        const strategy = item.value;
+        const defaultCommand = DEFAULT_COMMANDS[strategy];
+        setNewPreset({
+            ...newPreset,
+            detectionStrategy: strategy,
+            command: defaultCommand,
+        });
+        setAddStep('command');
+        setInputValue(defaultCommand);
         setIsSelectingStrategyInAdd(false);
-        setErrorMessage(null);
     };
     const handleDeleteConfirm = () => {
         if (selectedIndex === 0) {
@@ -234,7 +259,7 @@ const ConfigureCommand = ({ onComplete }) => {
             else if (isSelectingStrategyInAdd) {
                 setIsSelectingStrategyInAdd(false);
                 setViewMode('list');
-                setAddStep('name');
+                setAddStep('detectionStrategy');
                 setNewPreset({});
             }
             else if (editField) {
@@ -333,6 +358,8 @@ const ConfigureCommand = ({ onComplete }) => {
                     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(Box, { marginBottom: 1 },
+                    React.createElement(Text, { dimColor: true }, "The command will be auto-set based on the strategy (can be changed later)")),
                 React.createElement(SelectInput, { items: strategyItems, onSelect: handleAddStrategySelect, initialIndex: 0 }),
                 React.createElement(Box, { marginTop: 1 },
                     React.createElement(Text, { dimColor: true },
@@ -342,23 +369,26 @@ const ConfigureCommand = ({ onComplete }) => {
                         " to cancel"))));
         }
         const titles = {
-            name: 'Enter preset name:',
-            command: 'Enter command (e.g., claude):',
+            detectionStrategy: 'Select detection strategy:',
+            command: 'Enter command (default set by strategy, can be modified):',
             args: 'Enter command arguments (space-separated):',
             fallbackArgs: 'Enter fallback arguments (space-separated):',
+            name: 'Enter preset name (freely customizable):',
         };
         return (React.createElement(Box, { flexDirection: "column" },
             React.createElement(Box, { marginBottom: 1 },
                 React.createElement(Text, { bold: true, color: "green" }, "Add New Preset")),
             React.createElement(Box, { marginBottom: 1 },
                 React.createElement(Text, null, titles[addStep])),
+            addStep === 'command' && (React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { dimColor: true }, "Auto-filled from your strategy selection. You can change this if needed."))),
             errorMessage && (React.createElement(Box, { marginBottom: 1 },
                 React.createElement(Text, { color: "red" }, errorMessage))),
             React.createElement(Box, null,
-                React.createElement(TextInputWrapper, { value: inputValue, onChange: setInputValue, onSubmit: handleAddPresetInput, placeholder: addStep === 'args' || addStep === 'fallbackArgs'
-                        ? 'e.g., --resume or leave empty'
-                        : addStep === 'name'
-                            ? 'e.g., Development'
+                React.createElement(TextInputWrapper, { value: inputValue, onChange: setInputValue, onSubmit: handleAddPresetInput, placeholder: addStep === 'name'
+                        ? 'e.g., Development'
+                        : addStep === 'args' || addStep === 'fallbackArgs'
+                            ? 'e.g., --resume or leave empty'
                             : '' })),
             React.createElement(Box, { marginTop: 1 },
                 React.createElement(Text, { dimColor: true },
@@ -489,7 +519,8 @@ const ConfigureCommand = ({ onComplete }) => {
             // Add New Preset
             setViewMode('add');
             setNewPreset({});
-            setAddStep('name');
+            setAddStep('detectionStrategy');
+            setIsSelectingStrategyInAdd(true);
             setInputValue('');
         }
         else if (item.value === 'exit') {

package/dist/services/sessionManager.js

@@ -12,6 +12,7 @@ import { ProcessError, ConfigError } from '../types/errors.js';
 import { autoApprovalVerifier } from './autoApprovalVerifier.js';
 import { logger } from '../utils/logger.js';
 import { Mutex, createInitialSessionStateData } from '../utils/mutex.js';
+import { getTerminalScreenContent } from '../utils/screenCapture.js';
 const { Terminal } = pkg;
 const execAsync = promisify(exec);
 const TERMINAL_CONTENT_MAX_LINES = 300;
@@ -41,20 +42,9 @@ export class SessionManager extends EventEmitter {
         return detectedState;
     }
     getTerminalContent(session) {
-        const buffer = session.terminal.buffer.active;
-        const lines = [];
-        // Start from the bottom and work our way up
-        for (let i = buffer.length - 1; i >= 0 && lines.length < TERMINAL_CONTENT_MAX_LINES; 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.join('\n');
+        // Use the new screen capture utility that correctly handles
+        // both normal and alternate screen buffers
+        return getTerminalScreenContent(session.terminal, TERMINAL_CONTENT_MAX_LINES);
     }
     handleAutoApproval(session) {
         // Cancel any existing verification before starting a new one

package/dist/services/stateDetector/index.js

@@ -4,6 +4,7 @@ import { CodexStateDetector } from './codex.js';
 import { CursorStateDetector } from './cursor.js';
 import { GitHubCopilotStateDetector } from './github-copilot.js';
 import { ClineStateDetector } from './cline.js';
+import { OpenCodeStateDetector } from './opencode.js';
 export function createStateDetector(strategy = 'claude') {
     switch (strategy) {
         case 'claude':
@@ -18,6 +19,8 @@ export function createStateDetector(strategy = 'claude') {
             return new GitHubCopilotStateDetector();
         case 'cline':
             return new ClineStateDetector();
+        case 'opencode':
+            return new OpenCodeStateDetector();
         default:
             return new ClaudeStateDetector();
     }

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

@@ -0,0 +1,5 @@
+import { SessionState, Terminal } from '../../types/index.js';
+import { BaseStateDetector } from './base.js';
+export declare class OpenCodeStateDetector extends BaseStateDetector {
+    detectState(terminal: Terminal, _currentState: SessionState): SessionState;
+}

package/dist/services/stateDetector/opencode.js

@@ -0,0 +1,17 @@
+import { BaseStateDetector } from './base.js';
+export class OpenCodeStateDetector extends BaseStateDetector {
+    detectState(terminal, _currentState) {
+        const content = this.getTerminalContent(terminal);
+        // Check for waiting input state - permission required prompt
+        // The triangle symbol (△) indicates permission is required
+        if (content.includes('△ Permission required')) {
+            return 'waiting_input';
+        }
+        // Check for busy state - "esc interrupt" pattern indicates active processing
+        if (/esc.*interrupt/i.test(content)) {
+            return 'busy';
+        }
+        // Otherwise idle
+        return 'idle';
+    }
+}

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

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

package/dist/services/stateDetector/opencode.test.js

@@ -0,0 +1,88 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { OpenCodeStateDetector } from './opencode.js';
+import { createMockTerminal } from './testUtils.js';
+describe('OpenCodeStateDetector', () => {
+    let detector;
+    let terminal;
+    beforeEach(() => {
+        detector = new OpenCodeStateDetector();
+    });
+    it('should detect waiting_input state for "△ Permission required" pattern', () => {
+        // Arrange
+        terminal = createMockTerminal([
+            'Some output',
+            '△ Permission required',
+            'Press Enter to allow',
+        ]);
+        // Act
+        const state = detector.detectState(terminal, 'idle');
+        // Assert
+        expect(state).toBe('waiting_input');
+    });
+    it('should detect busy state for "esc interrupt" pattern', () => {
+        // Arrange
+        terminal = createMockTerminal([
+            'Processing...',
+            'Press esc to interrupt',
+            'Working...',
+        ]);
+        // Act
+        const state = detector.detectState(terminal, 'idle');
+        // Assert
+        expect(state).toBe('busy');
+    });
+    it('should detect busy state for "ESC INTERRUPT" (uppercase)', () => {
+        // Arrange
+        terminal = createMockTerminal([
+            'Processing...',
+            'PRESS ESC TO INTERRUPT',
+            'Working...',
+        ]);
+        // Act
+        const state = detector.detectState(terminal, 'idle');
+        // Assert
+        expect(state).toBe('busy');
+    });
+    it('should detect busy state for "Esc to interrupt" pattern', () => {
+        // Arrange
+        terminal = createMockTerminal(['Processing...', 'Esc to interrupt']);
+        // Act
+        const state = detector.detectState(terminal, 'idle');
+        // 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, 'idle');
+        // Assert
+        expect(state).toBe('idle');
+    });
+    it('should prioritize waiting_input over busy when both patterns present', () => {
+        // Arrange
+        terminal = createMockTerminal([
+            'esc to interrupt',
+            '△ Permission required',
+        ]);
+        // Act
+        const state = detector.detectState(terminal, 'idle');
+        // Assert
+        expect(state).toBe('waiting_input');
+    });
+    it('should detect waiting_input with full permission prompt', () => {
+        // Arrange
+        terminal = createMockTerminal([
+            'opencode v0.1.0',
+            '',
+            '△ Permission required',
+            'The AI wants to execute a shell command',
+            '',
+            'Press Enter to allow, Esc to deny',
+        ]);
+        // Act
+        const state = detector.detectState(terminal, 'idle');
+        // Assert
+        expect(state).toBe('waiting_input');
+    });
+});

package/dist/types/index.d.ts

@@ -4,7 +4,7 @@ import { GitStatus } from '../utils/gitStatus.js';
 import { Mutex, SessionStateData } from '../utils/mutex.js';
 export type Terminal = InstanceType<typeof pkg.Terminal>;
 export type SessionState = 'idle' | 'busy' | 'waiting_input' | 'pending_auto_approval';
-export type StateDetectionStrategy = 'claude' | 'gemini' | 'codex' | 'cursor' | 'github-copilot' | 'cline';
+export type StateDetectionStrategy = 'claude' | 'gemini' | 'codex' | 'cursor' | 'github-copilot' | 'cline' | 'opencode';
 export interface Worktree {
     path: string;
     branch?: string;

package/dist/utils/screenCapture.d.ts

@@ -0,0 +1,36 @@
+import type { Terminal } from '@xterm/headless';
+export interface ScreenState {
+    timestamp: string;
+    bufferType: 'normal' | 'alternate';
+    cursorX: number;
+    cursorY: number;
+    cols: number;
+    rows: number;
+    lines: string[];
+}
+/**
+ * Captures the current screen state of the terminal.
+ * This correctly handles both normal and alternate screen buffers,
+ * capturing only the visible screen content (not scrollback history).
+ *
+ * @param terminal - The xterm terminal instance
+ * @returns The current screen state including all visible lines
+ */
+export declare function captureScreen(terminal: Terminal): ScreenState;
+/**
+ * Formats the screen state into a human-readable string.
+ *
+ * @param state - The screen state to format
+ * @returns Formatted string representation of the screen state
+ */
+export declare function formatScreenState(state: ScreenState): string;
+/**
+ * Gets the terminal content as a single string.
+ * This is a convenience function that captures the screen and returns
+ * just the lines joined together.
+ *
+ * @param terminal - The xterm terminal instance
+ * @param maxLines - Optional maximum number of lines to return (from the bottom)
+ * @returns The terminal content as a string
+ */
+export declare function getTerminalScreenContent(terminal: Terminal, maxLines?: number): string;

package/dist/utils/screenCapture.js

@@ -0,0 +1,70 @@
+function lineToString(line, cols) {
+    if (!line) {
+        return '';
+    }
+    return line.translateToString(true, 0, cols);
+}
+/**
+ * Captures the current screen state of the terminal.
+ * This correctly handles both normal and alternate screen buffers,
+ * capturing only the visible screen content (not scrollback history).
+ *
+ * @param terminal - The xterm terminal instance
+ * @returns The current screen state including all visible lines
+ */
+export function captureScreen(terminal) {
+    const buffer = terminal.buffer.active;
+    const lines = [];
+    // Capture only the visible screen area (terminal.rows lines)
+    // This works correctly for both normal and alternate screen buffers
+    for (let y = 0; y < terminal.rows; y++) {
+        const line = buffer.getLine(y);
+        lines.push(lineToString(line, terminal.cols));
+    }
+    return {
+        timestamp: new Date().toISOString(),
+        bufferType: buffer.type,
+        cursorX: buffer.cursorX,
+        cursorY: buffer.cursorY,
+        cols: terminal.cols,
+        rows: terminal.rows,
+        lines,
+    };
+}
+/**
+ * Formats the screen state into a human-readable string.
+ *
+ * @param state - The screen state to format
+ * @returns Formatted string representation of the screen state
+ */
+export function formatScreenState(state) {
+    const separator = '-'.repeat(state.cols);
+    let output = `\n[${state.timestamp}] Buffer: ${state.bufferType} | Cursor: (${state.cursorX}, ${state.cursorY}) | Size: ${state.cols}x${state.rows}\n${separator}\n`;
+    for (const line of state.lines) {
+        output += line + '\n';
+    }
+    output += `${separator}\n\n`;
+    return output;
+}
+/**
+ * Gets the terminal content as a single string.
+ * This is a convenience function that captures the screen and returns
+ * just the lines joined together.
+ *
+ * @param terminal - The xterm terminal instance
+ * @param maxLines - Optional maximum number of lines to return (from the bottom)
+ * @returns The terminal content as a string
+ */
+export function getTerminalScreenContent(terminal, maxLines) {
+    const state = captureScreen(terminal);
+    let lines = state.lines;
+    // Trim empty lines from the bottom
+    while (lines.length > 0 && lines[lines.length - 1]?.trim() === '') {
+        lines.pop();
+    }
+    // If maxLines is specified, take only the last maxLines
+    if (maxLines !== undefined && lines.length > maxLines) {
+        lines = lines.slice(-maxLines);
+    }
+    return lines.join('\n');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ccmanager",
-	"version": "3.2.10",
+	"version": "3.3.1",
 	"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.2.10",
-		"@kodaikabasawa/ccmanager-darwin-x64": "3.2.10",
-		"@kodaikabasawa/ccmanager-linux-arm64": "3.2.10",
-		"@kodaikabasawa/ccmanager-linux-x64": "3.2.10",
-		"@kodaikabasawa/ccmanager-win32-x64": "3.2.10"
+		"@kodaikabasawa/ccmanager-darwin-arm64": "3.3.1",
+		"@kodaikabasawa/ccmanager-darwin-x64": "3.3.1",
+		"@kodaikabasawa/ccmanager-linux-arm64": "3.3.1",
+		"@kodaikabasawa/ccmanager-linux-x64": "3.3.1",
+		"@kodaikabasawa/ccmanager-win32-x64": "3.3.1"
 	},
 	"devDependencies": {
 		"@eslint/js": "^9.28.0",
@@ -68,14 +68,14 @@
 	},
 	"prettier": "@vdemedes/prettier-config",
 	"dependencies": {
-		"@xterm/headless": "^5.5.0",
+		"@xterm/headless": "^6.0.0",
 		"effect": "^3.18.2",
 		"ink": "5.2.1",
 		"ink-select-input": "^6.0.0",
 		"ink-text-input": "^6.0.0",
 		"meow": "^11.0.0",
 		"react": "18.3.1",
-		"react-devtools-core": "^4.19.1",
+		"react-devtools-core": "^7.0.1",
 		"react-dom": "18.3.1",
 		"strip-ansi": "^7.1.0"
 	}