0xray 4.0.12 → 4.0.13

package/dist/orchestrator/orchestrator.js

@@ -1,648 +0,0 @@
-/**
- * Orchestrator Agent
- *
- * Coordinates multi-step tasks and delegates to specialized subagents.
- * Implements Sisyphus integration for relentless execution.
- *
- * @since 2026-01-07
- */
-import { enhancedMultiAgentOrchestrator } from "./enhanced-multi-agent-orchestrator.js";
-import { featuresConfigLoader } from "../core/features-config.js";
-import { frameworkLogger } from "../core/framework-logger.js";
-import { routingOutcomeTracker } from "../delegation/analytics/outcome-tracker.js";
-import { patternPerformanceTracker } from "../analytics/pattern-performance-tracker.js";
-import { VotingCoordinator } from "../delegation/voting-coordinator.js";
-import { getAgentExpertiseLevel } from "../delegation/agent-expertise.js";
-import { XrayStateManager } from "../state/state-manager.js";
-export class XrayOrchestrator {
-    config;
-    activeTasks = new Map();
-    taskToAgentMap = new Map();
-    votingCoordinator;
-    constructor(config = {}) {
-        const loadedConfig = this.loadOrchestratorConfig();
-        this.config = {
-            maxConcurrentTasks: loadedConfig?.maxConcurrentTasks ?? 5,
-            taskTimeout: 300000,
-            conflictResolutionStrategy: loadedConfig?.conflictResolutionStrategy ?? "majority_vote",
-            ...config,
-        };
-        this.votingCoordinator = new VotingCoordinator(new XrayStateManager());
-    }
-    /**
-     * Load orchestrator config from features.json
-     */
-    loadOrchestratorConfig() {
-        try {
-            const features = featuresConfigLoader.loadConfig();
-            if (features.multi_agent_orchestration) {
-                const ma = features.multi_agent_orchestration;
-                return {
-                    maxConcurrentTasks: ma.max_concurrent_agents,
-                    conflictResolutionStrategy: this.mapConflictResolution(ma.conflict_resolution),
-                };
-            }
-        }
-        catch (e) {
-            // Silently continue with defaults
-        }
-        return null;
-    }
-    /**
-     * Map config key to enum value
-     */
-    mapConflictResolution(strategy) {
-        switch (strategy) {
-            case "expert-priority": return "expert_priority";
-            case "consensus": return "consensus";
-            case "majority-vote":
-            case "majority_vote":
-            default: return "majority_vote";
-        }
-    }
-    /**
-     * Execute a complex multi-step task
-     */
-    async executeComplexTask(description, tasks, sessionId) {
-        const jobId = `complex-task-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
-        // Task execution start - operational logging, keep for monitoring
-        const results = [];
-        const taskMap = new Map();
-        // Build task dependency graph
-        tasks.forEach((task) => taskMap.set(task.id, task));
-        // Execute tasks in dependency order
-        const completedTasks = new Set();
-        while (completedTasks.size < tasks.length) {
-            const executableTasks = tasks.filter((task) => !completedTasks.has(task.id) &&
-                (!task.dependencies ||
-                    task.dependencies.every((dep) => completedTasks.has(dep))));
-            if (executableTasks.length === 0) {
-                throw new Error("Circular dependency detected or no executable tasks");
-            }
-            // Execute tasks concurrently up to maxConcurrentTasks
-            const batchSize = Math.min(executableTasks.length, this.config.maxConcurrentTasks);
-            const batchTasks = executableTasks.slice(0, batchSize);
-            const batchPromises = batchTasks.map((task) => this.executeSingleTask(task, jobId));
-            try {
-                const batchResults = await Promise.all(batchPromises);
-                // Add all results - conflict resolution will be applied in consolidateWorkflowResults
-                results.push(...batchResults);
-                // Mark tasks as completed
-                batchTasks.forEach((task) => completedTasks.add(task.id));
-            }
-            catch (error) {
-                await frameworkLogger.log("orchestrator", "batch-execution-failed", "error", { error: String(error) });
-                throw error;
-            }
-        }
-        // Task completion logging removed - use frameworkLogger instead
-        // Final conflict resolution pass
-        const finalConflictResult = this.detectAndResolveConflicts(results);
-        if (finalConflictResult.conflictsFound > 0) {
-            await frameworkLogger.log("orchestrator", "final-conflicts-resolved", "info", {
-                conflictsFound: finalConflictResult.conflictsFound,
-                resolutionStrategy: this.config.conflictResolutionStrategy,
-                totalResults: results.length,
-            });
-            return finalConflictResult.resolvedResults;
-        }
-        return results;
-    }
-    /**
-     * Execute a single task by delegating to appropriate subagent
-     */
-    async executeSingleTask(task, jobId) {
-        const startTime = Date.now();
-        try {
-            // Delegate to subagent (this would integrate with the actual agent system)
-            const result = await this.delegateToSubagent(task);
-            const duration = Date.now() - startTime;
-            // Track routing outcome for analytics
-            const resultObj = result;
-            const success = !resultObj?.error;
-            routingOutcomeTracker.recordOutcome({
-                taskId: task.id,
-                taskDescription: task.description,
-                routedAgent: task.subagentType,
-                routedSkill: task.subagentType.replace("-", "_") + "_skill",
-                confidence: 0.8,
-                success,
-            });
-            // Update pattern performance tracker for learning
-            patternPerformanceTracker.trackPatternPerformance(`${task.subagentType}:${task.subagentType.replace("-", "_")}_skill`, { success, confidence: 0.8 });
-            await frameworkLogger.log("orchestrator", "complex-task-completed", "success", {
-                jobId,
-                taskExecuted: true,
-                taskId: task.id,
-                taskType: task.subagentType,
-                duration,
-                success,
-            });
-            // Execute post-processors for agent task completion logging
-            try {
-                // Get processor manager from global state
-                const globalStateManager = globalThis.xrayStateManager;
-                frameworkLogger.log("orchestrator", "global-state-check", "debug", {
-                    jobId,
-                    exists: !!globalStateManager,
-                    type: typeof globalStateManager,
-                    hasGet: typeof globalStateManager?.get === "function",
-                });
-                const processorManager = globalStateManager?.get("processor:manager");
-                frameworkLogger.log("orchestrator", "processor-manager-check", "debug", {
-                    jobId,
-                    retrieved: !!processorManager,
-                    type: typeof processorManager,
-                    hasExecutePostProcessors: typeof processorManager?.executePostProcessors === "function",
-                });
-                if (processorManager) {
-                    // Create agent task context for logging with metadata
-                    const agentContext = {
-                        agentName: task.subagentType,
-                        task: task.description,
-                        startTime,
-                        endTime: Date.now(),
-                        success: true,
-                        result,
-                        capabilities: [task.subagentType],
-                        metadata: {
-                            isAgentTask: true,
-                            agentType: task.subagentType,
-                            taskId: task.id,
-                            hook: "agent_execution",
-                            timestamp: Date.now(),
-                        },
-                    };
-                    await processorManager.executePostProcessors(`agent-${task.subagentType}`, agentContext, []);
-                }
-            }
-            catch (processorError) {
-                await frameworkLogger.log("orchestrator", "post-processor-execution-failed", "warning", { taskId: task.id, error: String(processorError) });
-            }
-            return {
-                success: true,
-                result: { ...result, id: task.id },
-                duration,
-            };
-        }
-        catch (error) {
-            const duration = Date.now() - startTime;
-            await frameworkLogger.log("orchestrator", "task-execution-failed", "error", { taskId: task.id, duration, error: String(error) });
-            // Execute post-processors even on failure for error logging
-            try {
-                const globalStateManager = globalThis.xrayStateManager;
-                const processorManager = globalStateManager?.get("processor:manager");
-                if (processorManager) {
-                    const agentContext = {
-                        agentName: task.subagentType,
-                        task: task.description,
-                        startTime,
-                        endTime: Date.now(),
-                        success: false,
-                        result: null,
-                        capabilities: [task.subagentType],
-                        error: error instanceof Error ? error.message : String(error),
-                        metadata: {
-                            isAgentTask: true,
-                            agentType: task.subagentType,
-                            taskId: task.id,
-                            hook: "agent_execution_failed",
-                            timestamp: Date.now(),
-                            failed: true,
-                        },
-                    };
-                    await processorManager.executePostProcessors(`agent-${task.subagentType}-failed`, agentContext, []);
-                }
-            }
-            catch (processorError) {
-                await frameworkLogger.log("orchestrator", "post-processor-execution-failed-on-error", "warning", { taskId: task.id, error: String(processorError) });
-            }
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-                duration,
-            };
-        }
-    }
-    /**
-     * Auto-healing orchestration for test failures - coordinates multi-agent response
-     */
-    async orchestrateTestAutoHealing(failureContext, sessionId) {
-        const jobId = `test-healing-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
-        const startTime = Date.now();
-        try {
-            // Step 1: Analyze failure patterns and create healing strategy
-            const healingStrategy = await this.analyzeTestFailurePatterns(failureContext);
-            // Step 2: Create coordinated multi-agent tasks
-            const healingTasks = this.createHealingTaskDefinitions(healingStrategy, failureContext);
-            // Step 3: Execute healing tasks through enhanced orchestration
-            const taskResults = await this.executeComplexTask(`Auto-healing test failures: ${failureContext.failedTests.length} issues detected`, healingTasks, sessionId);
-            // Step 4: Consolidate results and measure improvements
-            const consolidationResult = await this.consolidateHealingResults(taskResults, failureContext);
-            const duration = Date.now() - startTime;
-            // Auto-healing completion - operational, keep
-            return {
-                success: consolidationResult.success,
-                healingResult: consolidationResult,
-                agentCoordination: healingStrategy.agentsNeeded,
-                performanceImprovement: consolidationResult.performanceImprovement,
-            };
-        }
-        catch (error) {
-            await frameworkLogger.log("orchestrator", "auto-healing-orchestration-failed", "error", { error: String(error) });
-            return {
-                success: false,
-                healingResult: {
-                    error: error instanceof Error ? error.message : String(error),
-                },
-                agentCoordination: [],
-                performanceImprovement: 0,
-            };
-        }
-    }
-    /**
-     * Analyze test failure patterns to determine healing strategy
-     */
-    async analyzeTestFailurePatterns(failureContext) {
-        const totalIssues = failureContext.failedTests.length +
-            failureContext.timeoutIssues.length +
-            failureContext.performanceIssues.length +
-            failureContext.flakyTests.length;
-        // Calculate complexity score (0-100)
-        const complexityScore = Math.min(100, failureContext.timeoutIssues.length * 20 +
-            failureContext.performanceIssues.length * 15 +
-            failureContext.flakyTests.length * 25 +
-            failureContext.failedTests.length * 5 +
-            (failureContext.testExecutionTime > 600000 ? 25 : 0));
-        // Determine priority and approach
-        let priorityLevel;
-        let agentsNeeded = [];
-        let healingApproach;
-        if (complexityScore < 25) {
-            priorityLevel = "low";
-            agentsNeeded = ["testing-lead"];
-            healingApproach = "simple";
-        }
-        else if (complexityScore < 50) {
-            priorityLevel = "medium";
-            agentsNeeded = ["testing-lead", "refactorer"];
-            healingApproach = "coordinated";
-        }
-        else if (complexityScore < 75) {
-            priorityLevel = "high";
-            agentsNeeded = ["testing-lead", "refactorer", "bug-triage-specialist"];
-            healingApproach = "coordinated";
-        }
-        else {
-            priorityLevel = "critical";
-            agentsNeeded = [
-                "orchestrator",
-                "architect",
-                "security-auditor",
-                "testing-lead",
-                "refactorer",
-                "bug-triage-specialist",
-            ];
-            healingApproach = "enterprise";
-        }
-        const estimatedTime = totalIssues * (complexityScore > 50 ? 15 : 5); // minutes
-        return {
-            priorityLevel,
-            agentsNeeded,
-            estimatedTime,
-            complexityScore,
-            healingApproach,
-        };
-    }
-    /**
-     * Create task definitions for healing orchestration
-     */
-    createHealingTaskDefinitions(strategy, failureContext) {
-        const tasks = [];
-        // Analysis task (always first)
-        tasks.push({
-            id: "failure-analysis",
-            description: "Analyze test failure patterns and root causes",
-            subagentType: "bug-triage-specialist",
-            priority: "high",
-        });
-        // Timeout optimization tasks
-        if (failureContext.timeoutIssues.length > 0) {
-            tasks.push({
-                id: "timeout-optimization",
-                description: `Optimize ${failureContext.timeoutIssues.length} timeout issues`,
-                subagentType: "testing-lead",
-                priority: strategy.priorityLevel === "critical" ? "high" : "medium",
-                dependencies: ["failure-analysis"],
-            });
-        }
-        // Performance optimization tasks
-        if (failureContext.performanceIssues.length > 0) {
-            tasks.push({
-                id: "performance-optimization",
-                description: `Fix ${failureContext.performanceIssues.length} performance bottlenecks`,
-                subagentType: "refactorer",
-                priority: strategy.priorityLevel === "critical" ? "high" : "medium",
-                dependencies: ["failure-analysis"],
-            });
-        }
-        // Flaky test investigation
-        if (failureContext.flakyTests.length > 0) {
-            tasks.push({
-                id: "flaky-test-investigation",
-                description: `Investigate ${failureContext.flakyTests.length} flaky tests`,
-                subagentType: "bug-triage-specialist",
-                priority: "high",
-                dependencies: ["failure-analysis"],
-            });
-        }
-        // General test refactoring
-        if (failureContext.failedTests.length > 0) {
-            tasks.push({
-                id: "test-refactoring",
-                description: `Refactor ${failureContext.failedTests.length} failing tests`,
-                subagentType: "refactorer",
-                priority: "medium",
-                dependencies: ["failure-analysis"],
-            });
-        }
-        // Architecture review for critical issues
-        if (strategy.priorityLevel === "critical") {
-            tasks.push({
-                id: "architecture-review",
-                description: "Review test architecture for systemic issues",
-                subagentType: "architect",
-                priority: "high",
-                dependencies: [
-                    "failure-analysis",
-                    "timeout-optimization",
-                    "performance-optimization",
-                ],
-            });
-        }
-        return tasks;
-    }
-    /**
-     * Consolidate healing results from multiple agents
-     */
-    async consolidateHealingResults(taskResults, originalContext) {
-        const successfulTasks = taskResults.filter((r) => r.success);
-        const failedTasks = taskResults.filter((r) => !r.success);
-        // Aggregate results from successful tasks
-        let totalFixesApplied = 0;
-        let totalTestsOptimized = 0;
-        let totalPerformanceImprovement = 0;
-        const recommendations = [];
-        for (const result of successfulTasks) {
-            if (result.result) {
-                totalFixesApplied += result.result.fixesApplied || 0;
-                totalTestsOptimized += result.result.testsOptimized || 0;
-                totalPerformanceImprovement +=
-                    result.result.performanceImprovement || 0;
-                if (result.result.recommendations) {
-                    recommendations.push(...result.result.recommendations);
-                }
-            }
-        }
-        const successRate = successfulTasks.length / taskResults.length;
-        const overallSuccess = successRate >= 0.8; // 80% success threshold
-        const summary = `Auto-healing completed: ${successfulTasks.length}/${taskResults.length} tasks successful. ` +
-            `Applied ${totalFixesApplied} fixes, optimized ${totalTestsOptimized} tests, ` +
-            `achieved ${totalPerformanceImprovement}% performance improvement.`;
-        return {
-            success: overallSuccess,
-            fixesApplied: totalFixesApplied,
-            testsOptimized: totalTestsOptimized,
-            performanceImprovement: totalPerformanceImprovement,
-            recommendations: recommendations.slice(0, 5), // Top 5 recommendations
-            summary,
-        };
-    }
-    /**
-     * Delegate task to appropriate subagent using enhanced orchestration
-     */
-    async delegateToSubagent(task) {
-        // Import complexity analyzer for delegation decisions
-        const { complexityAnalyzer } = await import("../delegation/complexity-analyzer.js");
-        // Analyze task complexity to determine delegation strategy
-        const complexityMetrics = complexityAnalyzer.analyzeComplexity("task-execution", {
-            description: task.description,
-            operation: "delegate",
-            agentType: task.subagentType,
-            priority: task.priority,
-            dependencies: task.dependencies,
-        });
-        const complexityScore = complexityAnalyzer.calculateComplexityScore(complexityMetrics);
-        // Log complexity analysis for monitoring
-        await frameworkLogger.log("orchestrator", "task-complexity-analyzed", "info", {
-            taskId: task.id,
-            agentType: task.subagentType,
-            complexityScore: complexityScore.score,
-            recommendedStrategy: complexityScore.recommendedStrategy,
-        });
-        // Convert task dependencies to agent IDs
-        const agentDependencies = [];
-        if (task.dependencies) {
-            for (const depTaskId of task.dependencies) {
-                const depAgentId = this.taskToAgentMap.get(depTaskId);
-                if (depAgentId) {
-                    agentDependencies.push(depAgentId);
-                }
-            }
-        }
-        // Use enhanced multi-agent orchestrator with clickable monitoring
-        const agentRequest = {
-            agentType: task.subagentType,
-            task: task.description,
-            context: {
-                taskId: task.id,
-                priority: task.priority || "medium",
-                orchestratorSession: "main-orchestrator",
-                complexityScore: complexityScore.score,
-                recommendedStrategy: complexityScore.recommendedStrategy,
-            },
-            priority: task.priority || "medium",
-            dependencies: agentDependencies,
-        };
-        const spawnedAgent = await enhancedMultiAgentOrchestrator.spawnAgent(agentRequest);
-        // Map task ID to agent ID for future dependencies
-        this.taskToAgentMap.set(task.id, spawnedAgent.id);
-        // Wait for agent completion with monitoring
-        return new Promise((resolve, reject) => {
-            const checkCompletion = () => {
-                const monitoringData = enhancedMultiAgentOrchestrator.getMonitoringInterface();
-                const agent = monitoringData[spawnedAgent.id];
-                if (!agent) {
-                    reject(new Error(`Agent ${spawnedAgent.id} not found in monitoring data`));
-                    return;
-                }
-                if (agent.status === "completed") {
-                    resolve(agent.result);
-                }
-                else if (agent.status === "failed") {
-                    reject(new Error(agent.error || `Agent ${spawnedAgent.id} failed`));
-                }
-                else {
-                    // Continue monitoring
-                    setTimeout(checkCompletion, 500);
-                }
-            };
-            checkCompletion();
-        });
-    }
-    /**
-     * Resolve conflicts between subagent responses
-     */
-    resolveConflicts(conflicts) {
-        if (conflicts.length === 0)
-            return undefined;
-        if (conflicts.length === 1)
-            return conflicts[0];
-        const agents = conflicts
-            .map((c) => c.agentType)
-            .filter((a) => typeof a === "string");
-        if (agents.length < 2)
-            return conflicts[0];
-        const voteId = this.votingCoordinator.initiateVoting(`orchestrator-conflict-${Date.now()}`, "conflict-resolution", "Resolve conflicting agent responses", agents, {
-            complexity: 30,
-            riskLevel: "medium",
-            hasSecurityConcerns: false,
-            hasArchitecturalImpact: false,
-            participantCount: agents.length,
-        });
-        void voteId.then((id) => {
-            for (const conflict of conflicts) {
-                if (conflict.agentType) {
-                    const vote = conflict.response ? "approve" : "reject";
-                    const confidence = (conflict.expertiseScore ?? 5) / 10;
-                    this.votingCoordinator.submitVote(id, conflict.agentType, vote, confidence);
-                }
-            }
-            this.votingCoordinator.resolveVoting(id);
-        });
-        return this.resolveByExpertPriority(conflicts);
-    }
-    resolveByMajorityVote(conflicts) {
-        // Find the response that appears most frequently
-        const counts = {};
-        conflicts.forEach((conflict) => {
-            const response = JSON.stringify(conflict.response);
-            counts[response] = (counts[response] || 0) + 1;
-        });
-        const majorityEntry = Object.entries(counts).reduce(([keyA, countA], [keyB, countB]) => countA > countB ? [keyA, countA] : [keyB, countB]);
-        if (majorityEntry) {
-            const majorityResponse = JSON.parse(majorityEntry[0]);
-            return conflicts.find((c) => JSON.stringify(c.response) === majorityEntry[0]);
-        }
-        return conflicts[0];
-    }
-    resolveByConsensus(conflicts) {
-        // Return the response if all are identical, otherwise fall back to majority_vote
-        const firstResponse = conflicts[0]?.response;
-        const allSame = conflicts.every((c) => JSON.stringify(c.response) === JSON.stringify(firstResponse));
-        if (allSame) {
-            return conflicts[0];
-        }
-        // Fall back to majority_vote on disagreement - prevents silent failure
-        return this.resolveByMajorityVote(conflicts);
-    }
-    /**
-     * Detect and resolve conflicts between task results in a batch.
-     * This enables multi-agent governance by comparing results from parallel agents.
-     *
-     * Current implementation: Disabled by default - needs refinement to properly
-     * detect actual conflicts vs. expected different results from different agent types.
-     * Set ENABLE_CONFLICT_DETECTION=true to enable.
-     */
-    detectAndResolveConflicts(results) {
-        // Conflict resolution disabled by default - needs proper conflict definition
-        // Set ENABLE_CONFLICT_DETECTION=true to enable
-        if (process.env.ENABLE_CONFLICT_DETECTION !== "true") {
-            return { conflictsFound: 0, resolvedResults: results, resolvedBy: "disabled" };
-        }
-        // Rest of implementation for when properly enabled...
-        if (results.length < 2) {
-            return { conflictsFound: 0, resolvedResults: results, resolvedBy: "none" };
-        }
-        // Group results by task type (subagentType) to find similar results
-        const resultsByType = {};
-        for (const result of results) {
-            const taskType = result.taskType || "default";
-            if (!resultsByType[taskType]) {
-                resultsByType[taskType] = [];
-            }
-            resultsByType[taskType].push(result);
-        }
-        let conflictsFound = 0;
-        const resolvedResults = [];
-        // Check each group for conflicts
-        for (const [taskType, taskResults] of Object.entries(resultsByType)) {
-            if (taskResults.length < 2) {
-                resolvedResults.push(...taskResults);
-                continue;
-            }
-            const conflicts = taskResults.map((r, idx) => ({
-                response: r.result,
-                agentType: taskType,
-                expertiseScore: 0,
-            }));
-            const responseStrings = conflicts.map(c => JSON.stringify(c.response));
-            const uniqueResponses = new Set(responseStrings);
-            if (uniqueResponses.size > 1) {
-                conflictsFound++;
-                const resolved = this.resolveConflicts(conflicts);
-                if (resolved?.response && taskResults.length > 0) {
-                    const first = taskResults[0];
-                    resolvedResults.push({
-                        success: first.success,
-                        result: resolved.response,
-                        duration: first.duration,
-                        taskId: "resolved-task",
-                        taskType: "resolved",
-                        resolved: true,
-                        resolutionStrategy: this.config.conflictResolutionStrategy,
-                    });
-                }
-                else {
-                    resolvedResults.push(...taskResults);
-                }
-            }
-            else {
-                resolvedResults.push(...taskResults);
-            }
-        }
-        return {
-            conflictsFound,
-            resolvedResults,
-            resolvedBy: conflictsFound > 0 ? this.config.conflictResolutionStrategy : "none",
-        };
-    }
-    /**
-     * Populate expertiseScore based on agent type for expert_priority resolution.
-     * This maps agent types to expertise levels for conflict resolution.
-     */
-    resolveByExpertPriority(conflicts) {
-        // Use centralized agent expertise from agent-expertise.ts
-        const scoredConflicts = conflicts.map((conflict) => {
-            const agentName = conflict.agentType ?? "default";
-            const expertiseLevel = getAgentExpertiseLevel(agentName);
-            return {
-                ...conflict,
-                expertiseScore: expertiseLevel,
-            };
-        });
-        return scoredConflicts.sort((a, b) => (b.expertiseScore || 0) - (a.expertiseScore || 0))[0];
-    }
-    /**
-     * Get orchestrator status
-     */
-    getStatus() {
-        return {
-            activeTasks: this.activeTasks.size,
-            config: this.config,
-        };
-    }
-}
-// Export singleton instance
-export const xrayOrchestrator = new XrayOrchestrator();
-// Backward compatibility alias