ccmanager 0.2.0 → 1.0.0

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,77 @@ 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);
+        this.sessions.set(worktreePath, session);
+        this.emit('sessionCreated', session);
+        return session;
+    }
+    async createSessionWithPreset(worktreePath, presetId) {
+        // Check if session already exists
+        const existing = this.sessions.get(worktreePath);
+        if (existing) {
+            return existing;
+        }
+        const id = `session-${Date.now()}-${Math.random()
+            .toString(36)
+            .substr(2, 9)}`;
+        // Get preset configuration
+        let preset = presetId ? configurationManager.getPresetById(presetId) : null;
+        if (!preset) {
+            preset = configurationManager.getDefaultPreset();
+        }
+        const command = preset.command;
+        const args = preset.args || [];
+        const commandConfig = {
+            command: preset.command,
+            args: preset.args,
+            fallbackArgs: preset.fallbackArgs,
+        };
+        // Try to spawn the process
+        let ptyProcess;
+        let isPrimaryCommand = true;
+        try {
+            ptyProcess = await this.spawn(command, args, worktreePath);
+        }
+        catch (error) {
+            // If primary command fails and we have fallback args, try them
+            if (preset.fallbackArgs) {
+                try {
+                    ptyProcess = await this.spawn(command, preset.fallbackArgs, worktreePath);
+                    isPrimaryCommand = false;
+                }
+                catch (_fallbackError) {
+                    // Both attempts failed, throw the original error
+                    throw error;
+                }
+            }
+            else {
+                // No fallback args, throw the error
+                throw error;
+            }
+        }
+        // Create virtual terminal for state detection
+        const terminal = new Terminal({
+            cols: process.stdout.columns || 80,
+            rows: process.stdout.rows || 24,
+            allowProposedApi: true,
+        });
+        const session = {
+            id,
+            worktreePath,
+            process: ptyProcess,
+            state: 'busy', // Session starts as busy when created
+            output: [],
+            outputHistory: [],
+            lastActivity: new Date(),
+            isActive: false,
+            terminal,
+            isPrimaryCommand,
+            commandConfig,
+            detectionStrategy: preset.detectionStrategy || 'claude',
         };
         // Set up persistent background data handler for state detection
         this.setupBackgroundHandler(session);
@@ -165,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/sessionManager.test.js

@@ -10,6 +10,8 @@ vi.mock('./configurationManager.js', () => ({
     configurationManager: {
         getCommandConfig: vi.fn(),
         getStatusHooks: vi.fn(() => ({})),
+        getDefaultPreset: vi.fn(),
+        getPresetById: vi.fn(),
     },
 }));
 // Mock Terminal
@@ -257,4 +259,105 @@ describe('SessionManager', () => {
             expect(sessionManager.getSession('/test/worktree')).toBeUndefined();
         });
     });
+    describe('createSession with presets', () => {
+        it('should use default preset when no preset ID specified', async () => {
+            // Setup mock preset
+            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+                id: '1',
+                name: 'Main',
+                command: 'claude',
+                args: ['--preset-arg'],
+            });
+            // Setup spawn mock
+            vi.mocked(spawn).mockReturnValue(mockPty);
+            // Create session with preset
+            await sessionManager.createSessionWithPreset('/test/worktree');
+            // Verify spawn was called with preset config
+            expect(spawn).toHaveBeenCalledWith('claude', ['--preset-arg'], {
+                name: 'xterm-color',
+                cols: expect.any(Number),
+                rows: expect.any(Number),
+                cwd: '/test/worktree',
+                env: process.env,
+            });
+        });
+        it('should use specific preset when ID provided', async () => {
+            // Setup mock preset
+            vi.mocked(configurationManager.getPresetById).mockReturnValue({
+                id: '2',
+                name: 'Development',
+                command: 'claude',
+                args: ['--resume', '--dev'],
+                fallbackArgs: ['--no-mcp'],
+            });
+            // Setup spawn mock
+            vi.mocked(spawn).mockReturnValue(mockPty);
+            // Create session with specific preset
+            await sessionManager.createSessionWithPreset('/test/worktree', '2');
+            // Verify getPresetById was called with correct ID
+            expect(configurationManager.getPresetById).toHaveBeenCalledWith('2');
+            // Verify spawn was called with preset config
+            expect(spawn).toHaveBeenCalledWith('claude', ['--resume', '--dev'], {
+                name: 'xterm-color',
+                cols: expect.any(Number),
+                rows: expect.any(Number),
+                cwd: '/test/worktree',
+                env: process.env,
+            });
+        });
+        it('should fall back to default preset if specified preset not found', async () => {
+            // Setup mocks
+            vi.mocked(configurationManager.getPresetById).mockReturnValue(undefined);
+            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+                id: '1',
+                name: 'Main',
+                command: 'claude',
+            });
+            // Setup spawn mock
+            vi.mocked(spawn).mockReturnValue(mockPty);
+            // Create session with non-existent preset
+            await sessionManager.createSessionWithPreset('/test/worktree', 'invalid');
+            // Verify fallback to default preset
+            expect(configurationManager.getDefaultPreset).toHaveBeenCalled();
+            expect(spawn).toHaveBeenCalledWith('claude', [], expect.any(Object));
+        });
+        it('should try fallback args with preset if main command fails', async () => {
+            // Setup mock preset with fallback
+            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+                id: '1',
+                name: 'Main',
+                command: 'claude',
+                args: ['--bad-flag'],
+                fallbackArgs: ['--good-flag'],
+            });
+            // Mock spawn to fail first, succeed second
+            let callCount = 0;
+            vi.mocked(spawn).mockImplementation(() => {
+                callCount++;
+                if (callCount === 1) {
+                    throw new Error('Command failed');
+                }
+                return mockPty;
+            });
+            // Create session
+            await sessionManager.createSessionWithPreset('/test/worktree');
+            // Verify both attempts were made
+            expect(spawn).toHaveBeenCalledTimes(2);
+            expect(spawn).toHaveBeenNthCalledWith(1, 'claude', ['--bad-flag'], expect.any(Object));
+            expect(spawn).toHaveBeenNthCalledWith(2, 'claude', ['--good-flag'], expect.any(Object));
+        });
+        it('should maintain backward compatibility with createSession', async () => {
+            // Setup legacy config
+            vi.mocked(configurationManager.getCommandConfig).mockReturnValue({
+                command: 'claude',
+                args: ['--legacy'],
+            });
+            // Setup spawn mock
+            vi.mocked(spawn).mockReturnValue(mockPty);
+            // Create session using legacy method
+            await sessionManager.createSession('/test/worktree');
+            // Verify legacy method still works
+            expect(spawn).toHaveBeenCalledWith('claude', ['--legacy'], expect.any(Object));
+        });
+    });
 });

package/dist/services/stateDetector.d.ts

@@ -0,0 +1,16 @@
+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;
+}

package/dist/services/stateDetector.js

@@ -0,0 +1,67 @@
+export function createStateDetector(strategy = 'claude') {
+    switch (strategy) {
+        case 'claude':
+            return new ClaudeStateDetector();
+        case 'gemini':
+            return new GeminiStateDetector();
+        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';
+    }
+}

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

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

package/dist/services/stateDetector.test.js

@@ -0,0 +1,242 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { ClaudeStateDetector, GeminiStateDetector } 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
+        });
+    });
+});

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';
 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>;
@@ -61,9 +63,23 @@ export interface CommandConfig {
     args?: string[];
     fallbackArgs?: string[];
 }
+export interface CommandPreset {
+    id: string;
+    name: string;
+    command: string;
+    args?: string[];
+    fallbackArgs?: string[];
+    detectionStrategy?: StateDetectionStrategy;
+}
+export interface CommandPresetsConfig {
+    presets: CommandPreset[];
+    defaultPresetId: string;
+    selectPresetOnStart?: boolean;
+}
 export interface ConfigurationData {
     shortcuts?: ShortcutConfig;
     statusHooks?: StatusHookConfig;
     worktree?: WorktreeConfig;
     command?: CommandConfig;
+    commandPresets?: CommandPresetsConfig;
 }

package/package.json

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