claude-flow 2.7.0-alpha.8 → 2.7.0

package/dist/hive-mind/integration/SwarmOrchestrator.js

@@ -0,0 +1,748 @@
+/**
+ * SwarmOrchestrator Class
+ *
+ * Orchestrates task distribution, agent coordination, and
+ * execution strategies within the Hive Mind swarm.
+ */
+import { EventEmitter } from 'events';
+import { DatabaseManager } from '../core/DatabaseManager.js';
+import { MCPToolWrapper } from './MCPToolWrapper.js';
+export class SwarmOrchestrator extends EventEmitter {
+    hiveMind;
+    db;
+    mcpWrapper;
+    executionPlans;
+    taskAssignments;
+    activeExecutions;
+    isActive = false;
+    constructor(hiveMind) {
+        super();
+        this.hiveMind = hiveMind;
+        this.executionPlans = new Map();
+        this.taskAssignments = new Map();
+        this.activeExecutions = new Map();
+    }
+    /**
+     * Initialize the orchestrator
+     */
+    async initialize() {
+        this.db = await DatabaseManager.getInstance();
+        this.mcpWrapper = new MCPToolWrapper();
+        await this.mcpWrapper.initialize();
+        // Start orchestration loops
+        this.startTaskDistributor();
+        this.startProgressMonitor();
+        this.startLoadBalancer();
+        this.isActive = true;
+        this.emit('initialized');
+    }
+    /**
+     * Submit a task for orchestration
+     */
+    async submitTask(task) {
+        // Create execution plan based on strategy
+        const plan = await this.createExecutionPlan(task);
+        this.executionPlans.set(task.id, plan);
+        // Orchestrate task using MCP tools
+        const orchestrationResult = await this.mcpWrapper.orchestrateTask({
+            task: task.description,
+            priority: task.priority,
+            strategy: task.strategy,
+            dependencies: task.dependencies,
+        });
+        if (orchestrationResult.success) {
+            // Start task execution
+            await this.executeTask(task, plan);
+        }
+        else {
+            this.emit('orchestrationError', { task, error: orchestrationResult.error });
+        }
+    }
+    /**
+     * Create execution plan for a task
+     */
+    async createExecutionPlan(task) {
+        const strategy = this.getStrategyImplementation(task.strategy);
+        // Analyze task complexity
+        const analysis = await this.analyzeTaskComplexity(task);
+        // Determine phases based on strategy and complexity
+        const phases = strategy.determinePhases(task, analysis);
+        // Create assignments for each phase
+        const phaseAssignments = await Promise.all(phases.map((phase) => this.createPhaseAssignments(task, phase, analysis)));
+        return {
+            taskId: task.id,
+            strategy: task.strategy,
+            phases,
+            phaseAssignments,
+            dependencies: task.dependencies,
+            checkpoints: this.createCheckpoints(phases),
+            parallelizable: strategy.isParallelizable(task),
+            estimatedDuration: analysis.estimatedDuration,
+            resourceRequirements: analysis.resourceRequirements,
+        };
+    }
+    /**
+     * Execute task according to plan
+     */
+    async executeTask(task, plan) {
+        const execution = {
+            taskId: task.id,
+            plan,
+            startTime: Date.now(),
+            currentPhase: 0,
+            phaseResults: [],
+            status: 'executing',
+        };
+        this.activeExecutions.set(task.id, execution);
+        try {
+            // Execute phases according to strategy
+            if (plan.parallelizable) {
+                await this.executeParallel(task, plan, execution);
+            }
+            else {
+                await this.executeSequential(task, plan, execution);
+            }
+            // Mark task as completed
+            execution.status = 'completed';
+            await this.completeTask(task, execution);
+        }
+        catch (error) {
+            execution.status = 'failed';
+            execution.error = error;
+            await this.handleTaskFailure(task, execution, error);
+        }
+        finally {
+            this.activeExecutions.delete(task.id);
+        }
+    }
+    /**
+     * Execute phases in parallel
+     */
+    async executeParallel(task, plan, execution) {
+        const parallelPhases = plan.phases.filter((_, index) => plan.phaseAssignments[index].some((a) => a.canRunParallel));
+        const results = await Promise.all(parallelPhases.map((phase) => this.executePhase(task, phase, plan, execution)));
+        execution.phaseResults = results;
+    }
+    /**
+     * Execute phases sequentially
+     */
+    async executeSequential(task, plan, execution) {
+        for (let i = 0; i < plan.phases.length; i++) {
+            const phase = plan.phases[i];
+            execution.currentPhase = i;
+            const result = await this.executePhase(task, phase, plan, execution);
+            execution.phaseResults.push(result);
+            // Check checkpoint
+            if (plan.checkpoints[i]) {
+                await this.evaluateCheckpoint(task, plan.checkpoints[i], execution);
+            }
+        }
+    }
+    /**
+     * Execute a single phase
+     */
+    async executePhase(task, phase, plan, execution) {
+        const phaseIndex = plan.phases.indexOf(phase);
+        const assignments = plan.phaseAssignments[phaseIndex];
+        // Assign agents to phase tasks
+        const agentAssignments = await this.assignAgentsToPhase(task, phase, assignments);
+        // Execute phase tasks
+        const phaseResults = await Promise.all(agentAssignments.map((assignment) => this.executeAssignment(task, phase, assignment)));
+        // Aggregate phase results
+        return this.aggregatePhaseResults(phase, phaseResults);
+    }
+    /**
+     * Assign agents to phase tasks
+     */
+    async assignAgentsToPhase(task, phase, assignments) {
+        const agentAssignments = [];
+        for (const assignment of assignments) {
+            // Find suitable agent
+            const agent = await this.findSuitableAgent(assignment.requiredCapabilities);
+            if (agent) {
+                await this.assignTaskToAgent(task.id, agent.id);
+                agentAssignments.push({
+                    agent,
+                    assignment,
+                    phase,
+                });
+            }
+            else {
+                // Queue for later assignment
+                this.queueAssignment(task.id, assignment);
+            }
+        }
+        return agentAssignments;
+    }
+    /**
+     * Execute a specific assignment
+     */
+    async executeAssignment(task, phase, assignment) {
+        const { agent, assignment: taskAssignment } = assignment;
+        // Send execution command to agent
+        await agent.assignTask(task.id, {
+            phase,
+            role: taskAssignment.role,
+            responsibilities: taskAssignment.responsibilities,
+            expectedOutput: taskAssignment.expectedOutput,
+        });
+        // Wait for completion or timeout
+        return this.waitForAgentCompletion(agent, task.id, taskAssignment.timeout);
+    }
+    /**
+     * Assign task to a specific agent
+     */
+    async assignTaskToAgent(taskId, agentId) {
+        // Update database
+        const task = await this.db.getTask(taskId);
+        const assignedAgents = JSON.parse(task.assigned_agents || '[]');
+        if (!assignedAgents.includes(agentId)) {
+            assignedAgents.push(agentId);
+            await this.db.updateTask(taskId, {
+                assigned_agents: JSON.stringify(assignedAgents),
+                status: 'assigned',
+            });
+        }
+        // Update agent
+        await this.db.updateAgent(agentId, {
+            current_task_id: taskId,
+            status: 'busy',
+        });
+        this.emit('taskAssigned', { taskId, agentId });
+    }
+    /**
+     * Cancel a task
+     */
+    async cancelTask(taskId) {
+        const execution = this.activeExecutions.get(taskId);
+        if (execution) {
+            execution.status = 'cancelled';
+            // Notify assigned agents
+            const task = await this.db.getTask(taskId);
+            const assignedAgents = JSON.parse(task.assigned_agents || '[]');
+            for (const agentId of assignedAgents) {
+                await this.notifyAgentTaskCancelled(agentId, taskId);
+            }
+        }
+        this.activeExecutions.delete(taskId);
+        this.executionPlans.delete(taskId);
+        this.emit('taskCancelled', { taskId });
+    }
+    /**
+     * Rebalance agent assignments
+     */
+    async rebalance() {
+        // Get current load distribution
+        const loadDistribution = await this.analyzeLoadDistribution();
+        // Use MCP tool for load balancing
+        const balanceResult = await this.mcpWrapper.loadBalance({
+            tasks: loadDistribution.unassignedTasks,
+        });
+        if (balanceResult.success && balanceResult.data.reassignments) {
+            await this.applyReassignments(balanceResult.data.reassignments);
+        }
+        this.emit('rebalanced', { loadDistribution });
+    }
+    /**
+     * Strategy implementations
+     */
+    getStrategyImplementation(strategy) {
+        const strategies = {
+            parallel: {
+                determinePhases: (task) => ['preparation', 'parallel-execution', 'aggregation'],
+                isParallelizable: () => true,
+                maxConcurrency: 5,
+            },
+            sequential: {
+                determinePhases: (task) => ['analysis', 'planning', 'execution', 'validation'],
+                isParallelizable: () => false,
+                maxConcurrency: 1,
+            },
+            adaptive: {
+                determinePhases: (task, analysis) => {
+                    if (analysis.complexity === 'high') {
+                        return ['deep-analysis', 'planning', 'phased-execution', 'integration', 'validation'];
+                    }
+                    return ['quick-analysis', 'execution', 'validation'];
+                },
+                isParallelizable: (task) => !task.requireConsensus,
+                maxConcurrency: 3,
+            },
+            consensus: {
+                determinePhases: () => ['proposal', 'discussion', 'voting', 'execution', 'ratification'],
+                isParallelizable: () => false,
+                maxConcurrency: 1,
+            },
+        };
+        return strategies[strategy] || strategies.adaptive;
+    }
+    /**
+     * Analyze task complexity
+     */
+    async analyzeTaskComplexity(task) {
+        const analysis = await this.mcpWrapper.analyzePattern({
+            action: 'analyze',
+            operation: 'task_complexity',
+            metadata: {
+                description: task.description,
+                priority: task.priority,
+                dependencies: task.dependencies.length,
+                requiresConsensus: task.requireConsensus,
+            },
+        });
+        return {
+            complexity: analysis.data?.complexity || 'medium',
+            estimatedDuration: analysis.data?.estimatedDuration || 3600000,
+            resourceRequirements: analysis.data?.resourceRequirements || {
+                minAgents: 1,
+                maxAgents: task.maxAgents,
+                capabilities: task.requiredCapabilities,
+            },
+        };
+    }
+    /**
+     * Create phase assignments
+     */
+    async createPhaseAssignments(task, phase, analysis) {
+        const assignments = [];
+        // Define assignments based on phase
+        switch (phase) {
+            case 'analysis':
+            case 'deep-analysis':
+                assignments.push({
+                    role: 'analyst',
+                    requiredCapabilities: ['data_analysis', 'pattern_recognition'],
+                    responsibilities: ['Analyze task requirements', 'Identify patterns', 'Assess complexity'],
+                    expectedOutput: 'Analysis report',
+                    timeout: 300000, // 5 minutes
+                    canRunParallel: false,
+                });
+                break;
+            case 'planning':
+                assignments.push({
+                    role: 'architect',
+                    requiredCapabilities: ['system_design', 'architecture_patterns'],
+                    responsibilities: ['Design solution', 'Create implementation plan', 'Define interfaces'],
+                    expectedOutput: 'Implementation plan',
+                    timeout: 600000, // 10 minutes
+                    canRunParallel: false,
+                });
+                break;
+            case 'execution':
+            case 'parallel-execution':
+                // Multiple execution assignments based on complexity
+                const executionCount = Math.min(analysis.resourceRequirements.maxAgents, 3);
+                for (let i = 0; i < executionCount; i++) {
+                    assignments.push({
+                        role: 'executor',
+                        requiredCapabilities: task.requiredCapabilities,
+                        responsibilities: ['Implement solution', 'Execute plan', 'Handle errors'],
+                        expectedOutput: 'Execution results',
+                        timeout: 1800000, // 30 minutes
+                        canRunParallel: true,
+                    });
+                }
+                break;
+            case 'validation':
+                assignments.push({
+                    role: 'validator',
+                    requiredCapabilities: ['quality_assurance', 'test_generation'],
+                    responsibilities: ['Validate results', 'Run tests', 'Ensure quality'],
+                    expectedOutput: 'Validation report',
+                    timeout: 600000, // 10 minutes
+                    canRunParallel: false,
+                });
+                break;
+            case 'consensus':
+            case 'voting':
+                assignments.push({
+                    role: 'consensus-coordinator',
+                    requiredCapabilities: ['consensus_building'],
+                    responsibilities: ['Coordinate voting', 'Collect opinions', 'Determine consensus'],
+                    expectedOutput: 'Consensus decision',
+                    timeout: 300000, // 5 minutes
+                    canRunParallel: false,
+                });
+                break;
+        }
+        return assignments;
+    }
+    /**
+     * Create execution checkpoints
+     */
+    createCheckpoints(phases) {
+        return phases.map((phase, index) => ({
+            phase,
+            index,
+            requiredProgress: Math.round(((index + 1) / phases.length) * 100),
+            validationCriteria: this.getValidationCriteria(phase),
+            failureThreshold: 0.3,
+        }));
+    }
+    /**
+     * Get validation criteria for a phase
+     */
+    getValidationCriteria(phase) {
+        const criteria = {
+            analysis: [
+                { name: 'completeness', weight: 0.4 },
+                { name: 'accuracy', weight: 0.6 },
+            ],
+            planning: [
+                { name: 'feasibility', weight: 0.5 },
+                { name: 'completeness', weight: 0.5 },
+            ],
+            execution: [
+                { name: 'correctness', weight: 0.7 },
+                { name: 'performance', weight: 0.3 },
+            ],
+            validation: [
+                { name: 'test_coverage', weight: 0.5 },
+                { name: 'quality_score', weight: 0.5 },
+            ],
+        };
+        return criteria[phase] || [{ name: 'completion', weight: 1.0 }];
+    }
+    /**
+     * Find suitable agent for capabilities
+     */
+    async findSuitableAgent(requiredCapabilities) {
+        const agents = await this.hiveMind.getAgents();
+        // Filter available agents with required capabilities
+        const suitableAgents = agents.filter((agent) => agent.status === 'idle' &&
+            requiredCapabilities.every((cap) => agent.capabilities.includes(cap)));
+        if (suitableAgents.length === 0) {
+            return null;
+        }
+        // Select best agent based on performance history
+        return this.selectBestAgent(suitableAgents, requiredCapabilities);
+    }
+    /**
+     * Select best agent from candidates
+     */
+    async selectBestAgent(agents, capabilities) {
+        // Simple selection - in production would use performance metrics
+        const scores = await Promise.all(agents.map(async (agent) => {
+            const performance = await this.db.getAgentPerformance(agent.id);
+            return {
+                agent,
+                score: performance?.successRate || 0.5,
+            };
+        }));
+        scores.sort((a, b) => b.score - a.score);
+        return scores[0].agent;
+    }
+    /**
+     * Wait for agent to complete task
+     */
+    async waitForAgentCompletion(agent, taskId, timeout) {
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                reject(new Error(`Agent ${agent.id} timeout on task ${taskId}`));
+            }, timeout);
+            const checkCompletion = async () => {
+                const agentState = await this.db.getAgent(agent.id);
+                if (agentState.current_task_id !== taskId) {
+                    clearTimeout(timer);
+                    clearInterval(interval);
+                    // Get task result
+                    const task = await this.db.getTask(taskId);
+                    resolve(task.result ? JSON.parse(task.result) : {});
+                }
+            };
+            const interval = setInterval(checkCompletion, 1000);
+        });
+    }
+    /**
+     * Aggregate results from phase execution
+     */
+    aggregatePhaseResults(phase, results) {
+        return {
+            phase,
+            results,
+            summary: this.summarizeResults(results),
+            timestamp: new Date(),
+        };
+    }
+    /**
+     * Summarize phase results
+     */
+    summarizeResults(results) {
+        const successful = results.filter((r) => r.success).length;
+        const total = results.length;
+        return {
+            successRate: total > 0 ? successful / total : 0,
+            totalExecutions: total,
+            aggregatedData: results.map((r) => r.data).filter(Boolean),
+        };
+    }
+    /**
+     * Queue assignment for later
+     */
+    queueAssignment(taskId, assignment) {
+        if (!this.taskAssignments.has(taskId)) {
+            this.taskAssignments.set(taskId, []);
+        }
+        this.taskAssignments.get(taskId).push(assignment);
+        this.emit('assignmentQueued', { taskId, assignment });
+    }
+    /**
+     * Evaluate checkpoint
+     */
+    async evaluateCheckpoint(task, checkpoint, execution) {
+        const phaseResult = execution.phaseResults[checkpoint.index];
+        if (!phaseResult)
+            return;
+        let score = 0;
+        for (const criterion of checkpoint.validationCriteria) {
+            const criterionScore = this.evaluateCriterion(phaseResult, criterion);
+            score += criterionScore * criterion.weight;
+        }
+        if (score < checkpoint.failureThreshold) {
+            throw new Error(`Checkpoint failed at phase ${checkpoint.phase}: score ${score}`);
+        }
+        this.emit('checkpointPassed', { task, checkpoint, score });
+    }
+    /**
+     * Evaluate validation criterion
+     */
+    evaluateCriterion(result, criterion) {
+        // Simplified evaluation - in production would be more sophisticated
+        if (result.summary && result.summary.successRate !== undefined) {
+            return result.summary.successRate;
+        }
+        return 0.7; // Default passing score
+    }
+    /**
+     * Complete task execution
+     */
+    async completeTask(task, execution) {
+        const finalResult = {
+            success: true,
+            executionTime: Date.now() - execution.startTime,
+            phases: execution.phaseResults,
+            summary: this.createExecutionSummary(execution),
+        };
+        await this.db.updateTask(task.id, {
+            status: 'completed',
+            result: JSON.stringify(finalResult),
+            progress: 100,
+            completed_at: new Date(),
+        });
+        this.emit('taskCompleted', { task, result: finalResult });
+    }
+    /**
+     * Handle task failure
+     */
+    async handleTaskFailure(task, execution, error) {
+        await this.db.updateTask(task.id, {
+            status: 'failed',
+            error: error.message,
+            completed_at: new Date(),
+        });
+        this.emit('taskFailed', { task, error });
+    }
+    /**
+     * Create execution summary
+     */
+    createExecutionSummary(execution) {
+        const phaseCount = execution.phaseResults.length;
+        const successfulPhases = execution.phaseResults.filter((r) => r.summary?.successRate > 0.5).length;
+        return {
+            totalPhases: phaseCount,
+            successfulPhases,
+            overallSuccess: phaseCount > 0 ? successfulPhases / phaseCount : 0,
+            executionTime: Date.now() - execution.startTime,
+        };
+    }
+    /**
+     * Notify agent of task cancellation
+     */
+    async notifyAgentTaskCancelled(agentId, taskId) {
+        // Send cancellation message to agent
+        await this.db.createCommunication({
+            from_agent_id: 'orchestrator',
+            to_agent_id: agentId,
+            swarm_id: this.hiveMind.id,
+            message_type: 'task_cancellation',
+            content: JSON.stringify({ taskId, reason: 'User cancelled' }),
+            priority: 'urgent',
+        });
+    }
+    /**
+     * Analyze load distribution
+     */
+    async analyzeLoadDistribution() {
+        const agents = await this.hiveMind.getAgents();
+        const tasks = await this.db.getActiveTasks(this.hiveMind.id);
+        const busyAgents = agents.filter((a) => a.status === 'busy');
+        const idleAgents = agents.filter((a) => a.status === 'idle');
+        const unassignedTasks = tasks.filter((t) => !t.assigned_agents || JSON.parse(t.assigned_agents).length === 0);
+        return {
+            totalAgents: agents.length,
+            busyAgents: busyAgents.length,
+            idleAgents: idleAgents.length,
+            activeTasks: tasks.length,
+            unassignedTasks: unassignedTasks.map((t) => ({
+                id: t.id,
+                priority: t.priority,
+                requiredCapabilities: JSON.parse(t.required_capabilities || '[]'),
+            })),
+            loadFactor: agents.length > 0 ? busyAgents.length / agents.length : 0,
+        };
+    }
+    /**
+     * Apply load balancing reassignments
+     */
+    async applyReassignments(reassignments) {
+        for (const reassignment of reassignments) {
+            await this.reassignTask(reassignment.taskId, reassignment.fromAgent, reassignment.toAgent);
+        }
+    }
+    /**
+     * Reassign task from one agent to another
+     */
+    async reassignTask(taskId, fromAgentId, toAgentId) {
+        // Update task assignment
+        await this.db.reassignTask(taskId, toAgentId);
+        // Update agent states
+        await this.db.updateAgent(fromAgentId, {
+            current_task_id: null,
+            status: 'idle',
+        });
+        await this.db.updateAgent(toAgentId, {
+            current_task_id: taskId,
+            status: 'busy',
+        });
+        // Notify agents
+        await this.notifyAgentReassignment(fromAgentId, toAgentId, taskId);
+    }
+    /**
+     * Notify agents of reassignment
+     */
+    async notifyAgentReassignment(fromAgentId, toAgentId, taskId) {
+        // Notify source agent
+        await this.db.createCommunication({
+            from_agent_id: 'orchestrator',
+            to_agent_id: fromAgentId,
+            swarm_id: this.hiveMind.id,
+            message_type: 'task_reassignment',
+            content: JSON.stringify({ taskId, reassignedTo: toAgentId }),
+            priority: 'high',
+        });
+        // Notify target agent
+        const task = await this.db.getTask(taskId);
+        const plan = this.executionPlans.get(taskId);
+        await this.db.createCommunication({
+            from_agent_id: 'orchestrator',
+            to_agent_id: toAgentId,
+            swarm_id: this.hiveMind.id,
+            message_type: 'task_assignment',
+            content: JSON.stringify({
+                taskId,
+                task: task.description,
+                executionPlan: plan,
+            }),
+            priority: 'high',
+        });
+    }
+    /**
+     * Start task distributor loop
+     */
+    startTaskDistributor() {
+        setInterval(async () => {
+            if (!this.isActive)
+                return;
+            try {
+                // Check for queued assignments
+                for (const [taskId, assignments] of this.taskAssignments) {
+                    for (const assignment of assignments) {
+                        const agent = await this.findSuitableAgent(assignment.requiredCapabilities);
+                        if (agent) {
+                            await this.assignTaskToAgent(taskId, agent.id);
+                            // Remove from queue
+                            const remaining = assignments.filter((a) => a !== assignment);
+                            if (remaining.length === 0) {
+                                this.taskAssignments.delete(taskId);
+                            }
+                            else {
+                                this.taskAssignments.set(taskId, remaining);
+                            }
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                this.emit('error', error);
+            }
+        }, 5000); // Every 5 seconds
+    }
+    /**
+     * Start progress monitor loop
+     */
+    startProgressMonitor() {
+        setInterval(async () => {
+            if (!this.isActive)
+                return;
+            try {
+                // Monitor active executions
+                for (const [taskId, execution] of this.activeExecutions) {
+                    const task = await this.db.getTask(taskId);
+                    if (task.status === 'in_progress') {
+                        const progress = this.calculateProgress(execution);
+                        if (progress !== task.progress) {
+                            await this.db.updateTask(taskId, { progress });
+                            this.emit('progressUpdate', { taskId, progress });
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                this.emit('error', error);
+            }
+        }, 2000); // Every 2 seconds
+    }
+    /**
+     * Start load balancer loop
+     */
+    startLoadBalancer() {
+        setInterval(async () => {
+            if (!this.isActive)
+                return;
+            try {
+                const load = await this.analyzeLoadDistribution();
+                // Trigger rebalancing if needed
+                if (load.loadFactor > 0.8 &&
+                    load.idleAgents.length > 0 &&
+                    load.unassignedTasks.length > 0) {
+                    await this.rebalance();
+                }
+            }
+            catch (error) {
+                this.emit('error', error);
+            }
+        }, 30000); // Every 30 seconds
+    }
+    /**
+     * Calculate task progress
+     */
+    calculateProgress(execution) {
+        if (!execution.plan || !execution.plan.phases)
+            return 0;
+        const totalPhases = execution.plan.phases.length;
+        const completedPhases = execution.currentPhase;
+        return Math.round((completedPhases / totalPhases) * 100);
+    }
+    /**
+     * Shutdown orchestrator
+     */
+    async shutdown() {
+        this.isActive = false;
+        // Cancel all active executions
+        for (const taskId of this.activeExecutions.keys()) {
+            await this.cancelTask(taskId);
+        }
+        this.emit('shutdown');
+    }
+}
+//# sourceMappingURL=SwarmOrchestrator.js.map