0xray 4.0.12 → 4.0.13

package/dist/orchestrator/multi-agent-orchestration-coordinator.js

@@ -1,455 +0,0 @@
-/**
- * Multi-Agent Orchestration Coordinator
- *
- * Central coordinator for multi-agent orchestration that integrates all orchestration components
- * for comprehensive E2E workflow management and coordination.
- *
- * @since 2026-01-23
- */
-import { KernelOrchestrator } from "../core/orchestrator.js";
-import { enhancedMultiAgentOrchestrator } from "./enhanced-multi-agent-orchestrator.js";
-import { createAgentDelegator } from "../delegation/agent-delegator.js";
-import { XrayStateManager } from "../state/state-manager.js";
-import { frameworkLogger } from "../core/framework-logger.js";
-import { ComplexityAnalyzer } from "../delegation/complexity-analyzer.js";
-import { xrayConfigLoader } from "../core/config-loader.js";
-export class MultiAgentOrchestrationCoordinator {
-    xrayOrchestrator;
-    enhancedOrchestrator;
-    agentDelegator;
-    stateManager;
-    complexityAnalyzer;
-    coordinationMetrics;
-    constructor(stateManager) {
-        this.stateManager = stateManager || new XrayStateManager();
-        this.xrayOrchestrator = new KernelOrchestrator();
-        this.enhancedOrchestrator = enhancedMultiAgentOrchestrator;
-        this.agentDelegator = createAgentDelegator(this.stateManager, xrayConfigLoader);
-        this.complexityAnalyzer = new ComplexityAnalyzer();
-        this.coordinationMetrics = {
-            totalWorkflows: 0,
-            successfulWorkflows: 0,
-            failedWorkflows: 0,
-            averageDuration: 0,
-            agentUtilization: {},
-            coordinationEfficiency: 0,
-        };
-        this.initializeCoordinationSystem();
-    }
-    /**
-     * Initialize the coordination system with all components
-     */
-    initializeCoordinationSystem() {
-        // Register coordination components in state manager
-        this.stateManager.set("coordination:main_coordinator", this);
-        this.stateManager.set("coordination:xray_orchestrator", this.xrayOrchestrator);
-        this.stateManager.set("coordination:enhanced_orchestrator", this.enhancedOrchestrator);
-        this.stateManager.set("coordination:agent_delegator", this.agentDelegator);
-        this.stateManager.set("coordination:metrics", this.coordinationMetrics);
-        frameworkLogger.log("orchestration-coordinator", "Multi-agent orchestration coordination system initialized", "info");
-    }
-    /**
-     * Execute a complete orchestration workflow with full coordination
-     */
-    async executeOrchestrationWorkflow(workflow, sessionId) {
-        const startTime = Date.now();
-        const jobId = `workflow-${workflow.id}-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
-        frameworkLogger.log("orchestration-coordinator", `Starting orchestration workflow: ${workflow.name}`, "info", { jobId, workflowId: workflow.id, taskCount: workflow.tasks.length });
-        this.coordinationMetrics.totalWorkflows++;
-        try {
-            // Phase 1: Analyze workflow complexity and plan execution
-            const executionPlan = await this.analyzeWorkflowComplexity(workflow);
-            // Phase 2: Coordinate agent availability and resource allocation
-            const resourceAllocation = await this.allocateWorkflowResources(workflow, executionPlan);
-            // Phase 3: Execute workflow using integrated orchestration
-            const executionResult = await this.executeCoordinatedWorkflow(workflow, executionPlan, resourceAllocation, sessionId, jobId);
-            // Phase 4: Consolidate results and update metrics
-            const consolidatedResult = await this.consolidateWorkflowResults(workflow, executionResult, startTime);
-            // Update coordination metrics
-            this.updateCoordinationMetrics(consolidatedResult);
-            frameworkLogger.log("orchestration-coordinator", `Workflow completed: ${workflow.name} - ${consolidatedResult.success ? "SUCCESS" : "FAILED"}`, consolidatedResult.success ? "success" : "error", {
-                jobId,
-                workflowId: workflow.id,
-                duration: consolidatedResult.duration,
-                completedTasks: consolidatedResult.completedTasks,
-                failedTasks: consolidatedResult.failedTasks,
-            });
-            return consolidatedResult;
-        }
-        catch (error) {
-            const duration = Date.now() - startTime;
-            this.coordinationMetrics.failedWorkflows++;
-            frameworkLogger.log("orchestration-coordinator", `Workflow failed: ${workflow.name}`, "error", {
-                jobId,
-                workflowId: workflow.id,
-                error: error instanceof Error ? error.message : String(error),
-                duration,
-            });
-            return {
-                success: false,
-                workflowId: workflow.id,
-                completedTasks: 0,
-                failedTasks: workflow.tasks.length,
-                totalTasks: workflow.tasks.length,
-                duration,
-                results: [],
-                errors: [error instanceof Error ? error.message : String(error)],
-                agentCoordination: {
-                    agentsUsed: [],
-                    coordinationEvents: 0,
-                    conflictsResolved: 0,
-                },
-            };
-        }
-    }
-    /**
-     * Analyze workflow complexity and create execution plan
-     */
-    async analyzeWorkflowComplexity(workflow) {
-        // Analyze overall workflow complexity
-        const workflowComplexity = await this.complexityAnalyzer.analyzeComplexity("workflow-execution", {
-            description: workflow.description,
-            files: workflow.tasks.map((t) => `task-${t.id}.txt`),
-            dependencies: workflow.dependencies,
-            estimatedDuration: workflow.tasks.reduce((sum, task) => sum + (task.priority === "high" ? 30 : 15), 0),
-        });
-        const complexityScore = await this.complexityAnalyzer.calculateComplexityScore(workflowComplexity);
-        // Build dependency graph
-        const dependencyGraph = new Map();
-        workflow.tasks.forEach((task) => {
-            dependencyGraph.set(task.id, task.dependencies || []);
-        });
-        // Group tasks by parallel execution potential
-        const parallelGroups = this.buildParallelExecutionGroups(workflow.tasks, dependencyGraph);
-        return {
-            complexityScore: complexityScore.score,
-            recommendedStrategy: complexityScore.recommendedStrategy,
-            parallelGroups,
-            dependencyGraph,
-            estimatedDuration: complexityScore.estimatedAgents * 60, // Rough estimate
-        };
-    }
-    /**
-     * Allocate resources for workflow execution
-     */
-    async allocateWorkflowResources(workflow, executionPlan) {
-        const allocatedAgents = [];
-        const resourceAvailability = {};
-        // Get available agents from agent delegator
-        const availableAgents = this.agentDelegator.getAvailableAgents();
-        // Allocate agents based on workflow requirements
-        workflow.tasks.forEach((task) => {
-            const matchingAgent = availableAgents.find((agent) => (agent.expertise?.some((exp) => task.subagentType?.includes(exp)) ?? false) ||
-                (agent.specialties?.some((spec) => task.subagentType?.includes(spec.split("-")[0] ?? "")) ?? false));
-            if (matchingAgent && !allocatedAgents.includes(matchingAgent.name)) {
-                allocatedAgents.push(matchingAgent.name);
-                resourceAvailability[matchingAgent.name] = true;
-            }
-        });
-        return {
-            allocatedAgents,
-            resourceAvailability,
-            coordinationCapacity: allocatedAgents.length * 2,
-        };
-    }
-    /**
-     * Execute coordinated workflow using all orchestration components
-     */
-    async executeCoordinatedWorkflow(workflow, executionPlan, resourceAllocation, sessionId, jobId) {
-        const taskResults = [];
-        let coordinationEvents = 0;
-        let conflictsResolved = 0;
-        const agentsUsed = [];
-        // Use different orchestration strategies based on complexity
-        if (executionPlan.recommendedStrategy === "single-agent") {
-            // Simple workflow - use 0xRay orchestrator
-            const task = {
-                id: `workflow-${workflow.id}`,
-                type: "simple",
-                description: workflow.description,
-                complexity: 50,
-                priority: "medium",
-                createdAt: new Date(),
-                status: "pending",
-                dependencies: [],
-                subagentType: "orchestrator",
-            };
-            const result = await this.xrayOrchestrator.executeComplexTask(task.description, [task]);
-            result.forEach((r) => {
-                taskResults.push({
-                    success: r.success,
-                    taskId: r.taskId,
-                    result: r.result,
-                    error: r.error,
-                    duration: r.duration,
-                });
-            });
-            coordinationEvents += 1;
-            agentsUsed.push(...resourceAllocation.allocatedAgents);
-        }
-        else {
-            // Complex workflow - use enhanced multi-agent orchestrator
-            const coordinationPromises = workflow.tasks.map(async (task) => {
-                coordinationEvents++;
-                const agentType = task.subagentType || "default-agent";
-                const agentRequest = {
-                    agentType,
-                    task: task.description || task.id,
-                    context: {
-                        taskId: task.id,
-                        workflowId: workflow.id,
-                        sessionId,
-                    },
-                    priority: task.priority ||
-                        "medium",
-                    dependencies: task.dependencies?.map((depId) => `agent_${depId}`) || [],
-                };
-                try {
-                    const spawnedAgent = await this.enhancedOrchestrator.spawnAgent(agentRequest);
-                    agentsUsed.push(agentType);
-                    // Wait for completion
-                    return new Promise((resolve) => {
-                        const checkCompletion = () => {
-                            const monitoringData = this.enhancedOrchestrator.getMonitoringInterface();
-                            const agent = monitoringData[spawnedAgent.id];
-                            if (agent?.status === "completed") {
-                                resolve({
-                                    success: true,
-                                    taskId: task.id,
-                                    result: agent.result,
-                                    duration: agent.endTime ? agent.endTime - agent.startTime : 0,
-                                });
-                            }
-                            else if (agent?.status === "failed") {
-                                resolve({
-                                    success: false,
-                                    taskId: task.id,
-                                    error: agent.error,
-                                    duration: agent.endTime ? agent.endTime - agent.startTime : 0,
-                                });
-                            }
-                            else {
-                                setTimeout(checkCompletion, 500);
-                            }
-                        };
-                        checkCompletion();
-                    });
-                }
-                catch (error) {
-                    conflictsResolved++; // Count as conflict resolution attempt
-                    return {
-                        success: false,
-                        taskId: task.id,
-                        error: error instanceof Error ? error.message : String(error),
-                        duration: 0,
-                    };
-                }
-            });
-            const coordinationResults = await Promise.allSettled(coordinationPromises);
-            coordinationResults.forEach((result) => {
-                if (result.status === "fulfilled") {
-                    taskResults.push(result.value);
-                }
-                else {
-                    taskResults.push({
-                        success: false,
-                        error: result.reason instanceof Error ? result.reason.message : String(result.reason),
-                        duration: 0,
-                    });
-                }
-            });
-        }
-        return {
-            taskResults,
-            coordinationEvents,
-            conflictsResolved,
-            agentsUsed: [...new Set(agentsUsed)], // Remove duplicates
-        };
-    }
-    /**
-     * Consolidate workflow results
-     */
-    async consolidateWorkflowResults(workflow, executionResult, startTime) {
-        const duration = Date.now() - startTime;
-        const successfulTasks = executionResult.taskResults.filter((r) => r.success);
-        const failedTasks = executionResult.taskResults.filter((r) => !r.success);
-        const success = successfulTasks.length === workflow.tasks.length;
-        if (success) {
-            this.coordinationMetrics.successfulWorkflows++;
-        }
-        else {
-            this.coordinationMetrics.failedWorkflows++;
-        }
-        return {
-            success,
-            workflowId: workflow.id,
-            completedTasks: successfulTasks.length,
-            failedTasks: failedTasks.length,
-            totalTasks: workflow.tasks.length,
-            duration,
-            results: successfulTasks.map((r) => r.result),
-            errors: failedTasks.map((r) => r.error || "Unknown error"),
-            agentCoordination: {
-                agentsUsed: executionResult.agentsUsed,
-                coordinationEvents: executionResult.coordinationEvents,
-                conflictsResolved: executionResult.conflictsResolved,
-            },
-        };
-    }
-    /**
-     * Build parallel execution groups based on dependencies
-     */
-    buildParallelExecutionGroups(tasks, dependencyGraph) {
-        const groups = [];
-        const processedTasks = new Set();
-        const taskMap = new Map(tasks.map((task) => [task.id, task]));
-        while (processedTasks.size < tasks.length) {
-            const currentGroup = [];
-            for (const task of tasks) {
-                if (processedTasks.has(task.id))
-                    continue;
-                // Check if all dependencies are processed
-                const dependencies = dependencyGraph.get(task.id) || [];
-                const depsMet = dependencies.every((dep) => processedTasks.has(dep));
-                if (depsMet) {
-                    currentGroup.push(task);
-                }
-            }
-            if (currentGroup.length === 0) {
-                // Circular dependency or no progress possible
-                break;
-            }
-            groups.push(currentGroup);
-            currentGroup.forEach((task) => processedTasks.add(task.id));
-        }
-        return groups;
-    }
-    /**
-     * Update coordination metrics
-     */
-    updateCoordinationMetrics(result) {
-        // Update agent utilization
-        result.agentCoordination.agentsUsed.forEach((agent) => {
-            this.coordinationMetrics.agentUtilization[agent] =
-                (this.coordinationMetrics.agentUtilization[agent] || 0) + 1;
-        });
-        // Update average duration
-        const totalDuration = this.coordinationMetrics.averageDuration *
-            (this.coordinationMetrics.totalWorkflows - 1) +
-            result.duration;
-        this.coordinationMetrics.averageDuration =
-            totalDuration / this.coordinationMetrics.totalWorkflows;
-        // Calculate coordination efficiency (tasks per minute)
-        const totalTasks = this.coordinationMetrics.totalWorkflows * 10; // Assume average 10 tasks per workflow
-        const totalTime = this.coordinationMetrics.averageDuration *
-            this.coordinationMetrics.totalWorkflows;
-        this.coordinationMetrics.coordinationEfficiency =
-            totalTasks / (totalTime / 60000); // tasks per minute
-    }
-    /**
-     * Get coordination metrics
-     */
-    getCoordinationMetrics() {
-        return { ...this.coordinationMetrics };
-    }
-    /**
-     * Validate orchestration workflow
-     */
-    validateWorkflow(workflow) {
-        const errors = [];
-        const warnings = [];
-        // Check for duplicate task IDs
-        const taskIds = workflow.tasks.map((t) => t.id);
-        const duplicates = taskIds.filter((id, index) => taskIds.indexOf(id) !== index);
-        if (duplicates.length > 0) {
-            errors.push(`Duplicate task IDs: ${duplicates.join(", ")}`);
-        }
-        // Check for circular dependencies
-        const dependencyGraph = new Map();
-        workflow.tasks.forEach((task) => {
-            dependencyGraph.set(task.id, task.dependencies || []);
-        });
-        const visited = new Set();
-        const recursionStack = new Set();
-        const hasCycle = (taskId) => {
-            if (recursionStack.has(taskId))
-                return true;
-            if (visited.has(taskId))
-                return false;
-            visited.add(taskId);
-            recursionStack.add(taskId);
-            const dependencies = dependencyGraph.get(taskId) || [];
-            for (const dep of dependencies) {
-                if (hasCycle(dep))
-                    return true;
-            }
-            recursionStack.delete(taskId);
-            return false;
-        };
-        for (const task of workflow.tasks) {
-            if (hasCycle(task.id)) {
-                errors.push(`Circular dependency detected involving task: ${task.id}`);
-                break;
-            }
-        }
-        // Check for invalid agent types
-        const validAgentTypes = [
-            "enforcer",
-            "architect",
-            "orchestrator",
-            "bug-triage-specialist",
-            "code-reviewer",
-            "security-auditor",
-            "refactorer",
-            "testing-lead",
-            "researcher",
-            "log-monitor",
-            "analyzer",
-            "code-analyzer",
-        ];
-        const agentAliasMap = {
-            researcher: "researcher",
-            "test-architect": "testing-lead",
-            "testing-lead": "testing-lead",
-            analyzer: "code-analyzer",
-        };
-        // Resolve aliases before validation
-        workflow.tasks.forEach((task) => {
-            const agentType = task.subagentType || "default-agent";
-            if (agentAliasMap[agentType]) {
-                task.subagentType = agentAliasMap[agentType];
-            }
-        });
-        workflow.tasks.forEach((task) => {
-            const agentType = task.subagentType || "default-agent";
-            if (!validAgentTypes.includes(agentType)) {
-                errors.push(`Invalid agent type: ${agentType} for task ${task.id}`);
-            }
-        });
-        // Check for missing dependencies
-        const allTaskIds = new Set(workflow.tasks.map((t) => t.id));
-        workflow.tasks.forEach((task) => {
-            task.dependencies?.forEach((dep) => {
-                if (!allTaskIds.has(dep)) {
-                    errors.push(`Task ${task.id} references non-existent dependency: ${dep}`);
-                }
-            });
-        });
-        return {
-            valid: errors.length === 0,
-            errors,
-            warnings,
-        };
-    }
-    /**
-     * Shutdown coordination system
-     */
-    async shutdown() {
-        frameworkLogger.log("orchestration-coordinator", "Shutting down multi-agent orchestration coordinator", "info");
-        await this.enhancedOrchestrator.shutdown();
-        await this.xrayOrchestrator.getStatus(); // Just get status, no actual shutdown method
-        frameworkLogger.log("orchestration-coordinator", "Multi-agent orchestration coordinator shutdown complete", "info");
-    }
-}
-// Export singleton instance
-export const multiAgentOrchestrationCoordinator = new MultiAgentOrchestrationCoordinator();

package/dist/orchestrator/orchestrator.d.ts

@@ -1,141 +0,0 @@
-/**
- * Orchestrator Agent
- *
- * Coordinates multi-step tasks and delegates to specialized subagents.
- * Implements Sisyphus integration for relentless execution.
- *
- * @since 2026-01-07
- */
-export interface OrchestratorConfig {
-    maxConcurrentTasks: number;
-    taskTimeout: number;
-    conflictResolutionStrategy: "majority_vote" | "expert_priority" | "consensus";
-}
-export interface TaskDefinition {
-    id: string;
-    description: string;
-    subagentType: string;
-    priority?: "high" | "medium" | "low";
-    dependencies?: string[];
-}
-export interface TaskResult {
-    success: boolean;
-    result?: TaskExecutionResult;
-    error?: string;
-    duration: number;
-    taskId?: string;
-    taskType?: string;
-    resolved?: boolean;
-    resolutionStrategy?: string;
-}
-export interface TaskExecutionResult {
-    fixesApplied?: number;
-    testsOptimized?: number;
-    performanceImprovement?: number;
-    recommendations?: string[];
-    [key: string]: unknown;
-}
-export interface TestFailureContext {
-    failedTests: string[];
-    timeoutIssues: string[];
-    performanceIssues: string[];
-    flakyTests: string[];
-    errorLogs: string[];
-    testExecutionTime: number;
-    sessionId?: string;
-}
-export interface HealingStrategy {
-    priorityLevel: "low" | "medium" | "high" | "critical";
-    agentsNeeded: string[];
-    estimatedTime: number;
-    complexityScore: number;
-    healingApproach: "simple" | "coordinated" | "enterprise";
-}
-export interface ConsolidationResult {
-    success: boolean;
-    fixesApplied: number;
-    testsOptimized: number;
-    performanceImprovement: number;
-    recommendations: string[];
-    summary: string;
-}
-export declare class XrayOrchestrator {
-    private config;
-    private activeTasks;
-    private taskToAgentMap;
-    private votingCoordinator;
-    constructor(config?: Partial<OrchestratorConfig>);
-    /**
-     * Load orchestrator config from features.json
-     */
-    private loadOrchestratorConfig;
-    /**
-     * Map config key to enum value
-     */
-    private mapConflictResolution;
-    /**
-     * Execute a complex multi-step task
-     */
-    executeComplexTask(description: string, tasks: TaskDefinition[], sessionId?: string): Promise<TaskResult[]>;
-    /**
-     * Execute a single task by delegating to appropriate subagent
-     */
-    private executeSingleTask;
-    /**
-     * Auto-healing orchestration for test failures - coordinates multi-agent response
-     */
-    orchestrateTestAutoHealing(failureContext: TestFailureContext, sessionId?: string): Promise<{
-        success: boolean;
-        healingResult: unknown;
-        agentCoordination: string[];
-        performanceImprovement: number;
-    }>;
-    /**
-     * Analyze test failure patterns to determine healing strategy
-     */
-    private analyzeTestFailurePatterns;
-    /**
-     * Create task definitions for healing orchestration
-     */
-    private createHealingTaskDefinitions;
-    /**
-     * Consolidate healing results from multiple agents
-     */
-    private consolidateHealingResults;
-    /**
-     * Delegate task to appropriate subagent using enhanced orchestration
-     */
-    private delegateToSubagent;
-    /**
-     * Resolve conflicts between subagent responses
-     */
-    resolveConflicts(conflicts: Array<{
-        response?: unknown;
-        agentType?: string;
-        expertiseScore?: number;
-    }>): unknown;
-    private resolveByMajorityVote;
-    private resolveByConsensus;
-    /**
-     * 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.
-     */
-    private detectAndResolveConflicts;
-    /**
-     * Populate expertiseScore based on agent type for expert_priority resolution.
-     * This maps agent types to expertise levels for conflict resolution.
-     */
-    private resolveByExpertPriority;
-    /**
-     * Get orchestrator status
-     */
-    getStatus(): {
-        activeTasks: number;
-        config: OrchestratorConfig;
-    };
-}
-export declare const xrayOrchestrator: XrayOrchestrator;