ted-mosby 1.0.0

package/dist/cli.js

@@ -0,0 +1,1379 @@
+#!/usr/bin/env node
+import { config as loadEnv } from 'dotenv';
+import { resolve } from 'path';
+import * as fs from 'fs';
+import * as path from 'path';
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import inquirer from 'inquirer';
+import inquirerAutocomplete from 'inquirer-autocomplete-prompt';
+import { DevelopmentAgentAgent } from './agent.js';
+import { ArchitecturalWikiAgent } from './wiki-agent.js';
+import { ConfigManager } from './config.js';
+import { PermissionManager } from './permissions.js';
+import { PlanManager, formatAge } from './planner.js';
+import { MCPConfigManager } from './mcp-config.js';
+import { loadClaudeConfig, getCommand, expandCommand } from './claude-config.js';
+// Register autocomplete prompt
+inquirer.registerPrompt('autocomplete', inquirerAutocomplete);
+// Load .env from current working directory (supports global installation)
+const workingDir = process.cwd();
+loadEnv({ path: resolve(workingDir, '.env') });
+// Load Claude Code configuration (skills, commands, memory)
+const claudeConfig = loadClaudeConfig(workingDir);
+const program = new Command();
+program
+    .name('ted-mosby')
+    .description('Generate architectural documentation wikis for code repositories with source traceability.')
+    .version('1.0.0');
+// Config command
+program
+    .command('config')
+    .description('Configure the agent')
+    .option('--show', 'Show current configuration')
+    .action(async (options) => {
+    const configManager = new ConfigManager();
+    await configManager.load();
+    if (options.show) {
+        const config = configManager.get();
+        console.log(chalk.cyan('\n📋 Current Configuration:'));
+        console.log(chalk.gray('API Key:'), config.apiKey ? '***' + config.apiKey.slice(-4) : chalk.red('Not set'));
+        console.log(chalk.gray('Source:'), process.env.CLAUDE_API_KEY ? 'Environment variable' : 'Config file');
+        return;
+    }
+    console.log(chalk.yellow('\n🔐 API Key Configuration\n'));
+    console.log(chalk.white('To configure your API key, create a .env file in the project root:\n'));
+    console.log(chalk.gray('  echo "CLAUDE_API_KEY=your-key-here" > .env\n'));
+    console.log(chalk.white('Or set the environment variable directly:\n'));
+    console.log(chalk.gray('  export CLAUDE_API_KEY=your-key-here\n'));
+    console.log(chalk.cyan('Tip: Copy .env.example to .env and fill in your API key.'));
+});
+// Generate command - main wiki generation functionality
+program
+    .command('generate')
+    .description('Generate architectural documentation wiki for a repository')
+    .requiredOption('-r, --repo <url>', 'Repository URL (GitHub/GitLab) or local path')
+    .option('-o, --output <dir>', 'Output directory for wiki', './wiki')
+    .option('-c, --config <file>', 'Path to wiki configuration file (wiki.json)')
+    .option('-t, --token <token>', 'Access token for private repositories')
+    .option('-m, --model <model>', 'Claude model to use', 'claude-sonnet-4-20250514')
+    .option('-p, --path <path>', 'Specific path within repo to focus on')
+    .option('-f, --force', 'Force regeneration (ignore cache)')
+    .option('-v, --verbose', 'Verbose output')
+    .option('-e, --estimate', 'Estimate time and cost without running (dry run)')
+    .action(async (options) => {
+    try {
+        const configManager = new ConfigManager();
+        const config = await configManager.load();
+        if (!configManager.hasApiKey()) {
+            console.log(chalk.red('❌ No API key found.'));
+            console.log(chalk.yellow('\nSet your Anthropic API key:'));
+            console.log(chalk.gray('  export ANTHROPIC_API_KEY=your-key-here'));
+            process.exit(1);
+        }
+        console.log(chalk.cyan.bold('\n📚 ArchitecturalWiki Generator\n'));
+        console.log(chalk.white('Repository:'), chalk.green(options.repo));
+        console.log(chalk.white('Output:'), chalk.green(path.resolve(options.output)));
+        if (options.path)
+            console.log(chalk.white('Focus path:'), chalk.green(options.path));
+        console.log();
+        const permissionManager = new PermissionManager({ policy: 'permissive' });
+        const agent = new ArchitecturalWikiAgent({
+            verbose: options.verbose,
+            apiKey: config.apiKey,
+            permissionManager
+        });
+        // Handle estimate mode (dry run)
+        if (options.estimate) {
+            const spinner = ora('Analyzing repository...').start();
+            try {
+                const estimate = await agent.estimateGeneration({
+                    repoUrl: options.repo,
+                    outputDir: options.output,
+                    accessToken: options.token || process.env.GITHUB_TOKEN
+                });
+                spinner.succeed('Analysis complete');
+                console.log();
+                // Display estimate
+                console.log(chalk.cyan.bold('📊 Generation Estimate\n'));
+                console.log(chalk.white('Files to process:'), chalk.yellow(estimate.files.toString()));
+                console.log(chalk.white('Estimated chunks:'), chalk.yellow(estimate.estimatedChunks.toString()));
+                console.log(chalk.white('Estimated tokens:'), chalk.yellow(estimate.estimatedTokens.toLocaleString()));
+                console.log();
+                console.log(chalk.white.bold('⏱️  Estimated Time'));
+                console.log(chalk.gray('  Indexing:'), chalk.yellow(`${estimate.estimatedTime.indexingMinutes} min`));
+                console.log(chalk.gray('  Generation:'), chalk.yellow(`${estimate.estimatedTime.generationMinutes} min`));
+                console.log(chalk.gray('  Total:'), chalk.green.bold(`~${estimate.estimatedTime.totalMinutes} min`));
+                console.log();
+                console.log(chalk.white.bold('💰 Estimated Cost (Claude Sonnet)'));
+                console.log(chalk.gray('  Input tokens:'), chalk.yellow(`$${estimate.estimatedCost.input.toFixed(2)}`));
+                console.log(chalk.gray('  Output tokens:'), chalk.yellow(`$${estimate.estimatedCost.output.toFixed(2)}`));
+                console.log(chalk.gray('  Total:'), chalk.green.bold(`$${estimate.estimatedCost.total.toFixed(2)}`));
+                console.log();
+                console.log(chalk.white.bold('📁 Files by Type'));
+                const sortedExts = Object.entries(estimate.breakdown.byExtension)
+                    .sort(([, a], [, b]) => b - a)
+                    .slice(0, 10);
+                for (const [ext, count] of sortedExts) {
+                    console.log(chalk.gray(`  ${ext}:`), chalk.yellow(count.toString()));
+                }
+                console.log();
+                if (estimate.breakdown.largestFiles.length > 0) {
+                    console.log(chalk.white.bold('📄 Largest Files'));
+                    for (const file of estimate.breakdown.largestFiles.slice(0, 5)) {
+                        const sizeKb = Math.round(file.size / 1024);
+                        console.log(chalk.gray(`  ${file.path}`), chalk.yellow(`(${sizeKb} KB)`));
+                    }
+                    console.log();
+                }
+                console.log(chalk.gray('Run without --estimate to start generation.\n'));
+            }
+            catch (error) {
+                spinner.fail('Analysis failed');
+                throw error;
+            }
+            return;
+        }
+        const spinner = ora('Starting wiki generation...').start();
+        let currentPhase = '';
+        try {
+            for await (const event of agent.generateWiki({
+                repoUrl: options.repo,
+                outputDir: options.output,
+                configPath: options.config,
+                accessToken: options.token || process.env.GITHUB_TOKEN,
+                model: options.model,
+                targetPath: options.path,
+                forceRegenerate: options.force,
+                verbose: options.verbose
+            })) {
+                // Handle progress events
+                if (event.type === 'phase') {
+                    // Stop spinner during indexing phase so RAG output is visible
+                    if (event.message.includes('Indexing')) {
+                        spinner.stop();
+                        console.log(chalk.cyan(`\n📊 ${event.message}`));
+                    }
+                    else {
+                        spinner.text = event.message;
+                    }
+                    currentPhase = event.message;
+                    if (options.verbose) {
+                        spinner.succeed(currentPhase);
+                        spinner.start(event.message);
+                    }
+                }
+                else if (event.type === 'step') {
+                    // Resume spinner after indexing completes
+                    if (event.message.includes('Indexed')) {
+                        console.log(chalk.green(`  ✓ ${event.message}`));
+                        spinner.start('Generating architectural documentation');
+                    }
+                    else if (options.verbose) {
+                        spinner.info(event.message);
+                        spinner.start(currentPhase);
+                    }
+                }
+                else if (event.type === 'file') {
+                    if (options.verbose) {
+                        console.log(chalk.gray(`  📄 ${event.message}`));
+                    }
+                }
+                else if (event.type === 'complete') {
+                    spinner.succeed(chalk.green('Wiki generation complete!'));
+                }
+                else if (event.type === 'error') {
+                    spinner.fail(chalk.red(event.message));
+                }
+                // Handle agent streaming messages
+                else if (event.type === 'stream_event') {
+                    const streamEvent = event.event;
+                    if (streamEvent?.type === 'content_block_delta' && streamEvent.delta?.type === 'text_delta') {
+                        if (options.verbose) {
+                            process.stdout.write(streamEvent.delta.text || '');
+                        }
+                    }
+                    else if (streamEvent?.type === 'content_block_start' && streamEvent.content_block?.type === 'tool_use') {
+                        spinner.text = `Using tool: ${streamEvent.content_block.name}`;
+                    }
+                }
+                else if (event.type === 'tool_result') {
+                    if (options.verbose) {
+                        spinner.info('Tool completed');
+                        spinner.start(currentPhase);
+                    }
+                }
+                else if (event.type === 'result') {
+                    if (event.subtype === 'success') {
+                        spinner.succeed(chalk.green('Wiki generation complete!'));
+                    }
+                }
+            }
+            console.log();
+            console.log(chalk.cyan('📁 Wiki generated at:'), chalk.white(path.resolve(options.output)));
+            console.log(chalk.gray('Open wiki/README.md to start exploring the documentation.'));
+            console.log();
+        }
+        catch (error) {
+            spinner.fail('Wiki generation failed');
+            throw error;
+        }
+    }
+    catch (error) {
+        console.error(chalk.red('\nError:'), error instanceof Error ? error.message : String(error));
+        if (options.verbose && error instanceof Error && error.stack) {
+            console.error(chalk.gray(error.stack));
+        }
+        process.exit(1);
+    }
+});
+program
+    .argument('[query]', 'Direct query to the agent')
+    .option('-i, --interactive', 'Start interactive session')
+    .option('-v, --verbose', 'Verbose output')
+    .option('-p, --plan', 'Planning mode - create plan before executing')
+    .action(async (query, options) => {
+    try {
+        const configManager = new ConfigManager();
+        const config = await configManager.load();
+        if (!configManager.hasApiKey()) {
+            console.log(chalk.red('❌ No API key found.'));
+            console.log(chalk.yellow('\nCreate a .env file with your API key:'));
+            console.log(chalk.gray('  echo "CLAUDE_API_KEY=your-key-here" > .env'));
+            console.log(chalk.yellow('\nOr set the environment variable:'));
+            console.log(chalk.gray('  export CLAUDE_API_KEY=your-key-here'));
+            process.exit(1);
+        }
+        const permissionManager = new PermissionManager({ policy: 'permissive' });
+        const agent = new DevelopmentAgentAgent({
+            verbose: options?.verbose || false,
+            apiKey: config.apiKey,
+            permissionManager
+        });
+        console.log(chalk.cyan.bold('\n🤖 Development Agent'));
+        console.log(chalk.gray('Full-stack development assistant with file operations, build tools, and code analysis capabilities.'));
+        console.log(chalk.gray(`📁 Working directory: ${workingDir}\n`));
+        if (query && options?.plan) {
+            // Planning mode with query
+            await handlePlanningMode(agent, query, permissionManager);
+        }
+        else if (query) {
+            await handleSingleQuery(agent, query, options?.verbose);
+        }
+        else {
+            await handleInteractiveMode(agent, permissionManager, options?.verbose);
+        }
+    }
+    catch (error) {
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+});
+function parseSlashCommand(input) {
+    // Remove leading slash
+    const trimmed = input.slice(1).trim();
+    // Split by spaces, but respect quotes
+    const parts = [];
+    let current = '';
+    let inQuotes = false;
+    let quoteChar = '';
+    for (let i = 0; i < trimmed.length; i++) {
+        const char = trimmed[i];
+        if ((char === '"' || char === "'") && (i === 0 || trimmed[i - 1] !== '\\')) {
+            if (!inQuotes) {
+                inQuotes = true;
+                quoteChar = char;
+            }
+            else if (char === quoteChar) {
+                inQuotes = false;
+                quoteChar = '';
+            }
+            else {
+                current += char;
+            }
+        }
+        else if (char === ' ' && !inQuotes) {
+            if (current) {
+                parts.push(current);
+                current = '';
+            }
+        }
+        else {
+            current += char;
+        }
+    }
+    if (current) {
+        parts.push(current);
+    }
+    if (inQuotes) {
+        return { command: '', args: {}, error: 'Unclosed quote in command' };
+    }
+    const command = parts[0];
+    const args = {};
+    for (let i = 1; i < parts.length; i++) {
+        const part = parts[i];
+        if (part.startsWith('--')) {
+            const key = part.slice(2);
+            const nextPart = parts[i + 1];
+            if (!nextPart || nextPart.startsWith('--')) {
+                args[key] = true;
+            }
+            else {
+                // Try to parse as number
+                const numValue = Number(nextPart);
+                args[key] = isNaN(numValue) ? nextPart : numValue;
+                i++;
+            }
+        }
+    }
+    return { command, args };
+}
+/** Global to store stdin history - read at startup before commander parses */
+let stdinHistory = [];
+/** Read conversation history from stdin synchronously using fs */
+function initStdinHistory() {
+    // If stdin is a TTY (interactive), no history
+    if (process.stdin.isTTY) {
+        return;
+    }
+    try {
+        // Read stdin synchronously using fs
+        const fs = require('fs');
+        const data = fs.readFileSync(0, 'utf8'); // fd 0 is stdin
+        if (data.trim()) {
+            const history = JSON.parse(data);
+            if (Array.isArray(history)) {
+                stdinHistory = history;
+            }
+        }
+    }
+    catch (e) {
+        // No stdin data or invalid JSON, ignore
+    }
+}
+async function handleSingleQuery(agent, query, verbose) {
+    // Use the global stdin history (read before commander.parse())
+    const history = stdinHistory;
+    const spinner = ora('Processing...').start();
+    try {
+        // Pass history to agent for multi-turn context
+        const response = agent.query(query, history);
+        spinner.stop();
+        console.log(chalk.yellow('Query:'), query);
+        console.log(chalk.green('Response:') + '\n');
+        for await (const message of response) {
+            // Handle streaming text deltas for real-time output
+            if (message.type === 'stream_event') {
+                const event = message.event;
+                if (event?.type === 'content_block_delta' && event.delta?.type === 'text_delta') {
+                    process.stdout.write(event.delta.text || '');
+                }
+                else if (event?.type === 'content_block_start' && event.content_block?.type === 'tool_use') {
+                    // Show tool being called
+                    console.log(chalk.cyan(`\n🔧 Using tool: ${event.content_block.name}`));
+                }
+                else if (event?.type === 'content_block_stop') {
+                    // Tool finished or content block ended
+                }
+            }
+            else if (message.type === 'tool_result') {
+                // Show tool result summary
+                const result = message.content;
+                if (verbose && result) {
+                    console.log(chalk.gray(`   ↳ Tool completed`));
+                }
+            }
+            else if (message.type === 'result') {
+                // Display statistics (verbose mode only)
+                if (verbose) {
+                    const stats = message.content || message;
+                    if (stats.durationMs) {
+                        console.log(chalk.gray('\n--- Statistics ---'));
+                        console.log(chalk.gray(`Duration: ${stats.durationMs}ms`));
+                        console.log(chalk.gray(`Input tokens: ${stats.inputTokens}`));
+                        console.log(chalk.gray(`Output tokens: ${stats.outputTokens}`));
+                        if (stats.cacheReadTokens)
+                            console.log(chalk.gray(`Cache read: ${stats.cacheReadTokens}`));
+                    }
+                }
+            }
+            else if (message.type === 'system') {
+                // System messages (verbose mode only)
+                if (verbose)
+                    console.log(chalk.blue(`[system] ${message.content || message.subtype || ''}`));
+            }
+        }
+        console.log('\n');
+    }
+    catch (error) {
+        spinner.fail('Failed to process query');
+        throw error;
+    }
+}
+async function handleInteractiveMode(agent, permissionManager, verbose) {
+    // Load workflow executor
+    const { WorkflowExecutor } = await import('./workflows.js');
+    const workflowExecutor = new WorkflowExecutor(agent.permissionManager);
+    const planManager = new PlanManager();
+    // Build list of all available slash commands
+    const builtinCommands = [
+        { name: 'help', description: 'Show available commands' },
+        { name: 'quit', description: 'Exit the agent' },
+        { name: 'exit', description: 'Exit the agent' },
+        { name: 'plan', description: 'Create a plan for a task' },
+        { name: 'plans', description: 'List all pending plans' },
+        { name: 'execute', description: 'Execute plan by number' },
+        { name: 'plan-delete', description: 'Delete plans' },
+        { name: 'mcp-list', description: 'List configured MCP servers' },
+        { name: 'mcp-add', description: 'Add a new MCP server' },
+        { name: 'mcp-remove', description: 'Remove an MCP server' },
+        { name: 'mcp-toggle', description: 'Enable/disable an MCP server' },
+        { name: 'command-add', description: 'Create a new custom slash command' },
+        { name: 'command-list', description: 'List all custom commands' },
+        { name: 'skill-add', description: 'Create a new skill' },
+        { name: 'skill-list', description: 'List all available skills' },
+        { name: 'files', description: 'List files in current directory' },
+        { name: 'run', description: 'Execute a command' },
+        { name: 'code-audit', description: 'Comprehensive code audit for technical debt and security' },
+        { name: 'test-suite', description: 'Generate comprehensive test suite' },
+        { name: 'refactor-analysis', description: 'Analyze code for refactoring opportunities' },
+    ];
+    // Add Claude Code commands from .claude/commands/
+    const allCommands = [
+        ...builtinCommands,
+        ...claudeConfig.commands.map(c => ({ name: c.name, description: c.description || 'Custom command' }))
+    ];
+    // Autocomplete source function
+    const commandSource = async (answers, input) => {
+        input = input || '';
+        // Only show autocomplete when typing slash commands
+        if (!input.startsWith('/')) {
+            return [];
+        }
+        const search = input.slice(1).toLowerCase();
+        const matches = allCommands.filter(cmd => cmd.name.toLowerCase().startsWith(search));
+        return matches.map(cmd => ({
+            name: `/${cmd.name} - ${cmd.description}`,
+            value: `/${cmd.name}`,
+            short: `/${cmd.name}`
+        }));
+    };
+    console.log(chalk.gray('Type your questions, or:'));
+    console.log(chalk.gray('• /help - Show available commands'));
+    console.log(chalk.gray('• /plan <query> - Create a plan before executing'));
+    console.log(chalk.gray('• /quit or Ctrl+C - Exit'));
+    if (claudeConfig.commands.length > 0) {
+        console.log(chalk.gray(`• ${claudeConfig.commands.length} custom commands available (type / to see them)`));
+    }
+    console.log();
+    while (true) {
+        try {
+            const { input } = await inquirer.prompt([
+                {
+                    type: 'autocomplete',
+                    name: 'input',
+                    message: chalk.cyan('ted-mosby>'),
+                    prefix: '',
+                    source: commandSource,
+                    suggestOnly: true, // Allow free text input
+                    emptyText: '', // Don't show "no results" message
+                }
+            ]);
+            if (!input.trim())
+                continue;
+            if (input === '/quit' || input === '/exit') {
+                console.log(chalk.yellow('\n👋 Goodbye!'));
+                break;
+            }
+            if (input === '/help') {
+                console.log(chalk.cyan.bold('\n📚 Available Commands:'));
+                console.log(chalk.gray('• /help - Show this help'));
+                console.log(chalk.gray('• /quit - Exit the agent'));
+                console.log(chalk.gray('• /files - List files in current directory'));
+                console.log(chalk.gray('• /run <command> - Execute a command'));
+                console.log(chalk.gray('\n📋 Planning Commands:'));
+                console.log(chalk.gray('• /plan <query> - Create a plan for a task'));
+                console.log(chalk.gray('• /plans - List all pending plans'));
+                console.log(chalk.gray('• /execute <num> - Execute plan by number'));
+                console.log(chalk.gray('• /plan-delete <num|all|all-completed> - Delete plans'));
+                console.log(chalk.gray('• <number> - Quick shortcut to execute plan by number'));
+                console.log(chalk.gray('\n🔌 MCP Server Commands:'));
+                console.log(chalk.gray('• /mcp-list - List configured MCP servers'));
+                console.log(chalk.gray('• /mcp-add - Add a new MCP server (interactive)'));
+                console.log(chalk.gray('• /mcp-remove [name] - Remove an MCP server'));
+                console.log(chalk.gray('• /mcp-toggle [name] - Enable/disable an MCP server'));
+                console.log(chalk.gray('\n✨ Customization Commands:'));
+                console.log(chalk.gray('• /command-add - Create a new custom slash command'));
+                console.log(chalk.gray('• /command-list - List all custom commands'));
+                console.log(chalk.gray('• /skill-add - Create a new skill'));
+                console.log(chalk.gray('• /skill-list - List all available skills'));
+                console.log(chalk.gray('\n🔮 Workflow Commands:'));
+                console.log(chalk.gray('• /code-audit --path <dir> [--output <path>] [--focus <area>]'));
+                console.log(chalk.gray('  Comprehensive code audit for technical debt and security'));
+                console.log(chalk.gray('• /test-suite --target <file> [--framework <name>] [--output <path>]'));
+                console.log(chalk.gray('  Generate comprehensive test suite'));
+                console.log(chalk.gray('• /refactor-analysis --target <file> [--goal <objective>]'));
+                console.log(chalk.gray('  Analyze code for refactoring opportunities'));
+                // Show custom Claude Code commands if any
+                if (claudeConfig.commands.length > 0) {
+                    console.log(chalk.gray('\n📌 Custom Commands:'));
+                    claudeConfig.commands.forEach(cmd => {
+                        console.log(chalk.gray(`• /${cmd.name} - ${cmd.description || 'Custom command'}`));
+                    });
+                }
+                // Show available skills if any
+                if (claudeConfig.skills.length > 0) {
+                    console.log(chalk.gray('\n🎯 Available Skills:'));
+                    claudeConfig.skills.forEach(skill => {
+                        console.log(chalk.gray(`• ${skill.name} - ${skill.description}`));
+                    });
+                    console.log(chalk.gray('  (Say "use <skill>" or "run the <skill> skill" to invoke)'));
+                }
+                console.log(chalk.gray('\n💡 Ask me anything about development!\n'));
+                continue;
+            }
+            // Handle planning commands
+            if (input.startsWith('/plan ')) {
+                const query = input.slice(6).trim();
+                await handlePlanningMode(agent, query, permissionManager);
+                continue;
+            }
+            if (input === '/plans') {
+                await listPlans(planManager);
+                continue;
+            }
+            if (input.startsWith('/execute ')) {
+                const arg = input.slice(9).trim();
+                await executePlanByRef(arg, agent, permissionManager, planManager);
+                continue;
+            }
+            if (input.startsWith('/plan-delete ')) {
+                const arg = input.slice(13).trim();
+                await deletePlanByRef(arg, planManager);
+                continue;
+            }
+            // Quick shortcut: just type a number to execute that plan
+            if (/^\d+$/.test(input.trim())) {
+                const planNum = parseInt(input.trim());
+                await executePlanByNumber(planNum, agent, permissionManager, planManager);
+                continue;
+            }
+            // Handle MCP commands
+            if (input === '/mcp-list') {
+                await handleMcpList();
+                continue;
+            }
+            if (input === '/mcp-add') {
+                await handleMcpAdd();
+                continue;
+            }
+            if (input.startsWith('/mcp-remove')) {
+                const name = input.slice(11).trim();
+                await handleMcpRemove(name);
+                continue;
+            }
+            if (input.startsWith('/mcp-toggle')) {
+                const name = input.slice(11).trim();
+                await handleMcpToggle(name);
+                continue;
+            }
+            // Handle command/skill creation
+            if (input === '/command-add') {
+                await handleCommandAdd();
+                continue;
+            }
+            if (input === '/command-list') {
+                handleCommandList();
+                continue;
+            }
+            if (input === '/skill-add') {
+                await handleSkillAdd();
+                continue;
+            }
+            if (input === '/skill-list') {
+                handleSkillList();
+                continue;
+            }
+            // Handle slash commands (including custom Claude Code commands)
+            if (input.startsWith('/')) {
+                const { command, args, error } = parseSlashCommand(input);
+                if (error) {
+                    console.log(chalk.red(`Error: ${error}`));
+                    continue;
+                }
+                // Check for custom Claude Code command first
+                const customCmd = getCommand(claudeConfig.commands, command);
+                if (customCmd) {
+                    // Get any positional arguments after the command name
+                    const inputAfterCommand = input.slice(command.length + 2).trim();
+                    const positionalArgs = inputAfterCommand.split(/\s+/).filter(Boolean);
+                    // Expand the command template with arguments
+                    const expandedPrompt = expandCommand(customCmd, inputAfterCommand);
+                    console.log(chalk.cyan(`\n📋 Running /${command}...\n`));
+                    // Send the expanded prompt to the agent
+                    const spinner = ora('Processing command...').start();
+                    try {
+                        const response = agent.query(expandedPrompt);
+                        spinner.stop();
+                        for await (const message of response) {
+                            if (message.type === 'stream_event') {
+                                const event = message.event;
+                                if (event?.type === 'content_block_delta' && event.delta?.type === 'text_delta') {
+                                    process.stdout.write(event.delta.text || '');
+                                }
+                                else if (event?.type === 'content_block_start' && event.content_block?.type === 'tool_use') {
+                                    console.log(chalk.cyan(`\n🔧 Using tool: ${event.content_block.name}`));
+                                }
+                            }
+                            else if (message.type === 'tool_result') {
+                                if (verbose)
+                                    console.log(chalk.gray(`   ↳ Tool completed`));
+                            }
+                        }
+                        console.log('\n');
+                    }
+                    catch (error) {
+                        spinner.fail('Command failed');
+                        console.error(chalk.red('Error:'), error instanceof Error ? error.message : String(error));
+                    }
+                    continue;
+                }
+                // List of all possible workflow commands
+                const validCommands = [
+                    'literature-review', 'experiment-log',
+                    'code-audit', 'test-suite', 'refactor-analysis',
+                    'invoice-batch', 'contract-review', 'meeting-summary',
+                    'content-calendar', 'blog-outline', 'campaign-brief',
+                    'dataset-profile', 'chart-report'
+                ];
+                if (validCommands.includes(command)) {
+                    try {
+                        const workflow = await workflowExecutor.loadWorkflow(command);
+                        const context = {
+                            variables: new Map(),
+                            agent,
+                            permissionManager: agent.permissionManager
+                        };
+                        await workflowExecutor.execute(workflow, args, context);
+                        continue;
+                    }
+                    catch (error) {
+                        console.error(chalk.red('Workflow error:'), error instanceof Error ? error.message : String(error));
+                        continue;
+                    }
+                }
+                console.log(chalk.yellow(`Unknown command: /${command}`));
+                console.log(chalk.gray('Type /help to see available commands'));
+                continue;
+            }
+            const spinner = ora('Processing...').start();
+            try {
+                const response = agent.query(input);
+                spinner.stop();
+                console.log();
+                for await (const message of response) {
+                    // Handle streaming text deltas for real-time output
+                    if (message.type === 'stream_event') {
+                        const event = message.event;
+                        if (event?.type === 'content_block_delta' && event.delta?.type === 'text_delta') {
+                            process.stdout.write(event.delta.text || '');
+                        }
+                        else if (event?.type === 'content_block_start' && event.content_block?.type === 'tool_use') {
+                            // Show tool being called
+                            console.log(chalk.cyan(`\n🔧 Using tool: ${event.content_block.name}`));
+                        }
+                    }
+                    else if (message.type === 'tool_result') {
+                        // Show tool result summary
+                        const result = message.content;
+                        if (verbose && result) {
+                            console.log(chalk.gray(`   ↳ Tool completed`));
+                        }
+                    }
+                    else if (message.type === 'result') {
+                        // Display statistics (verbose mode only)
+                        if (verbose) {
+                            const stats = message.content || message;
+                            if (stats.durationMs) {
+                                console.log(chalk.gray('\n--- Statistics ---'));
+                                console.log(chalk.gray(`Duration: ${stats.durationMs}ms`));
+                                console.log(chalk.gray(`Input tokens: ${stats.inputTokens}`));
+                                console.log(chalk.gray(`Output tokens: ${stats.outputTokens}`));
+                                if (stats.cacheReadTokens)
+                                    console.log(chalk.gray(`Cache read: ${stats.cacheReadTokens}`));
+                            }
+                        }
+                    }
+                    else if (message.type === 'system') {
+                        // System messages (verbose mode only)
+                        if (verbose)
+                            console.log(chalk.blue(`[system] ${message.content || message.subtype || ''}`));
+                    }
+                }
+                console.log('\n');
+            }
+            catch (error) {
+                spinner.fail('Failed to process query');
+                console.error(chalk.red('Error:'), error instanceof Error ? error.message : String(error));
+            }
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('User force closed')) {
+                console.log(chalk.yellow('\n\n👋 Goodbye!'));
+                break;
+            }
+            console.error(chalk.red('Unexpected error:'), error);
+        }
+    }
+}
+// MCP Server management functions
+async function handleMcpList() {
+    const mcpConfig = new MCPConfigManager();
+    await mcpConfig.load();
+    console.log(chalk.cyan.bold('\n📦 MCP Servers\n'));
+    console.log(mcpConfig.formatServerList());
+    console.log(chalk.gray(`\nConfig: ${process.cwd()}/.mcp.json\n`));
+}
+async function handleMcpAdd() {
+    const mcpConfig = new MCPConfigManager();
+    await mcpConfig.load();
+    console.log(chalk.cyan.bold('\n📦 Add MCP Server\n'));
+    // Step 1: Server name
+    const { name } = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'name',
+            message: 'Server name (lowercase, alphanumeric, hyphens):',
+            validate: (input) => {
+                if (!input.trim())
+                    return 'Name is required';
+                if (!/^[a-z][a-z0-9-]*$/.test(input)) {
+                    return 'Name must be lowercase, start with a letter, and contain only letters, numbers, and hyphens';
+                }
+                if (mcpConfig.getServers()[input]) {
+                    return 'A server with this name already exists';
+                }
+                return true;
+            }
+        }
+    ]);
+    // Step 2: Transport type
+    const { transportType } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'transportType',
+            message: 'Transport type:',
+            choices: [
+                { name: 'Stdio (local command)', value: 'stdio' },
+                { name: 'HTTP (REST endpoint)', value: 'http' },
+                { name: 'SSE (Server-Sent Events)', value: 'sse' },
+                { name: 'SDK (in-process module)', value: 'sdk' }
+            ]
+        }
+    ]);
+    let serverConfig;
+    if (transportType === 'stdio') {
+        const { command, args } = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'command',
+                message: 'Command to run:',
+                default: 'npx',
+                validate: (input) => input.trim() ? true : 'Command is required'
+            },
+            {
+                type: 'input',
+                name: 'args',
+                message: 'Arguments (space-separated):',
+                default: '-y @modelcontextprotocol/server-filesystem'
+            }
+        ]);
+        serverConfig = {
+            type: 'stdio',
+            command: command.trim(),
+            args: args.trim() ? args.trim().split(/\s+/) : [],
+            enabled: true
+        };
+    }
+    else if (transportType === 'http' || transportType === 'sse') {
+        const { url } = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'url',
+                message: 'Server URL:',
+                validate: (input) => {
+                    if (!input.trim())
+                        return 'URL is required';
+                    try {
+                        const testUrl = input.replace(/\$\{[^}]+\}/g, 'placeholder');
+                        new URL(testUrl);
+                        return true;
+                    }
+                    catch {
+                        return 'Invalid URL format';
+                    }
+                }
+            }
+        ]);
+        serverConfig = {
+            type: transportType,
+            url: url.trim(),
+            enabled: true
+        };
+    }
+    else {
+        const { serverModule } = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'serverModule',
+                message: 'Module path:',
+                default: './custom-mcp-server.js',
+                validate: (input) => input.trim() ? true : 'Module path is required'
+            }
+        ]);
+        serverConfig = {
+            type: 'sdk',
+            serverModule: serverModule.trim(),
+            enabled: true
+        };
+    }
+    // Step 3: Optional description
+    const { description } = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'description',
+            message: 'Description (optional):'
+        }
+    ]);
+    if (description.trim()) {
+        serverConfig.description = description.trim();
+    }
+    await mcpConfig.addServer(name, serverConfig);
+    console.log(chalk.green(`\n✓ Server '${name}' added successfully!\n`));
+    console.log(chalk.yellow('Note: Restart the agent to load the new server.\n'));
+}
+async function handleMcpRemove(name) {
+    const mcpConfig = new MCPConfigManager();
+    await mcpConfig.load();
+    const servers = Object.keys(mcpConfig.getServers());
+    if (servers.length === 0) {
+        console.log(chalk.yellow('\nNo MCP servers configured.\n'));
+        return;
+    }
+    let serverName = name?.trim();
+    if (!serverName) {
+        const { selected } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'selected',
+                message: 'Select server to remove:',
+                choices: servers
+            }
+        ]);
+        serverName = selected;
+    }
+    if (!servers.includes(serverName)) {
+        console.log(chalk.red(`\nServer '${serverName}' not found.\n`));
+        return;
+    }
+    const { confirm } = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'confirm',
+            message: `Remove server '${serverName}'?`,
+            default: false
+        }
+    ]);
+    if (confirm) {
+        await mcpConfig.removeServer(serverName);
+        console.log(chalk.green(`\n✓ Server '${serverName}' removed.\n`));
+    }
+    else {
+        console.log(chalk.gray('\nCancelled.\n'));
+    }
+}
+async function handleMcpToggle(name) {
+    const mcpConfig = new MCPConfigManager();
+    await mcpConfig.load();
+    const servers = mcpConfig.getServers();
+    const serverNames = Object.keys(servers);
+    if (serverNames.length === 0) {
+        console.log(chalk.yellow('\nNo MCP servers configured.\n'));
+        return;
+    }
+    let serverName = name?.trim();
+    if (!serverName) {
+        const { selected } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'selected',
+                message: 'Select server to toggle:',
+                choices: serverNames.map(n => ({
+                    name: `${n} (${servers[n].enabled !== false ? 'enabled' : 'disabled'})`,
+                    value: n
+                }))
+            }
+        ]);
+        serverName = selected;
+    }
+    if (!serverNames.includes(serverName)) {
+        console.log(chalk.red(`\nServer '${serverName}' not found.\n`));
+        return;
+    }
+    const wasEnabled = servers[serverName].enabled !== false;
+    await mcpConfig.toggleServer(serverName);
+    console.log(chalk.green(`\n✓ Server '${serverName}' ${wasEnabled ? 'disabled' : 'enabled'}.\n`));
+    console.log(chalk.yellow('Note: Restart the agent to apply changes.\n'));
+}
+// Custom command creation handler
+async function handleCommandAdd() {
+    console.log(chalk.cyan.bold('\n✨ Create New Slash Command\n'));
+    const { name, description, template } = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'name',
+            message: 'Command name (without /):',
+            validate: (input) => {
+                if (!input.trim())
+                    return 'Name is required';
+                if (!/^[a-z][a-z0-9-]*$/.test(input)) {
+                    return 'Name must be lowercase, start with a letter, and contain only letters, numbers, and hyphens';
+                }
+                return true;
+            }
+        },
+        {
+            type: 'input',
+            name: 'description',
+            message: 'Description:',
+            validate: (input) => input.trim() ? true : 'Description is required'
+        },
+        {
+            type: 'editor',
+            name: 'template',
+            message: 'Command template (use $ARGUMENTS for all args, $1, $2 for positional):',
+            default: 'Perform the following task:\n\n$ARGUMENTS'
+        }
+    ]);
+    // Create .claude/commands directory if it doesn't exist
+    const commandsDir = path.join(workingDir, '.claude', 'commands');
+    if (!fs.existsSync(commandsDir)) {
+        fs.mkdirSync(commandsDir, { recursive: true });
+    }
+    // Create the command file
+    const content = `---
+description: ${description}
+---
+
+${template}
+`;
+    const filePath = path.join(commandsDir, `${name}.md`);
+    fs.writeFileSync(filePath, content);
+    console.log(chalk.green(`\n✓ Created command /${name}`));
+    console.log(chalk.gray(`  File: ${filePath}`));
+    console.log(chalk.yellow('\nRestart the agent to use the new command.\n'));
+    // Reload the config to pick up the new command
+    Object.assign(claudeConfig, loadClaudeConfig(workingDir));
+}
+function handleCommandList() {
+    console.log(chalk.cyan.bold('\n📋 Custom Slash Commands\n'));
+    if (claudeConfig.commands.length === 0) {
+        console.log(chalk.gray('No custom commands defined.'));
+        console.log(chalk.gray('Use /command-add to create one.\n'));
+        return;
+    }
+    claudeConfig.commands.forEach(cmd => {
+        console.log(chalk.white(`  /${cmd.name}`));
+        console.log(chalk.gray(`    ${cmd.description || 'No description'}`));
+        console.log(chalk.gray(`    File: ${cmd.filePath}\n`));
+    });
+}
+// Custom skill creation handler
+async function handleSkillAdd() {
+    console.log(chalk.cyan.bold('\n🎯 Create New Skill\n'));
+    const { name, description, tools, instructions } = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'name',
+            message: 'Skill name:',
+            validate: (input) => {
+                if (!input.trim())
+                    return 'Name is required';
+                if (!/^[a-z][a-z0-9-]*$/.test(input)) {
+                    return 'Name must be lowercase, start with a letter, and contain only letters, numbers, and hyphens';
+                }
+                return true;
+            }
+        },
+        {
+            type: 'input',
+            name: 'description',
+            message: 'Description:',
+            validate: (input) => input.trim() ? true : 'Description is required'
+        },
+        {
+            type: 'checkbox',
+            name: 'tools',
+            message: 'Select tools this skill can use:',
+            choices: [
+                { name: 'Read files', value: 'Read' },
+                { name: 'Write files', value: 'Write' },
+                { name: 'Run commands', value: 'Bash' },
+                { name: 'Web search', value: 'WebSearch' },
+                { name: 'Web fetch', value: 'WebFetch' }
+            ],
+            default: ['Read']
+        },
+        {
+            type: 'editor',
+            name: 'instructions',
+            message: 'Skill instructions (what should the agent do when this skill is invoked?):',
+            default: '# Skill Instructions\n\nWhen this skill is invoked:\n\n1. First, understand the user\'s request\n2. Apply your expertise to solve the problem\n3. Provide a clear, actionable response'
+        }
+    ]);
+    // Create .claude/skills/<name> directory
+    const skillDir = path.join(workingDir, '.claude', 'skills', name);
+    if (!fs.existsSync(skillDir)) {
+        fs.mkdirSync(skillDir, { recursive: true });
+    }
+    // Create the SKILL.md file
+    const content = `---
+description: ${description}
+tools: ${tools.join(', ')}
+---
+
+${instructions}
+`;
+    const filePath = path.join(skillDir, 'SKILL.md');
+    fs.writeFileSync(filePath, content);
+    console.log(chalk.green(`\n✓ Created skill: ${name}`));
+    console.log(chalk.gray(`  File: ${filePath}`));
+    console.log(chalk.yellow('\nRestart the agent to use the new skill.'));
+    console.log(chalk.gray('Invoke it by saying "use ' + name + '" or "run the ' + name + ' skill"\n'));
+    // Reload the config to pick up the new skill
+    Object.assign(claudeConfig, loadClaudeConfig(workingDir));
+}
+function handleSkillList() {
+    console.log(chalk.cyan.bold('\n🎯 Available Skills\n'));
+    if (claudeConfig.skills.length === 0) {
+        console.log(chalk.gray('No skills defined.'));
+        console.log(chalk.gray('Use /skill-add to create one.\n'));
+        return;
+    }
+    claudeConfig.skills.forEach(skill => {
+        console.log(chalk.white(`  ${skill.name}`));
+        console.log(chalk.gray(`    ${skill.description}`));
+        console.log(chalk.gray(`    Tools: ${skill.tools.join(', ') || 'none'}`));
+        console.log(chalk.gray(`    File: ${skill.filePath}\n`));
+    });
+}
+// Planning mode helper functions
+async function handlePlanningMode(agent, query, pm) {
+    const planManager = new PlanManager();
+    console.log(chalk.cyan('\n📋 Planning Mode'));
+    console.log(chalk.gray('Analyzing: ' + query + '\n'));
+    const spinner = ora('Creating plan...').start();
+    try {
+        // Query the agent in planning mode to analyze and create a plan
+        const planPrompt = `You are in PLANNING MODE. Analyze this request and create a structured plan.
+
+REQUEST: ${query}
+
+Create a plan with the following format:
+1. A brief summary (1 sentence)
+2. Your analysis of what needs to be done
+3. Step-by-step actions with risk assessment
+4. Rollback strategy if something goes wrong
+
+Output your plan in this exact format:
+
+SUMMARY: [one sentence describing what will be accomplished]
+
+ANALYSIS:
+[what you discovered and your approach]
+
+STEPS:
+1. [Step Name] | Action: [read/write/edit/command/query] | Target: [file or command] | Purpose: [why] | Risk: [low/medium/high]
+2. [Next step...]
+
+ROLLBACK:
+- [How to undo if needed]
+- [Additional recovery steps]`;
+        let planText = '';
+        const response = agent.query(planPrompt);
+        for await (const message of response) {
+            if (message.type === 'stream_event') {
+                const event = message.event;
+                if (event?.type === 'content_block_delta' && event.delta?.type === 'text_delta') {
+                    planText += event.delta.text || '';
+                }
+            }
+        }
+        spinner.stop();
+        // Parse the plan response
+        const plan = parsePlanResponse(planText, query, planManager);
+        // Display plan
+        displayPlan(plan);
+        // Save plan
+        const planPath = await planManager.savePlan(plan);
+        console.log(chalk.gray('\nPlan saved: ' + planPath));
+        // Prompt for action
+        const { action } = await inquirer.prompt([{
+                type: 'list',
+                name: 'action',
+                message: 'What would you like to do?',
+                choices: [
+                    { name: 'Execute now', value: 'execute' },
+                    { name: 'Edit plan first (opens in editor)', value: 'edit' },
+                    { name: 'Save for later', value: 'save' },
+                    { name: 'Discard', value: 'discard' }
+                ]
+            }]);
+        if (action === 'execute') {
+            await executePlan(plan, agent, pm, planManager);
+        }
+        else if (action === 'edit') {
+            console.log(chalk.yellow('\nEdit: ' + planPath));
+            console.log(chalk.gray('Then run: /execute ' + planPath));
+        }
+        else if (action === 'save') {
+            const pending = (await planManager.listPlans()).filter(p => p.plan.status === 'pending').length;
+            console.log(chalk.green(`\n✅ Plan saved. You now have ${pending} pending plan(s).`));
+            console.log(chalk.cyan('\nTo return to this plan later:'));
+            console.log(chalk.gray('  /plans          - List all pending plans'));
+            console.log(chalk.gray('  /execute 1      - Execute plan #1'));
+            console.log(chalk.gray('  1               - Shortcut: just type the number'));
+        }
+        else if (action === 'discard') {
+            await planManager.deletePlan(plan.id);
+            console.log(chalk.yellow('Plan discarded.'));
+        }
+    }
+    catch (error) {
+        spinner.fail('Failed to create plan');
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : String(error));
+    }
+}
+function parsePlanResponse(text, query, planManager) {
+    const summaryMatch = text.match(/SUMMARY:\s*(.+?)(?=\n|ANALYSIS:)/s);
+    const analysisMatch = text.match(/ANALYSIS:\s*([\s\S]+?)(?=STEPS:|$)/);
+    const stepsMatch = text.match(/STEPS:\s*([\s\S]+?)(?=ROLLBACK:|$)/);
+    const rollbackMatch = text.match(/ROLLBACK:\s*([\s\S]+?)$/);
+    const steps = [];
+    if (stepsMatch) {
+        const stepLines = stepsMatch[1].trim().split('\n').filter(l => l.trim());
+        let stepNum = 1;
+        for (const line of stepLines) {
+            const match = line.match(/\d+\.\s*(.+?)\s*\|\s*Action:\s*(\w+)\s*\|\s*Target:\s*(.+?)\s*\|\s*Purpose:\s*(.+?)\s*\|\s*Risk:\s*(\w+)/i);
+            if (match) {
+                steps.push({
+                    id: `step-${stepNum++}`,
+                    name: match[1].trim(),
+                    action: match[2].toLowerCase(),
+                    target: match[3].trim(),
+                    purpose: match[4].trim(),
+                    risk: match[5].toLowerCase(),
+                    status: 'pending'
+                });
+            }
+        }
+    }
+    const rollbackStrategy = [];
+    if (rollbackMatch) {
+        const rollbackLines = rollbackMatch[1].trim().split('\n');
+        for (const line of rollbackLines) {
+            const clean = line.replace(/^-\s*/, '').trim();
+            if (clean)
+                rollbackStrategy.push(clean);
+        }
+    }
+    const now = new Date();
+    const date = now.toISOString().split('T')[0].replace(/-/g, '');
+    const time = now.toTimeString().split(' ')[0].replace(/:/g, '').slice(0, 6);
+    return {
+        id: `plan-${date}-${time}`,
+        created: now,
+        status: 'pending',
+        query,
+        summary: summaryMatch?.[1]?.trim() || 'Plan for: ' + query.slice(0, 50),
+        analysis: analysisMatch?.[1]?.trim() || '',
+        steps,
+        rollbackStrategy
+    };
+}
+function displayPlan(plan) {
+    console.log(chalk.cyan.bold('\n📋 Plan Created'));
+    console.log(chalk.white('\nSummary: ') + plan.summary);
+    if (plan.analysis) {
+        console.log(chalk.white('\nAnalysis:'));
+        console.log(chalk.gray(plan.analysis));
+    }
+    console.log(chalk.white('\nSteps:'));
+    plan.steps.forEach((step, i) => {
+        const riskColor = step.risk === 'high' ? chalk.red : step.risk === 'medium' ? chalk.yellow : chalk.green;
+        console.log(chalk.white(`  ${i + 1}. ${step.name}`));
+        console.log(chalk.gray(`     Action: ${step.action}`) + (step.target ? chalk.gray(` → ${step.target}`) : ''));
+        console.log(chalk.gray(`     Purpose: ${step.purpose}`));
+        console.log(`     Risk: ` + riskColor(step.risk));
+    });
+    if (plan.rollbackStrategy.length > 0) {
+        console.log(chalk.white('\nRollback Strategy:'));
+        plan.rollbackStrategy.forEach(s => console.log(chalk.gray(`  - ${s}`)));
+    }
+}
+async function executePlan(plan, agent, pm, planManager) {
+    console.log(chalk.cyan('\n⚡ Executing plan: ' + plan.summary));
+    await planManager.updateStatus(plan.id, 'executing');
+    for (const step of plan.steps) {
+        console.log(chalk.white(`\n→ Step ${step.id.replace('step-', '')}: ${step.name}`));
+        const spinner = ora(`Executing: ${step.action}`).start();
+        try {
+            // Execute based on action type
+            const stepPrompt = `Execute this step of the plan:
+Step: ${step.name}
+Action: ${step.action}
+Target: ${step.target || 'N/A'}
+Purpose: ${step.purpose}
+
+Please execute this step now.`;
+            const response = agent.query(stepPrompt);
+            spinner.stop();
+            for await (const message of response) {
+                if (message.type === 'stream_event') {
+                    const event = message.event;
+                    if (event?.type === 'content_block_delta' && event.delta?.type === 'text_delta') {
+                        process.stdout.write(event.delta.text || '');
+                    }
+                }
+            }
+            await planManager.updateStepStatus(plan.id, step.id, 'completed');
+            console.log(chalk.green(`\n✓ Step ${step.id.replace('step-', '')} completed`));
+        }
+        catch (error) {
+            spinner.fail(`Step ${step.id.replace('step-', '')} failed`);
+            await planManager.updateStepStatus(plan.id, step.id, 'failed');
+            console.error(chalk.red('Error:'), error instanceof Error ? error.message : String(error));
+            const { cont } = await inquirer.prompt([{
+                    type: 'confirm',
+                    name: 'cont',
+                    message: 'Continue with remaining steps?',
+                    default: false
+                }]);
+            if (!cont) {
+                await planManager.updateStatus(plan.id, 'failed');
+                return;
+            }
+        }
+    }
+    await planManager.updateStatus(plan.id, 'completed');
+    console.log(chalk.green('\n✅ Plan completed successfully!'));
+    console.log(chalk.gray('Plan archived. Run /plan-delete all-completed to clean up.'));
+}
+async function listPlans(planManager) {
+    const plans = await planManager.listPlans();
+    const pending = plans.filter(p => p.plan.status === 'pending');
+    const completed = plans.filter(p => p.plan.status === 'completed');
+    if (pending.length === 0 && completed.length === 0) {
+        console.log(chalk.gray('\nNo plans found. Use /plan <query> to create one.'));
+        return;
+    }
+    if (pending.length > 0) {
+        console.log(chalk.cyan('\n📋 Pending Plans:'));
+        pending.forEach((p, i) => {
+            const age = formatAge(p.plan.created);
+            console.log(chalk.white(`  ${i + 1}. ${p.plan.summary}`));
+            console.log(chalk.gray(`     Created ${age} • ${p.plan.steps.length} steps`));
+        });
+        console.log(chalk.gray('\n  Type a number to execute, or /execute <num>'));
+    }
+    if (completed.length > 0) {
+        console.log(chalk.gray(`\n✅ ${completed.length} completed plan(s) - run /plan-delete all-completed to clean up`));
+    }
+}
+async function executePlanByRef(ref, agent, pm, planManager) {
+    if (/^\d+$/.test(ref)) {
+        await executePlanByNumber(parseInt(ref), agent, pm, planManager);
+        return;
+    }
+    // Assume it's a path
+    try {
+        const plan = await planManager.loadPlan(ref);
+        await executePlan(plan, agent, pm, planManager);
+    }
+    catch (error) {
+        console.log(chalk.red(`Error loading plan: ${ref}`));
+    }
+}
+async function executePlanByNumber(num, agent, pm, planManager) {
+    const plans = await planManager.listPlans();
+    const pending = plans.filter(p => p.plan.status === 'pending');
+    if (num < 1 || num > pending.length) {
+        console.log(chalk.red(`Invalid plan number. You have ${pending.length} pending plan(s).`));
+        return;
+    }
+    const planEntry = pending[num - 1];
+    await executePlan(planEntry.plan, agent, pm, planManager);
+}
+async function deletePlanByRef(ref, planManager) {
+    if (ref === 'all-completed') {
+        const deleted = await planManager.deleteCompleted();
+        console.log(chalk.green(`\n✅ Deleted ${deleted} completed plan(s).`));
+        return;
+    }
+    if (ref === 'all') {
+        const { confirm } = await inquirer.prompt([{
+                type: 'confirm',
+                name: 'confirm',
+                message: 'Delete ALL plans (pending and completed)?',
+                default: false
+            }]);
+        if (confirm) {
+            const deleted = await planManager.deleteAll();
+            console.log(chalk.green(`\n✅ Deleted ${deleted} plan(s).`));
+        }
+        return;
+    }
+    // Delete by number
+    if (/^\d+$/.test(ref)) {
+        const plans = await planManager.listPlans();
+        const pending = plans.filter(p => p.plan.status === 'pending');
+        const num = parseInt(ref);
+        if (num >= 1 && num <= pending.length) {
+            await planManager.deletePlan(pending[num - 1].plan.id);
+            console.log(chalk.green('\n✅ Plan deleted.'));
+            return;
+        }
+    }
+    // Try as plan ID
+    await planManager.deletePlan(ref);
+    console.log(chalk.green('\n✅ Plan deleted.'));
+}
+// Robust signal handling - force exit even with hanging child processes
+let isExiting = false;
+function handleExit(signal) {
+    if (isExiting) {
+        // Force exit on second signal
+        console.log(chalk.red('\n\nForce quitting...'));
+        process.exit(1);
+    }
+    isExiting = true;
+    console.log(chalk.yellow(`\n\n👋 Received ${signal}, shutting down...`));
+    // Give processes 2 seconds to clean up, then force exit
+    setTimeout(() => {
+        console.log(chalk.red('Force exit after timeout'));
+        process.exit(1);
+    }, 2000).unref();
+    // Try graceful exit
+    process.exit(0);
+}
+process.on('SIGINT', () => handleExit('SIGINT'));
+process.on('SIGTERM', () => handleExit('SIGTERM'));
+// Prevent unhandled rejections from hanging
+process.on('unhandledRejection', (reason, promise) => {
+    console.error(chalk.red('Unhandled Rejection:'), reason);
+});
+// Read stdin history before parsing commander args (synchronous)
+initStdinHistory();
+program.parse();
+//# sourceMappingURL=cli.js.map