ccmanager 0.0.1 → 0.0.2

package/README.md

@@ -2,13 +2,37 @@
 
 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
 - 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**
+- Configurable keyboard shortcuts
+
+## Why CCManager over Claude Squad?
+
+Both tools solve the same problem - managing multiple Claude Code sessions - but take different approaches.
+
+**If you love tmux-based workflows, stick with Claude Squad!** It's a great tool that leverages tmux's power for session management.
+
+CCManager is for developers who want:
+
+### 🚀 No tmux dependency
+CCManager is completely self-contained. No need to install or configure tmux - it works out of the box. Perfect if you don't use tmux or want to keep your tmux setup separate from Claude Code management.
+
+### 👁️ Real-time session monitoring
+CCManager shows the actual state of each Claude Code session directly in the menu:
+- **Waiting**: Claude is asking for user input
+- **Busy**: Claude is processing
+- **Idle**: Ready for new tasks
+
+Claude Squad doesn't show session states in its menu, making it hard to know which sessions need attention. While Claude Squad offers an AutoYes feature, this bypasses Claude Code's built-in security confirmations - not recommended for safe operation.
+
+### 🎯 Simple and intuitive interface
+Following Claude Code's philosophy, CCManager keeps things minimal and intuitive. The interface is so simple you'll understand it in seconds - no manual needed.
 
 ## Install
 
@@ -28,7 +52,8 @@ $ npx ccmanager
 
 ### Default Shortcuts
 
-- **Ctrl+E**: Return to menu from active session (by default)
+- **Ctrl+E**: Return to menu from active session
+- **Escape**: Cancel/Go back in dialogs
 
 ### Customizing Shortcuts
 

package/dist/components/StatusBar.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { SessionState, ViewType, Worktree } from '../types/index.js';
+interface StatusBarProps {
+    view: ViewType;
+    sessionState?: SessionState;
+    worktree?: Worktree;
+}
+export declare const StatusBar: React.FC<StatusBarProps>;
+export {};

package/dist/components/StatusBar.js

@@ -0,0 +1,51 @@
+import React from 'react';
+import { Box, Text } from 'ink';
+import { SessionState, ViewType } from '../types/index.js';
+export const StatusBar = ({ view, sessionState, worktree, }) => {
+    const getStateText = () => {
+        if (!sessionState)
+            return '';
+        switch (sessionState) {
+            case SessionState.Processing:
+                return 'Processing...';
+            case SessionState.WaitingForInput:
+                return 'Ready';
+            case SessionState.NeedsInteraction:
+                return 'Needs input';
+            case SessionState.Error:
+                return 'Error';
+            case SessionState.Terminated:
+                return 'Terminated';
+            default:
+                return 'Idle';
+        }
+    };
+    const getStateColor = () => {
+        if (!sessionState)
+            return 'gray';
+        switch (sessionState) {
+            case SessionState.Processing:
+                return 'yellow';
+            case SessionState.WaitingForInput:
+                return 'green';
+            case SessionState.NeedsInteraction:
+                return 'cyan';
+            case SessionState.Error:
+                return 'red';
+            case SessionState.Terminated:
+                return 'gray';
+            default:
+                return 'gray';
+        }
+    };
+    return (React.createElement(Box, { borderStyle: "single", borderTop: true, paddingLeft: 1, paddingRight: 1, justifyContent: "space-between" },
+        React.createElement(Box, null, worktree && (React.createElement(Text, null,
+            React.createElement(Text, { bold: true }, worktree.branch),
+            React.createElement(Text, { dimColor: true },
+                " (",
+                worktree.path,
+                ")")))),
+        React.createElement(Box, { gap: 2 },
+            sessionState && React.createElement(Text, { color: getStateColor() }, getStateText()),
+            React.createElement(Text, { dimColor: true }, view === ViewType.Session ? 'Ctrl+E Return to Menu' : 'Q Quit'))));
+};

package/dist/hooks/useSession.d.ts

@@ -0,0 +1,9 @@
+import { Session } from '../types/index.js';
+export declare const useSession: () => {
+    sessions: Session[];
+    createOrActivateSession: (worktreePath: string) => Session;
+    writeToSession: (sessionId: string, data: string) => void;
+    resizeSession: (sessionId: string, cols: number, rows: number) => void;
+    terminateSession: (sessionId: string) => void;
+    getSession: (id: string) => Session | undefined;
+};

package/dist/hooks/useSession.js

@@ -0,0 +1,44 @@
+import { useState, useEffect, useCallback } from 'react';
+import { SessionManager } from '../services/sessionManager.js';
+export const useSession = () => {
+    const [sessions, setSessions] = useState([]);
+    const [sessionManager] = useState(() => new SessionManager());
+    const refreshSessions = useCallback(() => {
+        setSessions(sessionManager.getAllSessions());
+    }, [sessionManager]);
+    const createOrActivateSession = useCallback((worktreePath) => {
+        let session = sessionManager.findSessionByWorktree(worktreePath);
+        if (!session) {
+            session = sessionManager.createSession(worktreePath);
+            sessionManager.startSession(session.id);
+        }
+        else if (!session.process) {
+            sessionManager.startSession(session.id);
+        }
+        refreshSessions();
+        return session;
+    }, [sessionManager, refreshSessions]);
+    const writeToSession = useCallback((sessionId, data) => {
+        sessionManager.writeToSession(sessionId, data);
+    }, [sessionManager]);
+    const resizeSession = useCallback((sessionId, cols, rows) => {
+        sessionManager.resizeSession(sessionId, cols, rows);
+    }, [sessionManager]);
+    const terminateSession = useCallback((sessionId) => {
+        sessionManager.terminateSession(sessionId);
+        refreshSessions();
+    }, [sessionManager, refreshSessions]);
+    // Update sessions when they change
+    useEffect(() => {
+        const interval = setInterval(refreshSessions, 100);
+        return () => clearInterval(interval);
+    }, [refreshSessions]);
+    return {
+        sessions,
+        createOrActivateSession,
+        writeToSession,
+        resizeSession,
+        terminateSession,
+        getSession: (id) => sessionManager.getSession(id),
+    };
+};

package/dist/hooks/useWorktree.d.ts

@@ -0,0 +1,7 @@
+import { Worktree } from '../types/index.js';
+export declare const useWorktree: () => {
+    worktrees: Worktree[];
+    loading: boolean;
+    error: string | null;
+    refreshWorktrees: () => Promise<void>;
+};

package/dist/hooks/useWorktree.js

@@ -0,0 +1,31 @@
+import { useState, useEffect } from 'react';
+import { WorktreeService } from '../services/worktreeService.js';
+export const useWorktree = () => {
+    const [worktrees, setWorktrees] = useState([]);
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(null);
+    const worktreeService = new WorktreeService();
+    const refreshWorktrees = async () => {
+        try {
+            setLoading(true);
+            setError(null);
+            const trees = await worktreeService.listWorktrees();
+            setWorktrees(trees);
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : 'Failed to load worktrees');
+        }
+        finally {
+            setLoading(false);
+        }
+    };
+    useEffect(() => {
+        refreshWorktrees();
+    }, []);
+    return {
+        worktrees,
+        loading,
+        error,
+        refreshWorktrees,
+    };
+};

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+import React from 'react';
+import { render } from 'ink';
+import App from './components/App.js';
+render(React.createElement(App, null));

package/dist/services/logger.d.ts

@@ -0,0 +1 @@
+export declare function log(...args: any[]): void;

package/dist/services/logger.js

@@ -0,0 +1,10 @@
+import fs from 'fs';
+import path from 'path';
+const logFile = path.join(process.cwd(), 'ccmanager.log');
+// Clear log file on module load
+fs.writeFileSync(logFile, '');
+export function log(...args) {
+    const timestamp = new Date().toISOString();
+    const message = args.map(arg => typeof arg === 'object' ? JSON.stringify(arg) : String(arg)).join(' ');
+    fs.appendFileSync(logFile, `[${timestamp}] ${message}\n`);
+}

package/dist/services/sessionManager.d.ts

@@ -3,6 +3,7 @@ import { EventEmitter } from 'events';
 export declare class SessionManager extends EventEmitter implements ISessionManager {
     sessions: Map<string, Session>;
     private waitingWithBottomBorder;
+    private busyTimers;
     private stripAnsi;
     detectSessionState(cleanData: string, currentState: SessionState, sessionId: string): SessionState;
     constructor();

package/dist/services/sessionManager.js

@@ -20,6 +20,9 @@ export class SessionManager extends EventEmitter {
         const hasBottomBorder = includesPromptBoxBottomBorder(cleanData);
         const hasWaitingPrompt = cleanData.includes('│ Do you want');
         const wasWaitingWithBottomBorder = this.waitingWithBottomBorder.get(sessionId) || false;
+        const hasEscToInterrupt = cleanData
+            .toLowerCase()
+            .includes('esc to interrupt');
         let newState = currentState;
         // Check if current state is waiting and this is just a prompt box bottom border
         if (hasWaitingPrompt) {
@@ -31,22 +34,69 @@ export class SessionManager extends EventEmitter {
             else {
                 this.waitingWithBottomBorder.set(sessionId, false);
             }
+            // Clear any pending busy timer
+            const existingTimer = this.busyTimers.get(sessionId);
+            if (existingTimer) {
+                clearTimeout(existingTimer);
+                this.busyTimers.delete(sessionId);
+            }
         }
         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);
+            !hasWaitingPrompt) {
+            if (wasWaitingWithBottomBorder) {
+                // We've already seen the bottom border, transition to idle
+                newState = 'idle';
+                this.waitingWithBottomBorder.set(sessionId, false);
+            }
+            else {
+                // First time seeing bottom border, keep waiting state
+                newState = 'waiting_input';
+                this.waitingWithBottomBorder.set(sessionId, true);
+            }
+            // Clear any pending busy timer
+            const existingTimer = this.busyTimers.get(sessionId);
+            if (existingTimer) {
+                clearTimeout(existingTimer);
+                this.busyTimers.delete(sessionId);
+            }
         }
-        else if (cleanData.toLowerCase().includes('esc to interrupt')) {
+        else if (hasEscToInterrupt) {
+            // If "esc to interrupt" is present, set state to busy
             newState = 'busy';
             this.waitingWithBottomBorder.set(sessionId, false);
+            // Clear any pending timer since we're confirming busy state
+            const existingTimer = this.busyTimers.get(sessionId);
+            if (existingTimer) {
+                clearTimeout(existingTimer);
+                this.busyTimers.delete(sessionId);
+            }
         }
-        else {
+        else if (currentState === 'busy' && !hasEscToInterrupt) {
+            // If we were busy but no "esc to interrupt" in current data,
+            // start a timer to switch to idle after 500ms
+            if (!this.busyTimers.has(sessionId)) {
+                const timer = setTimeout(() => {
+                    // sessionId is actually the worktreePath
+                    const session = this.sessions.get(sessionId);
+                    if (session && session.state === 'busy') {
+                        session.state = 'idle';
+                        this.emit('sessionStateChanged', session);
+                    }
+                    this.busyTimers.delete(sessionId);
+                }, 500);
+                this.busyTimers.set(sessionId, timer);
+            }
+            // Keep current busy state for now
+            newState = 'busy';
+        }
+        else if (!hasWaitingPrompt && !hasEscToInterrupt && !hasBottomBorder) {
+            // No special prompts or indicators, transition to idle
             newState = 'idle';
-            this.waitingWithBottomBorder.set(sessionId, false);
+            // Clear the waiting flag when transitioning to idle
+            if (currentState === 'waiting_input') {
+                this.waitingWithBottomBorder.set(sessionId, false);
+            }
         }
         return newState;
     }
@@ -64,6 +114,12 @@ export class SessionManager extends EventEmitter {
             writable: true,
             value: new Map()
         });
+        Object.defineProperty(this, "busyTimers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
         this.sessions = new Map();
     }
     createSession(worktreePath) {
@@ -132,7 +188,7 @@ export class SessionManager extends EventEmitter {
             }
             // Detect state based on the new data
             const oldState = session.state;
-            const newState = this.detectSessionState(cleanData, oldState, session.id);
+            const newState = this.detectSessionState(cleanData, oldState, session.worktreePath);
             // Update state if changed
             if (newState !== oldState) {
                 session.state = newState;
@@ -173,6 +229,12 @@ export class SessionManager extends EventEmitter {
             catch (_error) {
                 // Process might already be dead
             }
+            // Clean up any pending timer
+            const timer = this.busyTimers.get(worktreePath);
+            if (timer) {
+                clearTimeout(timer);
+                this.busyTimers.delete(worktreePath);
+            }
             this.sessions.delete(worktreePath);
             this.waitingWithBottomBorder.delete(session.id);
             this.emit('sessionDestroyed', session);

package/dist/services/sessionManager.test.js

@@ -47,12 +47,13 @@ describe('SessionManager', () => {
             const newState = sessionManager.detectSessionState(cleanData, currentState, mockSessionId);
             expect(newState).toBe('busy');
         });
-        it('should detect idle state when no specific patterns are found', () => {
+        it('should maintain busy state when transitioning from busy without "esc to interrupt"', () => {
             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');
+            // With the new logic, it should remain busy and start a timer
+            expect(newState).toBe('busy');
         });
         it('should handle case-insensitive "esc to interrupt" detection', () => {
             const cleanData = 'Running task... PRESS ESC TO INTERRUPT';
@@ -95,5 +96,64 @@ describe('SessionManager', () => {
             const newState = sessionManager.detectSessionState(cleanData, currentState, mockSessionId);
             expect(newState).toBe('idle');
         });
+        it('should transition from busy to idle after 500ms timer when no "esc to interrupt"', async () => {
+            // Create a mock session for the timer test
+            const mockWorktreePath = '/test/worktree';
+            const mockSession = {
+                id: mockSessionId,
+                worktreePath: mockWorktreePath,
+                state: 'busy',
+                process: {},
+                output: [],
+                outputHistory: [],
+                lastActivity: new Date(),
+                isActive: false,
+            };
+            // Add the session to the manager
+            sessionManager.sessions.set(mockWorktreePath, mockSession);
+            // Mock the EventEmitter emit method
+            const emitSpy = vi.spyOn(sessionManager, 'emit');
+            // First call with no esc to interrupt should maintain busy state
+            const cleanData = 'Some regular output text';
+            vi.mocked(includesPromptBoxBottomBorder).mockReturnValue(false);
+            const newState = sessionManager.detectSessionState(cleanData, 'busy', mockWorktreePath);
+            expect(newState).toBe('busy');
+            // Wait for timer to fire (500ms + buffer)
+            await new Promise(resolve => setTimeout(resolve, 600));
+            // Check that the session state was changed to idle
+            expect(mockSession.state).toBe('idle');
+            expect(emitSpy).toHaveBeenCalledWith('sessionStateChanged', mockSession);
+        });
+        it('should cancel timer when "esc to interrupt" appears again', async () => {
+            // Create a mock session for the timer test
+            const mockWorktreePath = '/test/worktree';
+            const mockSession = {
+                id: mockSessionId,
+                worktreePath: mockWorktreePath,
+                state: 'busy',
+                process: {},
+                output: [],
+                outputHistory: [],
+                lastActivity: new Date(),
+                isActive: false,
+            };
+            // Add the session to the manager
+            sessionManager.sessions.set(mockWorktreePath, mockSession);
+            // First call with no esc to interrupt should maintain busy state and start timer
+            const cleanData1 = 'Some regular output text';
+            vi.mocked(includesPromptBoxBottomBorder).mockReturnValue(false);
+            const newState1 = sessionManager.detectSessionState(cleanData1, 'busy', mockWorktreePath);
+            expect(newState1).toBe('busy');
+            // Wait 200ms (less than timer duration)
+            await new Promise(resolve => setTimeout(resolve, 200));
+            // Second call with esc to interrupt should cancel timer and keep busy
+            const cleanData2 = 'Running... Press ESC to interrupt';
+            const newState2 = sessionManager.detectSessionState(cleanData2, 'busy', mockWorktreePath);
+            expect(newState2).toBe('busy');
+            // Wait another 400ms (total 600ms, more than timer duration)
+            await new Promise(resolve => setTimeout(resolve, 400));
+            // State should still be busy because timer was cancelled
+            expect(mockSession.state).toBe('busy');
+        });
     });
 });

package/dist/services/stateDetector.d.ts

@@ -0,0 +1,9 @@
+import { SessionState } from '../types/index.js';
+export declare class StateDetector {
+    private readonly promptPatterns;
+    private readonly errorPatterns;
+    private readonly processingPatterns;
+    detectState(output: string, currentState: SessionState): SessionState;
+    private stripAnsi;
+    private matchesAny;
+}

package/dist/services/stateDetector.js

@@ -0,0 +1,82 @@
+import { SessionState } from '../types/index.js';
+export class StateDetector {
+    constructor() {
+        Object.defineProperty(this, "promptPatterns", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: [
+                />\s*$/,
+                /\?\s*$/,
+                /:\s*$/,
+                /Press Enter to continue/i,
+                /\(y\/n\)/i,
+                /\[y\/N\]/i,
+                /Enter your choice/i,
+            ]
+        });
+        Object.defineProperty(this, "errorPatterns", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: [
+                /error:/i,
+                /failed:/i,
+                /exception:/i,
+                /traceback/i,
+                /command not found/i,
+            ]
+        });
+        Object.defineProperty(this, "processingPatterns", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: [
+                /processing/i,
+                /loading/i,
+                /running/i,
+                /executing/i,
+                /analyzing/i,
+                /searching/i,
+                /\.\.\./,
+                /in progress/i,
+            ]
+        });
+    }
+    detectState(output, currentState) {
+        // Clean ANSI codes for better pattern matching
+        const cleanOutput = this.stripAnsi(output);
+        // Check for errors first
+        if (this.matchesAny(cleanOutput, this.errorPatterns)) {
+            return SessionState.Error;
+        }
+        // Check if processing
+        if (this.matchesAny(cleanOutput, this.processingPatterns)) {
+            return SessionState.Processing;
+        }
+        // Check for prompts that need interaction
+        if (this.matchesAny(cleanOutput, this.promptPatterns)) {
+            // Check if it's a yes/no prompt or choice prompt
+            if (/\(y\/n\)/i.test(cleanOutput) ||
+                /\[y\/N\]/i.test(cleanOutput) ||
+                /Enter your choice/i.test(cleanOutput)) {
+                return SessionState.NeedsInteraction;
+            }
+            return SessionState.WaitingForInput;
+        }
+        // If we're getting output but no clear patterns, assume processing
+        if (cleanOutput.trim().length > 0 &&
+            currentState === SessionState.WaitingForInput) {
+            return SessionState.Processing;
+        }
+        // Default to current state
+        return currentState;
+    }
+    stripAnsi(str) {
+        // eslint-disable-next-line no-control-regex
+        return str.replace(/\x1b\[[0-9;]*m/g, '');
+    }
+    matchesAny(text, patterns) {
+        return patterns.some(pattern => pattern.test(text));
+    }
+}

package/dist/utils/debug.d.ts

@@ -0,0 +1 @@
+export declare function debugLog(location: string, message: string, data?: any): void;

package/dist/utils/debug.js

@@ -0,0 +1,109 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { homedir } from 'os';
+class DebugLogger {
+    constructor() {
+        Object.defineProperty(this, "logFile", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "stream", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        // Create log file in user's home directory
+        const logDir = path.join(homedir(), '.ccmanager');
+        if (!fs.existsSync(logDir)) {
+            fs.mkdirSync(logDir, { recursive: true });
+        }
+        this.logFile = path.join(logDir, 'debug.log');
+        this.initStream();
+    }
+    initStream() {
+        this.stream = fs.createWriteStream(this.logFile, { flags: 'a' });
+        // Add separator when starting new session
+        this.stream.write('\n' + '='.repeat(80) + '\n');
+        this.stream.write(`Session started at ${new Date().toISOString()}\n`);
+        this.stream.write('='.repeat(80) + '\n\n');
+    }
+    stripAnsi(str) {
+        // Remove ANSI escape sequences
+        return str.replace(/\x1B\[[0-9;]*m/g, '') // Color codes
+            .replace(/\x1B\[\?[0-9]+[hl]/g, '') // Cursor visibility
+            .replace(/\x1B\[[0-9]*[ABCDEFGHJKST]/g, '') // Cursor movement
+            .replace(/\x1B\[[0-9]*K/g, '') // Clear line
+            .replace(/\r/g, '') // Carriage returns
+            .replace(/\x1B\[2004[hl]/g, '') // Bracketed paste mode
+            .replace(/\x1B\[1004[hl]/g, ''); // Focus tracking mode
+    }
+    formatData(data) {
+        if (typeof data === 'string') {
+            const cleaned = this.stripAnsi(data);
+            // Only show non-empty, meaningful content
+            if (cleaned.trim()) {
+                // Truncate very long outputs
+                if (cleaned.length > 200) {
+                    return cleaned.substring(0, 200) + '... [truncated]';
+                }
+                return cleaned;
+            }
+            return '[empty or control sequences only]';
+        }
+        else if (typeof data === 'object' && data !== null) {
+            // Pretty print objects
+            return JSON.stringify(data, null, 2);
+        }
+        return String(data);
+    }
+    log(location, message, data) {
+        if (!this.stream)
+            return;
+        const timestampParts = new Date().toISOString().split('T');
+        const timestamp = timestampParts[1] ? timestampParts[1].replace('Z', '') : new Date().toTimeString().split(' ')[0];
+        // Format the log entry in a human-readable way
+        this.stream.write(`[${timestamp}] ${location}\n`);
+        this.stream.write(`  ${message}:\n`);
+        if (data !== undefined) {
+            const formattedData = this.formatData(data);
+            const lines = formattedData.split('\n');
+            lines.forEach(line => {
+                if (this.stream) {
+                    this.stream.write(`    ${line}\n`);
+                }
+            });
+        }
+        if (this.stream) {
+            this.stream.write('\n');
+        }
+    }
+    close() {
+        if (this.stream) {
+            this.stream.write(`\nSession ended at ${new Date().toISOString()}\n`);
+            this.stream.write('='.repeat(80) + '\n');
+            this.stream.end();
+            this.stream = null;
+        }
+    }
+}
+// Singleton instance
+const debugLogger = new DebugLogger();
+// Export a simple function for logging
+export function debugLog(location, message, data) {
+    debugLogger.log(location, message, data);
+}
+// Clean up on process exit
+process.on('exit', () => {
+    debugLogger.close();
+});
+process.on('SIGINT', () => {
+    debugLogger.close();
+    process.exit();
+});
+process.on('SIGTERM', () => {
+    debugLogger.close();
+    process.exit();
+});

package/dist/utils/promptDetector.d.ts

@@ -1 +1,3 @@
+export declare function includesPromptBoxLine(output: string): boolean;
+export declare function includesPromptBoxTopBorder(output: string): boolean;
 export declare function includesPromptBoxBottomBorder(output: string): boolean;

package/dist/utils/promptDetector.js

@@ -1,3 +1,27 @@
+export function includesPromptBoxLine(output) {
+    // Check if the output includes a prompt box line pattern (│ > [spaces])
+    return output.split('\n').some(line => /│\s*>\s*/.test(line));
+}
+export function includesPromptBoxTopBorder(output) {
+    // Check if the output includes a prompt box top border
+    return output
+        .trim()
+        .split('\n')
+        .some(line => {
+        // Accept patterns:
+        // - `──╮` (ends with ╮)
+        // - `╭───╮` (starts with ╭ and ends with ╮)
+        // Reject if:
+        // - vertical line exists after ╮
+        // - line starts with ╭ but doesn't end with ╮
+        // Check if line ends with ╮ but not followed by │
+        if (line.endsWith('╮') && !line.includes('╮ │')) {
+            // Accept if it's just ──╮ or ╭───╮ pattern
+            return /─+╮$/.test(line) || /^╭─+╮$/.test(line);
+        }
+        return false;
+    });
+}
 export function includesPromptBoxBottomBorder(output) {
     // Check if the output includes a prompt box bottom border
     return output

package/dist/utils/promptDetector.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { includesPromptBoxBottomBorder } from './promptDetector.js';
+import { includesPromptBoxBottomBorder, includesPromptBoxTopBorder, includesPromptBoxLine, } from './promptDetector.js';
 describe('includesPromptBoxBottomBorder', () => {
     it('should return false for empty output', () => {
         expect(includesPromptBoxBottomBorder('')).toBe(false);
@@ -79,3 +79,161 @@ Some other text`;
         expect(includesPromptBoxBottomBorder(partialInvalid)).toBe(false);
     });
 });
+describe('includesPromptBoxTopBorder', () => {
+    it('should return false for empty output', () => {
+        expect(includesPromptBoxTopBorder('')).toBe(false);
+        expect(includesPromptBoxTopBorder('   ')).toBe(false);
+        expect(includesPromptBoxTopBorder('\n\n')).toBe(false);
+    });
+    it('should accept lines ending with ╮', () => {
+        // Basic pattern
+        expect(includesPromptBoxTopBorder('──╮')).toBe(true);
+        expect(includesPromptBoxTopBorder('────────╮')).toBe(true);
+        expect(includesPromptBoxTopBorder('─╮')).toBe(true);
+    });
+    it('should accept complete top border (╭───╮)', () => {
+        expect(includesPromptBoxTopBorder('╭───╮')).toBe(true);
+        expect(includesPromptBoxTopBorder('╭─────────────╮')).toBe(true);
+        expect(includesPromptBoxTopBorder('╭─╮')).toBe(true);
+    });
+    it('should accept when part of multi-line output', () => {
+        const output1 = `Some text
+──╮
+More text`;
+        expect(includesPromptBoxTopBorder(output1)).toBe(true);
+        const output2 = `First line
+╭─────────────╮
+Last line`;
+        expect(includesPromptBoxTopBorder(output2)).toBe(true);
+    });
+    it('should accept with leading/trailing whitespace', () => {
+        expect(includesPromptBoxTopBorder('  ──╮  ')).toBe(true);
+        expect(includesPromptBoxTopBorder('\t╭───╮\t')).toBe(true);
+        expect(includesPromptBoxTopBorder('\n──╮\n')).toBe(true);
+    });
+    it('should reject when ╮ is followed by │', () => {
+        expect(includesPromptBoxTopBorder('──╮ │')).toBe(false);
+        expect(includesPromptBoxTopBorder('╭───╮ │')).toBe(false);
+        expect(includesPromptBoxTopBorder('──╮ │ some text')).toBe(false);
+    });
+    it('should reject when line starts with ╭ but does not end with ╮', () => {
+        expect(includesPromptBoxTopBorder('╭──')).toBe(false);
+        expect(includesPromptBoxTopBorder('╭─────────')).toBe(false);
+        expect(includesPromptBoxTopBorder('╭─── some text')).toBe(false);
+    });
+    it('should reject lines that do not match the pattern', () => {
+        // Missing ─ characters
+        expect(includesPromptBoxTopBorder('╮')).toBe(false);
+        expect(includesPromptBoxTopBorder('╭╮')).toBe(false);
+        // Wrong characters
+        expect(includesPromptBoxTopBorder('===╮')).toBe(false);
+        expect(includesPromptBoxTopBorder('╭===╮')).toBe(false);
+        expect(includesPromptBoxTopBorder('---╮')).toBe(false);
+        // Bottom border pattern
+        expect(includesPromptBoxTopBorder('╰───╯')).toBe(false);
+        // Middle line pattern
+        expect(includesPromptBoxTopBorder('│ > │')).toBe(false);
+        // Random text
+        expect(includesPromptBoxTopBorder('Some random text')).toBe(false);
+        expect(includesPromptBoxTopBorder('Exit code: 0')).toBe(false);
+    });
+    it('should handle complex multi-line scenarios correctly', () => {
+        const validOutput = `
+Some status text
+╭────────────────────╮
+│ > hello            │
+╰────────────────────╯`;
+        expect(includesPromptBoxTopBorder(validOutput)).toBe(true);
+        const invalidOutput = `
+Some status text
+ ────────────────────╮
+│ > hello            │
+╰────────────────────╯`;
+        expect(includesPromptBoxTopBorder(invalidOutput)).toBe(true);
+    });
+    it('should handle partial border at end of line', () => {
+        const partialBorder = `Some output text ──╮`;
+        expect(includesPromptBoxTopBorder(partialBorder)).toBe(true);
+        const partialInvalid = `Some output text ──╮ │`;
+        expect(includesPromptBoxTopBorder(partialInvalid)).toBe(false);
+    });
+});
+describe('includesPromptBoxLine', () => {
+    it('should return false for empty output', () => {
+        expect(includesPromptBoxLine('')).toBe(false);
+        expect(includesPromptBoxLine('   ')).toBe(false);
+        expect(includesPromptBoxLine('\n\n')).toBe(false);
+    });
+    it('should accept lines with prompt box pattern', () => {
+        // Basic patterns
+        expect(includesPromptBoxLine('│ > ')).toBe(true);
+        expect(includesPromptBoxLine('│ >  ')).toBe(true);
+        expect(includesPromptBoxLine('│ >   ')).toBe(true);
+        expect(includesPromptBoxLine('│ >                     ')).toBe(true);
+        // With spaces before >
+        expect(includesPromptBoxLine('│  > ')).toBe(true);
+        expect(includesPromptBoxLine('│   >  ')).toBe(true);
+        expect(includesPromptBoxLine('│\t> ')).toBe(true);
+    });
+    it('should accept when part of multi-line output', () => {
+        const output1 = `╭────────────────────╮
+│ >                  │
+╰────────────────────╯`;
+        expect(includesPromptBoxLine(output1)).toBe(true);
+        const output2 = `Some text before
+│ > hello world      │
+Some text after`;
+        expect(includesPromptBoxLine(output2)).toBe(true);
+    });
+    it('should accept with content after the prompt', () => {
+        expect(includesPromptBoxLine('│ > hello')).toBe(true);
+        expect(includesPromptBoxLine('│ > hello world │')).toBe(true);
+        expect(includesPromptBoxLine('│ > some command here │')).toBe(true);
+    });
+    it('should reject lines without the pattern', () => {
+        // Missing space after > (now accepts zero spaces)
+        expect(includesPromptBoxLine('│ >')).toBe(true);
+        expect(includesPromptBoxLine('│>')).toBe(true);
+        // Missing >
+        expect(includesPromptBoxLine('│   ')).toBe(false);
+        expect(includesPromptBoxLine('│ hello')).toBe(false);
+        // Missing │
+        expect(includesPromptBoxLine(' > ')).toBe(false);
+        expect(includesPromptBoxLine('> ')).toBe(false);
+        // Wrong characters
+        expect(includesPromptBoxLine('| > ')).toBe(false);
+        expect(includesPromptBoxLine('│ < ')).toBe(false);
+        expect(includesPromptBoxLine('│ » ')).toBe(false);
+        // Random text
+        expect(includesPromptBoxLine('Some random text')).toBe(false);
+        expect(includesPromptBoxLine('Exit code: 0')).toBe(false);
+    });
+    it('should handle complex scenarios', () => {
+        const validPromptBox = `
+╭────────────────────────────────────────────────────────────────────────────────╮
+│ Enter your message below. Press ESC to send | Type /help for help              │
+├────────────────────────────────────────────────────────────────────────────────┤
+│ >                                                                              │
+╰────────────────────────────────────────────────────────────────────────────────╯`;
+        expect(includesPromptBoxLine(validPromptBox)).toBe(true);
+        const invalidPromptBox = `
+╭────────────────────────────────────────────────────────────────────────────────╮
+│ Enter your message below. Press ESC to send | Type /help for help              │
+├────────────────────────────────────────────────────────────────────────────────┤
+│                                                                                │
+╰────────────────────────────────────────────────────────────────────────────────╯`;
+        expect(includesPromptBoxLine(invalidPromptBox)).toBe(false);
+    });
+    it('should handle edge cases', () => {
+        // Multiple prompt lines
+        const multiplePrompts = `│ > first
+│ > second
+│ > third`;
+        expect(includesPromptBoxLine(multiplePrompts)).toBe(true);
+        // Mixed valid and invalid
+        const mixed = `│ no prompt here
+│ > valid prompt
+│ also no prompt`;
+        expect(includesPromptBoxLine(mixed)).toBe(true);
+    });
+});

package/dist/utils/waitingPatternDetector.d.ts

@@ -0,0 +1 @@
+export declare function isWaitingForInput(output: string): boolean;

package/dist/utils/waitingPatternDetector.js

@@ -0,0 +1,16 @@
+export function isWaitingForInput(output) {
+    // Don't trim - we need to check end patterns
+    if (!output) {
+        return false;
+    }
+    // Check if output ends with Claude prompt ("> " at the end)
+    if (output.trimEnd().endsWith('>')) {
+        return true;
+    }
+    // Check for user interaction
+    // │ Do you want to proceed?
+    if (output.includes('│ Do you want')) {
+        return true;
+    }
+    return false;
+}

package/package.json

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