ccmanager 0.0.1

package/dist/services/sessionManager.d.ts

@@ -0,0 +1,16 @@
+import { Session, SessionManager as ISessionManager, SessionState } from '../types/index.js';
+import { EventEmitter } from 'events';
+export declare class SessionManager extends EventEmitter implements ISessionManager {
+    sessions: Map<string, Session>;
+    private waitingWithBottomBorder;
+    private stripAnsi;
+    detectSessionState(cleanData: string, currentState: SessionState, sessionId: string): SessionState;
+    constructor();
+    createSession(worktreePath: string): Session;
+    private setupBackgroundHandler;
+    getSession(worktreePath: string): Session | undefined;
+    setSessionActive(worktreePath: string, active: boolean): void;
+    destroySession(worktreePath: string): void;
+    getAllSessions(): Session[];
+    destroy(): void;
+}

package/dist/services/sessionManager.js

@@ -0,0 +1,190 @@
+import { spawn } from 'node-pty';
+import { EventEmitter } from 'events';
+import { includesPromptBoxBottomBorder } from '../utils/promptDetector.js';
+export class SessionManager extends EventEmitter {
+    stripAnsi(str) {
+        // Remove all ANSI escape sequences including cursor movement, color codes, etc.
+        return str
+            .replace(/\x1b\[[0-9;]*m/g, '') // Color codes (including 24-bit)
+            .replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '') // CSI sequences
+            .replace(/\x1b\][^\x07]*\x07/g, '') // OSC sequences
+            .replace(/\x1b[PX^_].*?\x1b\\/g, '') // DCS/PM/APC/SOS sequences
+            .replace(/\x1b\[\?[0-9;]*[hl]/g, '') // Private mode sequences
+            .replace(/\x1b[>=]/g, '') // Other escape sequences
+            .replace(/[\x00-\x09\x0B-\x1F\x7F]/g, '') // Control characters except newline (\x0A)
+            .replace(/\r/g, '') // Carriage returns
+            .replace(/^[0-9;]+m/gm, '') // Orphaned color codes at line start
+            .replace(/[0-9]+;[0-9]+;[0-9;]+m/g, ''); // Orphaned 24-bit color codes
+    }
+    detectSessionState(cleanData, currentState, sessionId) {
+        const hasBottomBorder = includesPromptBoxBottomBorder(cleanData);
+        const hasWaitingPrompt = cleanData.includes('│ Do you want');
+        const wasWaitingWithBottomBorder = this.waitingWithBottomBorder.get(sessionId) || false;
+        let newState = currentState;
+        // Check if current state is waiting and this is just a prompt box bottom border
+        if (hasWaitingPrompt) {
+            newState = 'waiting_input';
+            // Check if this same data also contains the bottom border
+            if (hasBottomBorder) {
+                this.waitingWithBottomBorder.set(sessionId, true);
+            }
+            else {
+                this.waitingWithBottomBorder.set(sessionId, false);
+            }
+        }
+        else if (currentState === 'waiting_input' &&
+            hasBottomBorder &&
+            !hasWaitingPrompt &&
+            !wasWaitingWithBottomBorder) {
+            // Keep the waiting state and mark that we've seen the bottom border
+            newState = 'waiting_input';
+            this.waitingWithBottomBorder.set(sessionId, true);
+        }
+        else if (cleanData.toLowerCase().includes('esc to interrupt')) {
+            newState = 'busy';
+            this.waitingWithBottomBorder.set(sessionId, false);
+        }
+        else {
+            newState = 'idle';
+            this.waitingWithBottomBorder.set(sessionId, false);
+        }
+        return newState;
+    }
+    constructor() {
+        super();
+        Object.defineProperty(this, "sessions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "waitingWithBottomBorder", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        this.sessions = new Map();
+    }
+    createSession(worktreePath) {
+        // 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)}`;
+        const ptyProcess = spawn('claude', [], {
+            name: 'xterm-color',
+            cols: process.stdout.columns || 80,
+            rows: process.stdout.rows || 24,
+            cwd: worktreePath,
+            env: process.env,
+        });
+        const session = {
+            id,
+            worktreePath,
+            process: ptyProcess,
+            state: 'busy', // Session starts as busy when created
+            output: [],
+            outputHistory: [],
+            lastActivity: new Date(),
+            isActive: false,
+        };
+        // Set up persistent background data handler for state detection
+        this.setupBackgroundHandler(session);
+        this.sessions.set(worktreePath, session);
+        this.emit('sessionCreated', session);
+        return session;
+    }
+    setupBackgroundHandler(session) {
+        // This handler always runs for all data
+        session.process.onData((data) => {
+            // Store in output history as Buffer
+            const buffer = Buffer.from(data, 'utf8');
+            session.outputHistory.push(buffer);
+            // Limit memory usage - keep max 10MB of output history
+            const MAX_HISTORY_SIZE = 10 * 1024 * 1024; // 10MB
+            let totalSize = session.outputHistory.reduce((sum, buf) => sum + buf.length, 0);
+            while (totalSize > MAX_HISTORY_SIZE && session.outputHistory.length > 0) {
+                const removed = session.outputHistory.shift();
+                if (removed) {
+                    totalSize -= removed.length;
+                }
+            }
+            // Also store for state detection
+            session.output.push(data);
+            // Keep only last 100 chunks for state detection
+            if (session.output.length > 100) {
+                session.output.shift();
+            }
+            session.lastActivity = new Date();
+            // Strip ANSI codes for pattern matching
+            const cleanData = this.stripAnsi(data);
+            // Skip state monitoring if cleanData is empty
+            if (!cleanData.trim()) {
+                // Only emit data events when session is active
+                if (session.isActive) {
+                    this.emit('sessionData', session, data);
+                }
+                return;
+            }
+            // Detect state based on the new data
+            const oldState = session.state;
+            const newState = this.detectSessionState(cleanData, oldState, session.id);
+            // Update state if changed
+            if (newState !== oldState) {
+                session.state = newState;
+                this.emit('sessionStateChanged', session);
+            }
+            // Only emit data events when session is active
+            if (session.isActive) {
+                this.emit('sessionData', session, data);
+            }
+        });
+        session.process.onExit(() => {
+            // Update state to idle before destroying
+            session.state = 'idle';
+            this.emit('sessionStateChanged', session);
+            this.destroySession(session.worktreePath);
+            this.emit('sessionExit', session);
+        });
+    }
+    getSession(worktreePath) {
+        return this.sessions.get(worktreePath);
+    }
+    setSessionActive(worktreePath, active) {
+        const session = this.sessions.get(worktreePath);
+        if (session) {
+            session.isActive = active;
+            // If becoming active, emit a restore event with the output history
+            if (active && session.outputHistory.length > 0) {
+                this.emit('sessionRestore', session);
+            }
+        }
+    }
+    destroySession(worktreePath) {
+        const session = this.sessions.get(worktreePath);
+        if (session) {
+            try {
+                session.process.kill();
+            }
+            catch (_error) {
+                // Process might already be dead
+            }
+            this.sessions.delete(worktreePath);
+            this.waitingWithBottomBorder.delete(session.id);
+            this.emit('sessionDestroyed', session);
+        }
+    }
+    getAllSessions() {
+        return Array.from(this.sessions.values());
+    }
+    destroy() {
+        // Clean up all sessions
+        for (const worktreePath of this.sessions.keys()) {
+            this.destroySession(worktreePath);
+        }
+    }
+}

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

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

package/dist/services/sessionManager.test.js

@@ -0,0 +1,99 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { SessionManager } from './sessionManager.js';
+// Mock the promptDetector module
+vi.mock('../utils/promptDetector.js', () => ({
+    includesPromptBoxBottomBorder: vi.fn(),
+}));
+import { includesPromptBoxBottomBorder } from '../utils/promptDetector.js';
+describe('SessionManager', () => {
+    let sessionManager;
+    const mockSessionId = 'test-session-123';
+    beforeEach(() => {
+        sessionManager = new SessionManager();
+        vi.clearAllMocks();
+    });
+    describe('detectSessionState', () => {
+        it('should detect waiting_input state when "Do you want" prompt is present', () => {
+            const cleanData = '│ Do you want to continue?';
+            const currentState = 'idle';
+            vi.mocked(includesPromptBoxBottomBorder).mockReturnValue(false);
+            const newState = sessionManager.detectSessionState(cleanData, currentState, mockSessionId);
+            expect(newState).toBe('waiting_input');
+        });
+        it('should set waitingWithBottomBorder when waiting prompt and bottom border are both present', () => {
+            const cleanData = '│ Do you want to continue?\n└───────────────────────┘';
+            const currentState = 'idle';
+            vi.mocked(includesPromptBoxBottomBorder).mockReturnValue(true);
+            const newState = sessionManager.detectSessionState(cleanData, currentState, mockSessionId);
+            expect(newState).toBe('waiting_input');
+            // The internal map should have been set to true
+        });
+        it('should maintain waiting_input state when bottom border appears after waiting prompt', () => {
+            const cleanData = '└───────────────────────┘';
+            const currentState = 'waiting_input';
+            vi.mocked(includesPromptBoxBottomBorder).mockReturnValue(true);
+            // First call to set up the waiting state without bottom border
+            vi.mocked(includesPromptBoxBottomBorder).mockReturnValue(false);
+            sessionManager.detectSessionState('│ Do you want to continue?', 'idle', mockSessionId);
+            // Now test the bottom border appearing
+            vi.mocked(includesPromptBoxBottomBorder).mockReturnValue(true);
+            const newState = sessionManager.detectSessionState(cleanData, currentState, mockSessionId);
+            expect(newState).toBe('waiting_input');
+        });
+        it('should detect busy state when "esc to interrupt" is present', () => {
+            const cleanData = 'Processing... Press ESC to interrupt';
+            const currentState = 'idle';
+            vi.mocked(includesPromptBoxBottomBorder).mockReturnValue(false);
+            const newState = sessionManager.detectSessionState(cleanData, currentState, mockSessionId);
+            expect(newState).toBe('busy');
+        });
+        it('should detect idle state when no specific patterns are found', () => {
+            const cleanData = 'Some regular output text';
+            const currentState = 'busy';
+            vi.mocked(includesPromptBoxBottomBorder).mockReturnValue(false);
+            const newState = sessionManager.detectSessionState(cleanData, currentState, mockSessionId);
+            expect(newState).toBe('idle');
+        });
+        it('should handle case-insensitive "esc to interrupt" detection', () => {
+            const cleanData = 'Running task... PRESS ESC TO INTERRUPT';
+            const currentState = 'idle';
+            vi.mocked(includesPromptBoxBottomBorder).mockReturnValue(false);
+            const newState = sessionManager.detectSessionState(cleanData, currentState, mockSessionId);
+            expect(newState).toBe('busy');
+        });
+        it('should not change from waiting_input when bottom border was already seen', () => {
+            const cleanData = '└───────────────────────┘';
+            const currentState = 'waiting_input';
+            vi.mocked(includesPromptBoxBottomBorder).mockReturnValue(true);
+            // First, simulate seeing waiting prompt with bottom border
+            sessionManager.detectSessionState('│ Do you want to continue?\n└───────────────────────┘', 'idle', mockSessionId);
+            // Now another bottom border appears
+            const newState = sessionManager.detectSessionState(cleanData, currentState, mockSessionId);
+            expect(newState).toBe('idle'); // Should change to idle since we already saw the bottom border
+        });
+        it('should clear waitingWithBottomBorder flag when transitioning to busy', () => {
+            const cleanData = 'Processing... Press ESC to interrupt';
+            const currentState = 'waiting_input';
+            vi.mocked(includesPromptBoxBottomBorder).mockReturnValue(false);
+            // First set up waiting state with bottom border
+            vi.mocked(includesPromptBoxBottomBorder).mockReturnValue(true);
+            sessionManager.detectSessionState('│ Do you want to continue?\n└───────────────────────┘', 'idle', mockSessionId);
+            // Now transition to busy
+            vi.mocked(includesPromptBoxBottomBorder).mockReturnValue(false);
+            const newState = sessionManager.detectSessionState(cleanData, currentState, mockSessionId);
+            expect(newState).toBe('busy');
+        });
+        it('should clear waitingWithBottomBorder flag when transitioning to idle', () => {
+            const cleanData = 'Task completed successfully';
+            const currentState = 'waiting_input';
+            vi.mocked(includesPromptBoxBottomBorder).mockReturnValue(false);
+            // First set up waiting state with bottom border
+            vi.mocked(includesPromptBoxBottomBorder).mockReturnValue(true);
+            sessionManager.detectSessionState('│ Do you want to continue?\n└───────────────────────┘', 'idle', mockSessionId);
+            // Now transition to idle
+            vi.mocked(includesPromptBoxBottomBorder).mockReturnValue(false);
+            const newState = sessionManager.detectSessionState(cleanData, currentState, mockSessionId);
+            expect(newState).toBe('idle');
+        });
+    });
+});

package/dist/services/shortcutManager.d.ts

@@ -0,0 +1,17 @@
+import { ShortcutKey, ShortcutConfig } from '../types/index.js';
+import { Key } from 'ink';
+export declare class ShortcutManager {
+    private shortcuts;
+    private configPath;
+    private reservedKeys;
+    constructor();
+    private loadShortcuts;
+    private validateShortcut;
+    private isReservedKey;
+    saveShortcuts(shortcuts: ShortcutConfig): boolean;
+    getShortcuts(): ShortcutConfig;
+    matchesShortcut(shortcutName: keyof ShortcutConfig, input: string, key: Key): boolean;
+    getShortcutDisplay(shortcutName: keyof ShortcutConfig): string;
+    getShortcutCode(shortcut: ShortcutKey): string | null;
+}
+export declare const shortcutManager: ShortcutManager;

package/dist/services/shortcutManager.js

@@ -0,0 +1,167 @@
+import { DEFAULT_SHORTCUTS, } from '../types/index.js';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+export class ShortcutManager {
+    constructor() {
+        Object.defineProperty(this, "shortcuts", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "configPath", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "reservedKeys", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: [
+                { ctrl: true, key: 'c' },
+                { ctrl: true, key: 'd' },
+                { key: 'escape' }, // Ctrl+[ is equivalent to Escape
+                { ctrl: true, key: '[' },
+            ]
+        });
+        // Use platform-specific config directory
+        const configDir = process.platform === 'win32'
+            ? path.join(process.env['APPDATA'] || os.homedir(), 'ccmanager')
+            : path.join(os.homedir(), '.config', 'ccmanager');
+        this.configPath = path.join(configDir, 'shortcuts.json');
+        this.shortcuts = this.loadShortcuts();
+    }
+    loadShortcuts() {
+        try {
+            if (fs.existsSync(this.configPath)) {
+                const data = fs.readFileSync(this.configPath, 'utf8');
+                const loaded = JSON.parse(data);
+                // Validate loaded shortcuts
+                const validated = {
+                    returnToMenu: this.validateShortcut(loaded.returnToMenu) ||
+                        DEFAULT_SHORTCUTS.returnToMenu,
+                    cancel: this.validateShortcut(loaded.cancel) || DEFAULT_SHORTCUTS.cancel,
+                };
+                return validated;
+            }
+        }
+        catch (error) {
+            console.error('Failed to load shortcuts:', error);
+        }
+        return { ...DEFAULT_SHORTCUTS };
+    }
+    validateShortcut(shortcut) {
+        if (!shortcut || typeof shortcut !== 'object') {
+            return null;
+        }
+        const s = shortcut;
+        if (!s['key'] || typeof s['key'] !== 'string') {
+            return null;
+        }
+        const validShortcut = {
+            key: s['key'],
+            ctrl: !!s['ctrl'],
+            alt: !!s['alt'],
+            shift: !!s['shift'],
+        };
+        // Check if it's a reserved key
+        if (this.isReservedKey(validShortcut)) {
+            return null;
+        }
+        // Ensure at least one modifier key is used (except for special keys like escape)
+        if (validShortcut.key !== 'escape' &&
+            !validShortcut.ctrl &&
+            !validShortcut.alt &&
+            !validShortcut.shift) {
+            return null;
+        }
+        return validShortcut;
+    }
+    isReservedKey(shortcut) {
+        return this.reservedKeys.some(reserved => reserved.key === shortcut.key &&
+            reserved.ctrl === shortcut.ctrl &&
+            reserved.alt === shortcut.alt &&
+            reserved.shift === shortcut.shift);
+    }
+    saveShortcuts(shortcuts) {
+        // Validate all shortcuts
+        const validated = {
+            returnToMenu: this.validateShortcut(shortcuts.returnToMenu) ||
+                this.shortcuts.returnToMenu,
+            cancel: this.validateShortcut(shortcuts.cancel) || this.shortcuts.cancel,
+        };
+        try {
+            const dir = path.dirname(this.configPath);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            fs.writeFileSync(this.configPath, JSON.stringify(validated, null, 2));
+            this.shortcuts = validated;
+            return true;
+        }
+        catch (error) {
+            console.error('Failed to save shortcuts:', error);
+            return false;
+        }
+    }
+    getShortcuts() {
+        return { ...this.shortcuts };
+    }
+    matchesShortcut(shortcutName, input, key) {
+        const shortcut = this.shortcuts[shortcutName];
+        if (!shortcut)
+            return false;
+        // Handle escape key specially
+        if (shortcut.key === 'escape') {
+            return key.escape === true;
+        }
+        // Check modifiers
+        if (shortcut.ctrl !== key.ctrl)
+            return false;
+        // Note: ink's Key type doesn't support alt or shift modifiers
+        // so we can't check them here. For now, we'll only support ctrl modifier
+        if (shortcut.alt || shortcut.shift)
+            return false;
+        // Check key
+        return input.toLowerCase() === shortcut.key.toLowerCase();
+    }
+    getShortcutDisplay(shortcutName) {
+        const shortcut = this.shortcuts[shortcutName];
+        if (!shortcut)
+            return '';
+        const parts = [];
+        if (shortcut.ctrl)
+            parts.push('Ctrl');
+        if (shortcut.alt)
+            parts.push('Alt');
+        if (shortcut.shift)
+            parts.push('Shift');
+        // Format special keys
+        let keyDisplay = shortcut.key;
+        if (keyDisplay === 'escape')
+            keyDisplay = 'Esc';
+        else if (keyDisplay.length === 1)
+            keyDisplay = keyDisplay.toUpperCase();
+        parts.push(keyDisplay);
+        return parts.join('+');
+    }
+    getShortcutCode(shortcut) {
+        // Convert shortcut to terminal code for raw stdin handling
+        if (!shortcut.ctrl || shortcut.alt || shortcut.shift) {
+            return null; // Only support Ctrl+key for raw codes
+        }
+        const key = shortcut.key.toLowerCase();
+        if (key.length !== 1)
+            return null;
+        // Convert Ctrl+letter to ASCII control code
+        const code = key.charCodeAt(0) - 96; // 'a' = 1, 'b' = 2, etc.
+        if (code >= 1 && code <= 26) {
+            return String.fromCharCode(code);
+        }
+        return null;
+    }
+}
+export const shortcutManager = new ShortcutManager();

package/dist/services/worktreeService.d.ts

@@ -0,0 +1,24 @@
+import { Worktree } from '../types/index.js';
+export declare class WorktreeService {
+    private rootPath;
+    constructor(rootPath?: string);
+    getWorktrees(): Worktree[];
+    private getCurrentBranch;
+    isGitRepository(): boolean;
+    createWorktree(worktreePath: string, branch: string): {
+        success: boolean;
+        error?: string;
+    };
+    deleteWorktree(worktreePath: string): {
+        success: boolean;
+        error?: string;
+    };
+    mergeWorktree(sourceBranch: string, targetBranch: string, useRebase?: boolean): {
+        success: boolean;
+        error?: string;
+    };
+    deleteWorktreeByBranch(branch: string): {
+        success: boolean;
+        error?: string;
+    };
+}