codehere 0.2.2 → 0.3.0-rc.1

package/dist/intelligent-retrieval.js

@@ -1,272 +0,0 @@
-/**
- * Intelligent Context Retrieval System
- * 10X effectiveness through smart context selection
- */
-import { parseFile, findCallers, findCallees, buildCallGraph } from './ast-parser.js';
-import { readFileSync, existsSync } from 'fs';
-import { join } from 'path';
-/**
- * Classify query intent
- */
-export function classifyQueryIntent(query) {
-    const lowerQuery = query.toLowerCase();
-    // Refactor intent
-    if (lowerQuery.includes('refactor') || lowerQuery.includes('rename') ||
-        lowerQuery.includes('extract') || lowerQuery.includes('move') ||
-        lowerQuery.includes('restructure')) {
-        return 'refactor';
-    }
-    // Debug intent
-    if (lowerQuery.includes('bug') || lowerQuery.includes('error') ||
-        lowerQuery.includes('fix') || lowerQuery.includes('issue') ||
-        lowerQuery.includes('problem') || lowerQuery.includes('wrong')) {
-        return 'debug';
-    }
-    // Implement intent
-    if (lowerQuery.includes('implement') || lowerQuery.includes('create') ||
-        lowerQuery.includes('add') || lowerQuery.includes('write') ||
-        lowerQuery.includes('build')) {
-        return 'implement';
-    }
-    // Find intent
-    if (lowerQuery.includes('find') || lowerQuery.includes('where') ||
-        lowerQuery.includes('locate') || lowerQuery.includes('search')) {
-        return 'find';
-    }
-    // Modify intent
-    if (lowerQuery.includes('modify') || lowerQuery.includes('change') ||
-        lowerQuery.includes('update') || lowerQuery.includes('edit')) {
-        return 'modify';
-    }
-    // Understand/Explain intent (default)
-    if (lowerQuery.includes('how') || lowerQuery.includes('what') ||
-        lowerQuery.includes('explain') || lowerQuery.includes('understand') ||
-        lowerQuery.includes('does') || lowerQuery.includes('work')) {
-        return 'explain';
-    }
-    return 'understand';
-}
-/**
- * Extract function/class names from query
- */
-export function extractSymbolNames(query) {
-    // Look for function/class names (capitalized words, camelCase, etc.)
-    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)
-    ];
-    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);
-}
-/**
- * Get intelligent context based on query intent and code structure
- */
-export async function getIntelligentContext(query, options = {}) {
-    const { maxTokens = 2000, baseDir = process.cwd() } = options;
-    // Classify query intent
-    const intent = classifyQueryIntent(query);
-    // Extract symbol names from query
-    const symbolNames = extractSymbolNames(query);
-    // Get initial search results (more than needed, we'll filter)
-    // Use searchSimilar directly - it's imported at top level now
-    const { searchSimilar } = await import('./search.js');
-    const initialResults = await searchSimilar(query, 30);
-    if (initialResults.length === 0) {
-        return {
-            primaryChunks: [],
-            relatedChunks: [],
-            codeStructure: { symbols: [], relationships: [] },
-            relevance: new Map(),
-            tokenEstimate: 0,
-        };
-    }
-    // Get unique filepaths
-    const filepaths = [...new Set(initialResults.map(r => r.filepath))];
-    // Parse files to get code structure
-    const analyses = [];
-    const filepathToAnalysis = new Map();
-    for (const filepath of filepaths.slice(0, 10)) { // Limit to 10 files for performance
-        const fullPath = join(baseDir, filepath);
-        if (existsSync(fullPath)) {
-            const analysis = parseFile(fullPath);
-            if (analysis) {
-                analyses.push(analysis);
-                filepathToAnalysis.set(filepath, analysis);
-            }
-        }
-    }
-    // Build call graph
-    const callGraph = buildCallGraph(analyses);
-    // Find relevant symbols
-    const relevantSymbols = new Set();
-    for (const symbolName of symbolNames) {
-        relevantSymbols.add(symbolName);
-        // Add callers and callees
-        const callers = findCallers(symbolName, callGraph);
-        const callees = findCallees(symbolName, callGraph);
-        callers.forEach(c => relevantSymbols.add(c));
-        callees.forEach(c => relevantSymbols.add(c));
-    }
-    // Calculate relevance scores
-    const relevance = new Map();
-    for (const result of initialResults) {
-        let score = result.score; // Base similarity score
-        // Boost if file contains relevant symbols
-        const analysis = filepathToAnalysis.get(result.filepath);
-        if (analysis) {
-            const hasRelevantSymbol = analysis.symbols.some(s => relevantSymbols.has(s.name) ||
-                symbolNames.some(sn => s.name.includes(sn) || sn.includes(s.name)));
-            if (hasRelevantSymbol) {
-                score *= 1.5; // Boost relevance
-            }
-            // Boost if chunk contains symbol names
-            const chunkHasSymbol = symbolNames.some(sn => result.content.toLowerCase().includes(sn.toLowerCase()));
-            if (chunkHasSymbol) {
-                score *= 1.3;
-            }
-        }
-        // Intent-based scoring
-        if (intent === 'refactor' || intent === 'modify') {
-            // Prefer chunks with function/class definitions
-            if (result.content.match(/(function|class|interface|type)\s+\w+/)) {
-                score *= 1.2;
-            }
-        }
-        if (intent === 'debug') {
-            // Prefer chunks with error handling, try-catch, etc.
-            if (result.content.match(/(try|catch|error|throw|if.*error)/i)) {
-                score *= 1.2;
-            }
-        }
-        relevance.set(result.filepath, score);
-    }
-    // Sort by relevance with source file priority
-    const sortedResults = initialResults.sort((a, b) => {
-        const scoreA = relevance.get(a.filepath) || a.score;
-        const scoreB = relevance.get(b.filepath) || b.score;
-        // Boost source files over documentation
-        const isSourceA = /\.(ts|tsx|js|jsx)$/.test(a.filepath) && !/\.(md|txt)$/.test(a.filepath);
-        const isSourceB = /\.(ts|tsx|js|jsx)$/.test(b.filepath) && !/\.(md|txt)$/.test(b.filepath);
-        if (isSourceA && !isSourceB)
-            return -1; // A is source, B is not
-        if (!isSourceA && isSourceB)
-            return 1; // B is source, A is not
-        return scoreB - scoreA;
-    });
-    // Filter and optimize chunks based on intent
-    const optimizedChunks = await optimizeChunks(sortedResults, intent, symbolNames, analyses, maxTokens);
-    // Split into primary and related
-    const primaryChunks = optimizedChunks.slice(0, Math.min(10, optimizedChunks.length));
-    const relatedChunks = optimizedChunks.slice(primaryChunks.length);
-    // Extract code structure info
-    const allSymbols = analyses.flatMap(a => a.symbols.map(s => ({
-        name: s.name,
-        filepath: a.filepath,
-        line: s.line,
-        kind: s.kind,
-    })));
-    const allRelationships = analyses.flatMap(a => a.relationships.map(r => ({
-        from: r.from,
-        to: r.to,
-        type: r.type,
-    })));
-    // Estimate tokens (rough: 1 token ≈ 4 characters)
-    const tokenEstimate = optimizedChunks.reduce((sum, chunk) => sum + Math.ceil(chunk.content.length / 4), 0);
-    return {
-        primaryChunks,
-        relatedChunks,
-        codeStructure: {
-            symbols: allSymbols,
-            relationships: allRelationships,
-        },
-        relevance,
-        tokenEstimate,
-    };
-}
-/**
- * Optimize chunks based on intent and token limit
- */
-async function optimizeChunks(results, intent, symbolNames, analyses, maxTokens) {
-    const optimized = [];
-    let currentTokens = 0;
-    // Create filepath to analysis map
-    const filepathToAnalysis = new Map();
-    for (const analysis of analyses) {
-        filepathToAnalysis.set(analysis.filepath, analysis);
-    }
-    for (const result of results) {
-        if (currentTokens >= maxTokens)
-            break;
-        const analysis = filepathToAnalysis.get(result.filepath);
-        // For function/class queries, extract just the relevant function/class
-        if (symbolNames.length > 0 && analysis) {
-            const relevantSymbol = analysis.symbols.find(s => symbolNames.some(sn => s.name === sn || s.name.includes(sn)));
-            if (relevantSymbol) {
-                // Extract just the function/class, not the entire chunk
-                const optimizedChunk = extractSymbolCode(result.filepath, relevantSymbol.line, relevantSymbol.kind);
-                if (optimizedChunk) {
-                    const chunkTokens = Math.ceil(optimizedChunk.length / 4);
-                    if (currentTokens + chunkTokens <= maxTokens) {
-                        optimized.push({
-                            ...result,
-                            content: optimizedChunk,
-                        });
-                        currentTokens += chunkTokens;
-                        continue;
-                    }
-                }
-            }
-        }
-        // Otherwise, use the chunk but truncate if needed
-        const chunkTokens = Math.ceil(result.content.length / 4);
-        const remainingTokens = maxTokens - currentTokens;
-        if (chunkTokens <= remainingTokens) {
-            optimized.push(result);
-            currentTokens += chunkTokens;
-        }
-        else if (remainingTokens > 100) {
-            // Truncate chunk to fit
-            const truncatedContent = result.content.substring(0, remainingTokens * 4);
-            optimized.push({
-                ...result,
-                content: truncatedContent + '...',
-            });
-            currentTokens = maxTokens;
-            break;
-        }
-    }
-    return optimized;
-}
-/**
- * Extract code for a specific symbol (function, class, etc.)
- */
-function extractSymbolCode(filepath, line, kind) {
-    try {
-        const content = readFileSync(filepath, 'utf-8');
-        const lines = content.split('\n');
-        // For now, return a window around the symbol
-        // TODO: Use AST to extract exact symbol boundaries
-        const start = Math.max(0, line - 5);
-        const end = Math.min(lines.length, line + 50);
-        return lines.slice(start, end).join('\n');
-    }
-    catch {
-        return null;
-    }
-}
-//# sourceMappingURL=intelligent-retrieval.js.map

package/dist/intent/classifier.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=classifier.js.map

package/dist/intent/context.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=context.js.map

package/dist/iterative-refinement.js

@@ -1,189 +0,0 @@
-/**
- * Iterative Refinement System
- * Feedback loop, self-correction, validation and retry, learn from mistakes
- */
-import { verifyTask } from './task-verification.js';
-import { generateDiff } from './chat.js';
-import { applyUnifiedDiff } from './edit.js';
-import { readFileSync, writeFileSync } from 'fs';
-import { container } from './application/services/dependency-container.js';
-/**
- * Refine task iteratively until it passes verification
- */
-export async function refineTask(filepath, instruction, requirements, maxIterations = 3) {
-    const corrections = [];
-    let currentContent = readFileSync(filepath, 'utf-8');
-    let iteration = 0;
-    while (iteration < maxIterations) {
-        iteration++;
-        // Generate diff
-        const diff = await generateDiff(currentContent, instruction, filepath);
-        // Apply diff
-        const modifiedContent = applyDiff(currentContent, diff);
-        // Create context
-        const context = {
-            filepath,
-            originalContent: readFileSync(filepath, 'utf-8'), // Keep original
-            modifiedContent,
-            diff,
-            instruction,
-            requirements,
-        };
-        // Temporarily write modified content
-        writeFileSync(filepath, modifiedContent, 'utf-8');
-        try {
-            // Verify
-            const result = await verifyTask(context);
-            if (result.success) {
-                // Success!
-                return {
-                    success: true,
-                    iterations: iteration,
-                    finalResult: result,
-                    corrections,
-                };
-            }
-            // Failed - extract errors and try to correct
-            const errors = result.errors.join('; ');
-            // Use Reflexion to generate learning
-            const reflexionUseCase = container.reflexionUseCase;
-            const reflexionResult = await reflexionUseCase.execute({
-                trajectory: {
-                    query: instruction,
-                    steps: corrections.map((c, i) => ({
-                        thought: { content: `Iteration ${i + 1}`, reasoning: c.correction },
-                        action: { type: 'tool', name: 'edit', parameters: {} },
-                        observation: { result: null, success: false, error: c.error },
-                        timestamp: new Date(),
-                    })),
-                    success: false,
-                },
-                reward: 0,
-                errors: result.errors,
-            });
-            const correction = await generateCorrection(currentContent, modifiedContent, instruction, errors, requirements);
-            corrections.push({
-                iteration,
-                error: errors,
-                correction: reflexionResult.reflection || correction,
-            });
-            // Update instruction with reflection-based learning
-            instruction = `${instruction}\n\nPrevious attempt failed with: ${errors}\nReflection: ${reflexionResult.reflection}\nCorrection: ${correction}`;
-            currentContent = modifiedContent; // Use current as base for next iteration
-        }
-        catch (error) {
-            // Error during verification - rollback and try again
-            writeFileSync(filepath, currentContent, 'utf-8');
-            const errorMsg = error instanceof Error ? error.message : String(error);
-            const correction = await generateCorrection(currentContent, modifiedContent, instruction, errorMsg, requirements);
-            corrections.push({
-                iteration,
-                error: errorMsg,
-                correction,
-            });
-            instruction = `${instruction}\n\nError: ${errorMsg}\nCorrection: ${correction}`;
-        }
-    }
-    // Max iterations reached - rollback
-    writeFileSync(filepath, currentContent, 'utf-8');
-    return {
-        success: false,
-        iterations: iteration,
-        finalResult: {
-            success: false,
-            compiled: false,
-            testsPassed: false,
-            requirementsMet: false,
-            errors: ['Max iterations reached'],
-            warnings: [],
-            rollbackRequired: true,
-        },
-        corrections,
-    };
-}
-/**
- * Apply diff to content (uses edit.ts function)
- */
-function applyDiff(originalContent, diff) {
-    return applyUnifiedDiff(originalContent, diff);
-}
-/**
- * Generate correction based on errors
- */
-async function generateCorrection(originalContent, modifiedContent, instruction, errors, requirements) {
-    // Use AI to generate correction
-    const { chatWithContext } = await import('./chat.js');
-    const prompt = `The following code modification failed with errors:
-
-Original instruction: ${instruction}
-${requirements ? `Requirements: ${requirements.join(', ')}` : ''}
-
-Errors encountered:
-${errors}
-
-Original code:
-\`\`\`
-${originalContent.substring(0, 1000)}
-\`\`\`
-
-Modified code (that failed):
-\`\`\`
-${modifiedContent.substring(0, 1000)}
-\`\`\`
-
-Please provide a brief correction strategy to fix these errors. Be specific about what needs to change.`;
-    const correction = await chatWithContext(prompt, [{
-            filepath: 'correction',
-            content: prompt,
-            score: 1.0,
-        }]);
-    return correction;
-}
-/**
- * Learn from corrections and improve
- */
-export function learnFromCorrections(corrections) {
-    const errorPatterns = new Map();
-    const correctionPatterns = new Map();
-    for (const correction of corrections) {
-        // Extract error patterns
-        const errorLower = correction.error.toLowerCase();
-        if (errorLower.includes('type'))
-            errorPatterns.set('type', (errorPatterns.get('type') || 0) + 1);
-        if (errorLower.includes('syntax'))
-            errorPatterns.set('syntax', (errorPatterns.get('syntax') || 0) + 1);
-        if (errorLower.includes('undefined'))
-            errorPatterns.set('undefined', (errorPatterns.get('undefined') || 0) + 1);
-        if (errorLower.includes('import'))
-            errorPatterns.set('import', (errorPatterns.get('import') || 0) + 1);
-        // Extract correction patterns
-        const correctionLower = correction.correction.toLowerCase();
-        if (correctionLower.includes('add'))
-            correctionPatterns.set('add', (correctionPatterns.get('add') || 0) + 1);
-        if (correctionLower.includes('remove'))
-            correctionPatterns.set('remove', (correctionPatterns.get('remove') || 0) + 1);
-        if (correctionLower.includes('change'))
-            correctionPatterns.set('change', (correctionPatterns.get('change') || 0) + 1);
-        if (correctionLower.includes('fix'))
-            correctionPatterns.set('fix', (correctionPatterns.get('fix') || 0) + 1);
-    }
-    const commonErrors = Array.from(errorPatterns.entries())
-        .sort((a, b) => b[1] - a[1])
-        .slice(0, 5)
-        .map(([error]) => error);
-    const improvementSuggestions = [];
-    if (errorPatterns.get('type') && errorPatterns.get('type') > 1) {
-        improvementSuggestions.push('Pay more attention to type definitions and type safety');
-    }
-    if (errorPatterns.get('syntax') && errorPatterns.get('syntax') > 1) {
-        improvementSuggestions.push('Double-check syntax before generating code');
-    }
-    if (errorPatterns.get('import') && errorPatterns.get('import') > 1) {
-        improvementSuggestions.push('Verify all imports are correct and available');
-    }
-    return {
-        commonErrors,
-        improvementSuggestions,
-    };
-}
-//# sourceMappingURL=iterative-refinement.js.map