commandmate 0.1.5 → 0.1.6

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; } });

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

@@ -0,0 +1,143 @@
+"use strict";
+/**
+ * CLI Tool Manager
+ * Singleton class to manage multiple CLI tools (Claude, Codex, Gemini)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLIToolManager = void 0;
+const claude_1 = require("./claude");
+const codex_1 = require("./codex");
+const gemini_1 = require("./gemini");
+/**
+ * CLI Tool Manager (Singleton)
+ * Provides centralized access to all CLI tools
+ */
+class CLIToolManager {
+    static instance;
+    tools;
+    /**
+     * Private constructor for Singleton pattern
+     */
+    constructor() {
+        this.tools = new Map();
+        // Initialize all tools
+        this.tools.set('claude', new claude_1.ClaudeTool());
+        this.tools.set('codex', new codex_1.CodexTool());
+        this.tools.set('gemini', new gemini_1.GeminiTool());
+    }
+    /**
+     * Get singleton instance
+     *
+     * @returns CLIToolManager instance
+     */
+    static getInstance() {
+        if (!CLIToolManager.instance) {
+            CLIToolManager.instance = new CLIToolManager();
+        }
+        return CLIToolManager.instance;
+    }
+    /**
+     * Get a specific CLI tool by type
+     *
+     * @param type - CLI tool type
+     * @returns CLI tool instance
+     *
+     * @example
+     * ```typescript
+     * const manager = CLIToolManager.getInstance();
+     * const claude = manager.getTool('claude');
+     * await claude.startSession('my-worktree', '/path/to/worktree');
+     * ```
+     */
+    getTool(type) {
+        const tool = this.tools.get(type);
+        if (!tool) {
+            throw new Error(`CLI tool '${type}' not found`);
+        }
+        return tool;
+    }
+    /**
+     * Get all CLI tools
+     *
+     * @returns Array of all CLI tool instances
+     *
+     * @example
+     * ```typescript
+     * const manager = CLIToolManager.getInstance();
+     * const allTools = manager.getAllTools();
+     * console.log(allTools.map(t => t.name)); // ['Claude Code', 'Codex CLI', 'Gemini CLI']
+     * ```
+     */
+    getAllTools() {
+        return Array.from(this.tools.values());
+    }
+    /**
+     * Get information about a specific tool including installation status
+     *
+     * @param type - CLI tool type
+     * @returns Tool information with installation status
+     *
+     * @example
+     * ```typescript
+     * const manager = CLIToolManager.getInstance();
+     * const info = await manager.getToolInfo('claude');
+     * if (info.installed) {
+     *   console.log(`${info.name} is installed`);
+     * }
+     * ```
+     */
+    async getToolInfo(type) {
+        const tool = this.getTool(type);
+        const installed = await tool.isInstalled();
+        return {
+            id: tool.id,
+            name: tool.name,
+            command: tool.command,
+            installed,
+        };
+    }
+    /**
+     * Get information about all tools including installation status
+     *
+     * @returns Array of tool information for all tools
+     *
+     * @example
+     * ```typescript
+     * const manager = CLIToolManager.getInstance();
+     * const allInfo = await manager.getAllToolsInfo();
+     * allInfo.forEach(info => {
+     *   console.log(`${info.name}: ${info.installed ? 'installed' : 'not installed'}`);
+     * });
+     * ```
+     */
+    async getAllToolsInfo() {
+        const tools = this.getAllTools();
+        const infoPromises = tools.map(async (tool) => {
+            const installed = await tool.isInstalled();
+            return {
+                id: tool.id,
+                name: tool.name,
+                command: tool.command,
+                installed,
+            };
+        });
+        return Promise.all(infoPromises);
+    }
+    /**
+     * Get only installed tools
+     *
+     * @returns Array of tool information for installed tools only
+     *
+     * @example
+     * ```typescript
+     * const manager = CLIToolManager.getInstance();
+     * const installed = await manager.getInstalledTools();
+     * console.log(`${installed.length} tools installed`);
+     * ```
+     */
+    async getInstalledTools() {
+        const allInfo = await this.getAllToolsInfo();
+        return allInfo.filter(info => info.installed);
+    }
+}
+exports.CLIToolManager = CLIToolManager;

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

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Type definitions and interfaces for CLI tools
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/server/src/lib/conversation-logger.js

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * Conversation logging helper
+ * Ensures Claude responses are paired with the latest user input before writing markdown logs
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recordClaudeConversation = recordClaudeConversation;
+const db_1 = require("./db");
+const log_manager_1 = require("./log-manager");
+/**
+ * Persist the latest Claude response alongside the most recent user prompt.
+ * Errors are swallowed so the calling API route can continue responding.
+ */
+async function recordClaudeConversation(db, worktreeId, claudeResponse, cliToolId = 'claude') {
+    const lastUserMessage = (0, db_1.getLastUserMessage)(db, worktreeId);
+    if (!lastUserMessage) {
+        return;
+    }
+    try {
+        await (0, log_manager_1.createLog)(worktreeId, lastUserMessage.content, claudeResponse, cliToolId);
+    }
+    catch (error) {
+        console.error('[recordClaudeConversation] Failed to create log file:', error);
+    }
+}