codehere 0.1.1

package/dist/index-backup-before-lazy-loading.js

@@ -0,0 +1,1551 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { config } from 'dotenv';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { existsSync } from 'fs';
+import { indexRepositoryParallel } from './embed.js';
+import { executeAskCommand } from './presentation/cli/commands/ask-command.js';
+import { executeReactCommand } from './presentation/cli/commands/react-command.js';
+import { executeSmartCommand } from './presentation/cli/commands/smart-command.js';
+import { executeFixCommand } from './presentation/cli/commands/fix-command.js';
+import { executeSetupCommand } from './presentation/cli/commands/setup-command.js';
+import { executeConfigCommand } from './presentation/cli/commands/config-command.js';
+import { executeHelpCommand } from './presentation/cli/commands/help-command.js';
+import { initLogFile, logEntry } from './log.js';
+import { checkProviderConfiguration, displayProviderError } from './utils/provider-check.js';
+import { performHealthCheck, formatHealthStatus, getMetrics } from './monitoring.js';
+import { refactorMultiFile, findFilesByPattern } from './refactor.js';
+import { getGitStatus, formatGitStatus, getAllGitDiffs, analyzeDiff, getGitDiff } from './git.js';
+import { executePlanCommand } from './presentation/cli/commands/plan-command.js';
+import { executeOrchestrateCommand } from './presentation/cli/commands/orchestrate-command.js';
+import { executeDocsCommand } from './presentation/cli/commands/docs-command.js';
+import { executeProductCommand } from './presentation/cli/commands/product-command.js';
+import { executeStatusCommand } from './presentation/cli/commands/status-command.js';
+import { executeSuggestCommand } from './presentation/cli/commands/suggest-command.js';
+import { executeCostCommand } from './presentation/cli/commands/cost-command.js';
+import { executeTrustCommand } from './presentation/cli/commands/trust-command.js';
+// TEMP DISABLED: Context command triggers WASM hang via SQLiteContextRepository
+// import { executeContextImportCommand, executeContextExportCommand, executeContextStatsCommand } from './presentation/cli/commands/context-command.js';
+import { executeRunCommand } from './presentation/cli/commands/run-command.js';
+import { executeModelsCommand } from './presentation/cli/commands/models-command.js';
+import { executeReviewCommand } from './presentation/cli/commands/review-command.js';
+import { executeDecisionCommand } from './presentation/cli/commands/decision-command.js';
+import { executeKnowledgeCommand } from './presentation/cli/commands/knowledge-command.js';
+import { executeLearningDashboardCommand } from './presentation/cli/commands/learning-dashboard-command.js';
+import { executeTraceCommand } from './presentation/cli/commands/trace-command.js';
+import { executeUndoCommand } from './presentation/cli/commands/undo-command.js';
+import { executeAuditCommand } from './presentation/cli/commands/audit-command.js';
+import { reviewFile, formatReview } from './review.js';
+import { formatLearningInsights, getPerformanceInsights } from './learning.js';
+import { getCacheStats, clearAllCaches } from './cache.js';
+import { planMigration, formatMigrationPlan } from './migrate.js';
+import { generateTests, getTestFilePath, saveTests, improveTests } from './testgen.js';
+import { startSession } from './session.js';
+import { cleanResponse } from './formatter.js';
+import { displayError } from './presentation/cli/error-display.js';
+import { getTelemetryService } from './infrastructure/telemetry/telemetry-service.js';
+import { colors, createSpinner, createBanner, createTable, success, error, warning, info, formatPath, formatNumber, sectionHeader, newline, createWelcomeMessage, isMinimalStyle, printMinimalHeader, } from './ui.js';
+// Load environment variables - try agent directory first, then current directory
+try {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname(__filename);
+    const agentDir = join(__dirname, '..');
+    config({ path: join(agentDir, '.env') });
+}
+catch {
+    // Fallback to current directory
+}
+config(); // Also try current directory
+// Import centralized version utility
+import { getVersion } from './utils/version.js';
+const program = new Command();
+program
+    .name('codehere')
+    .description('AI-powered coding assistant with local embeddings and semantic search')
+    .version(getVersion())
+    .configureHelp({
+    helpWidth: 80,
+    sortSubcommands: true,
+})
+    .addHelpText('beforeAll', () => {
+    return createWelcomeMessage();
+});
+// Smart routing: if query provided as argument, route intelligently
+program
+    .argument('[query]', 'Your query - Codehere will understand what you need')
+    .option('--review', 'Enable review & feedback capture (used for trust scoring and Validation Mode)')
+    .option('--quick', 'Quick mode - work without indexing by reading files directly')
+    .option('-c, --continue', 'Continue from previous conversation (session continuity)')
+    .option('-m, --model <model>', 'Specify AI model (e.g., gpt-4, claude-3, command-r-plus, llama3)')
+    .action(async (query, options) => {
+    if (query && query.trim()) {
+        // Direct query - use intelligent router
+        initLogFile();
+        // Check for valid AI provider (supports Cohere, OpenAI, OpenRouter, Local, Fake)
+        const providerCheck = checkProviderConfiguration();
+        if (!providerCheck.hasValidProvider) {
+            displayProviderError(providerCheck);
+            process.exit(1);
+        }
+        try {
+            const opts = program.opts();
+            // Set model in environment if specified
+            if (opts.model) {
+                process.env.CODEHERE_MODEL = opts.model;
+            }
+            await executeSmartCommand(query.trim(), {
+                review: opts.review || false,
+                quick: opts.quick || false,
+                continue: opts.continue || false,
+                model: opts.model,
+            });
+            logEntry({
+                timestamp: new Date().toISOString(),
+                command: 'smart',
+                query: query.trim(),
+                policyStatus: 'allowed',
+            });
+        }
+        catch (err) {
+            console.error(error('Error:'), err instanceof Error ? err.message : String(err));
+            process.exit(1);
+        }
+    }
+    else if (process.stdin.isTTY) {
+        // Interactive mode - start session
+        await startSession();
+    }
+    else {
+        // Non-interactive - show help
+        console.log(createWelcomeMessage());
+        newline();
+        console.log(colors.bold('Usage:'));
+        newline();
+        console.log(colors.cyan('  codehere "<your query>"') + '     Ask anything - Codehere understands');
+        console.log(colors.cyan('  codehere') + '                    Start interactive session');
+        console.log(colors.cyan('  codehere index') + '              Build embeddings index');
+        newline();
+        console.log(colors.dim('Examples:'));
+        console.log(colors.dim('  codehere "How does authentication work?"'));
+        console.log(colors.dim('  codehere "Explain src/auth.ts"'));
+        console.log(colors.dim('  codehere "Fix src/utils.ts add error handling"'));
+        newline();
+        console.log(colors.dim('Run "codehere --help" for all commands'));
+        newline();
+    }
+});
+program
+    .command('setup')
+    .description('Interactive setup wizard for first-time users')
+    .option('-f, --force', 'Force reconfiguration even if already set up')
+    .action(async (options) => {
+    await executeSetupCommand(options.force || false);
+});
+program
+    .command('config')
+    .description('Manage configuration and preferences')
+    .argument('[action]', 'Action: show, get, set, reset')
+    .argument('[key]', 'Preference key (for get/set)')
+    .argument('[value]', 'Preference value (for set)')
+    .action(async (action, key, value) => {
+    await executeConfigCommand(action, key, value);
+});
+program
+    .command('models')
+    .description('List, search, and get info about available AI models')
+    .option('-l, --list', 'List all available models')
+    .option('-s, --search <query>', 'Search models by name or ID')
+    .option('-i, --info <model-id>', 'Get detailed info about a specific model')
+    .option('-p, --provider <provider>', 'Filter by provider (cohere, openai, openrouter, etc.)')
+    .option('--json', 'Output in JSON format')
+    .action(async (options) => {
+    initLogFile();
+    try {
+        await executeModelsCommand({
+            list: options.list,
+            search: options.search,
+            info: options.info,
+            provider: options.provider,
+            json: options.json,
+        });
+    }
+    catch (err) {
+        console.error(error('Error:'), err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+});
+program
+    .command('telemetry')
+    .description('Manage telemetry settings (opt-in, privacy-first)')
+    .option('--enable', 'Enable telemetry')
+    .option('--disable', 'Disable telemetry')
+    .option('--status', 'Show telemetry status')
+    .action(async (options) => {
+    const telemetry = getTelemetryService();
+    if (options.enable) {
+        telemetry.enable();
+        console.log(success('Telemetry enabled. Thank you for helping improve Codehere!'));
+        console.log(colors.dim('Data is anonymized and no code/content is transmitted.'));
+        newline();
+    }
+    else if (options.disable) {
+        telemetry.disable();
+        console.log(success('Telemetry disabled.'));
+        newline();
+    }
+    else {
+        console.log(colors.bold('Telemetry Status:'));
+        newline();
+        console.log(telemetry.isEnabled()
+            ? success('Enabled (opt-in)')
+            : colors.dim('Disabled (set --enable to opt-in)'));
+        newline();
+        console.log(colors.dim('Telemetry helps us understand usage patterns and improve Codehere.'));
+        console.log(colors.dim('All data is anonymized. No code or content is transmitted.'));
+        console.log(colors.dim('Enable with: codehere telemetry --enable'));
+        newline();
+    }
+});
+program
+    .command('help')
+    .description('Show help for commands')
+    .argument('[command]', 'Command name to get help for')
+    .action(async (commandName) => {
+    await executeHelpCommand(commandName);
+});
+program
+    .command('index')
+    .description('Build embeddings index of the repository')
+    .option('-r, --repo <path>', 'Repository path (default: current directory)')
+    .action(async (options) => {
+    initLogFile();
+    // Check provider configuration (supports all providers)
+    const { checkProviderConfiguration, displayProviderError } = await import('./utils/provider-check.js');
+    const providerCheck = checkProviderConfiguration();
+    if (!providerCheck.hasValidProvider) {
+        displayProviderError(providerCheck);
+        process.exit(1);
+    }
+    try {
+        if (isMinimalStyle()) {
+            console.log(colors.cyan('Indexing codebase...'));
+        }
+        else {
+            console.log(createBanner('Indexing Repository', 'Building semantic search index'));
+        }
+        newline();
+        const repoPath = options.repo || process.cwd();
+        // Show progress spinner for indexing
+        const spinner = createSpinner('Scanning files...');
+        spinner.start();
+        const startTime = Date.now();
+        // NEW: Use parallel indexing with caching
+        await indexRepositoryParallel(repoPath, {
+            useCache: true,
+            maxConcurrency: 5,
+        });
+        const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+        spinner.succeed(`Indexed codebase in ${elapsed}s`);
+        logEntry({
+            timestamp: new Date().toISOString(),
+            command: 'index',
+            policyStatus: 'allowed',
+        });
+        newline();
+        if (isMinimalStyle()) {
+            console.log(success('Indexing complete. Cache written to .codehere-cache/'));
+        }
+        else {
+            console.log(success('Indexing complete!'));
+        }
+        process.exit(0);
+    }
+    catch (err) {
+        const errorMessage = err instanceof Error ? err.message : String(err);
+        // Check for 401 Unauthorized errors
+        if (errorMessage.includes('401') || errorMessage.includes('Unauthorized') || errorMessage.includes('no api key')) {
+            newline();
+            console.error(error('Authentication failed: Invalid or missing API key'));
+            newline();
+            console.log(colors.bold('Troubleshooting:'));
+            console.log('  1. Verify your COHERE_API_KEY is set correctly:');
+            console.log(colors.cyan('     echo $COHERE_API_KEY'));
+            console.log('  2. Check if the key is valid at: https://dashboard.cohere.com/api-keys');
+            console.log('  3. If using a .env file, ensure it\'s loaded (e.g., use dotenv)');
+            console.log('  4. For testing, you can use: CODEHERE_FAKE_AI=1 codehere index');
+            newline();
+        }
+        else {
+            console.error(error('Error indexing repository:'), errorMessage);
+        }
+        process.exit(1);
+    }
+});
+program
+    .command('ask')
+    .description('Ask questions about your codebase using semantic search')
+    .argument('<question>', 'The question to ask about your code')
+    .option('-q, --quick', 'Quick mode - work without indexing by reading files directly')
+    .alias('q')
+    .addHelpText('after', `
+Examples:
+  $ codehere ask "How does authentication work?"
+  $ codehere ask "Where is the user login function?"
+  $ codehere q "Explain the database schema"
+  $ codehere ask "What does this project do?" --quick
+
+This command will:
+  • Search your indexed codebase for relevant code
+  • Use AI to generate a contextual answer
+  • Show which files were used as context
+
+Make sure to run "codehere index" first (or use --quick to bypass indexing)!
+  `)
+    .action(async (question, options) => {
+    initLogFile();
+    // Check if any valid provider is configured
+    const providerCheck = checkProviderConfiguration();
+    if (!providerCheck.hasValidProvider) {
+        newline();
+        console.error(error(providerCheck.message));
+        if (providerCheck.setupInstructions) {
+            newline();
+            console.log(colors.bold('Setup Instructions:'));
+            providerCheck.setupInstructions.forEach(instruction => {
+                console.log('  ' + instruction);
+            });
+        }
+        newline();
+        process.exit(1);
+    }
+    try {
+        await executeAskCommand(question, { quick: options.quick });
+        logEntry({
+            timestamp: new Date().toISOString(),
+            command: 'ask',
+            query: question,
+            policyStatus: 'allowed',
+        });
+    }
+    catch (err) {
+        const errMessage = err instanceof Error ? err.message : String(err);
+        // If it's a missing embeddings error, exit with 1
+        if (errMessage.includes('No embeddings found')) {
+            process.exit(1);
+        }
+        console.error(error('Error:'), errMessage);
+        process.exit(1);
+    }
+});
+program
+    .command('fix')
+    .description('Apply AI-generated code edits to a file')
+    .argument('<file>', 'Path to the file to edit')
+    .argument('<instruction>', 'Natural language instruction for the edit')
+    .alias('edit')
+    .option('--review', 'Enable review & feedback capture (used for trust scoring and Validation Mode)')
+    .addHelpText('after', `
+Examples:
+  $ codehere fix src/auth.ts "Add error handling for invalid tokens"
+  $ codehere fix utils/helpers.js "Rename function foo() to bar()" --review
+  $ codehere edit app.js "Add input validation"
+
+This command will:
+  • Generate a unified diff using AI
+  • Apply safety policy checks
+  • Apply the changes to your file
+  • Log the operation for audit
+
+Options:
+  --review    Enable review & feedback capture (used for trust scoring and Validation Mode)
+
+Safety policies:
+  • Maximum 50 lines changed per edit
+  • Cannot edit files in restricted folders (infra/, billing/)
+  • Only one file can be edited at a time
+  `)
+    .action(async (file, instruction, options) => {
+    initLogFile();
+    const providerCheck = checkProviderConfiguration();
+    if (!providerCheck.hasValidProvider) {
+        newline();
+        displayProviderError(providerCheck);
+        process.exit(1);
+    }
+    try {
+        // Check if embeddings exist for this repository (skip check if using fake AI for testing)
+        if (process.env.CODEHERE_FAKE_AI !== '1') {
+            const { container } = await import('./application/services/dependency-container.js');
+            const embeddingRepo = container.getEmbeddingRepository(process.cwd());
+            const hasEmbeddings = await embeddingRepo.hasEmbeddings();
+            if (!hasEmbeddings) {
+                newline();
+                console.error(colors.red('No embeddings found for this repository.'));
+                newline();
+                console.log('Run:');
+                console.log(colors.cyan('  codehere index'));
+                console.log('');
+                console.log('then re-run this command.');
+                newline();
+                process.exit(1);
+            }
+        }
+        await executeFixCommand(file, instruction, { review: options?.review });
+        logEntry({
+            timestamp: new Date().toISOString(),
+            command: 'fix',
+            query: instruction,
+            filepath: file,
+            policyStatus: 'allowed',
+        });
+    }
+    catch (err) {
+        displayError(err, {
+            operation: 'edit',
+            query: instruction,
+            filepath: file,
+            showSuggestions: true,
+        });
+        process.exit(1);
+    }
+});
+program
+    .command('explain')
+    .description('Get AI explanation of a code file')
+    .argument('<file>', 'Path to the file to explain')
+    .alias('e')
+    .addHelpText('after', `
+Examples:
+  $ codehere explain src/auth.ts
+  $ codehere explain utils/helpers.js
+  $ codehere e app.js
+
+This command will:
+  • Read the file content
+  • Generate an AI explanation
+  • Show file structure, functions, and logic
+  `)
+    .action(async (file) => {
+    initLogFile();
+    const providerCheck = checkProviderConfiguration();
+    if (!providerCheck.hasValidProvider) {
+        newline();
+        displayProviderError(providerCheck);
+        process.exit(1);
+    }
+    try {
+        // Check if embeddings exist for this repository (skip check if using fake AI for testing)
+        if (process.env.CODEHERE_FAKE_AI !== '1') {
+            const { container } = await import('./application/services/dependency-container.js');
+            const embeddingRepo = container.getEmbeddingRepository(process.cwd());
+            const hasEmbeddings = await embeddingRepo.hasEmbeddings();
+            if (!hasEmbeddings) {
+                newline();
+                console.error(colors.red('No embeddings found for this repository.'));
+                newline();
+                console.log('Run:');
+                console.log(colors.cyan('  codehere index'));
+                console.log('');
+                console.log('then re-run this command.');
+                newline();
+                process.exit(1);
+            }
+        }
+        if (isMinimalStyle()) {
+            printMinimalHeader('explain', file);
+        }
+        else {
+            console.log(createBanner('Explain File', 'AI-powered code explanation'));
+            newline();
+        }
+        const fullPath = join(process.cwd(), file);
+        // Check if file exists
+        const { existsSync } = await import('fs');
+        if (!existsSync(fullPath)) {
+            newline();
+            console.error(error(`File not found: ${file}`));
+            console.log(info(`Looking for: ${fullPath}`));
+            console.log(info('Tip: Use a relative path from your current directory'));
+            newline();
+            process.exit(1);
+        }
+        // Use clean architecture
+        const { container } = await import('./application/services/dependency-container.js');
+        const useCase = container.explainFileUseCase;
+        const explainSpinner = createSpinner('Generating explanation...');
+        explainSpinner.start();
+        const result = await useCase.execute({ filepath: file });
+        explainSpinner.stop();
+        // File info
+        const lines = result.fileContent.split('\n').length;
+        const size = (result.fileContent.length / 1024).toFixed(2);
+        console.log(colors.bold('File:') + ' ' + formatPath(file));
+        console.log(colors.dim(`  Lines: ${lines} | Size: ${size} KB`));
+        newline();
+        // Display explanation
+        sectionHeader('Explanation');
+        const formattedResponse = cleanResponse(result.explanation);
+        console.log(formattedResponse);
+        newline();
+        logEntry({
+            timestamp: new Date().toISOString(),
+            command: 'explain',
+            query: `Explain ${file}`,
+            filepath: file,
+            policyStatus: 'allowed',
+            retrievedFiles: [file],
+        });
+    }
+    catch (err) {
+        console.error(error('Error:'), err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+});
+program
+    .command('health')
+    .description('Check system health and metrics')
+    .option('-m, --metrics', 'Show detailed metrics')
+    .action((options) => {
+    const health = performHealthCheck();
+    if (isMinimalStyle()) {
+        printMinimalHeader('health', '');
+    }
+    else {
+        newline();
+        console.log(createBanner('System Health', 'Enterprise monitoring'));
+        newline();
+    }
+    console.log(formatHealthStatus(health));
+    if (options.metrics) {
+        newline();
+        sectionHeader('Metrics');
+        const metrics = getMetrics();
+        const metricsTable = createTable(['Metric', 'Value'], [
+            ['Total Operations', formatNumber(metrics.operations.total)],
+            ['Successful', formatNumber(metrics.operations.successful)],
+            ['Failed', formatNumber(metrics.operations.failed)],
+            ['Retries', formatNumber(metrics.operations.retries)],
+            ['Avg Response Time', `${metrics.performance.avgResponseTime.toFixed(2)}ms`],
+            ['API Calls', formatNumber(metrics.performance.apiCalls)],
+            ['Cache Hits', formatNumber(metrics.performance.cacheHits)],
+        ]);
+        console.log(metricsTable.toString());
+        if (Object.keys(metrics.errors.byType).length > 0) {
+            newline();
+            sectionHeader('Error Summary');
+            const errorTable = createTable(['Error Type', 'Count'], Object.entries(metrics.errors.byType).map(([type, count]) => [
+                type,
+                formatNumber(count),
+            ]));
+            console.log(errorTable.toString());
+        }
+    }
+    newline();
+    if (health.status === 'unhealthy') {
+        process.exit(1);
+    }
+});
+program
+    .command('refactor')
+    .description('Refactor multiple files with coordinated changes')
+    .argument('<pattern>', 'File pattern (e.g., "src/**/*.ts") or comma-separated files')
+    .argument('<instruction>', 'Refactoring instruction')
+    .option('--dry-run', 'Show changes without applying')
+    .option('--max-files <number>', 'Maximum files to process', '10')
+    .action(async (pattern, instruction, options) => {
+    initLogFile();
+    const providerCheck = checkProviderConfiguration();
+    if (!providerCheck.hasValidProvider) {
+        displayProviderError(providerCheck);
+        process.exit(1);
+    }
+    try {
+        console.log(createBanner('Multi-File Refactor', 'Enterprise-grade cross-file operations'));
+        newline();
+        // Parse files from pattern
+        let files;
+        if (pattern.includes(',')) {
+            files = pattern.split(',').map(f => f.trim());
+        }
+        else {
+            files = findFilesByPattern(pattern);
+        }
+        if (files.length === 0) {
+            console.log(warning('No files found matching pattern'));
+            return;
+        }
+        console.log(colors.bold('Files to refactor:'));
+        files.slice(0, 10).forEach(f => console.log(colors.cyan('  ' + f)));
+        if (files.length > 10) {
+            console.log(colors.dim(`  ... and ${files.length - 10} more`));
+        }
+        newline();
+        console.log(colors.bold('Instruction:') + ' ' + colors.cyan(instruction));
+        newline();
+        const maxFiles = parseInt(options.maxFiles || '10', 10);
+        const result = await refactorMultiFile(files.slice(0, maxFiles), instruction, {
+            dryRun: options.dryRun || false,
+            maxFiles,
+        });
+        // Display results
+        sectionHeader('Refactoring Results');
+        const resultsTable = createTable(['Metric', 'Value'], [
+            ['Files Processed', formatNumber(files.length)],
+            ['Files Changed', formatNumber(result.filesChanged.length)],
+            ['Total Lines Added', formatNumber(result.totalChanges.linesAdded)],
+            ['Total Lines Removed', formatNumber(result.totalChanges.linesRemoved)],
+            ['Errors', formatNumber(result.errors.length)],
+        ]);
+        console.log(resultsTable.toString());
+        if (result.errors.length > 0) {
+            newline();
+            sectionHeader('Errors');
+            result.errors.forEach(err => {
+                console.log(error(`${err.file}: ${err.error}`));
+            });
+        }
+        if (result.filesChanged.length > 0) {
+            newline();
+            console.log(success(`Refactoring ${options.dryRun ? 'planned' : 'completed'} successfully`));
+        }
+    }
+    catch (err) {
+        console.error(error('Error:'), err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+});
+program
+    .command('git-review')
+    .description('Review git changes and suggest improvements')
+    .option('-f, --file <file>', 'Review specific file')
+    .action((options) => {
+    initLogFile();
+    try {
+        console.log(createBanner('Git Review', 'Git-aware code analysis'));
+        newline();
+        const status = getGitStatus();
+        if (!status.isRepo) {
+            console.log(warning('Not a git repository'));
+            return;
+        }
+        console.log(formatGitStatus(status));
+        newline();
+        if (!status.hasChanges) {
+            console.log(info('No changes to review'));
+            return;
+        }
+        // Get diffs
+        const diffs = options.file
+            ? (() => {
+                const diff = getGitDiff(options.file);
+                return diff ? new Map([[options.file, diff]]) : new Map();
+            })()
+            : getAllGitDiffs();
+        if (diffs.size === 0) {
+            console.log(info('No diffs found'));
+            return;
+        }
+        sectionHeader('Change Analysis');
+        for (const [file, diff] of diffs.entries()) {
+            const analysis = analyzeDiff(diff);
+            console.log(colors.bold(file));
+            console.log(colors.dim(`  ${analysis.summary}`));
+            console.log(colors.dim(`  Risk: ${analysis.riskLevel.toUpperCase()}`));
+            if (analysis.suggestions.length > 0) {
+                console.log(colors.yellow('  Suggestions:'));
+                analysis.suggestions.forEach(s => {
+                    console.log(colors.yellow(`    - ${s}`));
+                });
+            }
+            newline();
+        }
+    }
+    catch (err) {
+        console.error(error('Error:'), err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+});
+program
+    .command('plan')
+    .description('Plan a complex multi-step task')
+    .argument('<instruction>', 'Complex instruction to plan')
+    .option('-e, --execute', 'Execute the plan after creating it')
+    .option('--review', 'Enable review & feedback capture (used for trust scoring and Validation Mode)')
+    .action(async (instruction, options) => {
+    initLogFile();
+    const providerCheck = checkProviderConfiguration();
+    if (!providerCheck.hasValidProvider) {
+        displayProviderError(providerCheck);
+        process.exit(1);
+    }
+    try {
+        if (isMinimalStyle()) {
+            printMinimalHeader('plan', instruction);
+        }
+        else {
+            console.log(createBanner('Task Planning', 'Intelligent multi-step execution'));
+            newline();
+            console.log(colors.bold('Instruction:') + ' ' + colors.cyan(instruction));
+        }
+        newline();
+        // Use new memory-based planning
+        await executePlanCommand(instruction, { execute: options.execute, review: options.review });
+    }
+    catch (err) {
+        console.error(error('Error:'), err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+});
+program
+    .command('decision')
+    .description('Record and query architectural/design decisions')
+    .argument('<action>', 'Action: record, list, query, or explain')
+    .argument('[args...]', 'Arguments for the action')
+    .option('-c, --codebase <path>', 'Codebase path (default: current directory)')
+    .option('-t, --type <type>', 'Decision type filter (for list)')
+    .option('-l, --limit <number>', 'Limit number of results', '10')
+    .action(async (action, args, options) => {
+    initLogFile();
+    try {
+        await executeDecisionCommand(action, args, {
+            codebase: options.codebase,
+            type: options.type,
+            limit: options.limit ? parseInt(options.limit, 10) : undefined,
+        });
+    }
+    catch (err) {
+        console.error(error('Error:'), err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+});
+program
+    .command('knowledge')
+    .description('Query and manage preserved knowledge from codebase')
+    .argument('<action>', 'Action: query, list, summary, or extract')
+    .argument('[args...]', 'Arguments for the action')
+    .option('-c, --codebase <path>', 'Codebase path (default: current directory)')
+    .option('-t, --type <type>', 'Knowledge type filter (for list)')
+    .option('--tags <tags>', 'Comma-separated tags (for list)')
+    .option('-l, --limit <number>', 'Limit number of results', '10')
+    .action(async (action, args, options) => {
+    initLogFile();
+    try {
+        await executeKnowledgeCommand(action, args, {
+            codebase: options.codebase,
+            type: options.type,
+            tags: options.tags ? options.tags.split(',') : undefined,
+            limit: options.limit ? parseInt(options.limit, 10) : undefined,
+        });
+    }
+    catch (err) {
+        console.error(error('Error:'), err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+});
+program
+    .command('learning')
+    .description('Learning dashboard - View patterns, knowledge, and insights')
+    .argument('<action>', 'Action: overview, patterns, knowledge, or insights')
+    .option('-c, --codebase <path>', 'Codebase path (default: current directory)')
+    .action(async (action, options) => {
+    initLogFile();
+    try {
+        await executeLearningDashboardCommand(action, options.codebase);
+    }
+    catch (err) {
+        console.error(error('Error:'), err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+});
+program
+    .command('review-file')
+    .description('Automated code review for a file')
+    .argument('<file>', 'File to review')
+    .action(async (file) => {
+    initLogFile();
+    const providerCheck = checkProviderConfiguration();
+    if (!providerCheck.hasValidProvider) {
+        displayProviderError(providerCheck);
+        process.exit(1);
+    }
+    try {
+        if (isMinimalStyle()) {
+            console.log(colors.bold(`Review: ${file}`));
+            newline();
+        }
+        else {
+            console.log(createBanner('Code Review', 'Automated senior-level analysis'));
+            newline();
+        }
+        const reviewSpinner = createSpinner('Reviewing code...');
+        reviewSpinner.start();
+        const review = await reviewFile(file);
+        reviewSpinner.stop();
+        newline();
+        if (isMinimalStyle()) {
+            console.log(colors.bold('Findings:'));
+            console.log(formatReview(review));
+            newline();
+            console.log(colors.dim(`Score: ${review.score}/100`));
+        }
+        else {
+            console.log(formatReview(review));
+            // Display score
+            newline();
+            sectionHeader('Review Score');
+            const scoreTable = createTable(['Metric', 'Value'], [
+                ['Overall Score', `${review.score}/100`],
+                ['Errors', formatNumber(review.issues.filter(i => i.severity === 'error').length)],
+                ['Warnings', formatNumber(review.issues.filter(i => i.severity === 'warning').length)],
+                ['Info', formatNumber(review.issues.filter(i => i.severity === 'info').length)],
+            ]);
+            console.log(scoreTable.toString());
+        }
+    }
+    catch (err) {
+        console.error(error('Error:'), err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+});
+program
+    .command('learn')
+    .description('Show learning insights and performance recommendations')
+    .action(() => {
+    try {
+        console.log(createBanner('Learning Insights', 'Self-improvement system'));
+        newline();
+        const insights = formatLearningInsights();
+        console.log(insights);
+        const perfInsights = getPerformanceInsights();
+        if (perfInsights.recommendations.length > 0) {
+            sectionHeader('Performance Recommendations');
+            perfInsights.recommendations.forEach(rec => {
+                console.log(info(rec));
+            });
+        }
+        const cacheStats = getCacheStats();
+        newline();
+        sectionHeader('Cache Statistics');
+        const cacheTable = createTable(['Metric', 'Value'], [
+            ['Memory Cache', `${cacheStats.memorySize}/${cacheStats.memoryMaxSize}`],
+            ['File Cache', formatNumber(cacheStats.fileCacheCount)],
+        ]);
+        console.log(cacheTable.toString());
+    }
+    catch (err) {
+        console.error(error('Error:'), err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+});
+program
+    .command('cache')
+    .description('Manage cache')
+    .option('--clear', 'Clear all caches')
+    .option('--stats', 'Show cache statistics')
+    .action((options) => {
+    if (options.clear) {
+        clearAllCaches();
+        console.log(success('All caches cleared'));
+    }
+    else if (options.stats) {
+        const stats = getCacheStats();
+        sectionHeader('Cache Statistics');
+        const cacheTable = createTable(['Metric', 'Value'], [
+            ['Memory Cache', `${stats.memorySize}/${stats.memoryMaxSize}`],
+            ['File Cache', formatNumber(stats.fileCacheCount)],
+        ]);
+        console.log(cacheTable.toString());
+    }
+    else {
+        console.log(info('Use --clear to clear caches or --stats to show statistics'));
+    }
+});
+program
+    .command('migrate')
+    .description('Plan and execute framework migrations')
+    .argument('<from>', 'Source framework/version')
+    .argument('<to>', 'Target framework/version')
+    .option('-f, --files <files...>', 'Specific files to migrate')
+    .option('--plan-only', 'Only show migration plan, do not execute')
+    .action(async (from, to, options) => {
+    initLogFile();
+    const providerCheck = checkProviderConfiguration();
+    if (!providerCheck.hasValidProvider) {
+        displayProviderError(providerCheck);
+        process.exit(1);
+    }
+    try {
+        console.log(createBanner('Migration Assistant', `From ${from} to ${to}`));
+        newline();
+        const plan = await planMigration(from, to, options.files);
+        sectionHeader('Migration Plan');
+        console.log(formatMigrationPlan(plan));
+        if (!options.planOnly) {
+            newline();
+            console.log(info('Migration execution coming soon...'));
+        }
+    }
+    catch (err) {
+        console.error(error('Error:'), err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+});
+// DocumentationAgent-based docs command
+program
+    .command('docs')
+    .description('Generate documentation using DocumentationAgent')
+    .argument('<generate>', 'Command: generate')
+    .argument('<type>', 'Documentation type: readme, api, or all')
+    .option('--target <dir>', 'Target directory for API docs (default: src)')
+    .option('--update-existing', 'Update existing documentation files')
+    .option('--output <path>', 'Output path for generated docs')
+    .option('--review', 'Enable review & feedback capture (used for trust scoring and Validation Mode)')
+    .addHelpText('after', `
+Examples:
+  $ codehere docs generate readme
+  $ codehere docs generate api --target src
+  $ codehere docs generate all --update-existing
+  $ codehere docs generate readme --review
+
+Warning: This command may modify README.md and docs/api.md files.
+  `)
+    .action(async (cmd, type, options) => {
+    if (cmd !== 'generate') {
+        console.error(error(`Unknown command: ${cmd}. Use 'generate' to create documentation.`));
+        process.exit(1);
+    }
+    const providerCheck = checkProviderConfiguration();
+    if (!providerCheck.hasValidProvider) {
+        displayProviderError(providerCheck);
+        process.exit(1);
+    }
+    initLogFile();
+    await executeDocsCommand(type, {
+        target: options.target,
+        updateExisting: options.updateExisting,
+        outputPath: options.output,
+        review: Boolean(options.review),
+    });
+});
+// ProductRequirementsAgent-based product command
+program
+    .command('product')
+    .description('Generate product requirements documents using ProductRequirementsAgent')
+    .argument('<spec>', 'Command: spec')
+    .argument('<goal>', 'Product goal or feature description')
+    .option('--format <format>', 'Output format: markdown, json, or both', 'both')
+    .option('--output <path>', 'Output path for generated PRD (optional)')
+    .option('--detail <level>', 'Detail level: low, medium, or high', 'medium')
+    .option('--include-technical-spec', 'Include technical specification document')
+    .option('--review', 'Enable review & feedback capture (used for trust scoring and Validation Mode)')
+    .addHelpText('after', `
+Examples:
+  $ codehere product spec "Add team dashboards for executive reporting"
+  $ codehere product spec "Build user authentication system" --format markdown --output prd.md
+  $ codehere product spec "Implement payment gateway" --detail high --include-technical-spec --review
+
+Warning: This command may create new files if --output is specified.
+  `)
+    .action(async (cmd, goal, options) => {
+    if (cmd !== 'spec') {
+        console.error(error(`Unknown command: ${cmd}. Use 'spec' to generate product requirements.`));
+        process.exit(1);
+    }
+    const providerCheck = checkProviderConfiguration();
+    if (!providerCheck.hasValidProvider) {
+        displayProviderError(providerCheck);
+        process.exit(1);
+    }
+    initLogFile();
+    // Note: --review flag is defined on parent 'product' command, not 'spec' subcommand
+    // In commander.js, parent command options may not be merged into subcommand options
+    // So we check both options.review (subcommand) and program.opts().review (parent command)
+    // This ensures --review works correctly for 'product spec' commands
+    const reviewValue = options.review !== undefined ? options.review : program.opts().review;
+    await executeProductCommand(goal, {
+        format: options.format,
+        output: options.output,
+        detail: options.detail,
+        includeTechnicalSpec: options.includeTechnicalSpec || false,
+        review: Boolean(reviewValue),
+    });
+});
+// Status command
+program
+    .command('status')
+    .description('Show system status and optionally list recent tasks')
+    .option('--json', 'Output machine-readable JSON summary instead of text')
+    .option('--tasks', 'Show recent tasks (experimental)')
+    .option('--env', 'Show environment details')
+    .option('--track', 'Show what works (success rates by command)')
+    .action(async (options) => {
+    await executeStatusCommand({
+        json: Boolean(options.json),
+        tasks: Boolean(options.tasks),
+        env: Boolean(options.env),
+        track: Boolean(options.track),
+    });
+});
+// Cost tracking command - doesn't require API key
+program
+    .command('cost')
+    .description('View API cost tracking and budget status (local estimates)')
+    .argument('[action]', 'Action: status, summary, run, reset', 'status')
+    .argument('[runId]', 'Run ID (for "run" action)')
+    .action(async (action, runId) => {
+    await executeCostCommand(action, runId);
+});
+// Trust dashboard command - shows agent reliability metrics
+program
+    .command('trust')
+    .description('View agent reliability and trust metrics')
+    .argument('[action]', 'Action: status, history, reset', 'status')
+    .option('--json', 'Output in JSON format')
+    .option('--limit <n>', 'Limit history entries', '20')
+    .action(async (action, options) => {
+    await executeTrustCommand(action, {
+        json: options.json,
+        limit: options.limit ? parseInt(options.limit, 10) : undefined,
+    });
+});
+// TEMP DISABLED: Context commands trigger WASM hang via SQLiteContextRepository
+// See: commit bc9cd03 fix(P0): Disable context-command to prevent WASM hang blocking CLI
+/*
+// Context continuity commands - import, export, stats
+// Use addCommand for proper subcommand handling
+const contextImportCmd = new Command('import')
+  .description('Import conversation context from other AI tools')
+  .requiredOption('--from <source>', 'Import source: claude-code, opencode, cursor, or file')
+  .option('--session <id>', 'Session ID (default: latest)', 'latest')
+  .option('--file <path>', 'File path (required for file import)')
+  .option('--project <path>', 'Project path override')
+  .addHelpText('after', `
+Examples:
+  $ codehere context import --from claude-code --session latest
+  $ codehere context import --from claude-code --session <session-id>
+  $ codehere context import --from opencode
+  $ codehere context import --from cursor
+  $ codehere context import --from file --file ./context.json
+
+Context continuity allows you to:
+  • Import conversations from Claude Code, OpenCode, or Cursor
+  • Continue conversations across different AI tools
+  • Preserve context when switching providers
+  `)
+  .action(async function(this: Command) {
+    initLogFile();
+    
+    try {
+      // Use 'this' context to access command options in Commander.js subcommands
+      const from = this.getOptionValue('from');
+      const session = this.getOptionValue('session') || 'latest';
+      const file = this.getOptionValue('file');
+      const project = this.getOptionValue('project');
+      
+      if (!from) {
+        console.error(error('--from is required for import'));
+        console.log(info('Usage: codehere context import --from <source> [options]'));
+        process.exit(1);
+      }
+      
+      if (from === 'file' && !file) {
+        console.error(error('--file is required when --from=file'));
+        console.log(info('Usage: codehere context import --from file --file <path>'));
+        process.exit(1);
+      }
+      
+      await executeContextImportCommand(from, {
+        session,
+        file,
+        project,
+      });
+    } catch (err) {
+      console.error(error('Error:'), err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+
+const contextCmd = new Command('context')
+  .description('Manage conversation contexts (import, export, stats)')
+  .addCommand(contextImportCmd);
+
+const contextExportCmd = new Command('export')
+  .description('Export conversation context to portable format')
+  .option('--session <id>', 'Session ID (default: latest)')
+  .option('--output <path>', 'Output file path')
+  .option('--json', 'Output in JSON format')
+  .addHelpText('after', `
+Examples:
+  $ codehere context export --session <sessionId> --output ./export.json
+  $ codehere context export --output my-context.json
+  $ codehere context export --session <sessionId> --json
+
+Exports context to portable JSON format that can be:
+  • Re-imported into Codehere
+  • Shared with team members
+  • Backed up for safekeeping
+  `)
+  .action(async function(this: Command) {
+    initLogFile();
+    
+    try {
+      const session = this.getOptionValue('session');
+      const output = this.getOptionValue('output');
+      const json = this.getOptionValue('json');
+      
+      await executeContextExportCommand(session, {
+        output,
+        json,
+      });
+    } catch (err) {
+      console.error(error('Error:'), err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+
+contextCmd.addCommand(contextExportCmd);
+
+const contextStatsCmd = new Command('stats')
+  .description('View conversation context statistics')
+  .option('--session <id>', 'Session ID (shows all if not specified)')
+  .option('--json', 'Output in JSON format')
+  .addHelpText('after', `
+Examples:
+  $ codehere context stats
+  $ codehere context stats --session <sessionId>
+  $ codehere context stats --session <sessionId> --json
+
+Shows:
+  • Message count and token usage
+  • Compaction history
+  • Model and provider information
+  • Project metadata
+  `)
+  .action(async function(this: Command) {
+    initLogFile();
+    
+    try {
+      const session = this.getOptionValue('session');
+      const json = this.getOptionValue('json');
+      
+      await executeContextStatsCommand(session, {
+        json,
+      });
+    } catch (err) {
+      console.error(error('Error:'), err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+
+contextCmd.addCommand(contextStatsCmd);
+program.addCommand(contextCmd);
+*/
+// END TEMP DISABLED context commands
+// Suggest command - Read-only assistant mode
+program
+    .command('suggest')
+    .description('Read-only assistant mode - ask questions and get explanations without making changes')
+    .argument('<query>', 'The question or request')
+    .option('--file <file>', 'Focus on a specific file')
+    .addHelpText('after', `
+Examples:
+  $ codehere suggest "How does authentication work?"
+  $ codehere suggest "Explain this function" --file src/auth.ts
+
+This command:
+  • Searches your codebase for relevant code
+  • Provides contextual answers and explanations
+  • Does NOT make any changes (read-only mode)
+  • Creates a task record for tracking
+  `)
+    .action(async (query, options) => {
+    initLogFile();
+    const providerCheck = checkProviderConfiguration();
+    if (!providerCheck.hasValidProvider) {
+        displayProviderError(providerCheck);
+        process.exit(1);
+    }
+    try {
+        await executeSuggestCommand(query, {
+            file: options.file,
+            stream: false,
+        });
+        logEntry({
+            timestamp: new Date().toISOString(),
+            command: 'suggest',
+            query,
+            policyStatus: 'allowed',
+        });
+    }
+    catch (err) {
+        const errMessage = err instanceof Error ? err.message : String(err);
+        // If it's a missing embeddings error, exit with 1 (message already shown)
+        if (errMessage.includes('No embeddings found')) {
+            process.exit(1);
+        }
+        console.error(error('Error:'), errMessage);
+        process.exit(1);
+    }
+});
+// Run command - Unified agentic execution
+program
+    .command('run')
+    .description('Unified agentic execution - execute a task or goal')
+    .argument('<goal>', 'The goal to execute')
+    .option('--task-id <id>', 'Continue execution of an existing task')
+    .option('--file <file>', 'Focus on a specific file')
+    .option('--files <files>', 'Comma-separated list of files to process')
+    .option('--review', 'Enable review before applying changes')
+    .addHelpText('after', `
+Examples:
+  $ codehere run "Add error handling to the login function"
+  $ codehere run "Refactor authentication module" --file src/auth.ts
+  $ codehere run "Fix bug in payment processing" --task-id task-12345
+
+This command:
+  • Creates a plan for the goal
+  • Executes the plan step-by-step
+  • Creates/updates task records for tracking
+  • Shows risk tier and environment mode (advisory)
+  `)
+    .action(async (goal, options) => {
+    initLogFile();
+    const providerCheck = checkProviderConfiguration();
+    if (!providerCheck.hasValidProvider) {
+        displayProviderError(providerCheck);
+        process.exit(1);
+    }
+    try {
+        const files = options.files ? options.files.split(',').map((f) => f.trim()) : undefined;
+        await executeRunCommand(goal, {
+            taskId: options.taskId,
+            file: options.file,
+            files,
+            review: Boolean(options.review),
+        });
+        logEntry({
+            timestamp: new Date().toISOString(),
+            command: 'run',
+            query: goal,
+            policyStatus: 'allowed',
+        });
+    }
+    catch (err) {
+        console.error(error('Error:'), err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+});
+// Review command - Task review interface
+program
+    .command('review')
+    .description('Review and approve/reject tasks')
+    .argument('[task-id]', 'Task ID to review (omit to list tasks)')
+    .option('--list', 'List tasks needing review')
+    .option('--approve', 'Approve the task')
+    .option('--reject', 'Reject the task')
+    .option('--comment <text>', 'Add a comment to the review')
+    .option('--all', 'Show all completed tasks in list mode')
+    .addHelpText('after', `
+Examples:
+  $ codehere review --list
+  $ codehere review task-12345
+  $ codehere review task-12345 --approve
+  $ codehere review task-12345 --reject --comment "Security concerns"
+
+This command:
+  • Lists tasks that need review
+  • Shows task details (files changed, risk tier, etc.)
+  • Allows approving or rejecting tasks
+  • Updates task status and review records
+  `)
+    .action(async (taskId, options) => {
+    initLogFile();
+    try {
+        await executeReviewCommand(taskId, {
+            list: Boolean(options.list),
+            approve: Boolean(options.approve),
+            reject: Boolean(options.reject),
+            comment: options.comment,
+            all: Boolean(options.all),
+        });
+        logEntry({
+            timestamp: new Date().toISOString(),
+            command: 'review',
+            query: taskId,
+            policyStatus: 'allowed',
+        });
+    }
+    catch (err) {
+        console.error(error('Error:'), err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+});
+program
+    .command('test')
+    .description('Generate tests for code')
+    .argument('<file>', 'File to generate tests for')
+    .option('--framework <framework>', 'Test framework (jest, pytest, etc.)')
+    .option('--coverage <type>', 'Coverage type (unit, integration, both)', 'unit')
+    .option('--improve', 'Improve existing test file')
+    .option('--save', 'Save tests to file')
+    .action(async (file, options) => {
+    initLogFile();
+    const providerCheck = checkProviderConfiguration();
+    if (!providerCheck.hasValidProvider) {
+        displayProviderError(providerCheck);
+        process.exit(1);
+    }
+    try {
+        console.log(createBanner('Test Generator', 'Comprehensive test generation'));
+        newline();
+        const testSpinner = createSpinner('Generating tests...');
+        testSpinner.start();
+        let tests;
+        if (options.improve) {
+            tests = await improveTests(file);
+        }
+        else {
+            tests = await generateTests(file, {
+                framework: options.framework,
+                coverage: options.coverage,
+            });
+        }
+        testSpinner.stop();
+        newline();
+        sectionHeader('Generated Tests');
+        const formattedTests = cleanResponse(tests);
+        console.log(formattedTests);
+        if (options.save) {
+            const testPath = options.improve ? file : getTestFilePath(file, options.framework);
+            saveTests(testPath, tests);
+            console.log(success(`Tests saved to ${testPath}`));
+        }
+    }
+    catch (err) {
+        console.error(error('Error:'), err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+});
+program
+    .command('react')
+    .description('Execute query using ReAct loop (iterative reasoning with tools)')
+    .argument('<query>', 'The query to process with ReAct reasoning')
+    .addHelpText('after', `
+Examples:
+  $ codehere react "How does authentication work in this codebase?"
+  $ codehere react "Find and explain the user login function"
+  $ codehere react "What files handle API requests?"
+
+This command uses ReAct (Reasoning + Acting) pattern:
+  • Generates thoughts about the problem
+  • Takes actions (uses tools, searches code)
+  • Observes results
+  • Iterates until solution found
+  • Learns from memory of past experiences
+  `)
+    .action(async (query) => {
+    initLogFile();
+    const providerCheck = checkProviderConfiguration();
+    if (!providerCheck.hasValidProvider) {
+        newline();
+        displayProviderError(providerCheck);
+        process.exit(1);
+    }
+    try {
+        await executeReactCommand(query);
+        logEntry({
+            timestamp: new Date().toISOString(),
+            command: 'react',
+            query: query,
+            policyStatus: 'allowed',
+        });
+    }
+    catch (err) {
+        console.error(error('Error:'), err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+});
+program
+    .command('orchestrate')
+    .description('Orchestrate multi-agent workflows (plan, execute, validate)')
+    .argument('<goal>', 'The goal to orchestrate')
+    .option('-m, --mode <mode>', 'Orchestration mode: plan-only, execute-only, or full', 'full')
+    .option('-p, --plan-id <planId>', 'Load and execute a previously saved plan by ID')
+    .option('--review', 'Enable review & feedback capture (used for trust scoring and Validation Mode)')
+    .action(async (goal, options) => {
+    initLogFile();
+    const providerCheck = checkProviderConfiguration();
+    if (!providerCheck.hasValidProvider) {
+        displayProviderError(providerCheck);
+        process.exit(1);
+    }
+    try {
+        await executeOrchestrateCommand(goal, {
+            mode: options.mode,
+            planId: options.planId,
+            review: options.review,
+        });
+        logEntry({
+            timestamp: new Date().toISOString(),
+            command: 'orchestrate',
+            query: goal,
+            policyStatus: 'allowed',
+        });
+    }
+    catch (err) {
+        console.error(error('Error:'), err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+});
+program
+    .command('trace')
+    .description('View execution traces and reproduce runs')
+    .argument('<action>', 'Action: list, show, or reproduce')
+    .argument('[runId]', 'Run ID (required for show/reproduce)')
+    .action(async (action, runId) => {
+    initLogFile();
+    try {
+        if (action === 'list') {
+            await executeTraceCommand('list');
+        }
+        else if (action === 'show') {
+            if (!runId) {
+                console.error(error('Run ID is required for "show" action'));
+                console.log(info('Usage: codehere trace show <runId>'));
+                process.exit(1);
+            }
+            await executeTraceCommand('show', runId);
+        }
+        else if (action === 'reproduce') {
+            if (!runId) {
+                console.error(error('Run ID is required for "reproduce" action'));
+                console.log(info('Usage: codehere trace reproduce <runId>'));
+                process.exit(1);
+            }
+            await executeTraceCommand('reproduce', runId);
+        }
+        else {
+            console.error(error(`Unknown action: ${action}`));
+            console.log(info('Available actions: list, show, reproduce'));
+            process.exit(1);
+        }
+    }
+    catch (err) {
+        console.error(error('Error:'), err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+});
+program
+    .command('undo')
+    .description('Undo file changes by restoring from backups')
+    .argument('<action>', 'Action: undo, list, restore')
+    .argument('[filepath]', 'File path (required for undo/list)')
+    .argument('[backupPath]', 'Backup path (required for restore)')
+    .addHelpText('after', `
+Examples:
+  $ codehere undo undo src/file.ts
+  $ codehere undo list src/file.ts
+  $ codehere undo restore src/file.ts .codehere/backups/file.ts.2024-12-30.backup
+
+Actions:
+  undo    - Restore file from most recent backup
+  list    - List all available backups for a file
+  restore - Restore file from a specific backup path
+  `)
+    .action(async (action, filepath, backupPath) => {
+    initLogFile();
+    try {
+        await executeUndoCommand(action, filepath, backupPath);
+    }
+    catch (err) {
+        console.error(error('Error:'), err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+});
+// Add completion command
+program
+    .command('completion')
+    .description('Generate shell completion script')
+    .argument('<shell>', 'Shell type: bash, zsh, or fish')
+    .action(async (shell) => {
+    try {
+        switch (shell.toLowerCase()) {
+            case 'bash': {
+                const { generateBashCompletion } = await import('./infrastructure/completion/bash-completion.js');
+                console.log(generateBashCompletion());
+                break;
+            }
+            case 'zsh': {
+                const { generateZshCompletion } = await import('./infrastructure/completion/zsh-completion.js');
+                console.log(generateZshCompletion());
+                break;
+            }
+            case 'fish': {
+                const { generateFishCompletion } = await import('./infrastructure/completion/fish-completion.js');
+                console.log(generateFishCompletion());
+                break;
+            }
+            default:
+                console.error(error(`Unsupported shell: ${shell}`));
+                console.log(info('Supported shells: bash, zsh, fish'));
+                console.log(info('Usage: codehere completion <bash|zsh|fish>'));
+                process.exit(1);
+        }
+    }
+    catch (err) {
+        displayError(err, {
+            operation: 'completion',
+            showSuggestions: true,
+        });
+        process.exit(1);
+    }
+});
+// Security audit export command
+program
+    .command('audit')
+    .description('Security audit trail export for compliance')
+    .argument('<action>', 'Action: export or list')
+    .option('-f, --format <format>', 'Export format: json, jsonl, or csv', 'json')
+    .option('--start-date <date>', 'Start date (ISO 8601 format, e.g., 2025-01-15T00:00:00Z)')
+    .option('--end-date <date>', 'End date (ISO 8601 format, e.g., 2025-01-15T23:59:59Z)')
+    .option('--include-inputs', 'Include input data in export (may contain sensitive data)')
+    .option('--include-outputs', 'Include output data in export (may contain sensitive data)')
+    .option('-o, --output <path>', 'Output file path (default: auto-generated)')
+    .action(async (action, options) => {
+    initLogFile();
+    try {
+        await executeAuditCommand(action, {
+            format: options.format,
+            startDate: options.startDate,
+            endDate: options.endDate,
+            includeInputs: options.includeInputs,
+            includeOutputs: options.includeOutputs,
+            outputPath: options.output,
+        });
+    }
+    catch (err) {
+        console.error(error('Error:'), err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+});
+// Initialize telemetry and track command
+const telemetry = getTelemetryService();
+// Track command usage (if enabled)
+const commandName = process.argv[2] || 'default';
+if (commandName !== 'telemetry') {
+    telemetry.trackCommand(commandName);
+}
+// Check for first run (install tracking)
+const codebaseRoot = process.cwd();
+const codehereDir = join(codebaseRoot, '.codehere');
+if (!existsSync(codehereDir)) {
+    // First run - track install
+    telemetry.track('install', {
+        version: process.env.npm_package_version || 'unknown',
+        os: process.platform,
+        nodeVersion: process.version,
+    });
+}
+program.parse();
+//# sourceMappingURL=index-backup-before-lazy-loading.js.map