snow-flow 2.0.4 → 2.0.6

package/dist/coordination/task-dependencies.js

@@ -0,0 +1,407 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskDependencyGraph = void 0;
+const eventemitter3_1 = require("eventemitter3");
+const logger_1 = require("../utils/logger");
+class TaskDependencyGraph extends eventemitter3_1.EventEmitter {
+    constructor(sharedMemory, config) {
+        super();
+        this.nodes = new Map();
+        this.edges = new Map();
+        this.reverseEdges = new Map();
+        this.sharedMemory = sharedMemory;
+        this.config = config;
+        logger_1.logger.info('📊 Task Dependency Graph initialized');
+    }
+    addTask(taskId, agent, requirements, dependencies = []) {
+        try {
+            // Create task node
+            const node = {
+                id: taskId,
+                agent,
+                requirements,
+                status: 'pending',
+                result: null,
+                retryCount: 0
+            };
+            this.nodes.set(taskId, node);
+            this.edges.set(taskId, new Set(dependencies));
+            // Build reverse dependency graph for efficient querying
+            for (const dep of dependencies) {
+                if (!this.reverseEdges.has(dep)) {
+                    this.reverseEdges.set(dep, new Set());
+                }
+                this.reverseEdges.get(dep).add(taskId);
+            }
+            logger_1.logger.debug('📝 Added task to dependency graph', {
+                taskId,
+                agentId: agent?.id,
+                dependencies: dependencies.length
+            });
+            this.emit('task:added', { taskId, dependencies });
+        }
+        catch (error) {
+            logger_1.logger.error('❌ Failed to add task to dependency graph', { taskId, error: error.message });
+            throw error;
+        }
+    }
+    async getReadyTasks() {
+        const ready = [];
+        for (const [taskId, node] of this.nodes) {
+            if (node.status === 'pending' && await this.areDependenciesComplete(taskId)) {
+                ready.push(node);
+            }
+        }
+        return ready;
+    }
+    async areDependenciesComplete(taskId) {
+        const dependencies = this.edges.get(taskId) || new Set();
+        for (const depId of dependencies) {
+            const depNode = this.nodes.get(depId);
+            if (!depNode || depNode.status !== 'completed') {
+                return false;
+            }
+        }
+        return true;
+    }
+    async executeTask(taskId) {
+        const node = this.nodes.get(taskId);
+        if (!node) {
+            throw new Error(`Task not found: ${taskId}`);
+        }
+        // Check if already executing or completed
+        if (node.status === 'in_progress' || node.status === 'completed') {
+            return node.result;
+        }
+        try {
+            logger_1.logger.info('🚀 Executing task', { taskId, agentId: node.agent?.id });
+            node.status = 'in_progress';
+            node.startTime = new Date();
+            this.emit('task:started', { taskId, agentId: node.agent?.id });
+            // Store task status in shared memory
+            await this.sharedMemory.store(`task_status_${taskId}`, {
+                status: 'in_progress',
+                startTime: node.startTime,
+                agentId: node.agent?.id
+            });
+            // Get dependency results
+            const dependencyResults = await this.getDependencyResults(taskId);
+            // Execute the task through the agent
+            const result = await this.executeTaskWithRetry(node, dependencyResults);
+            // Update node
+            node.status = 'completed';
+            node.result = result;
+            node.endTime = new Date();
+            // Store result in shared memory
+            await this.sharedMemory.store(`task_result_${taskId}`, result);
+            await this.sharedMemory.store(`task_status_${taskId}`, {
+                status: 'completed',
+                endTime: node.endTime,
+                duration: node.endTime.getTime() - node.startTime.getTime()
+            });
+            logger_1.logger.info('✅ Task completed successfully', {
+                taskId,
+                duration: node.endTime.getTime() - node.startTime.getTime()
+            });
+            this.emit('task:completed', { taskId, result });
+            return result;
+        }
+        catch (error) {
+            node.status = 'failed';
+            node.error = error;
+            node.endTime = new Date();
+            // Store error in shared memory
+            await this.sharedMemory.store(`task_error_${taskId}`, {
+                error: error.message,
+                timestamp: node.endTime
+            });
+            logger_1.logger.error('❌ Task execution failed', {
+                taskId,
+                error: error.message,
+                retryCount: node.retryCount
+            });
+            this.emit('task:failed', { taskId, error });
+            // Handle error recovery
+            if (this.config.enableRetries && node.retryCount < this.config.maxRetries) {
+                await this.scheduleRetry(taskId);
+            }
+            else {
+                await this.handleTaskFailure(taskId, error);
+            }
+            throw error;
+        }
+    }
+    async executeTaskWithRetry(node, dependencyResults) {
+        const maxRetries = this.config.enableRetries ? this.config.maxRetries : 0;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            try {
+                if (attempt > 0) {
+                    logger_1.logger.info('🔄 Retrying task execution', {
+                        taskId: node.id,
+                        attempt: attempt + 1,
+                        maxRetries: maxRetries + 1
+                    });
+                }
+                // Execute task through agent
+                const result = await this.executeAgentTask(node, dependencyResults);
+                return result;
+            }
+            catch (error) {
+                node.retryCount = attempt + 1;
+                if (attempt < maxRetries) {
+                    // Wait before retry with exponential backoff
+                    const delay = Math.min(1000 * Math.pow(2, attempt), 30000);
+                    await new Promise(resolve => setTimeout(resolve, delay));
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+    }
+    async executeAgentTask(node, dependencyResults) {
+        // This would be the interface to the actual agent execution
+        // For now, we'll simulate agent task execution
+        if (!node.agent) {
+            throw new Error(`No agent assigned to task: ${node.id}`);
+        }
+        // Prepare task context
+        const taskContext = {
+            taskId: node.id,
+            requirements: node.requirements,
+            dependencies: dependencyResults,
+            sharedMemory: this.sharedMemory
+        };
+        // Simulate task execution (in real implementation, this would call the agent)
+        // TODO: Replace with actual agent task execution interface
+        return await this.simulateAgentExecution(node, taskContext);
+    }
+    async simulateAgentExecution(node, context) {
+        // Simulation of agent task execution
+        // In real implementation, this would interface with the actual agent system
+        const delay = Math.random() * 2000 + 1000; // 1-3 seconds
+        await new Promise(resolve => setTimeout(resolve, delay));
+        return {
+            taskId: node.id,
+            agentId: node.agent?.id,
+            outputs: node.requirements.outputs,
+            executionTime: delay,
+            timestamp: new Date()
+        };
+    }
+    async scheduleRetry(taskId) {
+        const node = this.nodes.get(taskId);
+        if (!node)
+            return;
+        node.status = 'pending';
+        logger_1.logger.info('⏰ Scheduled task retry', { taskId, retryCount: node.retryCount });
+        this.emit('task:retry_scheduled', { taskId, retryCount: node.retryCount });
+    }
+    async handleTaskFailure(taskId, error) {
+        logger_1.logger.error('💥 Task failed permanently', { taskId, error: error.message });
+        switch (this.config.errorRecoveryStrategy) {
+            case 'abort':
+                this.emit('graph:abort_requested', { failedTask: taskId, error });
+                break;
+            case 'continue':
+                // Mark dependent tasks as skipped
+                await this.markDependentTasksAsSkipped(taskId);
+                break;
+            case 'retry':
+                // Already handled in executeTaskWithRetry
+                break;
+        }
+    }
+    async markDependentTasksAsSkipped(failedTaskId) {
+        const dependents = this.reverseEdges.get(failedTaskId) || new Set();
+        for (const dependentId of dependents) {
+            const dependentNode = this.nodes.get(dependentId);
+            if (dependentNode && dependentNode.status === 'pending') {
+                dependentNode.status = 'cancelled';
+                logger_1.logger.warn('⏭️ Skipped dependent task due to failure', {
+                    taskId: dependentId,
+                    failedDependency: failedTaskId
+                });
+                // Recursively skip dependents
+                await this.markDependentTasksAsSkipped(dependentId);
+            }
+        }
+    }
+    async getDependencyResults(taskId) {
+        const dependencies = this.edges.get(taskId) || new Set();
+        const results = {};
+        for (const depId of dependencies) {
+            const depNode = this.nodes.get(depId);
+            if (depNode && depNode.status === 'completed') {
+                results[depId] = depNode.result;
+            }
+        }
+        return results;
+    }
+    async topologicalSort() {
+        const levels = [];
+        const visited = new Set();
+        const inDegree = new Map();
+        // Calculate in-degrees
+        for (const [taskId] of this.nodes) {
+            inDegree.set(taskId, (this.edges.get(taskId) || new Set()).size);
+        }
+        while (visited.size < this.nodes.size) {
+            const currentLevel = [];
+            // Find tasks with no dependencies
+            for (const [taskId] of this.nodes) {
+                if (!visited.has(taskId) && inDegree.get(taskId) === 0) {
+                    currentLevel.push(taskId);
+                }
+            }
+            if (currentLevel.length === 0) {
+                const remaining = Array.from(this.nodes.keys()).filter(id => !visited.has(id));
+                throw new Error(`Circular dependency detected among tasks: ${remaining.join(', ')}`);
+            }
+            levels.push(currentLevel);
+            // Update in-degrees and mark as visited
+            for (const taskId of currentLevel) {
+                visited.add(taskId);
+                const dependents = this.reverseEdges.get(taskId) || new Set();
+                for (const dependent of dependents) {
+                    const currentInDegree = inDegree.get(dependent) || 0;
+                    inDegree.set(dependent, currentInDegree - 1);
+                }
+            }
+        }
+        return levels;
+    }
+    async validateGraph() {
+        try {
+            // Check for circular dependencies
+            await this.topologicalSort();
+            // Check that all dependencies exist
+            for (const [taskId, dependencies] of this.edges) {
+                for (const depId of dependencies) {
+                    if (!this.nodes.has(depId)) {
+                        throw new Error(`Task ${taskId} depends on non-existent task: ${depId}`);
+                    }
+                }
+            }
+            logger_1.logger.info('✅ Task dependency graph validation passed');
+        }
+        catch (error) {
+            logger_1.logger.error('❌ Task dependency graph validation failed', { error: error.message });
+            throw error;
+        }
+    }
+    async generateExecutionPlan() {
+        const levels = await this.topologicalSort();
+        const phases = [];
+        for (let i = 0; i < levels.length; i++) {
+            const level = levels[i];
+            phases.push({
+                id: `phase_${i}`,
+                type: level.length > 1 ? 'parallel' : 'sequential',
+                tasks: level,
+                estimatedDuration: this.estimatePhaseDuration(level),
+                dependencies: i > 0 ? [`phase_${i - 1}`] : []
+            });
+        }
+        const criticalPath = this.findCriticalPath();
+        const parallelizationOpportunities = this.findParallelizationOpportunities(levels);
+        return {
+            phases,
+            totalEstimatedTime: phases.reduce((sum, phase) => sum + phase.estimatedDuration, 0),
+            criticalPath,
+            parallelizationOpportunities
+        };
+    }
+    estimatePhaseDuration(tasks) {
+        // Simple estimation - in practice this would be more sophisticated
+        return Math.max(...tasks.map(taskId => {
+            const node = this.nodes.get(taskId);
+            return node?.requirements.constraints?.find(c => c.type === 'time')?.value || 60000; // Default 1 minute
+        }));
+    }
+    findCriticalPath() {
+        // Simplified critical path calculation
+        // In practice, this would use more sophisticated algorithms
+        const levels = this.getTopologicalLevels();
+        return levels.flat();
+    }
+    getTopologicalLevels() {
+        try {
+            return this.topologicalSort();
+        }
+        catch {
+            return [];
+        }
+    }
+    findParallelizationOpportunities(levels) {
+        const opportunities = [];
+        for (const level of levels) {
+            if (level.length > 1) {
+                opportunities.push({
+                    tasks: level,
+                    estimatedSavings: (level.length - 1) * this.estimatePhaseDuration(level),
+                    riskLevel: level.length > 3 ? 'high' : level.length > 1 ? 'medium' : 'low'
+                });
+            }
+        }
+        return opportunities;
+    }
+    // Query methods
+    getTotalTasks() {
+        return this.nodes.size;
+    }
+    getCompletedTasks() {
+        return Array.from(this.nodes.values()).filter(node => node.status === 'completed');
+    }
+    getFailedTasks() {
+        return Array.from(this.nodes.values()).filter(node => node.status === 'failed');
+    }
+    getInProgressTasks() {
+        return Array.from(this.nodes.values()).filter(node => node.status === 'in_progress');
+    }
+    getPendingTasks() {
+        return Array.from(this.nodes.values()).filter(node => node.status === 'pending');
+    }
+    getTask(taskId) {
+        return this.nodes.get(taskId);
+    }
+    getMaxParallelism() {
+        try {
+            const levels = this.getTopologicalLevels();
+            return Math.max(...levels.map(level => level.length));
+        }
+        catch {
+            return 1;
+        }
+    }
+    getComplexityScore() {
+        const totalTasks = this.getTotalTasks();
+        const totalDependencies = Array.from(this.edges.values())
+            .reduce((sum, deps) => sum + deps.size, 0);
+        // Complexity score between 0 and 1
+        return totalTasks > 0 ? Math.min(totalDependencies / (totalTasks * totalTasks), 1) : 0;
+    }
+    async getExecutionStats() {
+        const total = this.getTotalTasks();
+        const completed = this.getCompletedTasks();
+        const failed = this.getFailedTasks();
+        const inProgress = this.getInProgressTasks();
+        return {
+            totalTasks: total,
+            completedTasks: completed.length,
+            failedTasks: failed.length,
+            inProgressTasks: inProgress.length,
+            averageExecutionTime: completed.length > 0
+                ? completed.reduce((sum, task) => {
+                    const duration = task.endTime && task.startTime
+                        ? task.endTime.getTime() - task.startTime.getTime()
+                        : 0;
+                    return sum + duration;
+                }, 0) / completed.length
+                : 0,
+            totalRetries: Array.from(this.nodes.values()).reduce((sum, node) => sum + node.retryCount, 0)
+        };
+    }
+}
+exports.TaskDependencyGraph = TaskDependencyGraph;
+//# sourceMappingURL=task-dependencies.js.map

package/dist/coordination/team-coordinator.d.ts

@@ -0,0 +1,59 @@
+import { TeamOptions } from '../teams/base-team.js';
+export interface CoordinationOptions extends TeamOptions {
+    preferTeams?: boolean;
+    maxComplexity?: 'simple' | 'moderate' | 'complex';
+    timeConstraint?: string;
+    qualityLevel?: 'quick' | 'standard' | 'comprehensive';
+}
+export interface TaskAnalysis {
+    domain: string;
+    complexity: 'simple' | 'moderate' | 'complex';
+    scope: 'focused' | 'medium' | 'broad';
+    timeEstimate: string;
+    recommendedApproach: 'individual' | 'team' | 'adaptive';
+    confidence: number;
+    reasoning: string[];
+}
+export interface ExecutionResult {
+    approach: string;
+    executor: string;
+    result: any;
+    executionTime: number;
+    qualityMetrics: any;
+    recommendations: string[];
+}
+export declare class TeamCoordinator {
+    private options;
+    private taskHistory;
+    private performanceMetrics;
+    constructor(options?: CoordinationOptions);
+    coordinate(task: string): Promise<ExecutionResult>;
+    private analyzeTask;
+    private identifyDomain;
+    private assessComplexity;
+    private assessScope;
+    private estimateTime;
+    private determineOptimalApproach;
+    private shouldUseIndividualSpecialist;
+    private shouldUseSpecializedTeam;
+    private selectIndividualSpecialist;
+    private selectSpecializedTeam;
+    private executeWithIndividualSpecialist;
+    private logAnalysis;
+    private calculateExecutionQuality;
+    private assessCompleteness;
+    private assessAccuracy;
+    private assessEfficiency;
+    private parseTimeToMs;
+    private assessMaintainability;
+    private assessScalability;
+    private generateRecommendations;
+    private updatePerformanceMetrics;
+    getTaskHistory(): Map<string, TaskAnalysis>;
+    getPerformanceMetrics(): Map<string, any>;
+    getCoordinatorInsights(): any;
+    private getMostUsedApproach;
+    private getAverageConfidence;
+    private getCoordinatorRecommendations;
+}
+//# sourceMappingURL=team-coordinator.d.ts.map