codehere 0.2.1 → 0.3.0-rc.1

package/dist/verification/index.js

@@ -1,273 +0,0 @@
-/**
- * Unified Verification Interface
- * Provides a single entry point for all verification operations
- */
-import { existsSync } from 'fs';
-import { verifyCompilation } from './compiler.js';
-import { runTests } from './test-runner.js';
-import { backupFile, rollbackFile } from './backup.js';
-/**
- * Verify file after edit
- *
- * This function:
- * 1. Creates a backup (if autoRollback is enabled)
- * 2. Verifies compilation (if verifyCompilation is enabled)
- * 3. Runs tests (if runTests is enabled)
- * 4. Returns comprehensive result
- *
- * Use with applyEditWithVerification() for automatic rollback on failure
- */
-export async function verifyFile(filepath, options = {}) {
-    const { verifyCompilation: shouldVerifyCompilation = true, runTests: shouldRunTests = true, autoRollback: shouldAutoRollback = true, compilationOptions = {}, testOptions = {}, } = options;
-    const result = {
-        success: false,
-        compiled: false,
-        testsPassed: false,
-        errors: [],
-        warnings: [],
-        rollbackRequired: false,
-    };
-    // Create backup if auto-rollback is enabled
-    let backupPath;
-    if (shouldAutoRollback) {
-        try {
-            backupPath = await backupFile(filepath);
-            result.backupPath = backupPath;
-        }
-        catch (error) {
-            result.warnings.push(`Failed to create backup: ${error instanceof Error ? error.message : String(error)}`);
-            // Don't fail verification if backup fails - just warn
-        }
-    }
-    // Step 1: Verify compilation
-    if (shouldVerifyCompilation) {
-        try {
-            const compilationResult = await verifyCompilation(filepath, undefined, compilationOptions);
-            result.compilationResult = compilationResult;
-            result.compiled = compilationResult.success;
-            if (!compilationResult.success) {
-                result.errors.push(...compilationResult.errors);
-                result.rollbackRequired = true;
-            }
-            result.warnings.push(...compilationResult.warnings);
-            // If compilation fails, stop here
-            if (!result.compiled) {
-                result.success = false;
-                return result;
-            }
-        }
-        catch (error) {
-            result.errors.push(`Compilation verification failed: ${error instanceof Error ? error.message : String(error)}`);
-            result.rollbackRequired = true;
-            result.success = false;
-            return result;
-        }
-    }
-    else {
-        // Skip compilation check
-        result.compiled = true;
-    }
-    // Step 2: Run tests (only if compilation succeeded or was skipped)
-    if (shouldRunTests && result.compiled) {
-        try {
-            const testResult = await runTests(filepath, testOptions);
-            result.testResult = testResult;
-            result.testsPassed = testResult.success;
-            if (testResult.ran && !testResult.success) {
-                result.errors.push(...testResult.errors);
-                result.rollbackRequired = true;
-            }
-            if (testResult.ran) {
-                result.warnings.push(...testResult.warnings);
-            }
-        }
-        catch (error) {
-            // Test execution failure is a warning, not an error
-            // (tests might not exist or framework might not be available)
-            result.warnings.push(`Test execution failed: ${error instanceof Error ? error.message : String(error)}`);
-            result.testsPassed = true; // Don't fail if tests can't run
-        }
-    }
-    else {
-        // Skip test check
-        result.testsPassed = true;
-    }
-    // Overall success: compilation passed AND (tests passed OR tests weren't run)
-    result.success = result.compiled && (result.testsPassed || !result.testResult?.ran);
-    return result;
-}
-/**
- * Apply edit with automatic verification and rollback
- *
- * This is the main function to use for safe code edits.
- * It:
- * 1. Creates backup
- * 2. Applies edit (you provide the new content)
- * 3. Verifies compilation and tests
- * 4. Rolls back automatically on failure
- */
-export async function applyEditWithVerification(filepath, newContent, options = {}) {
-    const { writeFileSync } = await import('fs');
-    const { readFileSync: readFile } = await import('fs');
-    // Read original content
-    const originalContent = existsSync(filepath)
-        ? readFile(filepath, 'utf-8')
-        : '';
-    // Create backup
-    let backupPath;
-    try {
-        if (options.autoRollback !== false) {
-            backupPath = await backupFile(filepath);
-        }
-    }
-    catch (error) {
-        return {
-            success: false,
-            verified: false,
-            result: {
-                success: false,
-                compiled: false,
-                testsPassed: false,
-                errors: [`Failed to create backup: ${error instanceof Error ? error.message : String(error)}`],
-                warnings: [],
-                rollbackRequired: true,
-            },
-            rolledBack: false,
-        };
-    }
-    // Write new content
-    try {
-        writeFileSync(filepath, newContent, 'utf-8');
-    }
-    catch (error) {
-        return {
-            success: false,
-            verified: false,
-            result: {
-                success: false,
-                compiled: false,
-                testsPassed: false,
-                errors: [`Failed to write file: ${error instanceof Error ? error.message : String(error)}`],
-                warnings: [],
-                rollbackRequired: true,
-            },
-            rolledBack: false,
-        };
-    }
-    // Verify
-    try {
-        const verificationResult = await verifyFile(filepath, {
-            ...options,
-            autoRollback: false, // Don't create another backup
-        });
-        // Rollback if verification failed
-        if (!verificationResult.success && options.autoRollback !== false) {
-            try {
-                await rollbackFile(filepath, backupPath);
-                return {
-                    success: false,
-                    verified: true,
-                    result: verificationResult,
-                    rolledBack: true,
-                };
-            }
-            catch (rollbackError) {
-                // Rollback failed - try to restore from original content
-                try {
-                    writeFileSync(filepath, originalContent, 'utf-8');
-                    return {
-                        success: false,
-                        verified: true,
-                        result: {
-                            ...verificationResult,
-                            errors: [
-                                ...verificationResult.errors,
-                                `Rollback failed: ${rollbackError instanceof Error ? rollbackError.message : String(rollbackError)}`,
-                            ],
-                        },
-                        rolledBack: true,
-                    };
-                }
-                catch (restoreError) {
-                    return {
-                        success: false,
-                        verified: true,
-                        result: {
-                            ...verificationResult,
-                            errors: [
-                                ...verificationResult.errors,
-                                `Rollback and restore both failed. File may be in inconsistent state.`,
-                            ],
-                        },
-                        rolledBack: false, // Rollback failed
-                    };
-                }
-            }
-        }
-        // Verification passed or rollback disabled
-        return {
-            success: verificationResult.success,
-            verified: true,
-            result: verificationResult,
-            rolledBack: false,
-        };
-    }
-    catch (error) {
-        // Verification threw an error - rollback
-        if (options.autoRollback !== false) {
-            try {
-                await rollbackFile(filepath, backupPath);
-                return {
-                    success: false,
-                    verified: false,
-                    result: {
-                        success: false,
-                        compiled: false,
-                        testsPassed: false,
-                        errors: [`Verification failed: ${error instanceof Error ? error.message : String(error)}`],
-                        warnings: [],
-                        rollbackRequired: true,
-                    },
-                    rolledBack: true,
-                };
-            }
-            catch (rollbackError) {
-                // Rollback failed
-                writeFileSync(filepath, originalContent, 'utf-8');
-                return {
-                    success: false,
-                    verified: false,
-                    result: {
-                        success: false,
-                        compiled: false,
-                        testsPassed: false,
-                        errors: [
-                            `Verification failed: ${error instanceof Error ? error.message : String(error)}`,
-                            `Rollback failed: ${rollbackError instanceof Error ? rollbackError.message : String(rollbackError)}`,
-                        ],
-                        warnings: [],
-                        rollbackRequired: true,
-                    },
-                    rolledBack: true, // Tried to rollback
-                };
-            }
-        }
-        return {
-            success: false,
-            verified: false,
-            result: {
-                success: false,
-                compiled: false,
-                testsPassed: false,
-                errors: [`Verification failed: ${error instanceof Error ? error.message : String(error)}`],
-                warnings: [],
-                rollbackRequired: true,
-            },
-            rolledBack: false,
-        };
-    }
-}
-export { verifyCompilation } from './compiler.js';
-export { runTests, detectTestFramework } from './test-runner.js';
-export { backupFile, rollbackFile, findLatestBackup, listBackups, deleteAllBackups } from './backup.js';
-//# sourceMappingURL=index.js.map

package/dist/verification/test-runner.js

@@ -1,379 +0,0 @@
-/**
- * Test Execution Module
- * Detects test frameworks and runs tests to verify code changes
- */
-import { readFileSync, existsSync } from 'fs';
-import { join, dirname } from 'path';
-import { execSync } from 'child_process';
-/**
- * Verify tests pass for a given file
- */
-export async function runTests(filepath, options = {}) {
-    try {
-        // Detect test framework
-        const framework = await detectTestFramework(filepath);
-        if (!framework || framework === 'unknown') {
-            return {
-                success: true,
-                ran: false,
-                errors: [],
-                warnings: ['No test framework detected. Skipping test verification.'],
-                framework: 'unknown',
-            };
-        }
-        // Find test files related to the changed file
-        const testFiles = findTestFiles(filepath, framework);
-        if (testFiles.length === 0) {
-            return {
-                success: true,
-                ran: false,
-                errors: [],
-                warnings: [`No test files found for ${filepath}. Skipping test verification.`],
-                framework,
-            };
-        }
-        // Run tests based on framework
-        switch (framework) {
-            case 'jest':
-                return await runJestTests(filepath, testFiles, options);
-            case 'mocha':
-                return await runMochaTests(filepath, testFiles, options);
-            case 'vitest':
-                return await runVitestTests(filepath, testFiles, options);
-            case 'tap':
-                return await runTapTests(filepath, testFiles, options);
-            case 'ava':
-                return await runAvaTests(filepath, testFiles, options);
-            default:
-                return {
-                    success: true,
-                    ran: false,
-                    errors: [],
-                    warnings: [`Test framework ${framework} not yet supported. Skipping test verification.`],
-                    framework,
-                };
-        }
-    }
-    catch (error) {
-        return {
-            success: false,
-            ran: true,
-            errors: [`Test execution failed: ${error instanceof Error ? error.message : String(error)}`],
-            warnings: [],
-        };
-    }
-}
-/**
- * Detect test framework in project
- */
-export async function detectTestFramework(filepath) {
-    const projectDir = findProjectRoot(filepath);
-    if (!projectDir) {
-        return null;
-    }
-    // Check package.json scripts and dependencies
-    const packageJsonPath = join(projectDir, 'package.json');
-    if (existsSync(packageJsonPath)) {
-        try {
-            const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
-            const deps = {
-                ...packageJson.dependencies,
-                ...packageJson.devDependencies,
-            };
-            const scripts = packageJson.scripts || {};
-            // Check for Jest
-            if (deps.jest ||
-                deps['@jest/globals'] ||
-                scripts.test?.includes('jest') ||
-                existsSync(join(projectDir, 'jest.config.js')) ||
-                existsSync(join(projectDir, 'jest.config.ts')) ||
-                existsSync(join(projectDir, 'jest.config.json'))) {
-                return 'jest';
-            }
-            // Check for Vitest
-            if (deps.vitest ||
-                scripts.test?.includes('vitest') ||
-                existsSync(join(projectDir, 'vitest.config.ts')) ||
-                existsSync(join(projectDir, 'vitest.config.js'))) {
-                return 'vitest';
-            }
-            // Check for Mocha
-            if (deps.mocha ||
-                scripts.test?.includes('mocha') ||
-                existsSync(join(projectDir, '.mocharc.js')) ||
-                existsSync(join(projectDir, '.mocharc.json'))) {
-                return 'mocha';
-            }
-            // Check for Tap
-            if (deps.tap || scripts.test?.includes('tap')) {
-                return 'tap';
-            }
-            // Check for Ava
-            if (deps.ava || scripts.test?.includes('ava')) {
-                return 'ava';
-            }
-            // Check script name
-            if (scripts.test) {
-                // Try to infer from test script
-                if (scripts.test.includes('jest'))
-                    return 'jest';
-                if (scripts.test.includes('vitest'))
-                    return 'vitest';
-                if (scripts.test.includes('mocha'))
-                    return 'mocha';
-            }
-        }
-        catch (error) {
-            // Ignore package.json parsing errors
-        }
-    }
-    return null;
-}
-/**
- * Find test files related to a source file
- */
-function findTestFiles(filepath, framework) {
-    const projectDir = findProjectRoot(filepath);
-    if (!projectDir) {
-        return [];
-    }
-    const dir = dirname(filepath);
-    const basename = filepath
-        .split('/')
-        .pop()
-        ?.replace(/\.[^.]+$/, '') || '';
-    const ext = filepath.split('.').pop()?.toLowerCase() || '';
-    // Common test file patterns
-    const testPatterns = [
-        // Same directory
-        join(dir, `${basename}.test.${ext}`),
-        join(dir, `${basename}.spec.${ext}`),
-        join(dir, `${basename}.test.ts`), // TypeScript tests for JS files
-        join(dir, `${basename}.spec.ts`),
-        // Test directory
-        join(dir, '__tests__', `${basename}.${ext}`),
-        join(dir, '__tests__', `${basename}.test.${ext}`),
-        join(dir, '__tests__', `${basename}.spec.${ext}`),
-        // Parent test directory
-        join(dirname(dir), '__tests__', `${basename}.${ext}`),
-        join(dirname(dir), '__tests__', `${basename}.test.${ext}`),
-        join(dirname(dir), '__tests__', `${basename}.spec.${ext}`),
-        // Test subdirectory
-        join(dir, 'test', `${basename}.${ext}`),
-        join(dir, 'tests', `${basename}.${ext}`),
-    ];
-    const testFiles = [];
-    for (const pattern of testPatterns) {
-        if (existsSync(pattern)) {
-            testFiles.push(pattern);
-        }
-    }
-    return testFiles;
-}
-/**
- * Run Jest tests
- */
-async function runJestTests(filepath, testFiles, options = {}) {
-    const projectDir = findProjectRoot(filepath);
-    if (!projectDir) {
-        return {
-            success: false,
-            ran: false,
-            errors: ['Could not find project root'],
-            warnings: [],
-        };
-    }
-    try {
-        const timeout = options.timeout || 30000; // 30 seconds
-        // Build Jest command
-        let command = 'npx jest';
-        if (options.testFile) {
-            command += ` ${options.testFile}`;
-        }
-        else if (testFiles.length > 0) {
-            // Run specific test files
-            command += ` ${testFiles.join(' ')}`;
-        }
-        else {
-            // Run all tests (fallback)
-            command += ' --findRelatedTests';
-        }
-        // Add flags for better output
-        command += ' --no-coverage --silent=false';
-        const output = execSync(command, {
-            cwd: projectDir,
-            encoding: 'utf-8',
-            stdio: 'pipe',
-            timeout,
-        });
-        // Parse Jest output
-        const passed = output.includes('PASS') ||
-            (output.includes('Test Suites:') && !output.includes('failed'));
-        return {
-            success: passed,
-            ran: true,
-            errors: passed ? [] : ['Tests failed'],
-            warnings: [],
-            output,
-            framework: 'jest',
-        };
-    }
-    catch (error) {
-        const output = error.stdout || error.stderr || error.message || '';
-        // Check if tests actually failed or if it's an execution error
-        const isTestFailure = output.includes('FAIL') || output.includes('Test Suites:');
-        return {
-            success: false,
-            ran: true,
-            errors: isTestFailure
-                ? ['Tests failed', output.substring(0, 1000)]
-                : [`Test execution error: ${output.substring(0, 500)}`],
-            warnings: [],
-            output: String(output),
-            framework: 'jest',
-        };
-    }
-}
-/**
- * Run Mocha tests
- */
-async function runMochaTests(filepath, testFiles, options = {}) {
-    const projectDir = findProjectRoot(filepath);
-    if (!projectDir) {
-        return {
-            success: false,
-            ran: false,
-            errors: ['Could not find project root'],
-            warnings: [],
-        };
-    }
-    try {
-        const timeout = options.timeout || 30000;
-        let command = 'npx mocha';
-        if (options.testFile) {
-            command += ` ${options.testFile}`;
-        }
-        else if (testFiles.length > 0) {
-            command += ` ${testFiles.join(' ')}`;
-        }
-        const output = execSync(command, {
-            cwd: projectDir,
-            encoding: 'utf-8',
-            stdio: 'pipe',
-            timeout,
-        });
-        const passed = output.includes('passing') && !output.includes('failing');
-        return {
-            success: passed,
-            ran: true,
-            errors: passed ? [] : ['Tests failed'],
-            warnings: [],
-            output,
-            framework: 'mocha',
-        };
-    }
-    catch (error) {
-        const output = error.stdout || error.stderr || error.message || '';
-        return {
-            success: false,
-            ran: true,
-            errors: [`Test execution failed: ${output.substring(0, 500)}`],
-            warnings: [],
-            output: String(output),
-            framework: 'mocha',
-        };
-    }
-}
-/**
- * Run Vitest tests
- */
-async function runVitestTests(filepath, testFiles, options = {}) {
-    const projectDir = findProjectRoot(filepath);
-    if (!projectDir) {
-        return {
-            success: false,
-            ran: false,
-            errors: ['Could not find project root'],
-            warnings: [],
-        };
-    }
-    try {
-        const timeout = options.timeout || 30000;
-        let command = 'npx vitest run';
-        if (options.testFile) {
-            command += ` ${options.testFile}`;
-        }
-        else if (testFiles.length > 0) {
-            command += ` ${testFiles.join(' ')}`;
-        }
-        const output = execSync(command, {
-            cwd: projectDir,
-            encoding: 'utf-8',
-            stdio: 'pipe',
-            timeout,
-        });
-        const passed = output.includes('PASS') || output.includes('✓') && !output.includes('FAIL');
-        return {
-            success: passed,
-            ran: true,
-            errors: passed ? [] : ['Tests failed'],
-            warnings: [],
-            output,
-            framework: 'vitest',
-        };
-    }
-    catch (error) {
-        const output = error.stdout || error.stderr || error.message || '';
-        return {
-            success: false,
-            ran: true,
-            errors: [`Test execution failed: ${output.substring(0, 500)}`],
-            warnings: [],
-            output: String(output),
-            framework: 'vitest',
-        };
-    }
-}
-/**
- * Run Tap tests (placeholder)
- */
-async function runTapTests(filepath, testFiles, options = {}) {
-    return {
-        success: true,
-        ran: false,
-        errors: [],
-        warnings: ['Tap test runner not yet implemented'],
-        framework: 'tap',
-    };
-}
-/**
- * Run Ava tests (placeholder)
- */
-async function runAvaTests(filepath, testFiles, options = {}) {
-    return {
-        success: true,
-        ran: false,
-        errors: [],
-        warnings: ['Ava test runner not yet implemented'],
-        framework: 'ava',
-    };
-}
-/**
- * Find project root (where package.json is)
- */
-function findProjectRoot(filepath) {
-    let currentDir = dirname(filepath);
-    const root = currentDir.split(/[/\\]/)[0];
-    while (currentDir !== root) {
-        if (existsSync(join(currentDir, 'package.json'))) {
-            return currentDir;
-        }
-        const parentDir = dirname(currentDir);
-        if (parentDir === currentDir) {
-            break;
-        }
-        currentDir = parentDir;
-    }
-    return null;
-}
-//# sourceMappingURL=test-runner.js.map