codehere 0.2.1 → 0.3.0-rc.1

package/dist/task-verification.js

@@ -1,336 +0,0 @@
-/**
- * Task Completion Verification System
- * Verify code compiles, runs, meets requirements, rollback on failure
- */
-import { readFileSync, writeFileSync, existsSync } from 'fs';
-import { join, dirname } from 'path';
-import { execSync } from 'child_process';
-import { applyUnifiedDiff } from './edit.js';
-/**
- * Verify task completion
- */
-export async function verifyTask(context) {
-    const result = {
-        success: false,
-        compiled: false,
-        testsPassed: false,
-        requirementsMet: false,
-        errors: [],
-        warnings: [],
-        rollbackRequired: false,
-    };
-    // Step 1: Check if code compiles
-    const compileResult = await verifyCompilation(context);
-    result.compiled = compileResult.success;
-    result.errors.push(...compileResult.errors);
-    result.warnings.push(...compileResult.warnings);
-    if (!result.compiled) {
-        result.rollbackRequired = true;
-        return result;
-    }
-    // Step 2: Check if tests pass
-    const testResult = await verifyTests(context);
-    result.testsPassed = testResult.success;
-    result.errors.push(...testResult.errors);
-    result.warnings.push(...testResult.warnings);
-    // Step 3: Check if requirements are met
-    if (context.requirements && context.requirements.length > 0) {
-        const reqResult = await verifyRequirements(context);
-        result.requirementsMet = reqResult.success;
-        result.errors.push(...reqResult.errors);
-        result.warnings.push(...reqResult.warnings);
-    }
-    else {
-        result.requirementsMet = true; // No requirements specified
-    }
-    // Overall success
-    result.success = result.compiled &&
-        (result.testsPassed || !testResult.ran) && // Tests optional if not run
-        result.requirementsMet;
-    if (!result.success) {
-        result.rollbackRequired = true;
-    }
-    return result;
-}
-/**
- * Verify code compiles
- */
-async function verifyCompilation(context) {
-    const errors = [];
-    const warnings = [];
-    try {
-        const ext = context.filepath.split('.').pop()?.toLowerCase();
-        if (ext === 'ts' || ext === 'tsx') {
-            // TypeScript compilation check
-            const result = checkTypeScript(context.filepath);
-            if (!result.success) {
-                errors.push(...result.errors);
-                warnings.push(...result.warnings);
-                return { success: false, errors, warnings };
-            }
-        }
-        else if (ext === 'js' || ext === 'jsx') {
-            // JavaScript syntax check
-            const result = checkJavaScript(context.filepath);
-            if (!result.success) {
-                errors.push(...result.errors);
-                warnings.push(...result.warnings);
-                return { success: false, errors, warnings };
-            }
-        }
-        return { success: true, errors, warnings };
-    }
-    catch (error) {
-        errors.push(`Compilation check failed: ${error instanceof Error ? error.message : String(error)}`);
-        return { success: false, errors, warnings };
-    }
-}
-/**
- * Check TypeScript compilation
- */
-function checkTypeScript(filepath) {
-    const errors = [];
-    const warnings = [];
-    try {
-        // Try to run tsc --noEmit on the file
-        const dir = dirname(filepath);
-        const result = execSync(`npx tsc --noEmit --skipLibCheck "${filepath}" 2>&1`, { cwd: dir, encoding: 'utf-8', stdio: 'pipe' });
-        // If there's output, there are errors
-        if (result.trim().length > 0) {
-            const lines = result.split('\n');
-            for (const line of lines) {
-                if (line.includes('error TS')) {
-                    errors.push(line);
-                }
-                else if (line.includes('warning TS')) {
-                    warnings.push(line);
-                }
-            }
-        }
-        return {
-            success: errors.length === 0,
-            errors,
-            warnings,
-        };
-    }
-    catch (error) {
-        // execSync throws on non-zero exit
-        const output = error.stdout || error.stderr || error.message || '';
-        const lines = output.split('\n');
-        for (const line of lines) {
-            if (line.includes('error TS')) {
-                errors.push(line);
-            }
-            else if (line.includes('warning TS')) {
-                warnings.push(line);
-            }
-        }
-        return {
-            success: false,
-            errors: errors.length > 0 ? errors : [output],
-            warnings,
-        };
-    }
-}
-/**
- * Check JavaScript syntax
- */
-function checkJavaScript(filepath) {
-    const errors = [];
-    const warnings = [];
-    try {
-        // Try to parse with node
-        const content = readFileSync(filepath, 'utf-8');
-        // Basic syntax check: use node --check (parse-only, no execution)
-        try {
-            execSync(`node --check "${filepath}"`, { stdio: 'pipe' });
-        }
-        catch (parseError) {
-            const msg = parseError instanceof Error ? parseError.message : String(parseError);
-            errors.push(`Syntax error: ${msg}`);
-            return { success: false, errors, warnings };
-        }
-        return { success: true, errors, warnings };
-    }
-    catch (error) {
-        errors.push(`JavaScript check failed: ${error instanceof Error ? error.message : String(error)}`);
-        return { success: false, errors, warnings };
-    }
-}
-/**
- * Verify tests pass
- */
-async function verifyTests(context) {
-    const errors = [];
-    const warnings = [];
-    try {
-        // Look for test files
-        const testFiles = findTestFiles(context.filepath);
-        if (testFiles.length === 0) {
-            return { success: true, ran: false, errors, warnings }; // No tests to run
-        }
-        // Try to run tests
-        const dir = dirname(context.filepath);
-        let testCommand = '';
-        // Detect test framework
-        if (existsSync(join(dir, 'package.json'))) {
-            const packageJson = JSON.parse(readFileSync(join(dir, 'package.json'), 'utf-8'));
-            const scripts = packageJson.scripts || {};
-            if (scripts.test) {
-                testCommand = scripts.test;
-            }
-            else if (scripts['test:unit']) {
-                testCommand = scripts['test:unit'];
-            }
-        }
-        if (!testCommand) {
-            // Try common test commands
-            if (existsSync(join(dir, 'jest.config.js')) || existsSync(join(dir, 'jest.config.ts'))) {
-                testCommand = 'npx jest';
-            }
-            else if (existsSync(join(dir, 'vitest.config.ts'))) {
-                testCommand = 'npx vitest run';
-            }
-            else {
-                return { success: true, ran: false, errors, warnings }; // Can't determine test framework
-            }
-        }
-        try {
-            const result = execSync(testCommand, {
-                cwd: dir,
-                encoding: 'utf-8',
-                stdio: 'pipe',
-                timeout: 30000, // 30 second timeout
-            });
-            // Check if tests passed (look for "PASS" or "✓" in output)
-            const passed = result.includes('PASS') ||
-                result.includes('✓') ||
-                (result.includes('passed') && !result.includes('failed'));
-            if (!passed) {
-                errors.push('Tests failed');
-                errors.push(result);
-            }
-            return {
-                success: passed,
-                ran: true,
-                errors,
-                warnings,
-            };
-        }
-        catch (error) {
-            const output = error.stdout || error.stderr || error.message || '';
-            errors.push(`Test execution failed: ${output}`);
-            return { success: false, ran: true, errors, warnings };
-        }
-    }
-    catch (error) {
-        warnings.push(`Could not verify tests: ${error instanceof Error ? error.message : String(error)}`);
-        return { success: true, ran: false, errors, warnings }; // Don't fail if we can't run tests
-    }
-}
-/**
- * Find test files for a given file
- */
-function findTestFiles(filepath) {
-    const dir = dirname(filepath);
-    const basename = filepath.split('/').pop()?.replace(/\.[^.]+$/, '') || '';
-    const testPatterns = [
-        `${basename}.test.ts`,
-        `${basename}.test.js`,
-        `${basename}.spec.ts`,
-        `${basename}.spec.js`,
-        `__tests__/${basename}.ts`,
-        `__tests__/${basename}.js`,
-    ];
-    const testFiles = [];
-    for (const pattern of testPatterns) {
-        const testPath = join(dir, pattern);
-        if (existsSync(testPath)) {
-            testFiles.push(testPath);
-        }
-    }
-    return testFiles;
-}
-/**
- * Verify requirements are met
- */
-async function verifyRequirements(context) {
-    const errors = [];
-    const warnings = [];
-    if (!context.requirements || context.requirements.length === 0) {
-        return { success: true, errors, warnings };
-    }
-    const content = context.modifiedContent.toLowerCase();
-    for (const requirement of context.requirements) {
-        const reqLower = requirement.toLowerCase();
-        // Simple keyword matching (can be enhanced with AI)
-        const keywords = reqLower.split(/\s+/).filter(w => w.length > 3);
-        const matches = keywords.filter(kw => content.includes(kw));
-        if (matches.length < keywords.length * 0.5) {
-            // Less than 50% of keywords found
-            warnings.push(`Requirement may not be met: ${requirement}`);
-        }
-    }
-    return {
-        success: warnings.length === 0,
-        errors,
-        warnings,
-    };
-}
-/**
- * Rollback changes
- */
-export function rollbackChanges(context) {
-    try {
-        writeFileSync(context.filepath, context.originalContent, 'utf-8');
-    }
-    catch (error) {
-        throw new Error(`Failed to rollback: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-/**
- * Apply changes with verification and rollback on failure
- */
-export async function applyWithVerification(filepath, diff, instruction, requirements) {
-    // Read original content
-    const originalContent = readFileSync(filepath, 'utf-8');
-    // Apply diff
-    const modifiedContent = applyUnifiedDiff(originalContent, diff);
-    // Create context
-    const context = {
-        filepath,
-        originalContent,
-        modifiedContent,
-        diff,
-        instruction,
-        requirements,
-    };
-    // Write modified content temporarily
-    writeFileSync(filepath, modifiedContent, 'utf-8');
-    try {
-        // Verify
-        const result = await verifyTask(context);
-        if (!result.success || result.rollbackRequired) {
-            // Rollback
-            rollbackChanges(context);
-            return {
-                success: false,
-                verified: false,
-                result,
-                rolledBack: true,
-            };
-        }
-        return {
-            success: true,
-            verified: true,
-            result,
-            rolledBack: false,
-        };
-    }
-    catch (error) {
-        // Rollback on error
-        rollbackChanges(context);
-        throw error;
-    }
-}
-//# sourceMappingURL=task-verification.js.map

package/dist/testgen.js

@@ -1,166 +0,0 @@
-/**
- * Test Generation System
- * Generate comprehensive tests for code
- */
-import { readFileSync, existsSync, writeFileSync, mkdirSync } from 'fs';
-import { join, dirname, basename } from 'path';
-import { chatWithContext } from './chat.js';
-import { getEnhancedContext } from './context.js';
-/**
- * Generate tests for a file
- */
-export async function generateTests(filepath, options = {}) {
-    const fullPath = join(process.cwd(), filepath);
-    if (!existsSync(fullPath)) {
-        throw new Error(`File not found: ${filepath}`);
-    }
-    const content = readFileSync(fullPath, 'utf-8');
-    const ext = filepath.split('.').pop()?.toLowerCase() || '';
-    // Detect test framework
-    const framework = options.framework || detectTestFramework(filepath, ext);
-    const coverage = options.coverage || 'unit';
-    // Get context
-    const context = await getEnhancedContext(`Generate ${coverage} tests for ${filepath}`, {
-        primaryChunks: 15,
-        includeRelationships: true,
-    });
-    // Create test generation prompt
-    const testPrompt = `Generate comprehensive ${coverage} tests for this code file:
-
-File: ${filepath}
-Test Framework: ${framework}
-Code:
-\`\`\`${ext}
-${content}
-\`\`\`
-
-Generate:
-1. Test file structure
-2. Test cases for all functions/methods
-3. Edge cases and error handling
-4. Mock setup if needed
-5. Assertions for expected behavior
-
-Use ${framework} testing framework. Format as complete test file.`;
-    const contextResults = [{
-            filepath,
-            content,
-            score: 1.0,
-        }, ...context.primaryChunks];
-    const tests = await chatWithContext(testPrompt, contextResults);
-    return tests;
-}
-/**
- * Detect test framework from file extension and content
- */
-function detectTestFramework(filepath, ext) {
-    // Check for existing test files
-    const testPatterns = [
-        { pattern: /\.test\./i, framework: 'jest' },
-        { pattern: /\.spec\./i, framework: 'jest' },
-        { pattern: /test_/i, framework: 'pytest' },
-        { pattern: /_test\./i, framework: 'go test' },
-    ];
-    for (const { pattern, framework } of testPatterns) {
-        if (pattern.test(filepath)) {
-            return framework;
-        }
-    }
-    // Default by extension
-    const frameworkMap = {
-        'ts': 'jest',
-        'tsx': 'jest',
-        'js': 'jest',
-        'jsx': 'jest',
-        'py': 'pytest',
-        'go': 'go test',
-        'java': 'junit',
-        'rb': 'rspec',
-    };
-    return frameworkMap[ext] || 'jest';
-}
-/**
- * Generate test file path
- */
-export function getTestFilePath(filepath, framework) {
-    const ext = filepath.split('.').pop() || '';
-    const baseName = filepath.replace(/\.[^/.]+$/, '');
-    const dir = dirname(filepath);
-    // Framework-specific naming
-    if (framework === 'pytest' || ext === 'py') {
-        return join(dir, `test_${basename(filepath)}`);
-    }
-    else if (framework === 'go test' || ext === 'go') {
-        return join(dir, `${baseName}_test.${ext}`);
-    }
-    else {
-        // Jest/Mocha style
-        return join(dir, `${baseName}.test.${ext}`);
-    }
-}
-/**
- * Save generated tests to file
- */
-export function saveTests(filepath, testContent) {
-    const fullPath = join(process.cwd(), filepath);
-    const dir = dirname(fullPath);
-    if (!existsSync(dir)) {
-        mkdirSync(dir, { recursive: true });
-    }
-    writeFileSync(fullPath, testContent, 'utf-8');
-}
-/**
- * Improve existing tests
- */
-export async function improveTests(testFilepath) {
-    const fullPath = join(process.cwd(), testFilepath);
-    if (!existsSync(fullPath)) {
-        throw new Error(`Test file not found: ${testFilepath}`);
-    }
-    const testContent = readFileSync(fullPath, 'utf-8');
-    // Find corresponding source file
-    const sourceFile = testFilepath
-        .replace(/\.test\./, '.')
-        .replace(/\.spec\./, '.')
-        .replace(/test_/, '')
-        .replace(/_test\./, '.');
-    let sourceContent = '';
-    try {
-        const sourcePath = join(process.cwd(), sourceFile);
-        if (existsSync(sourcePath)) {
-            sourceContent = readFileSync(sourcePath, 'utf-8');
-        }
-    }
-    catch {
-        // Source file might not exist
-    }
-    const improvePrompt = `Improve this test file with better coverage and edge cases:
-
-Test file: ${testFilepath}
-Current tests:
-\`\`\`
-${testContent}
-\`\`\`
-
-Source code:
-\`\`\`
-${sourceContent.substring(0, 1000)}
-\`\`\`
-
-Improve by:
-1. Adding missing test cases
-2. Adding edge case tests
-3. Improving assertions
-4. Adding error handling tests
-5. Improving test organization
-
-Provide the improved test file.`;
-    const contextResults = [{
-            filepath: testFilepath,
-            content: testContent,
-            score: 1.0,
-        }];
-    const improvedTests = await chatWithContext(improvePrompt, contextResults);
-    return improvedTests;
-}
-//# sourceMappingURL=testgen.js.map