codehere 0.2.1 → 0.3.0-rc.1

package/dist/utils/diff-parser.js

@@ -1,162 +0,0 @@
-/**
- * Unified Diff Parser
- * Parses and applies unified diff patches to file content
- *
- * Handles standard unified diff format:
- * --- a/filepath
- * +++ b/filepath
- * @@ -start,count +start,count @@
- * -old line (remove)
- * +new line (add)
- *  context line (keep)
- */
-/**
- * Apply a unified diff to file content
- */
-export function applyUnifiedDiff(originalContent, diff) {
-    if (!diff || !diff.trim()) {
-        return originalContent;
-    }
-    // Clean diff - remove any markdown formatting
-    let cleanDiff = diff.trim();
-    // Extract the actual diff lines
-    const diffLines = cleanDiff.split('\n');
-    const originalLines = originalContent.split('\n');
-    const result = [];
-    let originalIndex = 0; // Current position in original file
-    let inHunk = false;
-    let hunkStartLine = 0; // Line number where hunk starts (1-based from diff)
-    let hunkOldLineCount = 0; // Number of old lines in this hunk
-    let hunkOldLinesProcessed = 0; // How many old lines we've processed
-    for (let i = 0; i < diffLines.length; i++) {
-        const line = diffLines[i];
-        // Skip header lines
-        if (line.startsWith('---') || line.startsWith('+++')) {
-            continue;
-        }
-        // Parse hunk header: @@ -start,count +start,count @@
-        const hunkMatch = line.match(/^@@\s+-(\d+)(?:,(\d+))?\s+\+(\d+)(?:,(\d+))?\s+@@/);
-        if (hunkMatch) {
-            // Finish previous hunk
-            if (inHunk) {
-                // Make sure we've processed all old lines from previous hunk
-                while (hunkOldLinesProcessed < hunkOldLineCount && originalIndex < originalLines.length) {
-                    originalIndex++;
-                    hunkOldLinesProcessed++;
-                }
-            }
-            // Start new hunk
-            inHunk = true;
-            hunkStartLine = parseInt(hunkMatch[1], 10); // 1-based line number
-            hunkOldLineCount = parseInt(hunkMatch[2] || '0', 10);
-            hunkOldLinesProcessed = 0;
-            // Copy all lines from original up to (but not including) the hunk start
-            // hunkStartLine is 1-based, originalIndex is 0-based
-            while (originalIndex < hunkStartLine - 1 && originalIndex < originalLines.length) {
-                result.push(originalLines[originalIndex]);
-                originalIndex++;
-            }
-            continue;
-        }
-        if (!inHunk) {
-            continue; // Skip lines outside hunks
-        }
-        // Process hunk content
-        if (line.startsWith('-')) {
-            // Remove line: skip this line from original
-            if (originalIndex < originalLines.length) {
-                originalIndex++;
-                hunkOldLinesProcessed++;
-            }
-        }
-        else if (line.startsWith('+')) {
-            // Add line: add new line to result
-            result.push(line.substring(1));
-            // Don't increment originalIndex or hunkOldLinesProcessed for additions
-        }
-        else if (line.startsWith(' ')) {
-            // Context line: keep from original
-            if (originalIndex < originalLines.length) {
-                result.push(originalLines[originalIndex]);
-                originalIndex++;
-                hunkOldLinesProcessed++;
-            }
-        }
-        else if (line.trim() === '') {
-            // Empty line - preserve if it's part of the diff structure
-            // But don't add it if we're in the middle of processing
-            if (hunkOldLinesProcessed < hunkOldLineCount) {
-                // This might be a continuation, skip it
-                continue;
-            }
-        }
-        // Check if hunk is complete
-        if (hunkOldLinesProcessed >= hunkOldLineCount) {
-            inHunk = false;
-        }
-    }
-    // Copy all remaining lines from original
-    while (originalIndex < originalLines.length) {
-        result.push(originalLines[originalIndex]);
-        originalIndex++;
-    }
-    return result.join('\n');
-}
-/**
- * Fallback: Try multiple strategies to apply the edit
- * Now optimized for complete file content (preferred) or unified diff
- */
-export function applyEditFallback(originalContent, diff) {
-    if (!diff || !diff.trim()) {
-        return originalContent;
-    }
-    // Clean the diff
-    let cleanDiff = diff.trim();
-    // Strategy 1: Extract from markdown code blocks
-    const codeBlockMatch = cleanDiff.match(/```(?:\w+)?\n([\s\S]*?)\n```/);
-    if (codeBlockMatch) {
-        cleanDiff = codeBlockMatch[1].trim();
-    }
-    // Strategy 2: Check if it's a complete file (no diff markers)
-    const hasDiffMarkers = cleanDiff.includes('---') || cleanDiff.includes('+++') || cleanDiff.includes('@@');
-    // If no diff markers and substantial content, treat as complete file
-    if (!hasDiffMarkers) {
-        // Verify it looks like code (has common patterns)
-        const looksLikeCode = cleanDiff.includes('function') ||
-            cleanDiff.includes('class') ||
-            cleanDiff.includes('import') ||
-            cleanDiff.includes('export') ||
-            cleanDiff.includes('const') ||
-            cleanDiff.includes('async');
-        if (looksLikeCode && cleanDiff.length > 100) {
-            // Likely complete file content
-            return cleanDiff;
-        }
-    }
-    // Strategy 3: Try unified diff parsing if it has diff markers
-    if (hasDiffMarkers) {
-        try {
-            const result = applyUnifiedDiff(originalContent, cleanDiff);
-            // Basic sanity check
-            if (result && result.length > 0 && result !== originalContent) {
-                // Verify it's not just the diff itself
-                if (!result.startsWith('---') && !result.startsWith('+++')) {
-                    return result;
-                }
-            }
-        }
-        catch (error) {
-            if (process.env.CODEHERE_DEBUG === '1')
-                console.warn('[DiffParser] Unified diff parsing failed:', error);
-        }
-    }
-    // Strategy 4: Last resort - if it's substantial content, use it
-    if (cleanDiff.length > 200 && !cleanDiff.startsWith('---') && !cleanDiff.startsWith('+++')) {
-        return cleanDiff;
-    }
-    // Strategy 5: If all else fails, return original (safer than broken code)
-    if (process.env.CODEHERE_DEBUG === '1')
-        console.warn('[DiffParser] Could not parse diff, returning original content');
-    return originalContent;
-}
-//# sourceMappingURL=diff-parser.js.map

package/dist/verification/backup.js

@@ -1,259 +0,0 @@
-/**
- * File Backup and Rollback Module
- * Creates backups before edits and enables rollback on verification failure
- */
-import { readFileSync, writeFileSync, existsSync, mkdirSync, unlinkSync, readdirSync, statSync } from 'fs';
-import { join, dirname, basename } from 'path';
-import { executionTracer } from '../infrastructure/observability/execution-tracer.js';
-const BACKUP_DIR = '.codehere/backups';
-const MAX_BACKUPS = 5; // Keep last 5 backups per file
-/**
- * Create backup of file before editing
- */
-export async function backupFile(filepath) {
-    try {
-        // Read original file
-        if (!existsSync(filepath)) {
-            throw new Error(`File not found: ${filepath}`);
-        }
-        const originalContent = readFileSync(filepath, 'utf-8');
-        // Create backup directory
-        const projectDir = findProjectRoot(filepath) || dirname(filepath);
-        const backupDir = join(projectDir, BACKUP_DIR);
-        if (!existsSync(backupDir)) {
-            mkdirSync(backupDir, { recursive: true });
-        }
-        // Generate backup filename with timestamp
-        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-        const filename = basename(filepath);
-        const backupPath = join(backupDir, `${filename}.${timestamp}.backup`);
-        // Write backup
-        writeFileSync(backupPath, originalContent, 'utf-8');
-        // Link backup to current run for traceability
-        const runId = executionTracer.getCurrentRunId();
-        if (runId) {
-            executionTracer.trace({
-                operationType: 'file_operation',
-                operationName: 'backup',
-                input: { filepath },
-                output: { backupPath },
-                metadata: {
-                    runId,
-                    filepath,
-                    timestamp: new Date().toISOString(),
-                },
-            });
-        }
-        // Clean up old backups for this file
-        await cleanupOldBackups(backupDir, filename);
-        return backupPath;
-    }
-    catch (error) {
-        throw new Error(`Failed to create backup: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-/**
- * Restore file from backup
- */
-export async function rollbackFile(filepath, backupPath) {
-    try {
-        // If no backup path provided, find most recent backup
-        if (!backupPath) {
-            const latestBackup = await findLatestBackup(filepath);
-            if (!latestBackup) {
-                throw new Error(`No backup found for file: ${filepath}`);
-            }
-            backupPath = latestBackup;
-        }
-        // Verify backup exists
-        if (!existsSync(backupPath)) {
-            throw new Error(`Backup file not found: ${backupPath}`);
-        }
-        // Read backup content
-        const backupContent = readFileSync(backupPath, 'utf-8');
-        // Restore original file
-        writeFileSync(filepath, backupContent, 'utf-8');
-        // Trace rollback operation
-        const runId = executionTracer.getCurrentRunId();
-        if (runId) {
-            executionTracer.trace({
-                operationType: 'file_operation',
-                operationName: 'rollback',
-                input: { filepath, backupPath },
-                output: { restored: true },
-                metadata: {
-                    runId,
-                    filepath,
-                    backupPath,
-                    timestamp: new Date().toISOString(),
-                },
-            });
-        }
-    }
-    catch (error) {
-        throw new Error(`Failed to rollback file: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-/**
- * Find latest backup for a file
- */
-export async function findLatestBackup(filepath) {
-    try {
-        const projectDir = findProjectRoot(filepath) || dirname(filepath);
-        const backupDir = join(projectDir, BACKUP_DIR);
-        if (!existsSync(backupDir)) {
-            return null;
-        }
-        const filename = basename(filepath);
-        const files = readdirSync(backupDir)
-            .filter(file => file.startsWith(`${filename}.`) && file.endsWith('.backup'))
-            .map(file => join(backupDir, file))
-            .filter(file => existsSync(file));
-        if (files.length === 0) {
-            return null;
-        }
-        // Sort by modification time (newest first)
-        files.sort((a, b) => {
-            const statA = statSync(a);
-            const statB = statSync(b);
-            return statB.mtime.getTime() - statA.mtime.getTime();
-        });
-        return files[0]; // Return most recent backup
-    }
-    catch (error) {
-        return null;
-    }
-}
-/**
- * List all backups for a file
- */
-export async function listBackups(filepath) {
-    try {
-        const projectDir = findProjectRoot(filepath) || dirname(filepath);
-        const backupDir = join(projectDir, BACKUP_DIR);
-        if (!existsSync(backupDir)) {
-            return [];
-        }
-        const filename = basename(filepath);
-        const files = readdirSync(backupDir)
-            .filter(file => file.startsWith(`${filename}.`) && file.endsWith('.backup'))
-            .map(file => {
-            const backupPath = join(backupDir, file);
-            if (!existsSync(backupPath)) {
-                return null;
-            }
-            const stat = statSync(backupPath);
-            const timestampMatch = file.match(/\.([^.]+)\.backup$/);
-            let timestamp;
-            if (timestampMatch) {
-                // Timestamp format: 2025-12-02T00-10-46-506Z (dashes instead of colons)
-                // Convert to ISO format: 2025-12-02T00:10:46.506Z
-                const timestampStr = timestampMatch[1];
-                // Replace dashes with colons, but keep date part dashes
-                // Format: YYYY-MM-DDTHH-MM-SS-MMMZ
-                // Convert: YYYY-MM-DDTHH:MM:SS.MMMZ
-                const isoStr = timestampStr
-                    .replace(/T(\d{2})-(\d{2})-(\d{2})-(\d{3})Z$/, 'T$1:$2:$3.$4Z');
-                try {
-                    timestamp = new Date(isoStr);
-                    // Validate date
-                    if (isNaN(timestamp.getTime())) {
-                        timestamp = stat.mtime; // Fallback to file mtime
-                    }
-                }
-                catch {
-                    timestamp = stat.mtime; // Fallback to file mtime
-                }
-            }
-            else {
-                timestamp = stat.mtime;
-            }
-            return {
-                backupPath,
-                originalPath: filepath,
-                timestamp,
-            };
-        })
-            .filter((info) => info !== null);
-        // Sort by timestamp (newest first)
-        files.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
-        return files;
-    }
-    catch (error) {
-        return [];
-    }
-}
-/**
- * Clean up old backups (keep only MAX_BACKUPS most recent)
- */
-async function cleanupOldBackups(backupDir, filename) {
-    try {
-        const files = readdirSync(backupDir)
-            .filter(file => file.startsWith(`${filename}.`) && file.endsWith('.backup'))
-            .map(file => join(backupDir, file))
-            .filter(file => existsSync(file));
-        if (files.length <= MAX_BACKUPS) {
-            return; // No cleanup needed
-        }
-        // Sort by modification time (oldest first)
-        files.sort((a, b) => {
-            const statA = statSync(a);
-            const statB = statSync(b);
-            return statA.mtime.getTime() - statB.mtime.getTime();
-        });
-        // Delete oldest backups
-        const toDelete = files.slice(0, files.length - MAX_BACKUPS);
-        for (const file of toDelete) {
-            try {
-                unlinkSync(file);
-            }
-            catch {
-                // Ignore deletion errors
-            }
-        }
-    }
-    catch (error) {
-        // Ignore cleanup errors - don't fail if cleanup fails
-    }
-}
-/**
- * Delete all backups for a file
- */
-export async function deleteAllBackups(filepath) {
-    try {
-        const backups = await listBackups(filepath);
-        for (const backup of backups) {
-            try {
-                if (existsSync(backup.backupPath)) {
-                    unlinkSync(backup.backupPath);
-                }
-            }
-            catch {
-                // Ignore deletion errors
-            }
-        }
-    }
-    catch (error) {
-        // Ignore cleanup errors
-    }
-}
-/**
- * Find project root (where package.json or .git is)
- */
-function findProjectRoot(filepath) {
-    let currentDir = dirname(filepath);
-    const root = currentDir.split(/[/\\]/)[0];
-    while (currentDir !== root) {
-        if (existsSync(join(currentDir, 'package.json')) ||
-            existsSync(join(currentDir, '.git'))) {
-            return currentDir;
-        }
-        const parentDir = dirname(currentDir);
-        if (parentDir === currentDir) {
-            break;
-        }
-        currentDir = parentDir;
-    }
-    return null;
-}
-//# sourceMappingURL=backup.js.map

package/dist/verification/compiler.js

@@ -1,264 +0,0 @@
-/**
- * Compilation Verification Module
- * Verifies TypeScript and JavaScript code compiles/syntax checks correctly
- */
-import { readFileSync, existsSync } from 'fs';
-import { join, dirname, extname } from 'path';
-import { execSync } from 'child_process';
-import { mkdirSync, writeFileSync, unlinkSync } from 'fs';
-import { tmpdir } from 'os';
-/**
- * Verify code compilation based on file type
- */
-export async function verifyCompilation(filepath, code, options = {}) {
-    const ext = extname(filepath).toLowerCase();
-    // Use provided code or read from file
-    const codeToCheck = code || (existsSync(filepath) ? readFileSync(filepath, 'utf-8') : '');
-    if (!codeToCheck) {
-        return {
-            success: false,
-            errors: ['No code provided and file does not exist'],
-            warnings: [],
-        };
-    }
-    // Route to appropriate verifier
-    if (ext === '.ts' || ext === '.tsx') {
-        return await verifyTypeScriptCompilation(filepath, codeToCheck, options);
-    }
-    else if (ext === '.js' || ext === '.jsx') {
-        return await verifyJavaScriptSyntax(filepath, codeToCheck, options);
-    }
-    // Unknown file type - skip verification
-    return {
-        success: true,
-        errors: [],
-        warnings: [`Unknown file type ${ext}, skipping compilation check`],
-    };
-}
-/**
- * Verify TypeScript compilation
- */
-async function verifyTypeScriptCompilation(filepath, code, options = {}) {
-    const errors = [];
-    const warnings = [];
-    const timeout = options.timeout || 30000; // 30 seconds default
-    const skipLibCheck = options.skipLibCheck !== false; // Default to true
-    try {
-        // Create temporary file for checking
-        const tmpDir = join(tmpdir(), 'codehere-verification');
-        if (!existsSync(tmpDir)) {
-            mkdirSync(tmpDir, { recursive: true });
-        }
-        const tmpFile = join(tmpDir, `check-${Date.now()}.ts`);
-        writeFileSync(tmpFile, code, 'utf-8');
-        try {
-            // Build tsc command
-            const tscArgs = [
-                '--noEmit',
-                skipLibCheck ? '--skipLibCheck' : '',
-                '--strict',
-                `"${tmpFile}"`,
-            ].filter(Boolean).join(' ');
-            // Try to find tsconfig.json in project root
-            const projectDir = findProjectRoot(filepath);
-            const hasTsConfig = projectDir && (existsSync(join(projectDir, 'tsconfig.json')) ||
-                existsSync(join(projectDir, 'tsconfig.base.json')));
-            let command;
-            if (hasTsConfig && projectDir) {
-                // Use project tsconfig.json
-                command = `cd "${projectDir}" && npx tsc ${tscArgs}`;
-            }
-            else {
-                // Use standalone file check
-                command = `npx tsc ${tscArgs}`;
-            }
-            const result = execSync(command, {
-                encoding: 'utf-8',
-                stdio: 'pipe',
-                timeout,
-                cwd: projectDir || dirname(filepath),
-            });
-            // If execution succeeded with no output, compilation passed
-            if (!result || result.trim().length === 0) {
-                return { success: true, errors: [], warnings: [] };
-            }
-            // Parse output for errors and warnings (enhanced pattern detection)
-            const lines = result.split('\n');
-            for (const line of lines) {
-                const trimmedLine = line.trim();
-                // Enhanced error detection patterns
-                if (trimmedLine.includes('error TS') ||
-                    trimmedLine.match(/error\s+TS\d+/i) ||
-                    trimmedLine.includes('Cannot find') ||
-                    trimmedLine.includes('is not defined') ||
-                    trimmedLine.includes('has no exported member') ||
-                    trimmedLine.includes('Property') && trimmedLine.includes('does not exist') ||
-                    trimmedLine.includes('Type') && trimmedLine.includes('is not assignable')) {
-                    errors.push(trimmedLine);
-                }
-                else if (trimmedLine.includes('warning TS') || trimmedLine.match(/warning\s+TS\d+/i)) {
-                    warnings.push(trimmedLine);
-                }
-            }
-            return {
-                success: errors.length === 0,
-                errors,
-                warnings,
-                output: result,
-            };
-        }
-        finally {
-            // Clean up temp file
-            try {
-                if (existsSync(tmpFile)) {
-                    unlinkSync(tmpFile);
-                }
-            }
-            catch {
-                // Ignore cleanup errors
-            }
-        }
-    }
-    catch (error) {
-        // execSync throws on non-zero exit code
-        const output = error.stdout || error.stderr || error.message || '';
-        const errorOutput = String(output);
-        // Parse error output (enhanced pattern detection)
-        const lines = errorOutput.split('\n');
-        for (const line of lines) {
-            const trimmedLine = line.trim();
-            // Enhanced error detection patterns
-            if (trimmedLine.includes('error TS') ||
-                trimmedLine.match(/error\s+TS\d+/i) ||
-                trimmedLine.includes('Cannot find') ||
-                trimmedLine.includes('is not defined') ||
-                trimmedLine.includes('has no exported member') ||
-                trimmedLine.includes('Property') && trimmedLine.includes('does not exist') ||
-                trimmedLine.includes('Type') && trimmedLine.includes('is not assignable') ||
-                trimmedLine.includes('Module') && trimmedLine.includes('has no exported member')) {
-                errors.push(trimmedLine);
-            }
-            else if (trimmedLine.includes('warning TS') || trimmedLine.match(/warning\s+TS\d+/i)) {
-                warnings.push(trimmedLine);
-            }
-        }
-        // If no structured errors found, try to extract meaningful error patterns
-        if (errors.length === 0) {
-            // Look for common error patterns in output
-            const errorPatterns = [
-                /(?:error|Error)[:\s]+(.+)/i,
-                /(?:failed|Failed)[:\s]+(.+)/i,
-                /(?:cannot|Cannot)[:\s]+(.+)/i,
-                /(?:undefined|Undefined)[:\s]+(.+)/i,
-            ];
-            let foundError = false;
-            for (const pattern of errorPatterns) {
-                const match = errorOutput.match(pattern);
-                if (match && match[1]) {
-                    errors.push(`TypeScript compilation error: ${match[1].trim().substring(0, 200)}`);
-                    foundError = true;
-                    break;
-                }
-            }
-            if (!foundError) {
-                errors.push(`TypeScript compilation failed: ${errorOutput.substring(0, 500)}`);
-            }
-        }
-        // Check for timeout
-        if (error.signal === 'SIGTERM' || errorOutput.includes('timeout')) {
-            errors.push('Compilation check timed out');
-        }
-        // Check if tsc is available
-        if (errorOutput.includes('command not found') || errorOutput.includes('Cannot find module')) {
-            warnings.push('TypeScript compiler (tsc) not found. Install it with: npm install -D typescript');
-            // Don't fail if tsc is not installed - this is a warning, not an error
-            return {
-                success: true, // Allow to proceed if compiler not available
-                errors: [],
-                warnings: ['TypeScript compiler not available, skipping compilation check'],
-            };
-        }
-        return {
-            success: false,
-            errors,
-            warnings,
-            output: errorOutput,
-        };
-    }
-}
-/**
- * Verify JavaScript syntax
- */
-async function verifyJavaScriptSyntax(filepath, code, options = {}) {
-    const errors = [];
-    const warnings = [];
-    try {
-        // Syntax check: write to temp file and use node --check (parse-only, no execution)
-        const tmpFile = join(tmpdir(), `codehere-syntax-${Date.now()}.js`);
-        try {
-            writeFileSync(tmpFile, code, 'utf-8');
-            execSync(`node --check "${tmpFile}"`, { stdio: 'pipe' });
-        }
-        catch (parseError) {
-            const errorMsg = parseError instanceof Error ? parseError.message : String(parseError);
-            const lineMatch = errorMsg.match(/line (\d+)/i) || errorMsg.match(/:(\d+):/);
-            const lineNum = lineMatch ? lineMatch[1] : '?';
-            errors.push(`Syntax error at line ${lineNum}: ${errorMsg}`);
-            return { success: false, errors, warnings };
-        }
-        finally {
-            try {
-                unlinkSync(tmpFile);
-            }
-            catch { /* ignore */ }
-        }
-        // Additional check: Try to parse as ES module
-        // This catches import/export syntax errors
-        try {
-            // Create temporary file and try to load it as module
-            // This is a lightweight check
-            if (code.includes('import ') || code.includes('export ')) {
-                // For ES modules, we'd need more sophisticated checking
-                // For now, syntax check is sufficient
-            }
-        }
-        catch (moduleError) {
-            warnings.push(`Module syntax warning: ${moduleError instanceof Error ? moduleError.message : String(moduleError)}`);
-        }
-        return {
-            success: true,
-            errors: [],
-            warnings,
-        };
-    }
-    catch (error) {
-        errors.push(`JavaScript syntax check failed: ${error instanceof Error ? error.message : String(error)}`);
-        return {
-            success: false,
-            errors,
-            warnings,
-        };
-    }
-}
-/**
- * Find project root (where package.json or tsconfig.json is)
- */
-function findProjectRoot(filepath) {
-    let currentDir = dirname(filepath);
-    const root = currentDir.split(/[/\\]/)[0]; // Get filesystem root
-    // Walk up directory tree
-    while (currentDir !== root) {
-        if (existsSync(join(currentDir, 'package.json')) ||
-            existsSync(join(currentDir, 'tsconfig.json')) ||
-            existsSync(join(currentDir, 'tsconfig.base.json'))) {
-            return currentDir;
-        }
-        const parentDir = dirname(currentDir);
-        if (parentDir === currentDir) {
-            break; // Reached root
-        }
-        currentDir = parentDir;
-    }
-    return null;
-}
-//# sourceMappingURL=compiler.js.map