codehere 0.2.2 → 0.3.0-rc.2

package/dist/application/agents/validation-agent.js

@@ -1,317 +0,0 @@
-/**
- * Application Agent: Validation Agent (Test Validator)
- * Specialized agent for updating/generating tests, executing test suite, analyzing results
- *
- * Based on enterprise architecture: Separate Validation Agent
- * Role: Validates execution results, runs tests, provides feedback
- */
-import { exec } from 'child_process';
-import { promisify } from 'util';
-import { existsSync, readFileSync } from 'fs';
-import { agentValidationHelper } from '../../infrastructure/validation/agent-validation-helper.js';
-import { findCodebaseRoot } from '../../domain/services/codebase-detector.js';
-const execAsync = promisify(exec);
-export class ValidationAgent {
-    aiService;
-    verificationService;
-    cwd = process.cwd();
-    constructor(aiService, verificationService, cwd) {
-        this.aiService = aiService;
-        this.verificationService = verificationService;
-        if (cwd) {
-            this.cwd = cwd;
-        }
-    }
-    /**
-     * Validate execution results
-     * Runs tests, checks compilation, analyzes quality
-     */
-    async validate(request) {
-        const { plan, executionResults, filesModified = [] } = request;
-        // Start validation context
-        const codebaseInfo = findCodebaseRoot(this.cwd);
-        const validationContext = agentValidationHelper.startAgentOperation('validation-agent', 'validate', {
-            query: plan.goal,
-            codebaseId: codebaseInfo?.codebaseId,
-        });
-        try {
-            // Track validation checks
-            const validationChecks = [];
-            const errors = [];
-            const warnings = [];
-            // 1. Check compilation for modified files
-            const compilationResult = await this.checkCompilation(filesModified);
-            // Record compilation check
-            validationChecks.push({
-                check: 'Compilation',
-                passed: compilationResult.success,
-                message: compilationResult.success
-                    ? 'All files compile successfully'
-                    : `${compilationResult.errors.length} compilation error(s)`,
-                critical: true,
-            });
-            if (!compilationResult.success && compilationResult.errors.length > 0) {
-                errors.push(...compilationResult.errors);
-            }
-            // Trace compilation check
-            agentValidationHelper.trace({
-                operationType: 'code_analysis',
-                operationName: 'compile_check',
-                input: { files: filesModified },
-                output: compilationResult,
-                error: compilationResult.success ? undefined : new Error('Compilation failed'),
-                metadata: {
-                    filesChecked: filesModified.length,
-                    errors: compilationResult.errors.length,
-                },
-            });
-            // 2. Run test suite
-            const testResult = await this.runTests();
-            // Record test check
-            const testsPassed = testResult.testsPassed;
-            if (testResult.testResults) {
-                validationChecks.push({
-                    check: 'Tests',
-                    passed: testsPassed,
-                    message: testsPassed
-                        ? `All ${testResult.testResults.total} tests passed`
-                        : `${testResult.testResults.failed} of ${testResult.testResults.total} tests failed`,
-                    critical: true,
-                });
-                if (testResult.testResults.failures) {
-                    testResult.testResults.failures.forEach(failure => {
-                        errors.push(`Test failure: ${failure.test} - ${failure.error}`);
-                    });
-                }
-            }
-            else {
-                validationChecks.push({
-                    check: 'Tests',
-                    passed: true,
-                    message: 'No tests to run',
-                });
-            }
-            // Trace test execution
-            agentValidationHelper.trace({
-                operationType: 'code_analysis',
-                operationName: 'test_execution',
-                input: {},
-                output: testResult,
-                metadata: {
-                    testsTotal: testResult.testResults?.total,
-                    testsPassed: testResult.testResults?.passed,
-                    testsFailed: testResult.testResults?.failed,
-                },
-            });
-            // 3. Analyze code quality
-            const qualityAnalysis = await this.analyzeQuality(plan, executionResults);
-            // Calculate quality score for validation check
-            const qualityScore = this.calculateQualityScore(compilationResult, testResult, qualityAnalysis);
-            // Record quality check
-            validationChecks.push({
-                check: 'Code Quality',
-                passed: qualityScore >= 70, // Threshold
-                message: `Quality score: ${qualityScore}/100`,
-                critical: false,
-            });
-            if (qualityAnalysis.errorRate > 0.3) {
-                warnings.push(`High error rate: ${(qualityAnalysis.errorRate * 100).toFixed(1)}%`);
-            }
-            // 4. Generate recommendations
-            const recommendations = await this.generateRecommendations(compilationResult, testResult, qualityAnalysis);
-            const success = compilationResult.success && testResult.testsPassed;
-            // Complete validation
-            const validationResult = await agentValidationHelper.completeAgentOperation(validationContext, {
-                success,
-                testsPassed: testResult.testsPassed,
-                compilationSuccess: compilationResult.success,
-                testResults: testResult.testResults,
-                compilationErrors: compilationResult.errors,
-                recommendations,
-                qualityScore,
-            }, {
-                outcome: success ? 'success' : 'failure',
-                validationChecks,
-                errors: errors.length > 0 ? errors : undefined,
-                warnings: warnings.length > 0 ? warnings : undefined,
-                metrics: {
-                    filesAnalyzed: filesModified.length,
-                },
-                additionalContext: {
-                    query: plan.goal,
-                    codebaseId: codebaseInfo?.codebaseId,
-                    qualityScore,
-                    testResults: testResult.testResults,
-                },
-            }).catch(error => {
-                // Non-blocking
-                console.warn('[ValidationAgent] Validation recording failed (non-critical):', error);
-                return null;
-            });
-            return {
-                success,
-                testsPassed: testResult.testsPassed,
-                compilationSuccess: compilationResult.success,
-                testResults: testResult.testResults,
-                compilationErrors: compilationResult.errors,
-                recommendations,
-                qualityScore,
-                ...(validationResult ? {
-                    validationSummary: validationResult.summary,
-                    feedbackId: validationResult.feedbackId || undefined,
-                    runId: validationResult.runId || undefined,
-                } : {}),
-            };
-        }
-        catch (error) {
-            // Record failure
-            await agentValidationHelper.completeAgentOperation(validationContext, null, {
-                outcome: 'failure',
-                errors: [error instanceof Error ? error.message : String(error)],
-                additionalContext: {
-                    query: plan.goal,
-                    codebaseId: codebaseInfo?.codebaseId,
-                },
-            }).catch(() => {
-                // Non-blocking
-            });
-            throw error;
-        }
-    }
-    /**
-     * Check compilation for modified files
-     */
-    async checkCompilation(filesModified) {
-        if (!this.verificationService || filesModified.length === 0) {
-            return { success: true, errors: [] };
-        }
-        const errors = [];
-        for (const filepath of filesModified) {
-            try {
-                // Use verification service verify method (includes compilation check)
-                const result = await this.verificationService.verify(filepath);
-                if (!result.compiled || !result.success) {
-                    errors.push(...(result.errors || []));
-                }
-            }
-            catch (error) {
-                errors.push(error instanceof Error ? error.message : String(error));
-            }
-        }
-        return {
-            success: errors.length === 0,
-            errors,
-        };
-    }
-    /**
-     * Run test suite
-     */
-    async runTests() {
-        try {
-            // Detect test framework
-            const packageJsonPath = 'package.json';
-            if (!existsSync(packageJsonPath)) {
-                return { testsPassed: true }; // No tests to run
-            }
-            const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
-            const testScript = packageJson.scripts?.test;
-            if (!testScript) {
-                return { testsPassed: true }; // No test script
-            }
-            // Run tests (with timeout)
-            const { stdout, stderr } = await Promise.race([
-                execAsync(testScript, { timeout: 60000 }),
-                new Promise((_, reject) => {
-                    setTimeout(() => reject(new Error('Test timeout')), 60000);
-                }),
-            ]);
-            // Parse test results (simplified - would need framework-specific parsing)
-            const passed = (stdout.match(/✓|passed|PASS/g) || []).length;
-            const failed = (stdout.match(/✗|failed|FAIL/g) || []).length;
-            const total = passed + failed;
-            return {
-                testsPassed: failed === 0,
-                testResults: {
-                    passed,
-                    failed,
-                    total,
-                    failures: [], // Would parse from output
-                },
-            };
-        }
-        catch (error) {
-            // Test execution failed
-            return {
-                testsPassed: false,
-                testResults: {
-                    passed: 0,
-                    failed: 0,
-                    total: 0,
-                    failures: [
-                        {
-                            test: 'Test suite execution',
-                            error: error instanceof Error ? error.message : String(error),
-                        },
-                    ],
-                },
-            };
-        }
-    }
-    /**
-     * Analyze code quality
-     */
-    async analyzeQuality(plan, executionResults) {
-        const successful = executionResults.filter(r => r.success).length;
-        const total = executionResults.length;
-        const successRate = total > 0 ? successful / total : 1.0;
-        const durations = executionResults.map(r => r.duration);
-        const averageDuration = durations.length > 0
-            ? durations.reduce((a, b) => a + b, 0) / durations.length
-            : 0;
-        const errors = executionResults.filter(r => !r.success).length;
-        const errorRate = total > 0 ? errors / total : 0;
-        return {
-            successRate,
-            averageDuration,
-            errorRate,
-        };
-    }
-    /**
-     * Generate recommendations based on validation results
-     */
-    async generateRecommendations(compilationResult, testResult, qualityAnalysis) {
-        const recommendations = [];
-        if (!compilationResult.success) {
-            recommendations.push(`Fix compilation errors: ${compilationResult.errors.slice(0, 3).join(', ')}`);
-        }
-        if (!testResult.testsPassed) {
-            recommendations.push('Review and fix failing tests');
-        }
-        if (qualityAnalysis.errorRate > 0.3) {
-            recommendations.push('High error rate detected - review execution strategy');
-        }
-        if (qualityAnalysis.averageDuration > 10000) {
-            recommendations.push('Execution duration is high - consider optimization');
-        }
-        if (recommendations.length === 0) {
-            recommendations.push('All validations passed - code quality is good');
-        }
-        return recommendations;
-    }
-    /**
-     * Calculate overall quality score
-     */
-    calculateQualityScore(compilationResult, testResult, qualityAnalysis) {
-        let score = 100;
-        if (!compilationResult.success) {
-            score -= 30;
-        }
-        if (!testResult.testsPassed) {
-            score -= 30;
-        }
-        score -= qualityAnalysis.errorRate * 20;
-        score = Math.max(0, Math.min(100, score));
-        return Math.round(score);
-    }
-}
-//# sourceMappingURL=validation-agent.js.map

package/dist/application/architectures/plan-and-act.js

@@ -1,242 +0,0 @@
-/**
- * Application: Plan-and-Act Architecture
- * Separates strategic planning from tactical execution
- *
- * Based on research: Plan-and-Act: Improving Planning of Agents for Long-Horizon Tasks
- * - Planner: High-accuracy reasoning (reserved for high-leverage tasks)
- * - Executor: High-throughput, cost-efficient (for token-intensive execution)
- * - Impact: 75% cost reduction, better accuracy for critical decisions
- *
- * Research findings:
- * - GPT-5 highest accuracy config is 4x slower than GPT-4.1
- * - Latency proportional to cost (reasoning tokens are expensive)
- * - Strategic allocation maximizes throughput while controlling cost
- */
-/**
- * Planner Module
- * Uses high-accuracy reasoning models for strategic planning
- * Reserved for high-leverage tasks: strategizing, planning, ambiguity resolution
- */
-export class PlannerModule {
-    plannerAIService;
-    context;
-    constructor(plannerAIService, // High-accuracy model (GPT-5, DeepSeek R1)
-    context = {}) {
-        this.plannerAIService = plannerAIService;
-        this.context = context;
-    }
-    /**
-     * Generate strategic plan from goal
-     */
-    async plan(goal, constraints) {
-        // Use high-accuracy model for planning
-        const planPrompt = this.buildPlanningPrompt(goal, constraints);
-        const response = await this.plannerAIService.chat(planPrompt, [], []);
-        const plan = this.parsePlan(response);
-        // Assess complexity and allocate resources
-        plan.estimatedComplexity = this.assessComplexity(plan);
-        return plan;
-    }
-    /**
-     * Refine plan based on execution feedback
-     */
-    async refinePlan(originalPlan, executionResults) {
-        // Analyze failures and update plan
-        const failures = executionResults.filter(r => !r.success);
-        if (failures.length === 0) {
-            return originalPlan; // Plan is working
-        }
-        // Use planner to adapt strategy
-        const refinementPrompt = this.buildRefinementPrompt(originalPlan, failures);
-        const refinedResponse = await this.plannerAIService.chat(refinementPrompt, [], []);
-        return this.parsePlan(refinedResponse);
-    }
-    buildPlanningPrompt(goal, constraints) {
-        return `You are a strategic planner. Create a detailed plan to achieve this goal:
-    
-Goal: ${goal}
-
-${constraints ? `Constraints: ${JSON.stringify(constraints)}` : ''}
-
-Provide a structured plan with:
-1. High-level strategy
-2. Sequential steps with dependencies
-3. Resource requirements
-4. Risk assessment
-
-Format as JSON with steps array.`;
-    }
-    buildRefinementPrompt(plan, failures) {
-        return `The following plan encountered failures. Refine the strategy:
-    
-Original Plan: ${JSON.stringify(plan)}
-Failures: ${JSON.stringify(failures)}
-
-Provide an improved plan that addresses these failures.`;
-    }
-    parsePlan(response) {
-        // Parse JSON plan from LLM response
-        try {
-            const parsed = JSON.parse(response);
-            return {
-                goal: parsed.goal || '',
-                steps: parsed.steps || [],
-                context: parsed.context || {},
-                estimatedComplexity: 'medium',
-            };
-        }
-        catch {
-            // Fallback: create simple plan
-            return {
-                goal: '',
-                steps: [],
-                context: {},
-                estimatedComplexity: 'medium',
-            };
-        }
-    }
-    assessComplexity(plan) {
-        const stepCount = plan.steps.length;
-        const dependencyCount = plan.steps.reduce((sum, step) => sum + (step.dependencies?.length || 0), 0);
-        if (stepCount > 10 || dependencyCount > 5) {
-            return 'high';
-        }
-        if (stepCount > 5 || dependencyCount > 2) {
-            return 'medium';
-        }
-        return 'low';
-    }
-}
-/**
- * Executor Module
- * Uses high-throughput, cost-efficient models for execution
- * Handles token-intensive, low-leverage tasks
- */
-export class ExecutorModule {
-    executorAIService;
-    toolExecutor;
-    constructor(executorAIService, // High-throughput model (GPT-4, optimized models)
-    toolExecutor) {
-        this.executorAIService = executorAIService;
-        this.toolExecutor = toolExecutor;
-    }
-    /**
-     * Execute a single plan step
-     */
-    async executeStep(step, context) {
-        const startTime = Date.now();
-        try {
-            // For high-accuracy steps, delegate back to planner
-            if (step.requiresHighAccuracy) {
-                // This shouldn't happen - executor only gets low-leverage steps
-                throw new Error('High-accuracy steps should use Planner, not Executor');
-            }
-            // Execute action using tools
-            const output = await this.toolExecutor.execute(step.action, step.parameters, context);
-            const latency = Date.now() - startTime;
-            return {
-                stepId: step.id,
-                success: true,
-                output,
-                cost: step.estimatedCost,
-                latency,
-            };
-        }
-        catch (error) {
-            const latency = Date.now() - startTime;
-            return {
-                stepId: step.id,
-                success: false,
-                output: null,
-                error: error instanceof Error ? error.message : String(error),
-                cost: step.estimatedCost,
-                latency,
-            };
-        }
-    }
-    /**
-     * Execute multiple steps in parallel (where possible)
-     */
-    async executeSteps(steps, context) {
-        // Identify parallelizable steps (no dependencies)
-        const independentSteps = steps.filter(step => !step.dependencies || step.dependencies.length === 0);
-        // Execute independent steps in parallel
-        const parallelResults = await Promise.all(independentSteps.map(step => this.executeStep(step, context)));
-        // Execute dependent steps sequentially
-        const dependentSteps = steps.filter(step => step.dependencies && step.dependencies.length > 0);
-        const sequentialResults = [];
-        for (const step of dependentSteps) {
-            // Wait for dependencies
-            const dependencyResults = sequentialResults.filter(r => step.dependencies.includes(r.stepId));
-            // Check if all dependencies succeeded
-            const allDependenciesSucceeded = dependencyResults.every(r => r.success);
-            if (!allDependenciesSucceeded) {
-                sequentialResults.push({
-                    stepId: step.id,
-                    success: false,
-                    output: null,
-                    error: 'Dependency failed',
-                    cost: step.estimatedCost,
-                    latency: 0,
-                });
-                continue;
-            }
-            // Execute step
-            const result = await this.executeStep(step, context);
-            sequentialResults.push(result);
-        }
-        return [...parallelResults, ...sequentialResults];
-    }
-}
-/**
- * Plan-and-Act Orchestrator
- * Coordinates Planner and Executor modules
- */
-export class PlanAndActOrchestrator {
-    planner;
-    executor;
-    maxRefinements;
-    constructor(planner, executor, maxRefinements = 3) {
-        this.planner = planner;
-        this.executor = executor;
-        this.maxRefinements = maxRefinements;
-    }
-    /**
-     * Execute goal using Plan-and-Act architecture
-     */
-    async execute(goal, constraints) {
-        // 1. Plan: Use high-accuracy model for strategy
-        let plan = await this.planner.plan(goal, constraints);
-        // 2. Separate steps by leverage
-        const highLeverageSteps = plan.steps.filter(s => s.requiresHighAccuracy);
-        const lowLeverageSteps = plan.steps.filter(s => !s.requiresHighAccuracy);
-        // 3. Execute high-leverage steps with planner (if any)
-        // Note: In practice, high-leverage steps might need planner assistance
-        // For now, we assume all steps can be executed by executor
-        // 4. Execute low-leverage steps with executor (parallelized)
-        let executionResults = [];
-        let refinementCount = 0;
-        while (refinementCount < this.maxRefinements) {
-            // Execute all steps
-            const results = await this.executor.executeSteps(plan.steps, plan.context);
-            executionResults = results;
-            // Check if all succeeded
-            const allSucceeded = results.every(r => r.success);
-            if (allSucceeded) {
-                break;
-            }
-            // Refine plan based on failures
-            plan = await this.planner.refinePlan(plan, results);
-            refinementCount++;
-        }
-        // 5. Return final results
-        return {
-            plan,
-            results: executionResults,
-            success: executionResults.every(r => r.success),
-            totalCost: executionResults.reduce((sum, r) => sum + r.cost, 0),
-            totalLatency: executionResults.reduce((sum, r) => sum + r.latency, 0),
-        };
-    }
-}
-//# sourceMappingURL=plan-and-act.js.map

package/dist/application/index.js

@@ -1,12 +0,0 @@
-/**
- * Application Layer - Public Exports
- */
-export * from './use-cases/ask-question-use-case.js';
-export * from './use-cases/index-codebase-use-case.js';
-export * from './use-cases/react-orchestration-use-case.js';
-export * from './use-cases/reflexion-use-case.js';
-export * from './use-cases/edit-file-use-case.js';
-export * from './services/dependency-container.js';
-export * from './services/agent-factory.js';
-export * from './services/tool-executor-service.js';
-//# sourceMappingURL=index.js.map

package/dist/application/services/agent-factory.js

@@ -1,28 +0,0 @@
-/**
- * Agent Factory
- * Creates and wires up agents with clean architecture
- */
-import { AgentRegistry } from '../../agents/base.js';
-import { ModelDrivenOrchestratorAgent } from '../../agents/orchestrator-model-driven.js';
-import { ReActOrchestratorAgent } from '../../agents/react-orchestrator-agent.js';
-export function createAgentRegistry(useReAct = true) {
-    const registry = new AgentRegistry();
-    // Create orchestrator (ReAct or Model-Driven)
-    if (useReAct) {
-        const reactOrchestrator = new ReActOrchestratorAgent();
-        registry.register(reactOrchestrator);
-    }
-    else {
-        const modelOrchestrator = new ModelDrivenOrchestratorAgent(registry);
-        registry.register(modelOrchestrator);
-    }
-    // TODO: Register other agents as they're created
-    // registry.register(new EditorAgent());
-    // registry.register(new SearchAgent());
-    // etc.
-    return registry;
-}
-export function getDefaultOrchestrator() {
-    return new ReActOrchestratorAgent();
-}
-//# sourceMappingURL=agent-factory.js.map