commandmate 0.1.5 → 0.1.7

package/dist/server/src/lib/cli-patterns.js

@@ -0,0 +1,137 @@
+"use strict";
+/**
+ * Common CLI tool patterns for response detection
+ * Shared between response-poller.ts and API routes
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GEMINI_PROMPT_PATTERN = exports.CODEX_SEPARATOR_PATTERN = exports.CODEX_PROMPT_PATTERN = exports.CLAUDE_SEPARATOR_PATTERN = exports.CLAUDE_PROMPT_PATTERN = exports.CODEX_THINKING_PATTERN = exports.CLAUDE_THINKING_PATTERN = exports.CLAUDE_SPINNER_CHARS = void 0;
+exports.detectThinking = detectThinking;
+exports.getCliToolPatterns = getCliToolPatterns;
+exports.stripAnsi = stripAnsi;
+const logger_1 = require("./logger");
+const logger = (0, logger_1.createLogger)('cli-patterns');
+/**
+ * Claude CLI spinner characters (expanded set)
+ * These are shown when Claude is thinking/processing
+ */
+exports.CLAUDE_SPINNER_CHARS = [
+    '✻', '✽', '⏺', '·', '∴', '✢', '✳', '✶',
+    '⦿', '◉', '●', '○', '◌', '◎', '⊙', '⊚',
+    '⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏', // Braille spinner
+];
+/**
+ * Claude thinking pattern
+ * Matches spinner character followed by activity text ending with …
+ * The text can contain spaces (e.g., "Verifying implementation (dead code detection)…")
+ */
+exports.CLAUDE_THINKING_PATTERN = new RegExp(`[${exports.CLAUDE_SPINNER_CHARS.join('')}]\\s+.+…|to interrupt\\)`, 'm');
+/**
+ * Codex thinking pattern
+ * Matches activity indicators like "• Planning", "• Searching", etc.
+ */
+exports.CODEX_THINKING_PATTERN = /•\s*(Planning|Searching|Exploring|Running|Thinking|Working|Reading|Writing|Analyzing)/m;
+/**
+ * Claude prompt pattern (waiting for input)
+ * Supports both legacy '>' and new '❯' (U+276F) prompt characters
+ */
+exports.CLAUDE_PROMPT_PATTERN = /^[>❯]\s*$/m;
+/**
+ * Claude separator pattern
+ */
+exports.CLAUDE_SEPARATOR_PATTERN = /^─{10,}$/m;
+/**
+ * Codex prompt pattern
+ */
+exports.CODEX_PROMPT_PATTERN = /^›\s+.+/m;
+/**
+ * Codex separator pattern
+ */
+exports.CODEX_SEPARATOR_PATTERN = /^─.*Worked for.*─+$/m;
+/**
+ * Gemini shell prompt pattern
+ */
+exports.GEMINI_PROMPT_PATTERN = /^(%|\$|.*@.*[%$#])\s*$/m;
+/**
+ * Detect if CLI tool is showing "thinking" indicator
+ */
+function detectThinking(cliToolId, content) {
+    const log = logger.withContext({ cliToolId });
+    log.debug('detectThinking:check', { contentLength: content.length });
+    let result;
+    switch (cliToolId) {
+        case 'claude':
+            result = exports.CLAUDE_THINKING_PATTERN.test(content);
+            break;
+        case 'codex':
+            result = exports.CODEX_THINKING_PATTERN.test(content);
+            break;
+        case 'gemini':
+            // Gemini doesn't have a thinking indicator in one-shot mode
+            result = false;
+            break;
+        default:
+            result = exports.CLAUDE_THINKING_PATTERN.test(content);
+    }
+    log.debug('detectThinking:result', { isThinking: result });
+    return result;
+}
+/**
+ * Get CLI tool patterns for response extraction
+ */
+function getCliToolPatterns(cliToolId) {
+    switch (cliToolId) {
+        case 'claude':
+            return {
+                promptPattern: exports.CLAUDE_PROMPT_PATTERN,
+                separatorPattern: exports.CLAUDE_SEPARATOR_PATTERN,
+                thinkingPattern: exports.CLAUDE_THINKING_PATTERN,
+                skipPatterns: [
+                    /^─{10,}$/, // Separator lines
+                    /^[>❯]\s*$/, // Prompt line (legacy '>' and new '❯')
+                    exports.CLAUDE_THINKING_PATTERN, // Thinking indicators
+                    /^\s*[⎿⏋]\s+Tip:/, // Tip lines
+                    /^\s*Tip:/, // Tip lines
+                    /^\s*\?\s*for shortcuts/, // Shortcuts hint
+                    /to interrupt\)/, // Part of "esc to interrupt" message
+                ],
+            };
+        case 'codex':
+            return {
+                promptPattern: exports.CODEX_PROMPT_PATTERN,
+                separatorPattern: exports.CODEX_SEPARATOR_PATTERN,
+                thinkingPattern: exports.CODEX_THINKING_PATTERN,
+                skipPatterns: [
+                    /^─.*─+$/, // Separator lines
+                    /^›\s*$/, // Empty prompt line
+                    /^›\s+(Implement|Find and fix|Type)/, // New prompt suggestions
+                    exports.CODEX_THINKING_PATTERN, // Activity indicators
+                    /^\s*\d+%\s+context left/, // Context indicator
+                    /^\s*for shortcuts$/, // Shortcuts hint
+                    /╭─+╮/, // Box drawing (top)
+                    /╰─+╯/, // Box drawing (bottom)
+                ],
+            };
+        case 'gemini':
+            return {
+                promptPattern: exports.GEMINI_PROMPT_PATTERN,
+                separatorPattern: /^gemini\s+--\s+/m,
+                thinkingPattern: /(?!)/m, // Never matches - one-shot execution
+                skipPatterns: [
+                    /^gemini\s+--\s+/, // Command line itself
+                    exports.GEMINI_PROMPT_PATTERN, // Shell prompt lines
+                    /^\s*$/, // Empty lines
+                ],
+            };
+        default:
+            // Default to Claude patterns
+            return getCliToolPatterns('claude');
+    }
+}
+/**
+ * Strip ANSI escape codes from a string
+ * Optimized version at module level for performance
+ */
+const ANSI_PATTERN = /\x1b\[[0-9;]*[a-zA-Z]|\x1b\][^\x07]*\x07|\[[0-9;]*m/g;
+function stripAnsi(str) {
+    return str.replace(ANSI_PATTERN, '');
+}

package/dist/server/src/lib/cli-session.js

@@ -0,0 +1,73 @@
+"use strict";
+/**
+ * Generic CLI session management
+ * Manages CLI tool sessions (Claude, Codex, Gemini) within tmux
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSessionRunning = isSessionRunning;
+exports.captureSessionOutput = captureSessionOutput;
+exports.getSessionName = getSessionName;
+const tmux_1 = require("./tmux");
+const manager_1 = require("./cli-tools/manager");
+const logger_1 = require("./logger");
+const logger = (0, logger_1.createLogger)('cli-session');
+/**
+ * Check if CLI tool session is running
+ *
+ * @param worktreeId - Worktree ID
+ * @param cliToolId - CLI tool ID (claude, codex, gemini)
+ * @returns True if session exists and is running
+ */
+async function isSessionRunning(worktreeId, cliToolId) {
+    const manager = manager_1.CLIToolManager.getInstance();
+    const cliTool = manager.getTool(cliToolId);
+    const sessionName = cliTool.getSessionName(worktreeId);
+    return await (0, tmux_1.hasSession)(sessionName);
+}
+/**
+ * Capture CLI session output
+ *
+ * @param worktreeId - Worktree ID
+ * @param cliToolId - CLI tool ID (claude, codex, gemini)
+ * @param lines - Number of lines to capture (default: 1000)
+ * @returns Captured output
+ */
+async function captureSessionOutput(worktreeId, cliToolId, lines = 1000) {
+    const log = logger.withContext({ worktreeId, cliToolId });
+    log.debug('captureSessionOutput:start', { requestedLines: lines });
+    const manager = manager_1.CLIToolManager.getInstance();
+    const cliTool = manager.getTool(cliToolId);
+    const sessionName = cliTool.getSessionName(worktreeId);
+    // Check if session exists
+    const exists = await (0, tmux_1.hasSession)(sessionName);
+    if (!exists) {
+        log.debug('captureSessionOutput:sessionNotFound', { sessionName });
+        throw new Error(`${cliTool.name} session ${sessionName} does not exist`);
+    }
+    try {
+        const output = await (0, tmux_1.capturePane)(sessionName, { startLine: -lines });
+        const actualLines = output.split('\n').length;
+        log.debug('captureSessionOutput:success', {
+            actualLines,
+            lastFewLines: output.split('\n').slice(-3).join(' | '),
+        });
+        return output;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        log.error('captureSessionOutput:failed', { error: errorMessage });
+        throw new Error(`Failed to capture ${cliTool.name} output: ${errorMessage}`);
+    }
+}
+/**
+ * Get session name for a CLI tool and worktree
+ *
+ * @param worktreeId - Worktree ID
+ * @param cliToolId - CLI tool ID
+ * @returns Session name
+ */
+function getSessionName(worktreeId, cliToolId) {
+    const manager = manager_1.CLIToolManager.getInstance();
+    const cliTool = manager.getTool(cliToolId);
+    return cliTool.getSessionName(worktreeId);
+}

package/dist/server/src/lib/cli-tools/base.js

@@ -0,0 +1,51 @@
+"use strict";
+/**
+ * Base implementation for CLI tools
+ * Provides common functionality for all CLI tool implementations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseCLITool = void 0;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const tmux_1 = require("../tmux");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+/**
+ * Abstract base class for CLI tools
+ * Implements common functionality and defines abstract methods for specific implementations
+ */
+class BaseCLITool {
+    /**
+     * Check if CLI tool is installed
+     * Uses 'which' command to check if the tool is available in PATH
+     */
+    async isInstalled() {
+        try {
+            await execAsync(`which ${this.command}`, { timeout: 5000 });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Generate session name for a worktree
+     * Format: mcbd-{cli_tool_id}-{worktree_id}
+     *
+     * @param worktreeId - Worktree ID
+     * @returns Session name
+     */
+    getSessionName(worktreeId) {
+        return `mcbd-${this.id}-${worktreeId}`;
+    }
+    /**
+     * Interrupt processing by sending Escape key
+     * Default implementation: send Escape key to tmux session
+     *
+     * @param worktreeId - Worktree ID
+     */
+    async interrupt(worktreeId) {
+        const sessionName = this.getSessionName(worktreeId);
+        await (0, tmux_1.sendSpecialKey)(sessionName, 'Escape');
+    }
+}
+exports.BaseCLITool = BaseCLITool;

package/dist/server/src/lib/cli-tools/claude.js

@@ -0,0 +1,65 @@
+"use strict";
+/**
+ * Claude Code CLI tool implementation
+ * Wraps existing claude-session functionality into the ICLITool interface
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClaudeTool = void 0;
+const base_1 = require("./base");
+const claude_session_1 = require("../claude-session");
+/**
+ * Claude Code CLI tool implementation
+ * Uses existing claude-session module for compatibility
+ */
+class ClaudeTool extends base_1.BaseCLITool {
+    id = 'claude';
+    name = 'Claude Code';
+    command = 'claude';
+    /**
+     * Check if Claude CLI is installed
+     * Uses existing isClaudeInstalled function for compatibility
+     */
+    async isInstalled() {
+        return await (0, claude_session_1.isClaudeInstalled)();
+    }
+    /**
+     * Check if Claude session is running for a worktree
+     *
+     * @param worktreeId - Worktree ID
+     * @returns True if session is running
+     */
+    async isRunning(worktreeId) {
+        return await (0, claude_session_1.isClaudeRunning)(worktreeId);
+    }
+    /**
+     * Start a new Claude session for a worktree
+     *
+     * @param worktreeId - Worktree ID
+     * @param worktreePath - Worktree path
+     */
+    async startSession(worktreeId, worktreePath) {
+        const options = {
+            worktreeId,
+            worktreePath,
+        };
+        await (0, claude_session_1.startClaudeSession)(options);
+    }
+    /**
+     * Send a message to Claude session
+     *
+     * @param worktreeId - Worktree ID
+     * @param message - Message to send
+     */
+    async sendMessage(worktreeId, message) {
+        await (0, claude_session_1.sendMessageToClaude)(worktreeId, message);
+    }
+    /**
+     * Kill Claude session
+     *
+     * @param worktreeId - Worktree ID
+     */
+    async killSession(worktreeId) {
+        await (0, claude_session_1.stopClaudeSession)(worktreeId);
+    }
+}
+exports.ClaudeTool = ClaudeTool;

package/dist/server/src/lib/cli-tools/codex.js

@@ -0,0 +1,132 @@
+"use strict";
+/**
+ * Codex CLI tool implementation
+ * Provides integration with OpenAI's Codex CLI
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodexTool = void 0;
+const base_1 = require("./base");
+const tmux_1 = require("../tmux");
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+/**
+ * Codex CLI tool implementation
+ * Manages Codex sessions using tmux
+ */
+class CodexTool extends base_1.BaseCLITool {
+    id = 'codex';
+    name = 'Codex CLI';
+    command = 'codex';
+    /**
+     * Check if Codex session is running for a worktree
+     *
+     * @param worktreeId - Worktree ID
+     * @returns True if session is running
+     */
+    async isRunning(worktreeId) {
+        const sessionName = this.getSessionName(worktreeId);
+        return await (0, tmux_1.hasSession)(sessionName);
+    }
+    /**
+     * Start a new Codex session for a worktree
+     *
+     * @param worktreeId - Worktree ID
+     * @param worktreePath - Worktree path
+     */
+    async startSession(worktreeId, worktreePath) {
+        // Check if Codex is installed
+        const codexAvailable = await this.isInstalled();
+        if (!codexAvailable) {
+            throw new Error('Codex CLI is not installed or not in PATH');
+        }
+        const sessionName = this.getSessionName(worktreeId);
+        // Check if session already exists
+        const exists = await (0, tmux_1.hasSession)(sessionName);
+        if (exists) {
+            console.log(`Codex session ${sessionName} already exists`);
+            return;
+        }
+        try {
+            // Create tmux session with large history buffer for Codex output
+            await (0, tmux_1.createSession)({
+                sessionName,
+                workingDirectory: worktreePath,
+                historyLimit: 50000,
+            });
+            // Wait a moment for the session to be created
+            await new Promise((resolve) => setTimeout(resolve, 100));
+            // Start Codex CLI in interactive mode
+            await (0, tmux_1.sendKeys)(sessionName, 'codex', true);
+            // Wait for Codex to initialize (and potentially show update notification)
+            await new Promise((resolve) => setTimeout(resolve, 3000));
+            // Auto-skip update notification if present (select option 2: Skip)
+            await (0, tmux_1.sendKeys)(sessionName, '2', true);
+            // Wait a moment for the selection to process
+            await new Promise((resolve) => setTimeout(resolve, 500));
+            console.log(`✓ Started Codex session: ${sessionName}`);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to start Codex session: ${errorMessage}`);
+        }
+    }
+    /**
+     * Send a message to Codex session
+     *
+     * @param worktreeId - Worktree ID
+     * @param message - Message to send
+     */
+    async sendMessage(worktreeId, message) {
+        const sessionName = this.getSessionName(worktreeId);
+        // Check if session exists
+        const exists = await (0, tmux_1.hasSession)(sessionName);
+        if (!exists) {
+            throw new Error(`Codex session ${sessionName} does not exist. Start the session first.`);
+        }
+        try {
+            // Send message to Codex (without Enter)
+            await (0, tmux_1.sendKeys)(sessionName, message, false);
+            // Wait a moment for the text to be typed
+            await new Promise((resolve) => setTimeout(resolve, 100));
+            // Send Enter key separately
+            await execAsync(`tmux send-keys -t "${sessionName}" C-m`);
+            // Wait a moment for the message to be processed
+            await new Promise((resolve) => setTimeout(resolve, 200));
+            console.log(`✓ Sent message to Codex session: ${sessionName}`);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to send message to Codex: ${errorMessage}`);
+        }
+    }
+    /**
+     * Kill Codex session
+     *
+     * @param worktreeId - Worktree ID
+     */
+    async killSession(worktreeId) {
+        const sessionName = this.getSessionName(worktreeId);
+        try {
+            // Send Ctrl+D to exit Codex gracefully
+            const exists = await (0, tmux_1.hasSession)(sessionName);
+            if (exists) {
+                // Send Ctrl+D (ASCII 4)
+                await execAsync(`tmux send-keys -t "${sessionName}" C-d`);
+                // Wait a moment for Codex to exit
+                await new Promise((resolve) => setTimeout(resolve, 500));
+            }
+            // Kill the tmux session
+            const killed = await (0, tmux_1.killSession)(sessionName);
+            if (killed) {
+                console.log(`✓ Stopped Codex session: ${sessionName}`);
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`Error stopping Codex session: ${errorMessage}`);
+            throw error;
+        }
+    }
+}
+exports.CodexTool = CodexTool;

package/dist/server/src/lib/cli-tools/gemini.js

@@ -0,0 +1,122 @@
+"use strict";
+/**
+ * Gemini CLI tool implementation
+ * Provides integration with Google's Gemini CLI
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeminiTool = void 0;
+const base_1 = require("./base");
+const tmux_1 = require("../tmux");
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+/**
+ * Gemini CLI tool implementation
+ * Manages Gemini sessions using tmux
+ */
+class GeminiTool extends base_1.BaseCLITool {
+    id = 'gemini';
+    name = 'Gemini CLI';
+    command = 'gemini';
+    /**
+     * Check if Gemini session is running for a worktree
+     *
+     * @param worktreeId - Worktree ID
+     * @returns True if session is running
+     */
+    async isRunning(worktreeId) {
+        const sessionName = this.getSessionName(worktreeId);
+        return await (0, tmux_1.hasSession)(sessionName);
+    }
+    /**
+     * Start a new Gemini session for a worktree
+     * Note: Gemini uses non-interactive mode, so we just create a tmux session
+     * for running one-shot commands
+     *
+     * @param worktreeId - Worktree ID
+     * @param worktreePath - Worktree path
+     */
+    async startSession(worktreeId, worktreePath) {
+        // Check if Gemini is installed
+        const geminiAvailable = await this.isInstalled();
+        if (!geminiAvailable) {
+            throw new Error('Gemini CLI is not installed or not in PATH');
+        }
+        const sessionName = this.getSessionName(worktreeId);
+        // Check if session already exists
+        const exists = await (0, tmux_1.hasSession)(sessionName);
+        if (exists) {
+            console.log(`Gemini session ${sessionName} already exists`);
+            return;
+        }
+        try {
+            // Create tmux session for running Gemini commands
+            await (0, tmux_1.createSession)({
+                sessionName,
+                workingDirectory: worktreePath,
+                historyLimit: 50000,
+            });
+            console.log(`✓ Started Gemini session: ${sessionName}`);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to start Gemini session: ${errorMessage}`);
+        }
+    }
+    /**
+     * Send a message to Gemini session (non-interactive mode)
+     * Executes a one-shot Gemini command and captures the output
+     *
+     * @param worktreeId - Worktree ID
+     * @param message - Message to send
+     */
+    async sendMessage(worktreeId, message) {
+        const sessionName = this.getSessionName(worktreeId);
+        // Check if session exists
+        const exists = await (0, tmux_1.hasSession)(sessionName);
+        if (!exists) {
+            throw new Error(`Gemini session ${sessionName} does not exist. Start the session first.`);
+        }
+        try {
+            // Escape the message for shell execution
+            const escapedMessage = message.replace(/'/g, "'\\''");
+            // Execute Gemini in non-interactive mode using stdin piping
+            // This approach bypasses the TUI and executes in one-shot mode
+            await (0, tmux_1.sendKeys)(sessionName, `echo '${escapedMessage}' | gemini`, true);
+            console.log(`✓ Sent message to Gemini session: ${sessionName}`);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to send message to Gemini: ${errorMessage}`);
+        }
+    }
+    /**
+     * Kill Gemini session
+     *
+     * @param worktreeId - Worktree ID
+     */
+    async killSession(worktreeId) {
+        const sessionName = this.getSessionName(worktreeId);
+        try {
+            // Send Ctrl+D to exit Gemini gracefully
+            const exists = await (0, tmux_1.hasSession)(sessionName);
+            if (exists) {
+                // Send Ctrl+D (ASCII 4)
+                await execAsync(`tmux send-keys -t "${sessionName}" C-d`);
+                // Wait a moment for Gemini to exit
+                await new Promise((resolve) => setTimeout(resolve, 500));
+            }
+            // Kill the tmux session
+            const killed = await (0, tmux_1.killSession)(sessionName);
+            if (killed) {
+                console.log(`✓ Stopped Gemini session: ${sessionName}`);
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`Error stopping Gemini session: ${errorMessage}`);
+            throw error;
+        }
+    }
+}
+exports.GeminiTool = GeminiTool;

package/dist/server/src/lib/cli-tools/index.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * CLI Tools Module
+ * Provides abstraction layer for multiple SWE CLI tools (Claude, Codex, Gemini)
+ *
+ * @module cli-tools
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLIToolManager = exports.GeminiTool = exports.CodexTool = exports.ClaudeTool = exports.BaseCLITool = void 0;
+// Export base class
+var base_1 = require("./base");
+Object.defineProperty(exports, "BaseCLITool", { enumerable: true, get: function () { return base_1.BaseCLITool; } });
+// Export CLI tool implementations
+var claude_1 = require("./claude");
+Object.defineProperty(exports, "ClaudeTool", { enumerable: true, get: function () { return claude_1.ClaudeTool; } });
+var codex_1 = require("./codex");
+Object.defineProperty(exports, "CodexTool", { enumerable: true, get: function () { return codex_1.CodexTool; } });
+var gemini_1 = require("./gemini");
+Object.defineProperty(exports, "GeminiTool", { enumerable: true, get: function () { return gemini_1.GeminiTool; } });
+// Export CLI tool manager
+var manager_1 = require("./manager");
+Object.defineProperty(exports, "CLIToolManager", { enumerable: true, get: function () { return manager_1.CLIToolManager; } });