codehere 0.1.0

package/dist/index.js

@@ -0,0 +1,964 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { config } from 'dotenv';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { indexRepositoryParallel } from './embed.js';
+import { searchIntelligent } from './search.js';
+import { chatWithContext } from './chat.js';
+import { generateAndApplyEdit, generateEditDryRun } from './edit.js';
+import { scaffoldTemplate, listTemplates } from './scaffold.js';
+import { initLogFile, logEntry } from './log.js';
+import { performHealthCheck, formatHealthStatus, getMetrics } from './monitoring.js';
+import { refactorMultiFile, findFilesByPattern } from './refactor.js';
+import { getGitStatus, formatGitStatus, getAllGitDiffs, analyzeDiff } from './git.js';
+import { planTask, executePlan, formatPlan } from './planner.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 { generateFileDocs, generateREADME, updateDocs, saveDocs } from './docs.js';
+import { generateTests, getTestFilePath, saveTests, improveTests } from './testgen.js';
+import { startSession } from './session.js';
+import { cleanResponse } from './formatter.js';
+import { readFileSync } from 'fs';
+import { colors, createSpinner, createBanner, createTable, success, error, warning, info, formatPath, formatNumber, formatScore, formatPercent, sectionHeader, newline, statusIndicator, createWelcomeMessage, } 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
+const program = new Command();
+program
+    .name('codehere')
+    .description('AI-powered coding assistant with local embeddings and semantic search')
+    .version('0.1.0')
+    .configureHelp({
+    helpWidth: 80,
+    sortSubcommands: true,
+})
+    .addHelpText('beforeAll', () => {
+    return createWelcomeMessage();
+});
+// Start interactive session when no command provided
+program
+    .action(async () => {
+    // Check if we should start interactive session
+    if (process.stdin.isTTY) {
+        // Interactive mode - start session
+        await startSession();
+    }
+    else {
+        // Non-interactive - show help
+        console.log(createWelcomeMessage());
+        newline();
+        console.log(colors.bold('Available Commands:'));
+        newline();
+        console.log(colors.cyan('  codehere') + '                    Start interactive session');
+        console.log(colors.cyan('  codehere index') + '              Build embeddings index');
+        console.log(colors.cyan('  codehere ask "<question>"') + '    Ask questions');
+        console.log(colors.cyan('  codehere explain <file>') + '     Explain a file');
+        console.log(colors.cyan('  codehere fix <file> "<instruction>"') + '  Edit files');
+        newline();
+        console.log(colors.dim('Run "codehere --help" for all commands'));
+        newline();
+    }
+});
+program
+    .command('index')
+    .description('Build embeddings index of the repository')
+    .option('-r, --repo <path>', 'Repository path (default: current directory)')
+    .action(async (options) => {
+    initLogFile();
+    if (!process.env.COHERE_API_KEY) {
+        newline();
+        console.error(error('COHERE_API_KEY not found in environment'));
+        newline();
+        console.log(colors.bold('Setup Instructions:'));
+        console.log('  1. Get your API key from: https://dashboard.cohere.com/api-keys');
+        console.log('  2. Create a .env file in your project root:');
+        console.log(colors.cyan('     echo "COHERE_API_KEY=your_key_here" > .env'));
+        console.log('  3. Run the command again');
+        newline();
+        process.exit(1);
+    }
+    try {
+        console.log(createBanner('Indexing Repository', 'Building semantic search index'));
+        newline();
+        const repoPath = options.repo || process.cwd();
+        // NEW: Use parallel indexing with caching
+        await indexRepositoryParallel(repoPath, {
+            useCache: true,
+            maxConcurrency: 5,
+        });
+        logEntry({
+            timestamp: new Date().toISOString(),
+            command: 'index',
+            policyStatus: 'allowed',
+        });
+        newline();
+        console.log(success('Indexing complete!'));
+    }
+    catch (err) {
+        console.error(error('Error indexing repository:'), err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+});
+program
+    .command('ask')
+    .description('Ask questions about your codebase using semantic search')
+    .argument('<question>', 'The question to ask about your code')
+    .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"
+
+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!
+  `)
+    .action(async (question) => {
+    initLogFile();
+    if (!process.env.COHERE_API_KEY) {
+        newline();
+        console.error(error('COHERE_API_KEY not found in environment'));
+        newline();
+        console.log(colors.bold('Setup Instructions:'));
+        console.log('  1. Get your API key from: https://dashboard.cohere.com/api-keys');
+        console.log('  2. Create a .env file in your project root:');
+        console.log(colors.cyan('     echo "COHERE_API_KEY=your_key_here" > .env'));
+        console.log('  3. Run the command again');
+        newline();
+        process.exit(1);
+    }
+    try {
+        console.log(createBanner('Ask Question', 'Semantic search + AI chat'));
+        newline();
+        // Display query
+        console.log(colors.bold('Query:'));
+        console.log(colors.cyan('  ' + question));
+        newline();
+        // NEW: Intelligent search with AST-based understanding
+        const searchSpinner = createSpinner('Searching with intelligent context (AST + code structure)...');
+        searchSpinner.start();
+        const searchResult = await searchIntelligent(question, {
+            baseDir: process.cwd(),
+        });
+        searchSpinner.stop();
+        if (searchResult.chunks.length === 0) {
+            newline();
+            console.log(warning('No relevant code found.'));
+            console.log(info('Make sure to run "codehere index" first to build the search index.'));
+            newline();
+            return;
+        }
+        // Display search results
+        sectionHeader('Search Results (Intelligent)');
+        const fileTable = createTable(['File', 'Relevance', 'Preview'], searchResult.chunks.slice(0, 10).map(r => [
+            formatPath(r.filepath),
+            formatScore(r.score),
+            colors.dim(r.content.substring(0, 50) + '...'),
+        ]));
+        console.log(fileTable.toString());
+        const retrievedFiles = [...new Set(searchResult.chunks.map(r => r.filepath))];
+        console.log(colors.dim(`\nFound ${formatNumber(searchResult.chunks.length)} optimized chunks from ${formatNumber(retrievedFiles.length)} file(s)`));
+        console.log(colors.dim(`Token reduction: ${formatPercent(searchResult.reductionPercent)} (${formatNumber(searchResult.tokenEstimate)} tokens)`));
+        newline();
+        // Generate response with spinner
+        const responseSpinner = createSpinner('Generating response with optimized context...');
+        responseSpinner.start();
+        const response = await chatWithContext(question, searchResult.chunks);
+        responseSpinner.stop();
+        newline();
+        // Display response - clean format
+        sectionHeader('Response');
+        const formattedResponse = cleanResponse(response);
+        console.log(formattedResponse);
+        newline();
+        logEntry({
+            timestamp: new Date().toISOString(),
+            command: 'ask',
+            query: question,
+            policyStatus: 'allowed',
+            retrievedFiles,
+        });
+    }
+    catch (err) {
+        console.error(error('Error:'), err instanceof Error ? err.message : String(err));
+        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')
+    .option('--dry-run', 'Show changes without applying them')
+    .alias('edit')
+    .addHelpText('after', `
+Examples:
+  $ codehere fix src/auth.ts "Add error handling for invalid tokens"
+  $ codehere fix utils/helpers.js "Rename function foo() to bar()"
+  $ 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
+
+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();
+    if (!process.env.COHERE_API_KEY) {
+        newline();
+        console.error(error('COHERE_API_KEY not found in environment'));
+        newline();
+        console.log(colors.bold('Setup Instructions:'));
+        console.log('  1. Get your API key from: https://dashboard.cohere.com/api-keys');
+        console.log('  2. Create a .env file in your project root:');
+        console.log(colors.cyan('     echo "COHERE_API_KEY=your_key_here" > .env'));
+        console.log('  3. Run the command again');
+        newline();
+        process.exit(1);
+    }
+    try {
+        console.log(createBanner('Edit File', 'AI-powered code editing'));
+        newline();
+        // Display edit info
+        console.log(colors.bold('File:') + ' ' + formatPath(file));
+        console.log(colors.bold('Instruction:') + ' ' + colors.cyan(instruction));
+        newline();
+        // Generate diff with spinner
+        const diffSpinner = createSpinner('Generating code changes...');
+        diffSpinner.start();
+        // Check if file exists
+        const { existsSync } = await import('fs');
+        const fullPath = join(process.cwd(), file);
+        if (!existsSync(fullPath)) {
+            diffSpinner.stop();
+            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);
+        }
+        const isDryRun = options.dryRun || false;
+        const result = isDryRun
+            ? await generateEditDryRun(file, instruction)
+            : await generateAndApplyEdit(file, instruction);
+        diffSpinner.stop();
+        if (result.success) {
+            newline();
+            // Policy check display
+            if (result.policyResult) {
+                sectionHeader('Policy Check');
+                const policyTable = createTable(['Check', 'Status'], [
+                    ['Line Limit (≤50)', result.policyResult.allowed ? statusIndicator('success') + ' Passed' : statusIndicator('error') + ' Failed'],
+                    ['Restricted Folders', result.policyResult.allowed ? statusIndicator('success') + ' Passed' : statusIndicator('error') + ' Failed'],
+                    ['Single File Only', result.policyResult.allowed ? statusIndicator('success') + ' Passed' : statusIndicator('error') + ' Failed'],
+                ]);
+                console.log(policyTable.toString());
+                newline();
+            }
+            // Diff stats
+            if (result.diffStats) {
+                sectionHeader('Changes');
+                const statsTable = createTable(['Metric', 'Value'], [
+                    ['Lines Added', formatNumber(result.diffStats.linesAdded)],
+                    ['Lines Removed', formatNumber(result.diffStats.linesRemoved)],
+                    ['Total Changes', formatNumber(result.diffStats.linesAdded + result.diffStats.linesRemoved)],
+                    ['Files Changed', formatNumber(result.diffStats.filesChanged)],
+                ]);
+                console.log(statsTable.toString());
+                newline();
+            }
+            // Show diff in dry-run mode
+            if (isDryRun && 'diffText' in result && result.diffText) {
+                sectionHeader('Generated Diff (Dry Run)');
+                console.log(colors.dim('---'));
+                console.log(result.diffText);
+                console.log(colors.dim('---'));
+                newline();
+                if ('syntaxValid' in result) {
+                    if (result.syntaxValid === false) {
+                        console.log(warning('⚠️  Syntax validation failed'));
+                        console.log(colors.yellow('  ' + (result.error || 'Unknown syntax error')));
+                        newline();
+                    }
+                    else if (result.syntaxValid === true) {
+                        console.log(success('✓ Syntax validation passed'));
+                        newline();
+                    }
+                }
+            }
+            if (isDryRun) {
+                console.log(info('Dry-run mode: No changes were applied to the file.'));
+                console.log(info('Remove --dry-run to apply changes.'));
+            }
+            else {
+                console.log(success('Edit applied successfully'));
+            }
+            logEntry({
+                timestamp: new Date().toISOString(),
+                command: 'fix',
+                query: instruction,
+                filepath: file,
+                diffStats: result.diffStats,
+                policyStatus: result.policyResult?.allowed ? 'allowed' : 'rejected',
+            });
+        }
+        else {
+            newline();
+            // Show policy rejection reason
+            newline();
+            sectionHeader('Error');
+            if (result.policyResult && !result.policyResult.allowed) {
+                console.log(error('Policy check failed'));
+                console.log(colors.yellow('  ' + (result.policyResult.reason || 'Unknown reason')));
+            }
+            else {
+                console.log(error('Edit failed'));
+                console.log(colors.red('  ' + (result.error || 'Unknown error')));
+            }
+            logEntry({
+                timestamp: new Date().toISOString(),
+                command: 'fix',
+                query: instruction,
+                filepath: file,
+                diffStats: result.diffStats,
+                policyStatus: 'rejected',
+                policyReason: result.error,
+            });
+            process.exit(1);
+        }
+    }
+    catch (err) {
+        console.error(error('Error:'), err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+});
+program
+    .command('debug-search')
+    .description('Debug search: show top results with scores and previews')
+    .argument('<query>', 'Search query')
+    .option('-n, --top <number>', 'Number of results to show', '10')
+    .action(async (query, options) => {
+    initLogFile();
+    if (!process.env.COHERE_API_KEY) {
+        newline();
+        console.error(error('COHERE_API_KEY not found in environment'));
+        process.exit(1);
+    }
+    try {
+        console.log(createBanner('Debug Search', 'Show search results with scores'));
+        newline();
+        console.log(colors.bold('Query:'));
+        console.log(colors.cyan('  ' + query));
+        newline();
+        const searchSpinner = createSpinner('Searching...');
+        searchSpinner.start();
+        const searchResult = await searchIntelligent(query, {
+            baseDir: process.cwd(),
+        });
+        searchSpinner.stop();
+        if (searchResult.chunks.length === 0) {
+            newline();
+            console.log(warning('No results found.'));
+            return;
+        }
+        const topN = parseInt(options.top || '10', 10);
+        const topResults = searchResult.chunks.slice(0, topN);
+        sectionHeader('Search Results');
+        const fileTable = createTable(['Rank', 'File', 'Score', 'Preview'], topResults.map((r, idx) => [
+            String(idx + 1),
+            formatPath(r.filepath),
+            formatScore(r.score),
+            colors.dim(r.content.substring(0, 60) + '...'),
+        ]));
+        console.log(fileTable.toString());
+        newline();
+        console.log(colors.dim(`Showing ${topResults.length} of ${searchResult.chunks.length} results`));
+        console.log(colors.dim(`Token reduction: ${formatPercent(searchResult.reductionPercent)}`));
+    }
+    catch (err) {
+        console.error(error('Search error:'), err instanceof Error ? err.message : String(err));
+        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();
+    if (!process.env.COHERE_API_KEY) {
+        newline();
+        console.error(error('COHERE_API_KEY not found in environment'));
+        newline();
+        console.log(colors.bold('Setup Instructions:'));
+        console.log('  1. Get your API key from: https://dashboard.cohere.com/api-keys');
+        console.log('  2. Create a .env file in your project root:');
+        console.log(colors.cyan('     echo "COHERE_API_KEY=your_key_here" > .env'));
+        console.log('  3. Run the command again');
+        newline();
+        process.exit(1);
+    }
+    try {
+        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);
+        }
+        const content = readFileSync(fullPath, 'utf-8');
+        // File info
+        const lines = content.split('\n').length;
+        const size = (content.length / 1024).toFixed(2);
+        console.log(colors.bold('File:') + ' ' + formatPath(file));
+        console.log(colors.dim(`  Lines: ${lines} | Size: ${size} KB`));
+        newline();
+        const context = [{
+                filepath: file,
+                content: content,
+                score: 1.0,
+            }];
+        const question = `Explain this file: ${file}`;
+        // Generate explanation with spinner
+        const explainSpinner = createSpinner('Generating explanation...');
+        explainSpinner.start();
+        const response = await chatWithContext(question, context);
+        explainSpinner.stop();
+        newline();
+        // Display explanation - clean format
+        sectionHeader('Explanation');
+        const formattedResponse = cleanResponse(response);
+        console.log(formattedResponse);
+        newline();
+        logEntry({
+            timestamp: new Date().toISOString(),
+            command: 'explain',
+            query: question,
+            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();
+    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();
+    if (!process.env.COHERE_API_KEY) {
+        newline();
+        console.error(error('COHERE_API_KEY not found in environment'));
+        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('review')
+    .description('Review git changes and suggest improvements')
+    .option('-f, --file <file>', 'Review specific file')
+    .action((options) => {
+    initLogFile();
+    try {
+        console.log(createBanner('Code 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 { getGitDiff } = require('./git.js');
+        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')
+    .action(async (instruction, options) => {
+    initLogFile();
+    if (!process.env.COHERE_API_KEY) {
+        console.error(error('COHERE_API_KEY not found in environment'));
+        process.exit(1);
+    }
+    try {
+        console.log(createBanner('Task Planning', 'Intelligent multi-step execution'));
+        newline();
+        console.log(colors.bold('Instruction:') + ' ' + colors.cyan(instruction));
+        newline();
+        const plan = await planTask(instruction);
+        sectionHeader('Execution Plan');
+        console.log(formatPlan(plan));
+        if (options.execute) {
+            newline();
+            const searchSpinner = createSpinner('Executing plan...');
+            searchSpinner.start();
+            const result = await executePlan(plan, { instruction });
+            searchSpinner.stop();
+            newline();
+            sectionHeader('Execution Results');
+            const resultsTable = createTable(['Metric', 'Value'], [
+                ['Tasks Completed', formatNumber(result.completedTasks)],
+                ['Total Tasks', formatNumber(plan.tasks.length)],
+                ['Success', result.success ? statusIndicator('success') + ' Yes' : statusIndicator('error') + ' No'],
+                ['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.task}: ${err.error}`));
+                });
+            }
+        }
+    }
+    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();
+    if (!process.env.COHERE_API_KEY) {
+        console.error(error('COHERE_API_KEY not found in environment'));
+        process.exit(1);
+    }
+    try {
+        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();
+        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();
+    if (!process.env.COHERE_API_KEY) {
+        console.error(error('COHERE_API_KEY not found in environment'));
+        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);
+    }
+});
+program
+    .command('docs')
+    .description('Generate and update documentation')
+    .argument('<file>', 'File to document')
+    .option('--readme', 'Generate README for entire project')
+    .option('--update', 'Update existing documentation')
+    .option('--save', 'Save documentation to file')
+    .action(async (file, options) => {
+    initLogFile();
+    if (!process.env.COHERE_API_KEY) {
+        console.error(error('COHERE_API_KEY not found in environment'));
+        process.exit(1);
+    }
+    try {
+        console.log(createBanner('Documentation Generator', 'Auto-generate docs'));
+        newline();
+        const docsSpinner = createSpinner('Generating documentation...');
+        docsSpinner.start();
+        let docs;
+        if (options.readme) {
+            docs = await generateREADME();
+        }
+        else if (options.update) {
+            docs = await updateDocs(file);
+        }
+        else {
+            docs = await generateFileDocs(file);
+        }
+        docsSpinner.stop();
+        newline();
+        sectionHeader('Generated Documentation');
+        const formattedDocs = cleanResponse(docs);
+        console.log(formattedDocs);
+        if (options.save) {
+            const outputPath = options.readme ? 'README.md' : file.replace(/\.[^/.]+$/, '.md');
+            saveDocs(outputPath, docs);
+            console.log(success(`Documentation saved to ${outputPath}`));
+        }
+    }
+    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();
+    if (!process.env.COHERE_API_KEY) {
+        console.error(error('COHERE_API_KEY not found in environment'));
+        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('scaffold')
+    .description('Scaffold a simple app skeleton from a template')
+    .argument('<template>', 'Template name (e.g., node-api, next-page)')
+    .argument('<targetDir>', 'Target directory (relative to current directory)')
+    .action(async (template, targetDir) => {
+    initLogFile();
+    try {
+        console.log(createBanner('Scaffold App', 'Create app skeleton from template'));
+        newline();
+        // List available templates if user asks
+        if (template === 'list' || template === '--list') {
+            const templates = listTemplates();
+            if (templates.length === 0) {
+                console.log(warning('No templates available.'));
+                return;
+            }
+            sectionHeader('Available Templates');
+            templates.forEach(t => {
+                console.log(colors.cyan(`  ${t}`));
+            });
+            newline();
+            return;
+        }
+        console.log(colors.bold('Template:') + ' ' + colors.cyan(template));
+        console.log(colors.bold('Target:') + ' ' + colors.cyan(targetDir));
+        newline();
+        const result = scaffoldTemplate(template, targetDir);
+        if (result.success) {
+            sectionHeader('Files Created');
+            result.filesCreated.forEach(file => {
+                console.log(colors.green('  ✓ ') + file);
+            });
+            newline();
+            console.log(success(`Scaffold complete! Created ${result.filesCreated.length} file(s).`));
+            newline();
+            console.log(info('Next steps:'));
+            console.log(colors.dim(`  1. cd ${targetDir}`));
+            console.log(colors.dim(`  2. codehere index`));
+            console.log(colors.dim(`  3. codehere explain <file>`));
+            console.log(colors.dim(`  4. codehere fix <file> "<instruction>"`));
+            newline();
+            logEntry({
+                timestamp: new Date().toISOString(),
+                command: 'scaffold',
+                query: `${template} -> ${targetDir}`,
+                policyStatus: 'allowed',
+            });
+        }
+        else {
+            newline();
+            console.error(error('Scaffold failed'));
+            console.log(colors.red('  ' + (result.error || 'Unknown error')));
+            newline();
+            process.exit(1);
+        }
+    }
+    catch (err) {
+        console.error(error('Error:'), err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+});
+program.parse();
+//# sourceMappingURL=index.js.map