codehere 0.2.2 → 0.3.0-rc.10

package/dist/presentation/cli/commands/undo-command.js

@@ -1,150 +0,0 @@
-/**
- * CLI Command: Undo
- * Undo file changes by restoring from backups
- *
- * Clean Architecture: Presentation Layer
- */
-import { rollbackFile, listBackups, findLatestBackup } from '../../../verification/backup.js';
-import { colors, sectionHeader, success, error, warning, info, newline, createBanner, createTable, } from '../../../ui.js';
-import { displayError } from '../error-display.js';
-import { executionTracer } from '../../../infrastructure/observability/execution-tracer.js';
-export async function executeUndoCommand(action, filepath, backupPath) {
-    // Start execution tracing
-    const runId = executionTracer.startRun('undo', {
-        codebaseId: process.cwd(),
-    });
-    try {
-        console.log(createBanner('Undo System', 'File recovery and rollback'));
-        newline();
-        switch (action) {
-            case 'undo': {
-                if (!filepath) {
-                    console.log(error('File path is required for undo'));
-                    console.log(info('Usage: codehere undo <filepath>'));
-                    return;
-                }
-                await undoFile(filepath);
-                break;
-            }
-            case 'list': {
-                if (!filepath) {
-                    console.log(error('File path is required for list'));
-                    console.log(info('Usage: codehere undo list <filepath>'));
-                    return;
-                }
-                await listFileBackups(filepath);
-                break;
-            }
-            case 'restore': {
-                if (!filepath || !backupPath) {
-                    console.log(error('File path and backup path are required for restore'));
-                    console.log(info('Usage: codehere undo restore <filepath> <backupPath>'));
-                    return;
-                }
-                await restoreFromBackup(filepath, backupPath);
-                break;
-            }
-            default:
-                console.log(error(`Unknown action: ${action}`));
-                console.log(info('Available actions: undo, list, restore'));
-        }
-    }
-    catch (err) {
-        displayError(err, {
-            operation: `undo-${action}`,
-            showSuggestions: true,
-        });
-        throw err;
-    }
-    finally {
-        executionTracer.endRun();
-    }
-}
-async function undoFile(filepath) {
-    const { join } = await import('path');
-    const fullPath = join(process.cwd(), filepath);
-    sectionHeader('Undo File Changes');
-    newline();
-    try {
-        const latestBackup = await findLatestBackup(fullPath);
-        if (!latestBackup) {
-            console.log(warning(`No backup found for: ${filepath}`));
-            console.log(colors.dim('  Backups are created automatically before edits.'));
-            console.log(colors.dim('  If you haven\'t made any edits, there may be no backup.'));
-            newline();
-            return;
-        }
-        console.log(colors.bold('Restoring from backup:'));
-        console.log(colors.dim(`  File: ${filepath}`));
-        console.log(colors.dim(`  Backup: ${latestBackup}`));
-        newline();
-        await rollbackFile(fullPath, latestBackup);
-        console.log(success('File restored'));
-        newline();
-    }
-    catch (err) {
-        displayError(err, {
-            operation: 'undo',
-            filepath: filepath,
-            showSuggestions: true,
-        });
-        throw err;
-    }
-}
-async function listFileBackups(filepath) {
-    const { join } = await import('path');
-    const fullPath = join(process.cwd(), filepath);
-    sectionHeader('Available Backups');
-    newline();
-    try {
-        const backups = await listBackups(fullPath);
-        if (backups.length === 0) {
-            console.log(warning(`No backups found for: ${filepath}`));
-            newline();
-            return;
-        }
-        const backupRows = backups.map((backup, index) => [
-            String(index + 1),
-            backup.timestamp.toISOString(),
-            backup.backupPath,
-        ]);
-        const table = createTable(['#', 'Timestamp', 'Backup Path'], backupRows);
-        console.log(table.toString());
-        newline();
-        console.log(colors.dim(`Total backups: ${backups.length}`));
-        console.log(colors.dim(`Use: codehere undo restore <filepath> <backupPath> to restore a specific backup`));
-        newline();
-    }
-    catch (err) {
-        displayError(err, {
-            operation: 'undo-list',
-            filepath: filepath,
-            showSuggestions: true,
-        });
-        throw err;
-    }
-}
-async function restoreFromBackup(filepath, backupPath) {
-    const { join } = await import('path');
-    const fullPath = join(process.cwd(), filepath);
-    sectionHeader('Restore from Backup');
-    newline();
-    try {
-        console.log(colors.bold('Restoring:'));
-        console.log(colors.dim(`  File: ${filepath}`));
-        console.log(colors.dim(`  Backup: ${backupPath}`));
-        newline();
-        await rollbackFile(fullPath, backupPath);
-        console.log(success('File restored'));
-        newline();
-    }
-    catch (err) {
-        displayError(err, {
-            operation: 'undo-restore',
-            filepath: filepath,
-            showSuggestions: true,
-        });
-        throw err;
-    }
-}
-//# sourceMappingURL=undo-command.js.map

package/dist/query-optimizer.js

@@ -1,205 +0,0 @@
-/**
- * Query Understanding & Optimization System
- * Classify intent, select strategy, optimize query, select best model
- */
-import { classifyQueryIntent } from './intelligent-retrieval.js';
-/**
- * Optimize query for best results
- */
-export function optimizeQuery(query) {
-    const intent = classifyQueryIntent(query);
-    const keywords = extractKeywords(query);
-    const symbols = extractSymbols(query);
-    const optimizedQuery = enhanceQuery(query, intent, keywords, symbols);
-    const strategy = selectStrategy(intent, query);
-    return {
-        optimizedQuery,
-        strategy,
-        keywords,
-        symbols,
-    };
-}
-/**
- * Extract keywords from query
- */
-function extractKeywords(query) {
-    // Remove common stop words
-    const stopWords = new Set([
-        'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for',
-        'of', 'with', 'by', 'from', 'as', 'is', 'was', 'are', 'were', 'be',
-        'been', 'being', 'have', 'has', 'had', 'do', 'does', 'did', 'will',
-        'would', 'should', 'could', 'may', 'might', 'must', 'can', 'this',
-        'that', 'these', 'those', 'what', 'which', 'who', 'whom', 'where',
-        'when', 'why', 'how', 'does', 'do', 'is', 'are', 'was', 'were',
-    ]);
-    const words = query
-        .toLowerCase()
-        .replace(/[^\w\s]/g, ' ')
-        .split(/\s+/)
-        .filter(word => word.length > 2 && !stopWords.has(word));
-    return [...new Set(words)];
-}
-/**
- * Extract symbol names from query
- */
-function extractSymbols(query) {
-    const patterns = [
-        /function\s+(\w+)/gi,
-        /class\s+(\w+)/gi,
-        /interface\s+(\w+)/gi,
-        /type\s+(\w+)/gi,
-        /const\s+(\w+)/gi,
-        /let\s+(\w+)/gi,
-        /var\s+(\w+)/gi,
-        /([A-Z][a-zA-Z0-9]+)/g, // Capitalized words (likely class names)
-        /([a-z][a-zA-Z0-9]*\(\))/g, // camelCase followed by () (likely function calls)
-        /`([^`]+)`/g, // Code in backticks
-        /'([^']+)'/g, // Code in single quotes
-        /"([^"]+)"/g, // Code in double quotes
-    ];
-    const symbols = new Set();
-    for (const pattern of patterns) {
-        const matches = query.matchAll(pattern);
-        for (const match of matches) {
-            if (match[1]) {
-                symbols.add(match[1]);
-            }
-        }
-    }
-    return Array.from(symbols);
-}
-/**
- * Enhance query with context
- */
-function enhanceQuery(query, intent, keywords, symbols) {
-    let enhanced = query;
-    // Add intent-specific context
-    switch (intent) {
-        case 'explain':
-            if (!query.toLowerCase().includes('how') && !query.toLowerCase().includes('what')) {
-                enhanced = `Explain how ${query}`;
-            }
-            break;
-        case 'refactor':
-            if (!query.toLowerCase().includes('refactor')) {
-                enhanced = `Refactor: ${query}`;
-            }
-            break;
-        case 'debug':
-            if (!query.toLowerCase().includes('bug') && !query.toLowerCase().includes('error')) {
-                enhanced = `Debug: ${query}`;
-            }
-            break;
-        case 'find':
-            if (!query.toLowerCase().includes('find') && !query.toLowerCase().includes('where')) {
-                enhanced = `Find: ${query}`;
-            }
-            break;
-    }
-    // Add symbol context if symbols found
-    if (symbols.length > 0) {
-        enhanced += ` (symbols: ${symbols.join(', ')})`;
-    }
-    return enhanced;
-}
-/**
- * Select optimal strategy based on intent
- */
-function selectStrategy(intent, query) {
-    const baseStrategy = {
-        intent,
-        contextStrategy: 'relevant-only',
-        maxTokens: 2000,
-        maxChunks: 10,
-        includeRelationships: true,
-        includeCallGraph: false,
-    };
-    switch (intent) {
-        case 'explain':
-            return {
-                ...baseStrategy,
-                contextStrategy: 'function-level',
-                maxTokens: 3000,
-                maxChunks: 15,
-                includeCallGraph: true, // Need call graph for explanations
-            };
-        case 'refactor':
-            return {
-                ...baseStrategy,
-                contextStrategy: 'file-level',
-                maxTokens: 4000,
-                maxChunks: 20,
-                includeRelationships: true,
-                includeCallGraph: true, // Need to understand dependencies
-            };
-        case 'debug':
-            return {
-                ...baseStrategy,
-                contextStrategy: 'relevant-only',
-                maxTokens: 2500,
-                maxChunks: 12,
-                includeRelationships: true,
-                includeCallGraph: false,
-            };
-        case 'implement':
-            return {
-                ...baseStrategy,
-                contextStrategy: 'compressed',
-                maxTokens: 3000,
-                maxChunks: 15,
-                includeRelationships: true,
-                includeCallGraph: false,
-            };
-        case 'find':
-            return {
-                ...baseStrategy,
-                contextStrategy: 'relevant-only',
-                maxTokens: 1500,
-                maxChunks: 8,
-                includeRelationships: false,
-                includeCallGraph: false,
-            };
-        case 'modify':
-            return {
-                ...baseStrategy,
-                contextStrategy: 'function-level',
-                maxTokens: 2000,
-                maxChunks: 10,
-                includeRelationships: true,
-                includeCallGraph: false,
-            };
-        default: // 'understand'
-            return {
-                ...baseStrategy,
-                contextStrategy: 'relevant-only',
-                maxTokens: 2000,
-                maxChunks: 10,
-                includeRelationships: true,
-                includeCallGraph: false,
-            };
-    }
-}
-/**
- * Select best model for task (future: multi-model support)
- */
-export function selectModel(intent, complexity) {
-    // For now, always use Cohere
-    // Future: Use GPT-4 for complex tasks, Claude for reasoning, etc.
-    return 'cohere';
-}
-/**
- * Estimate query complexity
- */
-export function estimateComplexity(query, symbols) {
-    const queryLength = query.length;
-    const symbolCount = symbols.length;
-    const hasMultipleConcepts = query.split(/\s+(and|or|but)\s+/i).length > 2;
-    if (queryLength < 50 && symbolCount === 0 && !hasMultipleConcepts) {
-        return 'simple';
-    }
-    if (queryLength < 200 && symbolCount < 3 && !hasMultipleConcepts) {
-        return 'medium';
-    }
-    return 'complex';
-}
-//# sourceMappingURL=query-optimizer.js.map

package/dist/refactor.js

@@ -1,116 +0,0 @@
-/**
- * Multi-File Refactoring System
- * Enterprise-grade cross-file operations
- */
-import { readFileSync, writeFileSync, existsSync, readdirSync, statSync } from 'fs';
-import { join, relative } from 'path';
-import { generateDiff } from './chat.js';
-import { checkPolicy } from './policy.js';
-import { applyUnifiedDiff, parseDiffStats } from './edit.js';
-import { retryWithBackoff } from './error-handler.js';
-/**
- * Refactor multiple files with coordinated changes
- */
-export async function refactorMultiFile(files, instruction, options = {}) {
-    const { dryRun = false, maxFiles = 10 } = options;
-    if (files.length > maxFiles) {
-        throw new Error(`Too many files (${files.length}). Maximum is ${maxFiles}.`);
-    }
-    const results = {
-        success: false,
-        filesChanged: [],
-        totalChanges: {
-            linesAdded: 0,
-            linesRemoved: 0,
-            filesChanged: 0,
-        },
-        policyResults: new Map(),
-        errors: [],
-    };
-    // Process each file
-    for (const file of files) {
-        try {
-            const fullPath = join(process.cwd(), file);
-            if (!existsSync(fullPath)) {
-                results.errors.push({ file, error: 'File not found' });
-                continue;
-            }
-            const content = readFileSync(fullPath, 'utf-8');
-            // Generate diff for this file
-            const diff = await retryWithBackoff(() => generateDiff(content, instruction, file), {
-                maxRetries: 3,
-                operationName: `generateDiff:${file}`,
-            });
-            // Parse diff stats first
-            const diffStats = parseDiffStats(diff);
-            // Check policy
-            const policyResult = checkPolicy(file, diffStats);
-            results.policyResults.set(file, policyResult);
-            if (!policyResult.allowed) {
-                results.errors.push({
-                    file,
-                    error: policyResult.reason || 'Policy check failed',
-                });
-                continue;
-            }
-            // Apply diff if not dry run
-            if (!dryRun) {
-                const newContent = applyUnifiedDiff(content, diff);
-                writeFileSync(fullPath, newContent, 'utf-8');
-                results.filesChanged.push(file);
-            }
-            else {
-                results.filesChanged.push(file + ' (dry-run)');
-            }
-            // Calculate stats
-            const stats = parseDiffStats(diff);
-            results.totalChanges.linesAdded += stats.linesAdded;
-            results.totalChanges.linesRemoved += stats.linesRemoved;
-            results.totalChanges.filesChanged += 1;
-        }
-        catch (error) {
-            results.errors.push({
-                file,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-    }
-    // Success if at least one file changed and no critical errors
-    results.success = results.filesChanged.length > 0 && results.errors.length === 0;
-    return results;
-}
-/**
- * Find files matching pattern
- */
-export function findFilesByPattern(pattern, baseDir = process.cwd()) {
-    // Simple glob pattern matching
-    // For production, consider using a proper glob library
-    const files = [];
-    const regex = new RegExp(pattern.replace(/\*/g, '.*'));
-    function walkDir(dir) {
-        try {
-            const entries = readdirSync(dir);
-            for (const entry of entries) {
-                const fullPath = join(dir, entry);
-                const relPath = relative(baseDir, fullPath);
-                // Skip common ignore patterns
-                if (relPath.includes('node_modules') || relPath.includes('.git')) {
-                    continue;
-                }
-                const stat = statSync(fullPath);
-                if (stat.isDirectory()) {
-                    walkDir(fullPath);
-                }
-                else if (stat.isFile() && regex.test(relPath)) {
-                    files.push(relPath);
-                }
-            }
-        }
-        catch (error) {
-            // Skip directories we can't read
-        }
-    }
-    walkDir(baseDir);
-    return files;
-}
-//# sourceMappingURL=refactor.js.map

package/dist/review.js

@@ -1,206 +0,0 @@
-/**
- * Automated Code Review System
- * Senior-level code analysis and suggestions
- */
-import { readFileSync, existsSync } from 'fs';
-import { join } from 'path';
-import { chatWithContext } from './chat.js';
-import { getEnhancedContext } from './context.js';
-import { cleanResponse } from './formatter.js';
-/**
- * Review a single file
- */
-export async function reviewFile(filepath) {
-    const fullPath = join(process.cwd(), filepath);
-    if (!existsSync(fullPath)) {
-        throw new Error(`File not found: ${filepath}`);
-    }
-    const content = readFileSync(fullPath, 'utf-8');
-    const lines = content.split('\n');
-    // Get context about the file
-    const context = await getEnhancedContext(`Review code in ${filepath}`, {
-        primaryChunks: 10,
-        includeRelationships: false,
-    });
-    // Create review context
-    const reviewContext = [{
-            filepath,
-            content,
-            score: 1.0,
-        }];
-    // Generate review using AI
-    const reviewPrompt = `You are a senior code reviewer. Review this code file and identify:
-1. Security vulnerabilities
-2. Performance issues
-3. Best practice violations
-4. Potential bugs
-5. Code style issues
-
-File: ${filepath}
-Code:
-\`\`\`
-${content}
-\`\`\`
-
-Provide a structured review with specific issues and suggestions.`;
-    const aiReviewRaw = await chatWithContext(reviewPrompt, reviewContext);
-    const aiReview = cleanResponse(aiReviewRaw);
-    // Parse AI review and extract issues
-    const issues = parseReviewResponse(aiReview, lines);
-    // Calculate score (100 - (errors * 10) - (warnings * 5) - (info * 1))
-    const errorCount = issues.filter(i => i.severity === 'error').length;
-    const warningCount = issues.filter(i => i.severity === 'warning').length;
-    const infoCount = issues.filter(i => i.severity === 'info').length;
-    const score = Math.max(0, 100 - (errorCount * 10) - (warningCount * 5) - (infoCount * 1));
-    // Extract suggestions
-    const suggestions = issues
-        .filter(i => i.suggestion)
-        .map(i => i.suggestion)
-        .filter((v, i, a) => a.indexOf(v) === i); // Deduplicate
-    return {
-        file: filepath,
-        issues,
-        score,
-        summary: generateSummary(issues, score),
-        suggestions,
-    };
-}
-/**
- * Review multiple files
- */
-export async function reviewFiles(filepaths) {
-    const reviews = [];
-    for (const filepath of filepaths) {
-        try {
-            const review = await reviewFile(filepath);
-            reviews.push(review);
-        }
-        catch (error) {
-            // Continue with other files if one fails
-            reviews.push({
-                file: filepath,
-                issues: [{
-                        severity: 'error',
-                        category: 'bug',
-                        message: `Failed to review: ${error instanceof Error ? error.message : String(error)}`,
-                    }],
-                score: 0,
-                summary: 'Review failed',
-                suggestions: [],
-            });
-        }
-    }
-    return reviews;
-}
-/**
- * Parse AI review response into structured issues
- */
-function parseReviewResponse(aiReview, lines) {
-    const issues = [];
-    // Simple parsing - look for common patterns
-    const lines_review = aiReview.split('\n');
-    for (let i = 0; i < lines_review.length; i++) {
-        const line = lines_review[i];
-        const lowerLine = line.toLowerCase();
-        // Detect severity
-        let severity = 'info';
-        if (lowerLine.includes('error') || lowerLine.includes('critical') || lowerLine.includes('security')) {
-            severity = 'error';
-        }
-        else if (lowerLine.includes('warning') || lowerLine.includes('should') || lowerLine.includes('consider')) {
-            severity = 'warning';
-        }
-        // Detect category
-        let category = 'best-practice';
-        if (lowerLine.includes('security') || lowerLine.includes('vulnerability')) {
-            category = 'security';
-        }
-        else if (lowerLine.includes('performance') || lowerLine.includes('slow') || lowerLine.includes('optimize')) {
-            category = 'performance';
-        }
-        else if (lowerLine.includes('bug') || lowerLine.includes('error') || lowerLine.includes('incorrect')) {
-            category = 'bug';
-        }
-        else if (lowerLine.includes('style') || lowerLine.includes('format')) {
-            category = 'style';
-        }
-        // Extract line number if mentioned
-        const lineMatch = line.match(/line\s+(\d+)/i);
-        const lineNumber = lineMatch ? parseInt(lineMatch[1], 10) : undefined;
-        // Extract suggestion
-        const suggestionMatch = line.match(/suggestion[:\s]+(.+)/i);
-        const suggestion = suggestionMatch ? suggestionMatch[1].trim() : undefined;
-        if (line.trim() && (severity !== 'info' || lineNumber || suggestion)) {
-            issues.push({
-                severity,
-                category,
-                message: line.trim(),
-                line: lineNumber,
-                suggestion,
-            });
-        }
-    }
-    // If no issues found, create a summary issue
-    if (issues.length === 0) {
-        issues.push({
-            severity: 'info',
-            category: 'best-practice',
-            message: 'AI review completed. See full review text for details.',
-        });
-    }
-    return issues;
-}
-/**
- * Generate summary from issues
- */
-function generateSummary(issues, score) {
-    const errorCount = issues.filter(i => i.severity === 'error').length;
-    const warningCount = issues.filter(i => i.severity === 'warning').length;
-    const infoCount = issues.filter(i => i.severity === 'info').length;
-    if (score >= 90) {
-        return `Excellent code quality (${score}/100). ${errorCount} errors, ${warningCount} warnings.`;
-    }
-    else if (score >= 70) {
-        return `Good code quality (${score}/100). ${errorCount} errors, ${warningCount} warnings need attention.`;
-    }
-    else if (score >= 50) {
-        return `Moderate code quality (${score}/100). ${errorCount} errors and ${warningCount} warnings should be addressed.`;
-    }
-    else {
-        return `Poor code quality (${score}/100). ${errorCount} critical errors and ${warningCount} warnings require immediate attention.`;
-    }
-}
-/**
- * Format review for display
- */
-export function formatReview(review) {
-    let output = `\nFile: ${review.file}\n`;
-    output += `Score: ${review.score}/100\n`;
-    output += `Summary: ${review.summary}\n\n`;
-    if (review.issues.length > 0) {
-        output += 'Issues:\n';
-        for (const issue of review.issues) {
-            const icon = {
-                error: '✗',
-                warning: '⚠',
-                info: '→',
-            }[issue.severity];
-            output += `  ${icon} [${issue.category}] ${issue.message}`;
-            if (issue.line) {
-                output += ` (line ${issue.line})`;
-            }
-            output += '\n';
-            if (issue.suggestion) {
-                output += `    Suggestion: ${issue.suggestion}\n`;
-            }
-        }
-    }
-    if (review.suggestions.length > 0) {
-        output += '\nSuggestions:\n';
-        for (const suggestion of review.suggestions) {
-            output += `  • ${suggestion}\n`;
-        }
-    }
-    return output;
-}
-//# sourceMappingURL=review.js.map