snow-flow 3.0.8 → 3.0.10

package/dist/agents/coordinator.js

@@ -1,777 +0,0 @@
-"use strict";
-/**
- * Agent Coordination System
- * Manages inter-agent communication, task dependencies, and handoffs
- * Integrates with SQLite memory for persistent coordination state
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AgentCoordinator = void 0;
-const eventemitter3_1 = require("eventemitter3");
-const crypto = __importStar(require("crypto"));
-class AgentCoordinator extends eventemitter3_1.EventEmitter {
-    constructor(memory) {
-        super();
-        this.memory = memory;
-        this.contexts = new Map();
-        this.strategies = new Map();
-        this.recoveryStrategies = new Map();
-        this.messageQueue = new Map();
-        this.initializeDefaultStrategies();
-        this.setupMemorySync();
-    }
-    /**
-     * Create a new coordination context for an objective
-     */
-    async createContext(sessionId, objectiveId) {
-        const context = {
-            sessionId,
-            objectiveId,
-            agents: new Map(),
-            dependencies: new Map(),
-            handoffs: new Map(),
-            blockages: new Map()
-        };
-        this.contexts.set(objectiveId, context);
-        // Store context in memory for persistence
-        await this.memory.store(`coordination_context_${objectiveId}`, {
-            sessionId,
-            objectiveId,
-            createdAt: new Date().toISOString()
-        });
-        this.emit('context:created', { sessionId, objectiveId });
-        return context;
-    }
-    /**
-     * Register an agent with the coordinator
-     */
-    async registerAgent(agent, objectiveId) {
-        // Find or create context
-        let context;
-        if (objectiveId) {
-            context = this.contexts.get(objectiveId);
-        }
-        else {
-            // Find context that needs this agent type
-            for (const ctx of this.contexts.values()) {
-                if (!Array.from(ctx.agents.values()).some(a => a.type === agent.type)) {
-                    context = ctx;
-                    break;
-                }
-            }
-        }
-        if (!context) {
-            throw new Error('No suitable coordination context found for agent');
-        }
-        context.agents.set(agent.id, agent);
-        // Store agent registration in memory
-        await this.memory.store(`agent_registration_${agent.id}`, {
-            agentId: agent.id,
-            agentType: agent.type,
-            objectiveId: context.objectiveId,
-            sessionId: context.sessionId,
-            registeredAt: new Date().toISOString()
-        });
-        // Initialize message queue for agent
-        this.messageQueue.set(agent.id, []);
-        this.emit('agent:registered', { agent, objectiveId: context.objectiveId });
-    }
-    /**
-     * Manage task dependencies between agents
-     */
-    async manageDependencies(objectiveId, taskId, dependencies) {
-        const context = this.contexts.get(objectiveId);
-        if (!context) {
-            throw new Error(`No context found for objective: ${objectiveId}`);
-        }
-        context.dependencies.set(taskId, dependencies);
-        // Store dependencies in memory
-        await this.memory.store(`dependencies_${taskId}`, {
-            taskId,
-            dependencies,
-            objectiveId,
-            createdAt: new Date().toISOString()
-        });
-        // Check if any dependencies are already satisfied
-        await this.checkDependencySatisfaction(context, taskId);
-    }
-    /**
-     * Coordinate handoff between agents
-     */
-    async coordinateHandoff(fromAgentId, toAgentId, artifactType, artifactData) {
-        const handoffId = this.generateId('handoff');
-        const handoff = {
-            id: handoffId,
-            fromAgent: fromAgentId,
-            toAgent: toAgentId,
-            artifactType,
-            artifactData,
-            status: 'pending',
-            createdAt: new Date()
-        };
-        // Find context containing these agents
-        let context;
-        for (const ctx of this.contexts.values()) {
-            if (ctx.agents.has(fromAgentId) && ctx.agents.has(toAgentId)) {
-                context = ctx;
-                break;
-            }
-        }
-        if (!context) {
-            throw new Error('No coordination context found for agents');
-        }
-        context.handoffs.set(handoffId, handoff);
-        // Store handoff in memory
-        await this.memory.store(`handoff_${handoffId}`, {
-            handoff,
-            objectiveId: context.objectiveId,
-            timestamp: new Date().toISOString()
-        });
-        // Notify receiving agent
-        await this.sendMessage(fromAgentId, toAgentId, 'coordination', {
-            type: 'handoff_request',
-            handoffId,
-            artifactType,
-            artifactData
-        });
-        this.emit('agent:handoff', {
-            handoffId,
-            fromAgent: fromAgentId,
-            toAgent: toAgentId,
-            artifactType,
-            objectiveId: context.objectiveId
-        });
-        return handoff;
-    }
-    /**
-     * Handle agent blockage with recovery strategies
-     */
-    async handleBlockage(agentId, reason, blockedTasks) {
-        // Find context containing this agent
-        let context;
-        for (const ctx of this.contexts.values()) {
-            if (ctx.agents.has(agentId)) {
-                context = ctx;
-                break;
-            }
-        }
-        if (!context) {
-            throw new Error(`No context found for agent: ${agentId}`);
-        }
-        const blockage = {
-            agentId,
-            reason,
-            blockedTasks,
-            dependencies: this.findBlockedDependencies(context, blockedTasks),
-            attemptedResolutions: [],
-            createdAt: new Date()
-        };
-        context.blockages.set(agentId, blockage);
-        // Store blockage in memory
-        await this.memory.store(`blockage_${agentId}_${Date.now()}`, {
-            blockage,
-            objectiveId: context.objectiveId,
-            timestamp: new Date().toISOString()
-        });
-        // Attempt recovery
-        await this.attemptRecovery(context, blockage);
-        this.emit('agent:blocked', {
-            agentId,
-            reason,
-            blockedTasks,
-            objectiveId: context.objectiveId
-        });
-    }
-    /**
-     * Send message between agents
-     */
-    async sendMessage(fromAgentId, toAgentId, messageType, content) {
-        const message = {
-            from: fromAgentId,
-            to: toAgentId,
-            type: messageType,
-            content,
-            timestamp: new Date()
-        };
-        // Add to message queue
-        const queue = this.messageQueue.get(toAgentId) || [];
-        queue.push(message);
-        this.messageQueue.set(toAgentId, queue);
-        // Store message in memory for audit
-        await this.memory.store(`message_${Date.now()}_${crypto.randomBytes(4).toString('hex')}`, {
-            message,
-            delivered: false,
-            timestamp: new Date().toISOString()
-        });
-        // Process message immediately if agent is listening
-        await this.processAgentMessages(toAgentId);
-        this.emit('message:sent', message);
-    }
-    /**
-     * Get pending messages for an agent
-     */
-    async getAgentMessages(agentId) {
-        const messages = this.messageQueue.get(agentId) || [];
-        // Clear processed messages
-        this.messageQueue.set(agentId, []);
-        return messages;
-    }
-    /**
-     * Update handoff status
-     */
-    async updateHandoffStatus(handoffId, status) {
-        let handoff;
-        let context;
-        // Find handoff in contexts
-        for (const ctx of this.contexts.values()) {
-            if (ctx.handoffs.has(handoffId)) {
-                handoff = ctx.handoffs.get(handoffId);
-                context = ctx;
-                break;
-            }
-        }
-        if (!handoff || !context) {
-            throw new Error(`Handoff not found: ${handoffId}`);
-        }
-        handoff.status = status;
-        if (status === 'completed' || status === 'failed') {
-            handoff.completedAt = new Date();
-        }
-        // Update memory
-        await this.memory.store(`handoff_status_${handoffId}`, {
-            handoffId,
-            newStatus: status,
-            timestamp: new Date().toISOString()
-        });
-        this.emit('handoff:updated', {
-            handoffId,
-            status,
-            objectiveId: context.objectiveId
-        });
-    }
-    /**
-     * Get coordination status for an objective
-     */
-    async getCoordinationStatus(objectiveId) {
-        const context = this.contexts.get(objectiveId);
-        if (!context) {
-            throw new Error(`No context found for objective: ${objectiveId}`);
-        }
-        const agents = Array.from(context.agents.values());
-        const handoffs = Array.from(context.handoffs.values());
-        // Count satisfied dependencies
-        let totalDeps = 0;
-        let satisfiedDeps = 0;
-        for (const deps of context.dependencies.values()) {
-            totalDeps += deps.length;
-            // Check each dependency (would need task completion tracking)
-            satisfiedDeps += deps.filter(d => this.isDependencySatisfied(context, d)).length;
-        }
-        return {
-            agents: {
-                total: agents.length,
-                active: agents.filter(a => a.status === 'working').length,
-                blocked: context.blockages.size
-            },
-            handoffs: {
-                total: handoffs.length,
-                pending: handoffs.filter(h => h.status === 'pending').length,
-                completed: handoffs.filter(h => h.status === 'completed').length
-            },
-            dependencies: {
-                total: totalDeps,
-                satisfied: satisfiedDeps
-            },
-            blockages: context.blockages.size
-        };
-    }
-    /**
-     * Apply coordination strategy
-     */
-    async applyStrategy(objectiveId, strategyType) {
-        const context = this.contexts.get(objectiveId);
-        if (!context) {
-            throw new Error(`No context found for objective: ${objectiveId}`);
-        }
-        const strategy = this.strategies.get(strategyType);
-        if (!strategy) {
-            throw new Error(`Unknown strategy: ${strategyType}`);
-        }
-        // Apply strategy rules
-        for (const rule of strategy.rules) {
-            if (this.evaluateCondition(context, rule.condition)) {
-                await this.executeAction(context, rule.action);
-            }
-        }
-        this.emit('strategy:applied', { objectiveId, strategyType });
-    }
-    /**
-     * Terminate an agent
-     */
-    async terminateAgent(agentId) {
-        // Find and remove agent from all contexts
-        for (const context of this.contexts.values()) {
-            if (context.agents.has(agentId)) {
-                context.agents.delete(agentId);
-                // Clear any blockages
-                context.blockages.delete(agentId);
-                // Update memory
-                await this.memory.store(`agent_terminated_${agentId}`, {
-                    agentId,
-                    objectiveId: context.objectiveId,
-                    terminatedAt: new Date().toISOString()
-                });
-                this.emit('agent:terminated', { agentId, objectiveId: context.objectiveId });
-                break;
-            }
-        }
-        // Clear message queue
-        this.messageQueue.delete(agentId);
-    }
-    /**
-     * Initialize default coordination strategies
-     */
-    initializeDefaultStrategies() {
-        // Sequential strategy
-        this.strategies.set('sequential', {
-            type: 'sequential',
-            rules: [
-                {
-                    condition: 'hasBlockedAgent',
-                    action: 'waitForDependencies',
-                    priority: 1
-                },
-                {
-                    condition: 'allDependenciesSatisfied',
-                    action: 'proceedToNextTask',
-                    priority: 2
-                }
-            ]
-        });
-        // Parallel strategy
-        this.strategies.set('parallel', {
-            type: 'parallel',
-            rules: [
-                {
-                    condition: 'hasIndependentTasks',
-                    action: 'assignToAvailableAgents',
-                    priority: 1
-                },
-                {
-                    condition: 'hasBlockedAgent',
-                    action: 'reassignToOtherAgent',
-                    priority: 2
-                }
-            ]
-        });
-        // Adaptive strategy
-        this.strategies.set('adaptive', {
-            type: 'adaptive',
-            rules: [
-                {
-                    condition: 'highComplexity',
-                    action: 'spawnSpecialistAgent',
-                    priority: 1
-                },
-                {
-                    condition: 'repeatedFailures',
-                    action: 'switchToFallbackApproach',
-                    priority: 2
-                }
-            ]
-        });
-        // Initialize recovery strategies
-        this.initializeRecoveryStrategies();
-    }
-    /**
-     * Initialize recovery strategies for error handling
-     */
-    initializeRecoveryStrategies() {
-        // Permission error recovery
-        this.recoveryStrategies.set('permission_error', {
-            errorType: 'permission_error',
-            recoveryActions: [
-                {
-                    type: 'fallback',
-                    config: { scope: 'global' }
-                },
-                {
-                    type: 'escalate',
-                    config: { requestElevation: true }
-                }
-            ],
-            maxRetries: 3
-        });
-        // Dependency timeout recovery
-        this.recoveryStrategies.set('dependency_timeout', {
-            errorType: 'dependency_timeout',
-            recoveryActions: [
-                {
-                    type: 'reassign',
-                    config: { preferredAgentType: 'any' }
-                },
-                {
-                    type: 'fallback',
-                    config: { skipDependency: true }
-                }
-            ],
-            maxRetries: 2
-        });
-        // Resource exhaustion recovery
-        this.recoveryStrategies.set('resource_exhaustion', {
-            errorType: 'resource_exhaustion',
-            recoveryActions: [
-                {
-                    type: 'retry',
-                    config: { delay: 5000 }
-                },
-                {
-                    type: 'reassign',
-                    config: { reduceComplexity: true }
-                }
-            ],
-            maxRetries: 3
-        });
-    }
-    /**
-     * Set up memory synchronization
-     */
-    setupMemorySync() {
-        // Periodically sync coordination state to memory
-        setInterval(async () => {
-            for (const [objectiveId, context] of this.contexts) {
-                await this.syncContextToMemory(objectiveId, context);
-            }
-        }, 30000); // Every 30 seconds
-    }
-    /**
-     * Sync context to memory
-     */
-    async syncContextToMemory(objectiveId, context) {
-        await this.memory.store(`coordination_state_${objectiveId}`, {
-            objectiveId,
-            sessionId: context.sessionId,
-            agentCount: context.agents.size,
-            activeHandoffs: Array.from(context.handoffs.values()).filter(h => h.status === 'pending').length,
-            blockages: context.blockages.size,
-            lastSync: new Date().toISOString()
-        });
-    }
-    /**
-     * Check if dependencies are satisfied
-     */
-    async checkDependencySatisfaction(context, taskId) {
-        const dependencies = context.dependencies.get(taskId) || [];
-        const allSatisfied = dependencies.every(dep => this.isDependencySatisfied(context, dep));
-        if (allSatisfied) {
-            this.emit('dependencies:satisfied', {
-                taskId,
-                objectiveId: context.objectiveId
-            });
-        }
-    }
-    /**
-     * Check if a specific dependency is satisfied
-     */
-    isDependencySatisfied(context, dependencyId) {
-        // Check if dependency task is completed
-        // This would integrate with TodoWrite status
-        // For now, check if there's a completed handoff for this dependency
-        for (const handoff of context.handoffs.values()) {
-            if (handoff.artifactType === dependencyId && handoff.status === 'completed') {
-                return true;
-            }
-        }
-        return false;
-    }
-    /**
-     * Find blocked dependencies
-     */
-    findBlockedDependencies(context, blockedTasks) {
-        const blockedDeps = [];
-        for (const task of blockedTasks) {
-            const deps = context.dependencies.get(task) || [];
-            blockedDeps.push(...deps);
-        }
-        return [...new Set(blockedDeps)]; // Remove duplicates
-    }
-    /**
-     * Attempt recovery for blocked agent
-     */
-    async attemptRecovery(context, blockage) {
-        // Find appropriate recovery strategy
-        const strategy = this.findRecoveryStrategy(blockage.reason);
-        if (!strategy) {
-            this.emit('recovery:failed', {
-                agentId: blockage.agentId,
-                reason: 'No recovery strategy available'
-            });
-            return;
-        }
-        // Try recovery actions
-        for (const action of strategy.recoveryActions) {
-            if (blockage.attemptedResolutions.length >= strategy.maxRetries) {
-                break;
-            }
-            try {
-                await this.executeRecoveryAction(context, blockage, action);
-                blockage.attemptedResolutions.push(action.type);
-                // If successful, remove blockage
-                context.blockages.delete(blockage.agentId);
-                this.emit('recovery:success', {
-                    agentId: blockage.agentId,
-                    action: action.type
-                });
-                return;
-            }
-            catch (error) {
-                blockage.attemptedResolutions.push(`${action.type}_failed`);
-            }
-        }
-        this.emit('recovery:exhausted', {
-            agentId: blockage.agentId,
-            attempts: blockage.attemptedResolutions
-        });
-    }
-    /**
-     * Find recovery strategy for error type
-     */
-    findRecoveryStrategy(errorReason) {
-        // Match error reason to strategy
-        for (const [key, strategy] of this.recoveryStrategies) {
-            if (errorReason.toLowerCase().includes(key.replace('_', ' '))) {
-                return strategy;
-            }
-        }
-        return undefined;
-    }
-    /**
-     * Execute recovery action
-     */
-    async executeRecoveryAction(context, blockage, action) {
-        switch (action.type) {
-            case 'retry':
-                // Wait and retry
-                await new Promise(resolve => setTimeout(resolve, action.config.delay || 1000));
-                // Agent would retry its task
-                break;
-            case 'fallback':
-                // Use fallback approach
-                await this.sendMessage('coordinator', blockage.agentId, 'coordination', {
-                    type: 'use_fallback',
-                    config: action.config
-                });
-                break;
-            case 'reassign': {
-                // Find another agent
-                const availableAgent = this.findAvailableAgent(context, action.config.preferredAgentType);
-                if (availableAgent) {
-                    await this.reassignTasks(context, blockage.agentId, availableAgent.id);
-                }
-                break;
-            }
-            case 'escalate':
-                // Escalate to Queen
-                this.emit('escalation:required', {
-                    blockage,
-                    action: action.config
-                });
-                break;
-        }
-    }
-    /**
-     * Find available agent of specified type
-     */
-    findAvailableAgent(context, preferredType) {
-        for (const agent of context.agents.values()) {
-            if (agent.status === 'idle' &&
-                (preferredType === 'any' || agent.type === preferredType)) {
-                return agent;
-            }
-        }
-        return undefined;
-    }
-    /**
-     * Reassign tasks from one agent to another
-     */
-    async reassignTasks(context, fromAgentId, toAgentId) {
-        // Send reassignment message
-        await this.sendMessage('coordinator', toAgentId, 'task_assignment', {
-            type: 'reassignment',
-            fromAgent: fromAgentId,
-            reason: 'agent_blocked'
-        });
-        this.emit('tasks:reassigned', {
-            fromAgent: fromAgentId,
-            toAgent: toAgentId,
-            objectiveId: context.objectiveId
-        });
-    }
-    /**
-     * Process pending messages for an agent
-     */
-    async processAgentMessages(agentId) {
-        const messages = await this.getAgentMessages(agentId);
-        for (const message of messages) {
-            this.emit('message:delivered', message);
-        }
-    }
-    /**
-     * Evaluate strategy condition
-     */
-    evaluateCondition(context, condition) {
-        switch (condition) {
-            case 'hasBlockedAgent':
-                return context.blockages.size > 0;
-            case 'allDependenciesSatisfied':
-                // Check if all dependencies are satisfied
-                for (const deps of context.dependencies.values()) {
-                    if (!deps.every(d => this.isDependencySatisfied(context, d))) {
-                        return false;
-                    }
-                }
-                return true;
-            case 'hasIndependentTasks':
-                // Check for tasks with no dependencies
-                return Array.from(context.dependencies.values()).some(deps => deps.length === 0);
-            case 'highComplexity':
-                // Would need complexity metric
-                return context.agents.size > 5;
-            case 'repeatedFailures':
-                // Check for multiple blockages
-                return context.blockages.size > 2;
-            default:
-                return false;
-        }
-    }
-    /**
-     * Execute strategy action
-     */
-    async executeAction(context, action) {
-        switch (action) {
-            case 'waitForDependencies':
-                // Agents would wait for dependencies
-                this.emit('action:wait', { objectiveId: context.objectiveId });
-                break;
-            case 'proceedToNextTask':
-                // Signal agents to proceed
-                for (const agent of context.agents.values()) {
-                    await this.sendMessage('coordinator', agent.id, 'coordination', {
-                        type: 'proceed'
-                    });
-                }
-                break;
-            case 'assignToAvailableAgents': {
-                // Distribute tasks to available agents
-                const availableAgents = Array.from(context.agents.values())
-                    .filter(a => a.status === 'idle');
-                // Would assign tasks here
-                this.emit('action:assign', {
-                    objectiveId: context.objectiveId,
-                    agentCount: availableAgents.length
-                });
-                break;
-            }
-            case 'spawnSpecialistAgent':
-                // Request Queen to spawn specialist
-                this.emit('action:spawn_specialist', { objectiveId: context.objectiveId });
-                break;
-            case 'switchToFallbackApproach':
-                // Signal all agents to use fallback
-                for (const agent of context.agents.values()) {
-                    await this.sendMessage('coordinator', agent.id, 'coordination', {
-                        type: 'use_fallback'
-                    });
-                }
-                break;
-        }
-    }
-    /**
-     * Generate unique ID
-     */
-    generateId(prefix) {
-        return `${prefix}_${Date.now()}_${crypto.randomBytes(4).toString('hex')}`;
-    }
-    /**
-     * Get coordinator statistics
-     */
-    async getStats() {
-        let totalAgents = 0;
-        let activeHandoffs = 0;
-        let blockedAgents = 0;
-        let messagesInQueue = 0;
-        for (const context of this.contexts.values()) {
-            totalAgents += context.agents.size;
-            activeHandoffs += Array.from(context.handoffs.values())
-                .filter(h => h.status === 'pending').length;
-            blockedAgents += context.blockages.size;
-        }
-        for (const queue of this.messageQueue.values()) {
-            messagesInQueue += queue.length;
-        }
-        return {
-            activeContexts: this.contexts.size,
-            totalAgents,
-            activeHandoffs,
-            blockedAgents,
-            messagesInQueue
-        };
-    }
-    /**
-     * Clean up completed contexts
-     */
-    async cleanup() {
-        const now = Date.now();
-        const maxAge = 3600000; // 1 hour
-        for (const [objectiveId, context] of this.contexts) {
-            // Check if all agents are terminated and no active handoffs
-            const allAgentsIdle = Array.from(context.agents.values())
-                .every(a => a.status === 'idle' || a.status === 'completed');
-            const noActiveHandoffs = Array.from(context.handoffs.values())
-                .every(h => h.status === 'completed' || h.status === 'failed');
-            if (allAgentsIdle && noActiveHandoffs) {
-                // Check age of last activity
-                const lastActivity = Math.max(...Array.from(context.handoffs.values())
-                    .map(h => h.completedAt?.getTime() || 0));
-                if (now - lastActivity > maxAge) {
-                    this.contexts.delete(objectiveId);
-                    this.emit('context:cleaned', { objectiveId });
-                }
-            }
-        }
-    }
-}
-exports.AgentCoordinator = AgentCoordinator;
-//# sourceMappingURL=coordinator.js.map