snow-flow 3.0.9 → 3.0.10

package/dist/coordination/task-dependencies.js

@@ -1,407 +0,0 @@
-"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

@@ -1,59 +0,0 @@
-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