codehere 0.2.2 → 0.3.0-rc.1

package/dist/application/agents/multi-agent-orchestrator.js

@@ -1,295 +0,0 @@
-/**
- * Application: Multi-Agent Orchestrator
- * Coordinates Planning, Execution, and Validation agents
- *
- * Based on enterprise architecture: Coordinator Pattern with specialized agents
- * Uses Command R+ as orchestrator (when available) or current AI service
- */
-import { PlanningAgent } from './planning-agent.js';
-import { ExecutionAgent } from './execution-agent.js';
-import { ValidationAgent } from './validation-agent.js';
-import { executionTracer } from '../../infrastructure/observability/execution-tracer.js';
-import { agentFeedbackManager } from '../../infrastructure/validation/agent-feedback.js';
-import { summaryAggregator } from '../../infrastructure/validation/summary-aggregator.js';
-import { findCodebaseRoot } from '../../domain/services/codebase-detector.js';
-export class MultiAgentOrchestrator {
-    aiService;
-    memoryStream;
-    memoryRepository;
-    toolExecutor;
-    verificationService;
-    sastScanner;
-    cwd;
-    planningAgent;
-    executionAgent;
-    validationAgent;
-    constructor(aiService, memoryStream, memoryRepository, toolExecutor, verificationService, sastScanner, cwd = process.cwd()) {
-        this.aiService = aiService;
-        this.memoryStream = memoryStream;
-        this.memoryRepository = memoryRepository;
-        this.toolExecutor = toolExecutor;
-        this.verificationService = verificationService;
-        this.sastScanner = sastScanner;
-        this.cwd = cwd;
-        // Initialize specialized agents
-        this.planningAgent = new PlanningAgent(aiService, memoryStream, memoryRepository, cwd);
-        this.executionAgent = new ExecutionAgent(aiService, toolExecutor, cwd);
-        this.validationAgent = new ValidationAgent(aiService, verificationService);
-    }
-    /**
-     * Orchestrate multi-agent workflow
-     * Coordinator Pattern: Plan → Execute → Validate → Feedback Loop
-     */
-    // TODO: Update task status during orchestration
-    // Update task.currentStep, task.totalSteps
-    // Update task.steps[].status
-    // Update task.status: RUNNING → COMPLETED/FAILED
-    // See: .internal/ARCHITECTURE.md (internal docs)
-    async orchestrate(request) {
-        const mode = request.mode || 'full';
-        // Create unified run context for entire orchestration
-        const codebaseInfo = findCodebaseRoot(this.cwd);
-        const unifiedRunId = executionTracer.startRun('multi-agent-orchestration', {
-            query: request.goal,
-            codebaseId: codebaseInfo?.codebaseId || codebaseInfo?.rootPath,
-        });
-        // Track summaries from each agent
-        const agentSummaries = [];
-        try {
-            // Phase 1: Planning (if needed)
-            let plan;
-            if (mode === 'full' || mode === 'plan-only') {
-                // Input validation
-                if (!request.goal || request.goal.trim().length === 0) {
-                    return {
-                        success: false,
-                        message: 'Goal cannot be empty',
-                    };
-                }
-                let planningResponse;
-                try {
-                    planningResponse = await this.planningAgent.createPlan({
-                        goal: request.goal,
-                        context: request.context,
-                    });
-                    plan = planningResponse.plan;
-                    // Capture planning summary
-                    if (planningResponse.validationSummary) {
-                        agentSummaries.push({
-                            agent: 'planning-agent',
-                            summary: planningResponse.validationSummary,
-                            runId: planningResponse.runId,
-                        });
-                    }
-                }
-                catch (error) {
-                    const errorMessage = error instanceof Error ? error.message : String(error);
-                    console.error('Orchestrator: Planning failed:', errorMessage);
-                    return {
-                        success: false,
-                        message: `Planning failed: ${errorMessage}`,
-                        plan: undefined,
-                    };
-                }
-                // Validate plan was generated
-                if (!plan) {
-                    return {
-                        success: false,
-                        message: 'Planning agent returned no plan',
-                        plan: undefined,
-                    };
-                }
-                if (!plan.subPlans || plan.subPlans.length === 0) {
-                    return {
-                        success: false,
-                        message: 'Planning agent returned plan with no sub-plans',
-                        plan,
-                    };
-                }
-                // If plan-only mode, return here
-                if (mode === 'plan-only') {
-                    // Aggregate summaries if available (filter out any undefined summaries)
-                    const validSummaries = agentSummaries.filter(s => s.summary !== undefined);
-                    const compositeSummary = validSummaries.length > 0
-                        ? summaryAggregator.mergeSummaries(validSummaries, unifiedRunId, 'multi-agent-orchestration')
-                        : undefined;
-                    executionTracer.endRun();
-                    return {
-                        plan,
-                        success: true,
-                        message: `Plan created with ${plan.subPlans.length} sub-plans (confidence: ${(planningResponse.confidence * 100).toFixed(0)}%)`,
-                        compositeSummary,
-                        unifiedRunId,
-                    };
-                }
-            }
-            if (!plan) {
-                return {
-                    success: false,
-                    message: 'No plan available for execution',
-                };
-            }
-            // Phase 2: Execution (if needed)
-            let execution;
-            if (mode === 'full' || mode === 'execute-only') {
-                execution = await this.executionAgent.execute({
-                    plan,
-                    context: request.context,
-                });
-                // Capture execution summary
-                if (execution.validationSummary) {
-                    agentSummaries.push({
-                        agent: 'execution-agent',
-                        summary: execution.validationSummary,
-                        runId: execution.runId,
-                    });
-                }
-                // If execute-only mode, return here
-                if (mode === 'execute-only') {
-                    // Aggregate summaries if available (filter out any undefined summaries)
-                    const validSummaries = agentSummaries.filter(s => s.summary !== undefined);
-                    const compositeSummary = validSummaries.length > 0
-                        ? summaryAggregator.mergeSummaries(validSummaries, unifiedRunId, 'multi-agent-orchestration')
-                        : undefined;
-                    executionTracer.endRun();
-                    return {
-                        plan,
-                        execution,
-                        success: execution.overallSuccess,
-                        message: `Execution completed: ${execution.completedSubPlans}/${execution.totalSubPlans} sub-plans`,
-                        compositeSummary,
-                        unifiedRunId,
-                    };
-                }
-            }
-            if (!execution) {
-                return {
-                    plan,
-                    success: false,
-                    message: 'Execution not performed',
-                };
-            }
-            // Phase 3: Validation
-            const filesModified = this.extractModifiedFiles(execution);
-            const validation = await this.validationAgent.validate({
-                plan,
-                executionResults: execution.results,
-                filesModified,
-            });
-            // Capture validation summary
-            if (validation.validationSummary) {
-                agentSummaries.push({
-                    agent: 'validation-agent',
-                    summary: validation.validationSummary,
-                    runId: validation.runId,
-                });
-            }
-            // Phase 4: Feedback Loop
-            // If validation fails, provide feedback for next iteration
-            let feedback;
-            if (!validation.success) {
-                feedback = this.generateFeedback(validation, execution);
-            }
-            // Aggregate all summaries into composite summary (filter out any undefined summaries)
-            const validSummaries = agentSummaries.filter(s => s.summary !== undefined);
-            const compositeSummary = validSummaries.length > 0
-                ? summaryAggregator.mergeSummaries(validSummaries, unifiedRunId, 'multi-agent-orchestration')
-                : undefined;
-            // Record in memory stream
-            await this.memoryStream.recordObservation(`Multi-agent orchestration completed for: "${request.goal}"`, {
-                goal: request.goal,
-                planId: plan.id,
-                executionSuccess: execution.overallSuccess,
-                validationSuccess: validation.success,
-                qualityScore: validation.qualityScore,
-            });
-            // End unified run context
-            executionTracer.endRun();
-            // Note: Feedback recording is handled by CLI commands with proper userAction
-            // This allows CLI to record feedback after review decision
-            return {
-                plan,
-                execution,
-                validation,
-                success: validation.success && execution.overallSuccess,
-                message: this.generateSuccessMessage(execution, validation),
-                feedback,
-                compositeSummary,
-                unifiedRunId,
-            };
-        }
-        catch (error) {
-            // End run context even on error
-            executionTracer.endRun();
-            // Record failure feedback
-            try {
-                agentFeedbackManager.recordFeedback({
-                    runId: unifiedRunId,
-                    agentName: 'multi-agent-orchestrator',
-                    operation: 'orchestrate',
-                    query: request.goal,
-                    outcome: 'failure',
-                    userAction: 'not_required', // Error case - no review flow
-                    errors: [error instanceof Error ? error.message : String(error)],
-                });
-            }
-            catch {
-                // Non-blocking
-            }
-            return {
-                success: false,
-                message: error instanceof Error ? error.message : String(error),
-                unifiedRunId,
-            };
-        }
-    }
-    /**
-     * Extract modified files from execution results
-     */
-    extractModifiedFiles(execution) {
-        const files = [];
-        for (const result of execution.results) {
-            if (result.result && typeof result.result === 'object') {
-                if ('filepath' in result.result) {
-                    files.push(result.result.filepath);
-                }
-            }
-        }
-        return [...new Set(files)]; // Deduplicate
-    }
-    /**
-     * Generate feedback for next iteration
-     */
-    generateFeedback(validation, execution) {
-        const feedback = [];
-        if (!validation.compilationSuccess) {
-            feedback.push(`Compilation errors: ${validation.compilationErrors?.slice(0, 2).join(', ')}`);
-        }
-        if (!validation.testsPassed) {
-            feedback.push('Tests are failing - review test results');
-        }
-        const failedSubPlans = execution.results.filter(r => !r.success);
-        if (failedSubPlans.length > 0) {
-            feedback.push(`${failedSubPlans.length} sub-plans failed: ${failedSubPlans.map(r => r.subPlanId).join(', ')}`);
-        }
-        if (validation.recommendations.length > 0) {
-            feedback.push(...validation.recommendations.slice(0, 3));
-        }
-        return feedback.join('. ');
-    }
-    /**
-     * Generate success message
-     */
-    generateSuccessMessage(execution, validation) {
-        if (validation.success && execution.overallSuccess) {
-            return `✅ Successfully completed: ${execution.completedSubPlans}/${execution.totalSubPlans} sub-plans executed, all tests passing (quality score: ${validation.qualityScore}/100)`;
-        }
-        else if (execution.overallSuccess) {
-            return `⚠️ Execution completed but validation issues: ${validation.recommendations.join(', ')}`;
-        }
-        else {
-            return `❌ Execution incomplete: ${execution.completedSubPlans}/${execution.totalSubPlans} sub-plans completed`;
-        }
-    }
-}
-//# sourceMappingURL=multi-agent-orchestrator.js.map