commandmate 0.1.5 → 0.1.6

package/README.md

@@ -49,11 +49,43 @@ Claude Code での開発経験があり、本業の傍らで個人開発を続
 
 - macOS / Linux（tmux 依存のため Windows は非対応）
 - Node.js v20+、npm、git、tmux、openssl
-- Claude CLI（CLAUDE_HOOKS_STOP 対応）
+- Claude CLI（オプション）
 
-> **Tip**: `./scripts/preflight-check.sh` で依存関係を確認できます。
+### インストール
 
-### セットアップ
+```bash
+npm install -g commandmate
+```
+
+### セットアップと起動
+
+```bash
+commandmate init              # 依存チェック、環境設定、DB初期化
+commandmate start --daemon    # バックグラウンドで起動
+```
+
+ブラウザで http://localhost:3000 にアクセスしてください。
+
+### CLI コマンド
+
+| コマンド | 説明 |
+|---------|------|
+| `commandmate init` | 初期設定（対話形式） |
+| `commandmate init --defaults` | 初期設定（デフォルト値） |
+| `commandmate start --daemon` | バックグラウンド起動 |
+| `commandmate start -p 3001` | ポート指定で起動 |
+| `commandmate stop` | サーバー停止 |
+| `commandmate status` | 状態確認 |
+
+詳しくは [CLI セットアップガイド](./docs/user-guide/cli-setup-guide.md) を参照してください。
+
+### モバイルからのアクセス
+
+`commandmate init` で外部アクセスを有効にすると、`CM_BIND=0.0.0.0` と `CM_AUTH_TOKEN` が自動設定されます。同一LAN内から `http://<PCのIP>:3000` にアクセスします。
+
+## 開発者向けセットアップ
+
+コントリビューターや開発環境を構築する場合は、git clone を使用してください。
 
 ```bash
 git clone https://github.com/Kewton/CommandMate.git
@@ -61,8 +93,6 @@ cd CommandMate
 ./scripts/setup.sh  # 依存チェック、環境設定、ビルド、起動まで自動実行
 ```
 
-ブラウザで http://localhost:3000 にアクセスしてください。
-
 ### 手動セットアップ（カスタマイズしたい場合）
 
 ```bash
@@ -76,7 +106,7 @@ npm run build
 npm start
 ```
 
-スマホから利用する場合は `./scripts/setup-env.sh` で外部アクセスを有効にすると、`CM_BIND=0.0.0.0` と `CM_AUTH_TOKEN` が自動設定されます。同一LAN内から `http://<PCのIP>:3000` にアクセスします。
+> **Note**: `./scripts/*` スクリプトは開発環境でのみ使用可能です。グローバルインストール（`npm install -g`）では `commandmate` CLI を使用してください。
 
 > **Note**: 旧名称の環境変数（`MCBD_*`）も後方互換性のためサポートされていますが、新名称（`CM_*`）の使用を推奨します。
 
@@ -104,13 +134,14 @@ A: 現時点では個人利用を想定しています。複数人での同時
 
 | ドキュメント | 説明 |
 |-------------|------|
+| [CLI セットアップガイド](./docs/user-guide/cli-setup-guide.md) | インストールと初期設定 |
+| [Webアプリ操作ガイド](./docs/user-guide/webapp-guide.md) | Webアプリの基本操作 |
+| [クイックスタート](./docs/user-guide/quick-start.md) | Claude Codeコマンドの使い方 |
 | [コンセプト](./docs/concept.md) | ビジョンと解決する課題 |
 | [アーキテクチャ](./docs/architecture.md) | システム設計 |
 | [デプロイガイド](./docs/DEPLOYMENT.md) | 本番環境構築手順 |
 | [移行ガイド](./docs/migration-to-commandmate.md) | MyCodeBranchDesk からの移行手順 |
 | [UI/UXガイド](./docs/UI_UX_GUIDE.md) | UI実装の詳細 |
-| [Webアプリ操作ガイド](./docs/user-guide/webapp-guide.md) | Webアプリの基本操作 |
-| [クイックスタート](./docs/user-guide/quick-start.md) | Claude Codeコマンドの使い方 |
 | [Trust & Safety](./docs/TRUST_AND_SAFETY.md) | セキュリティと権限の考え方 |
 
 ## Contributing

package/dist/server/server.js

@@ -0,0 +1,123 @@
+"use strict";
+/**
+ * Custom Next.js Server with WebSocket Support
+ * Integrates WebSocket server for real-time communication
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// IMPORTANT: Register uncaught exception handler FIRST, before any imports
+// This ensures we catch WebSocket frame errors before other handlers
+process.on('uncaughtException', (error) => {
+    // Check for WebSocket-related errors that are non-fatal
+    const isWebSocketError = error.code === 'WS_ERR_INVALID_UTF8' ||
+        error.code === 'WS_ERR_INVALID_CLOSE_CODE' ||
+        error.code === 'WS_ERR_UNEXPECTED_RSV_1' ||
+        error.code === 'ECONNRESET' ||
+        error.code === 'EPIPE' ||
+        (error instanceof RangeError && error.message?.includes('Invalid WebSocket frame')) ||
+        error.message?.includes('write after end');
+    if (isWebSocketError) {
+        // Silently ignore these non-fatal WebSocket frame errors
+        // They commonly occur when mobile browsers send malformed close frames
+        return;
+    }
+    // For other uncaught exceptions, log and exit
+    console.error('Uncaught exception:', error);
+    process.exit(1);
+});
+const http_1 = require("http");
+const url_1 = require("url");
+const next_1 = __importDefault(require("next"));
+const ws_server_1 = require("./src/lib/ws-server");
+const worktrees_1 = require("./src/lib/worktrees");
+const db_instance_1 = require("./src/lib/db-instance");
+const response_poller_1 = require("./src/lib/response-poller");
+const db_migrations_1 = require("./src/lib/db-migrations");
+const env_1 = require("./src/lib/env");
+const dev = process.env.NODE_ENV !== 'production';
+const hostname = (0, env_1.getEnvByKey)('CM_BIND') || '127.0.0.1';
+const port = parseInt((0, env_1.getEnvByKey)('CM_PORT') || '3000', 10);
+// Create Next.js app
+const app = (0, next_1.default)({ dev, hostname, port });
+const handle = app.getRequestHandler();
+app.prepare().then(() => {
+    // Create HTTP server
+    const server = (0, http_1.createServer)(async (req, res) => {
+        try {
+            const parsedUrl = (0, url_1.parse)(req.url, true);
+            await handle(req, res, parsedUrl);
+        }
+        catch (err) {
+            console.error('Error handling request', err);
+            res.statusCode = 500;
+            res.end('Internal Server Error');
+        }
+    });
+    // Setup WebSocket server
+    (0, ws_server_1.setupWebSocket)(server);
+    // Scan and sync worktrees on startup
+    async function initializeWorktrees() {
+        try {
+            // Run database migrations first
+            console.log('Running database migrations...');
+            const db = (0, db_instance_1.getDbInstance)();
+            (0, db_migrations_1.runMigrations)(db);
+            // Get repository paths from environment variables
+            const repositoryPaths = (0, worktrees_1.getRepositoryPaths)();
+            if (repositoryPaths.length === 0) {
+                console.warn('Warning: No repository paths configured');
+                console.warn('Set WORKTREE_REPOS (comma-separated) or MCBD_ROOT_DIR');
+                return;
+            }
+            console.log(`Configured repositories: ${repositoryPaths.length}`);
+            repositoryPaths.forEach((path, i) => {
+                console.log(`  ${i + 1}. ${path}`);
+            });
+            // Scan all repositories
+            const worktrees = await (0, worktrees_1.scanMultipleRepositories)(repositoryPaths);
+            // Sync to database
+            (0, worktrees_1.syncWorktreesToDB)(db, worktrees);
+            console.log(`✓ Total: ${worktrees.length} worktree(s) synced to database`);
+        }
+        catch (error) {
+            console.error('Error initializing worktrees:', error);
+        }
+    }
+    server.listen(port, async (err) => {
+        if (err)
+            throw err;
+        console.log(`> Ready on http://${hostname}:${port}`);
+        console.log(`> WebSocket server ready`);
+        // Initialize worktrees after server starts
+        await initializeWorktrees();
+    });
+    // Graceful shutdown with timeout
+    let isShuttingDown = false;
+    function gracefulShutdown(signal) {
+        if (isShuttingDown) {
+            console.log('Shutdown already in progress, forcing exit...');
+            process.exit(1);
+        }
+        isShuttingDown = true;
+        console.log(`${signal} received: shutting down...`);
+        // Stop polling first
+        (0, response_poller_1.stopAllPolling)();
+        // Close WebSocket connections immediately (don't wait)
+        (0, ws_server_1.closeWebSocket)();
+        // Force exit after 3 seconds if graceful shutdown fails
+        const forceExitTimeout = setTimeout(() => {
+            console.log('Graceful shutdown timeout, forcing exit...');
+            process.exit(1);
+        }, 3000);
+        // Try graceful HTTP server close
+        server.close(() => {
+            clearTimeout(forceExitTimeout);
+            console.log('Server closed gracefully');
+            process.exit(0);
+        });
+    }
+    process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));
+    process.on('SIGINT', () => gracefulShutdown('SIGINT'));
+});

package/dist/server/src/lib/claude-output.js

@@ -0,0 +1,33 @@
+"use strict";
+/**
+ * Claude output parsing utilities
+ * Shared between webhook handlers and polling logic
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseClaudeOutput = parseClaudeOutput;
+const LOG_FILE_REGEX = /📄 Session log: (.+?\/([^\/\s]+\.jsonl))/;
+const REQUEST_ID_REGEX = /Request ID: ([^\s\n]+)/;
+const SUMMARY_REGEX = /Summary: (.+?)(?:\n─|$)/s;
+/**
+ * Parse Claude CLI output and extract metadata that the UI relies on.
+ *
+ * @param output Raw tmux capture string
+ */
+function parseClaudeOutput(output) {
+    const result = {
+        content: output,
+    };
+    const logFileMatch = LOG_FILE_REGEX.exec(output);
+    if (logFileMatch) {
+        result.logFileName = logFileMatch[2];
+    }
+    const requestIdMatch = REQUEST_ID_REGEX.exec(output);
+    if (requestIdMatch) {
+        result.requestId = requestIdMatch[1];
+    }
+    const summaryMatch = SUMMARY_REGEX.exec(output);
+    if (summaryMatch) {
+        result.summary = summaryMatch[1].trim();
+    }
+    return result;
+}

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

@@ -0,0 +1,312 @@
+"use strict";
+/**
+ * Claude CLI session management
+ * Manages Claude CLI sessions within tmux for each worktree
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSessionName = getSessionName;
+exports.isClaudeInstalled = isClaudeInstalled;
+exports.isClaudeRunning = isClaudeRunning;
+exports.getClaudeSessionState = getClaudeSessionState;
+exports.startClaudeSession = startClaudeSession;
+exports.sendMessageToClaude = sendMessageToClaude;
+exports.captureClaudeOutput = captureClaudeOutput;
+exports.stopClaudeSession = stopClaudeSession;
+exports.restartClaudeSession = restartClaudeSession;
+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);
+/**
+ * Cached Claude CLI path
+ */
+let cachedClaudePath = null;
+/**
+ * Get Claude CLI path dynamically
+ * Uses CLAUDE_PATH environment variable if set, otherwise finds via 'which'
+ */
+async function getClaudePath() {
+    // Return cached path if available
+    if (cachedClaudePath) {
+        return cachedClaudePath;
+    }
+    // Check environment variable first
+    if (process.env.CLAUDE_PATH) {
+        cachedClaudePath = process.env.CLAUDE_PATH;
+        return cachedClaudePath;
+    }
+    // Find claude via 'which' command
+    try {
+        const { stdout } = await execAsync('which claude', { timeout: 5000 });
+        cachedClaudePath = stdout.trim();
+        return cachedClaudePath;
+    }
+    catch {
+        // Fallback to common paths
+        const fallbackPaths = [
+            '/opt/homebrew/bin/claude', // macOS Homebrew (Apple Silicon)
+            '/usr/local/bin/claude', // macOS Homebrew (Intel) / Linux
+            '/usr/bin/claude', // Linux system install
+        ];
+        for (const path of fallbackPaths) {
+            try {
+                await execAsync(`test -x "${path}"`, { timeout: 1000 });
+                cachedClaudePath = path;
+                return cachedClaudePath;
+            }
+            catch {
+                // Path not found, try next
+            }
+        }
+        throw new Error('Claude CLI not found. Set CLAUDE_PATH environment variable or install Claude CLI.');
+    }
+}
+/**
+ * Get tmux session name for a worktree
+ *
+ * @param worktreeId - Worktree ID
+ * @returns tmux session name
+ *
+ * @example
+ * ```typescript
+ * getSessionName('feature-foo') // => 'mcbd-claude-feature-foo'
+ * ```
+ */
+function getSessionName(worktreeId) {
+    return `mcbd-claude-${worktreeId}`;
+}
+/**
+ * Check if Claude is installed and available
+ *
+ * @returns True if Claude CLI is available
+ */
+async function isClaudeInstalled() {
+    try {
+        await execAsync('which claude', { timeout: 5000 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if Claude session is running
+ *
+ * @param worktreeId - Worktree ID
+ * @returns True if Claude session exists and is running
+ *
+ * @example
+ * ```typescript
+ * const running = await isClaudeRunning('feature-foo');
+ * if (running) {
+ *   console.log('Claude is ready');
+ * }
+ * ```
+ */
+async function isClaudeRunning(worktreeId) {
+    const sessionName = getSessionName(worktreeId);
+    return await (0, tmux_1.hasSession)(sessionName);
+}
+/**
+ * Get Claude session state
+ *
+ * @param worktreeId - Worktree ID
+ * @returns Session state information
+ */
+async function getClaudeSessionState(worktreeId) {
+    const sessionName = getSessionName(worktreeId);
+    const isRunning = await (0, tmux_1.hasSession)(sessionName);
+    return {
+        sessionName,
+        isRunning,
+        lastActivity: new Date(),
+    };
+}
+/**
+ * Start a Claude CLI session in tmux
+ *
+ * @param options - Session options
+ * @throws {Error} If Claude CLI is not installed or session creation fails
+ *
+ * @example
+ * ```typescript
+ * await startClaudeSession({
+ *   worktreeId: 'feature-foo',
+ *   worktreePath: '/path/to/worktree',
+ *   baseUrl: 'http://localhost:3000',
+ * });
+ * ```
+ */
+async function startClaudeSession(options) {
+    const { worktreeId, worktreePath } = options;
+    // Check if Claude is installed
+    const claudeAvailable = await isClaudeInstalled();
+    if (!claudeAvailable) {
+        throw new Error('Claude CLI is not installed or not in PATH');
+    }
+    const sessionName = getSessionName(worktreeId);
+    // Check if session already exists
+    const exists = await (0, tmux_1.hasSession)(sessionName);
+    if (exists) {
+        console.log(`Claude session ${sessionName} already exists`);
+        return;
+    }
+    try {
+        // Create tmux session with large history buffer for Claude output
+        await (0, tmux_1.createSession)({
+            sessionName,
+            workingDirectory: worktreePath,
+            historyLimit: 50000,
+        });
+        // Get Claude CLI path dynamically
+        const claudePath = await getClaudePath();
+        // Start Claude CLI in interactive mode using dynamically resolved path
+        await (0, tmux_1.sendKeys)(sessionName, claudePath, true);
+        // Wait for Claude to initialize with dynamic detection
+        // Check for Claude prompt instead of fixed delay
+        const maxWaitTime = 10000; // 10 seconds max
+        const pollInterval = 500; // Check every 500ms
+        const startTime = Date.now();
+        while (Date.now() - startTime < maxWaitTime) {
+            await new Promise((resolve) => setTimeout(resolve, pollInterval));
+            try {
+                const output = await (0, tmux_1.capturePane)(sessionName, { startLine: -50 });
+                // Claude is ready when we see the prompt (> ) or separator line
+                if (/^>\s*$/m.test(output) || /^─{10,}$/m.test(output)) {
+                    console.log(`✓ Claude initialized in ${Date.now() - startTime}ms`);
+                    break;
+                }
+            }
+            catch {
+                // Ignore capture errors during initialization
+            }
+        }
+        console.log(`✓ Started Claude session: ${sessionName}`);
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to start Claude session: ${errorMessage}`);
+    }
+}
+/**
+ * Send a message to Claude CLI
+ *
+ * @param worktreeId - Worktree ID
+ * @param message - Message content to send
+ * @throws {Error} If session doesn't exist
+ *
+ * @example
+ * ```typescript
+ * await sendMessageToClaude('feature-foo', 'Explain this code');
+ * ```
+ */
+async function sendMessageToClaude(worktreeId, message) {
+    const sessionName = getSessionName(worktreeId);
+    // Check if session exists
+    const exists = await (0, tmux_1.hasSession)(sessionName);
+    if (!exists) {
+        throw new Error(`Claude session ${sessionName} does not exist. Start the session first.`);
+    }
+    try {
+        // Send message to Claude (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 to submit (single Enter submits in Claude Code CLI)
+        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 Claude session: ${sessionName}`);
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to send message to Claude: ${errorMessage}`);
+    }
+}
+/**
+ * Capture Claude session output
+ *
+ * @param worktreeId - Worktree ID
+ * @param lines - Number of lines to capture (default: 1000)
+ * @returns Captured output
+ *
+ * @example
+ * ```typescript
+ * const output = await captureClaudeOutput('feature-foo');
+ * console.log(output);
+ * ```
+ */
+async function captureClaudeOutput(worktreeId, lines = 1000) {
+    const sessionName = getSessionName(worktreeId);
+    // Check if session exists
+    const exists = await (0, tmux_1.hasSession)(sessionName);
+    if (!exists) {
+        throw new Error(`Claude session ${sessionName} does not exist`);
+    }
+    try {
+        return await (0, tmux_1.capturePane)(sessionName, { startLine: -lines });
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to capture Claude output: ${errorMessage}`);
+    }
+}
+/**
+ * Stop a Claude session
+ *
+ * @param worktreeId - Worktree ID
+ * @returns True if session was stopped, false if it didn't exist
+ *
+ * @example
+ * ```typescript
+ * await stopClaudeSession('feature-foo');
+ * ```
+ */
+async function stopClaudeSession(worktreeId) {
+    const sessionName = getSessionName(worktreeId);
+    try {
+        // Send Ctrl+D to exit Claude gracefully
+        const exists = await (0, tmux_1.hasSession)(sessionName);
+        if (exists) {
+            await (0, tmux_1.sendKeys)(sessionName, '', false);
+            // Send Ctrl+D (ASCII 4)
+            await execAsync(`tmux send-keys -t "${sessionName}" C-d`);
+            // Wait a moment for Claude 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 Claude session: ${sessionName}`);
+        }
+        return killed;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error(`Error stopping Claude session: ${errorMessage}`);
+        return false;
+    }
+}
+/**
+ * Restart a Claude session
+ *
+ * @param options - Session options
+ *
+ * @example
+ * ```typescript
+ * await restartClaudeSession({
+ *   worktreeId: 'feature-foo',
+ *   worktreePath: '/path/to/worktree',
+ *   baseUrl: 'http://localhost:3000',
+ * });
+ * ```
+ */
+async function restartClaudeSession(options) {
+    const { worktreeId } = options;
+    // Stop existing session
+    await stopClaudeSession(worktreeId);
+    // Wait a moment before restarting
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+    // Start new session
+    await startClaudeSession(options);
+}

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, '');
+}