snow-flow 2.0.4 → 2.0.6

package/dist/coordination/execution-patterns.js

@@ -0,0 +1,507 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdaptiveExecutionPattern = exports.HybridExecutionPattern = exports.ParallelExecutionPattern = exports.SequentialExecutionPattern = exports.ExecutionPattern = void 0;
+const eventemitter3_1 = require("eventemitter3");
+const logger_1 = require("../utils/logger");
+class ExecutionPattern extends eventemitter3_1.EventEmitter {
+    constructor(qualityGates, progressMonitor, config) {
+        super();
+        this.qualityGates = qualityGates;
+        this.progressMonitor = progressMonitor;
+        this.config = config;
+    }
+    async executeTaskWithQualityGates(taskId, taskGraph) {
+        try {
+            // Execute the task
+            const result = await taskGraph.executeTask(taskId);
+            // Run quality gates if enabled
+            if (this.config.enableQualityGates) {
+                const gateResult = await this.qualityGates.validateTask(taskId, result);
+                if (!gateResult.passed && gateResult.blocking) {
+                    throw new Error(`Quality gate failed for task ${taskId}: ${gateResult.validations.map(v => v.error).join('; ')}`);
+                }
+                // Store quality gate results
+                return {
+                    ...result,
+                    qualityGates: gateResult
+                };
+            }
+            return result;
+        }
+        catch (error) {
+            logger_1.logger.error('❌ Task execution with quality gates failed', {
+                taskId,
+                error: error.message
+            });
+            throw error;
+        }
+    }
+    async waitForAvailableSlot(currentTasks) {
+        while (currentTasks.size >= this.config.maxConcurrentTasks) {
+            await new Promise(resolve => setTimeout(resolve, 100));
+        }
+    }
+}
+exports.ExecutionPattern = ExecutionPattern;
+class SequentialExecutionPattern extends ExecutionPattern {
+    async execute(team, taskGraph) {
+        logger_1.logger.info('🚶‍♂️ Starting sequential execution pattern');
+        const result = {};
+        const executionOrder = await this.getSequentialOrder(taskGraph);
+        let completedTasks = 0;
+        const totalTasks = executionOrder.length;
+        for (const taskId of executionOrder) {
+            try {
+                logger_1.logger.info('🔄 Executing task sequentially', {
+                    taskId,
+                    progress: `${completedTasks + 1}/${totalTasks}`
+                });
+                const taskResult = await this.executeTaskWithQualityGates(taskId, taskGraph);
+                result[taskId] = taskResult;
+                completedTasks++;
+                this.emit('task:completed', {
+                    taskId,
+                    result: taskResult,
+                    progress: completedTasks / totalTasks
+                });
+                logger_1.logger.info('✅ Task completed sequentially', {
+                    taskId,
+                    remainingTasks: totalTasks - completedTasks
+                });
+            }
+            catch (error) {
+                logger_1.logger.error('❌ Sequential task execution failed', {
+                    taskId,
+                    error: error.message
+                });
+                this.emit('task:failed', { taskId, error });
+                // Handle error based on recovery strategy
+                if (this.config.errorRecoveryStrategy === 'abort') {
+                    throw error;
+                }
+                // Continue with next task for 'continue' strategy
+            }
+        }
+        logger_1.logger.info('🏁 Sequential execution completed', {
+            completedTasks,
+            totalTasks
+        });
+        return result;
+    }
+    async getSequentialOrder(taskGraph) {
+        const levels = await taskGraph.topologicalSort();
+        return levels.flat();
+    }
+}
+exports.SequentialExecutionPattern = SequentialExecutionPattern;
+class ParallelExecutionPattern extends ExecutionPattern {
+    async execute(team, taskGraph) {
+        logger_1.logger.info('🏃‍♂️ Starting parallel execution pattern');
+        const result = {};
+        const executionLevels = await taskGraph.topologicalSort();
+        let totalCompleted = 0;
+        const totalTasks = executionLevels.flat().length;
+        for (let levelIndex = 0; levelIndex < executionLevels.length; levelIndex++) {
+            const level = executionLevels[levelIndex];
+            logger_1.logger.info('🚀 Executing parallel level', {
+                level: levelIndex + 1,
+                tasks: level,
+                parallelTasks: level.length
+            });
+            try {
+                // Execute all tasks in the level in parallel
+                const levelTasks = level.map(taskId => this.executeTaskWithQualityGates(taskId, taskGraph)
+                    .then(taskResult => ({ taskId, result: taskResult }))
+                    .catch(error => ({ taskId, error })));
+                const levelResults = await Promise.allSettled(levelTasks);
+                // Process results
+                for (const settled of levelResults) {
+                    if (settled.status === 'fulfilled') {
+                        const { taskId, result: taskResult, error } = settled.value;
+                        if (error) {
+                            logger_1.logger.error('❌ Parallel task failed', { taskId, error: error.message });
+                            this.emit('task:failed', { taskId, error });
+                            if (this.config.errorRecoveryStrategy === 'abort') {
+                                throw error;
+                            }
+                        }
+                        else {
+                            result[taskId] = taskResult;
+                            totalCompleted++;
+                            this.emit('task:completed', {
+                                taskId,
+                                result: taskResult,
+                                progress: totalCompleted / totalTasks
+                            });
+                            logger_1.logger.info('✅ Parallel task completed', { taskId });
+                        }
+                    }
+                }
+                logger_1.logger.info('✅ Parallel level completed', {
+                    level: levelIndex + 1,
+                    completedTasks: level.length
+                });
+            }
+            catch (error) {
+                logger_1.logger.error('❌ Parallel level execution failed', {
+                    level: levelIndex + 1,
+                    error: error.message
+                });
+                if (this.config.errorRecoveryStrategy === 'abort') {
+                    throw error;
+                }
+            }
+        }
+        logger_1.logger.info('🏁 Parallel execution completed', {
+            totalCompleted,
+            totalTasks,
+            levels: executionLevels.length
+        });
+        return result;
+    }
+}
+exports.ParallelExecutionPattern = ParallelExecutionPattern;
+class HybridExecutionPattern extends ExecutionPattern {
+    async execute(team, taskGraph) {
+        logger_1.logger.info('🤸‍♂️ Starting hybrid execution pattern');
+        const result = {};
+        const optimizedPlan = await this.optimizeExecutionPlan(taskGraph);
+        let totalCompleted = 0;
+        const totalTasks = taskGraph.getTotalTasks();
+        for (let phaseIndex = 0; phaseIndex < optimizedPlan.phases.length; phaseIndex++) {
+            const phase = optimizedPlan.phases[phaseIndex];
+            logger_1.logger.info('🔄 Executing hybrid phase', {
+                phase: phaseIndex + 1,
+                type: phase.type,
+                tasks: phase.tasks.length
+            });
+            try {
+                if (phase.type === 'parallel') {
+                    await this.executeParallelPhase(phase.tasks, taskGraph, result);
+                }
+                else {
+                    await this.executeSequentialPhase(phase.tasks, taskGraph, result);
+                }
+                totalCompleted += phase.tasks.length;
+                this.emit('phase:completed', {
+                    phase: phaseIndex + 1,
+                    type: phase.type,
+                    progress: totalCompleted / totalTasks
+                });
+            }
+            catch (error) {
+                logger_1.logger.error('❌ Hybrid phase execution failed', {
+                    phase: phaseIndex + 1,
+                    error: error.message
+                });
+                if (this.config.errorRecoveryStrategy === 'abort') {
+                    throw error;
+                }
+            }
+        }
+        logger_1.logger.info('🏁 Hybrid execution completed', {
+            totalCompleted,
+            totalTasks,
+            phases: optimizedPlan.phases.length
+        });
+        return result;
+    }
+    async optimizeExecutionPlan(taskGraph) {
+        const levels = await taskGraph.topologicalSort();
+        const phases = [];
+        for (const level of levels) {
+            if (level.length === 1) {
+                // Single task - run sequentially
+                phases.push({
+                    type: 'sequential',
+                    tasks: level,
+                    estimatedDuration: this.estimateTaskDuration(level[0], taskGraph),
+                    riskLevel: 'low'
+                });
+            }
+            else {
+                // Multiple tasks - analyze for optimization
+                const riskLevel = this.assessParallelRisk(level, taskGraph);
+                if (riskLevel === 'high' || level.length > this.config.maxConcurrentTasks) {
+                    // Break into smaller parallel groups or sequential
+                    phases.push(...this.optimizeLargeLevel(level, taskGraph));
+                }
+                else {
+                    // Run in parallel
+                    phases.push({
+                        type: 'parallel',
+                        tasks: level,
+                        estimatedDuration: Math.max(...level.map(taskId => this.estimateTaskDuration(taskId, taskGraph))),
+                        riskLevel
+                    });
+                }
+            }
+        }
+        return {
+            phases,
+            totalEstimatedTime: phases.reduce((sum, phase) => sum + phase.estimatedDuration, 0),
+            optimizationStrategy: 'hybrid'
+        };
+    }
+    optimizeLargeLevel(tasks, taskGraph) {
+        const phases = [];
+        const maxParallel = this.config.maxConcurrentTasks;
+        // Split into chunks that can run in parallel
+        for (let i = 0; i < tasks.length; i += maxParallel) {
+            const chunk = tasks.slice(i, i + maxParallel);
+            phases.push({
+                type: 'parallel',
+                tasks: chunk,
+                estimatedDuration: Math.max(...chunk.map(taskId => this.estimateTaskDuration(taskId, taskGraph))),
+                riskLevel: this.assessParallelRisk(chunk, taskGraph)
+            });
+        }
+        return phases;
+    }
+    async executeParallelPhase(tasks, taskGraph, result) {
+        const parallelTasks = tasks.map(taskId => this.executeTaskWithQualityGates(taskId, taskGraph)
+            .then(taskResult => {
+            result[taskId] = taskResult;
+            this.emit('task:completed', { taskId, result: taskResult });
+            return { taskId, success: true };
+        })
+            .catch(error => {
+            this.emit('task:failed', { taskId, error });
+            if (this.config.errorRecoveryStrategy === 'abort') {
+                throw error;
+            }
+            return { taskId, success: false, error };
+        }));
+        await Promise.all(parallelTasks);
+    }
+    async executeSequentialPhase(tasks, taskGraph, result) {
+        for (const taskId of tasks) {
+            try {
+                const taskResult = await this.executeTaskWithQualityGates(taskId, taskGraph);
+                result[taskId] = taskResult;
+                this.emit('task:completed', { taskId, result: taskResult });
+            }
+            catch (error) {
+                this.emit('task:failed', { taskId, error });
+                if (this.config.errorRecoveryStrategy === 'abort') {
+                    throw error;
+                }
+            }
+        }
+    }
+    estimateTaskDuration(taskId, taskGraph) {
+        const task = taskGraph.getTask(taskId);
+        if (!task)
+            return 60000; // Default 1 minute
+        // Look for time constraints
+        const timeConstraint = task.requirements.constraints?.find(c => c.type === 'time');
+        if (timeConstraint) {
+            return timeConstraint.value;
+        }
+        // Estimate based on task complexity
+        const complexity = task.requirements.capabilities?.length || 1;
+        return Math.min(complexity * 30000, 300000); // 30s per capability, max 5 minutes
+    }
+    assessParallelRisk(tasks, taskGraph) {
+        // Assess risk based on resource requirements
+        let resourceConflicts = 0;
+        const requiredResources = new Set();
+        for (const taskId of tasks) {
+            const task = taskGraph.getTask(taskId);
+            if (!task)
+                continue;
+            const resources = task.requirements.resources || [];
+            for (const resource of resources) {
+                const resourceKey = `${resource.type}:${resource.metadata?.identifier || 'default'}`;
+                if (requiredResources.has(resourceKey)) {
+                    resourceConflicts++;
+                }
+                requiredResources.add(resourceKey);
+            }
+        }
+        if (resourceConflicts > 2 || tasks.length > 5)
+            return 'high';
+        if (resourceConflicts > 0 || tasks.length > 3)
+            return 'medium';
+        return 'low';
+    }
+}
+exports.HybridExecutionPattern = HybridExecutionPattern;
+class AdaptiveExecutionPattern extends ExecutionPattern {
+    constructor() {
+        super(...arguments);
+        this.performanceHistory = new Map();
+    }
+    async execute(team, taskGraph) {
+        logger_1.logger.info('🧠 Starting adaptive execution pattern');
+        const result = {};
+        let currentStrategy = 'hybrid';
+        const levels = await taskGraph.topologicalSort();
+        let totalCompleted = 0;
+        const totalTasks = levels.flat().length;
+        for (let levelIndex = 0; levelIndex < levels.length; levelIndex++) {
+            const level = levels[levelIndex];
+            // Adapt strategy based on performance history and current conditions
+            const adaptedStrategy = await this.adaptStrategy(level, taskGraph);
+            if (adaptedStrategy !== currentStrategy) {
+                logger_1.logger.info('🔄 Adapting execution strategy', {
+                    from: currentStrategy,
+                    to: adaptedStrategy,
+                    level: levelIndex + 1
+                });
+                currentStrategy = adaptedStrategy;
+            }
+            const startTime = Date.now();
+            try {
+                switch (currentStrategy) {
+                    case 'sequential':
+                        await this.executeSequentialLevel(level, taskGraph, result);
+                        break;
+                    case 'parallel':
+                        await this.executeParallelLevel(level, taskGraph, result);
+                        break;
+                    case 'hybrid':
+                        await this.executeHybridLevel(level, taskGraph, result);
+                        break;
+                }
+                const executionTime = Date.now() - startTime;
+                this.recordPerformanceMetrics(levelIndex, currentStrategy, level.length, executionTime, true);
+                totalCompleted += level.length;
+            }
+            catch (error) {
+                const executionTime = Date.now() - startTime;
+                this.recordPerformanceMetrics(levelIndex, currentStrategy, level.length, executionTime, false);
+                logger_1.logger.error('❌ Adaptive level execution failed', {
+                    level: levelIndex + 1,
+                    strategy: currentStrategy,
+                    error: error.message
+                });
+                if (this.config.errorRecoveryStrategy === 'abort') {
+                    throw error;
+                }
+            }
+        }
+        logger_1.logger.info('🏁 Adaptive execution completed', {
+            totalCompleted,
+            totalTasks,
+            finalStrategy: currentStrategy
+        });
+        return result;
+    }
+    async adaptStrategy(level, taskGraph) {
+        const levelSize = level.length;
+        const complexity = this.calculateLevelComplexity(level, taskGraph);
+        const riskLevel = this.assessParallelRisk(level, taskGraph);
+        const historicalPerformance = this.getHistoricalPerformance();
+        // Decision matrix based on multiple factors
+        if (levelSize === 1) {
+            return 'sequential';
+        }
+        if (riskLevel === 'high' || complexity > 0.8) {
+            return 'sequential';
+        }
+        if (levelSize <= 3 && riskLevel === 'low' && historicalPerformance.parallelSuccessRate > 0.8) {
+            return 'parallel';
+        }
+        if (levelSize > this.config.maxConcurrentTasks || complexity > 0.6) {
+            return 'hybrid';
+        }
+        // Default to parallel for medium-sized, low-risk levels
+        return historicalPerformance.parallelSuccessRate > 0.6 ? 'parallel' : 'hybrid';
+    }
+    calculateLevelComplexity(level, taskGraph) {
+        let totalComplexity = 0;
+        for (const taskId of level) {
+            const task = taskGraph.getTask(taskId);
+            if (!task)
+                continue;
+            const capabilities = task.requirements.capabilities?.length || 1;
+            const resources = task.requirements.resources?.length || 1;
+            const constraints = task.requirements.constraints?.length || 0;
+            totalComplexity += (capabilities + resources + constraints) / 10;
+        }
+        return Math.min(totalComplexity / level.length, 1);
+    }
+    async executeSequentialLevel(level, taskGraph, result) {
+        for (const taskId of level) {
+            const taskResult = await this.executeTaskWithQualityGates(taskId, taskGraph);
+            result[taskId] = taskResult;
+        }
+    }
+    async executeParallelLevel(level, taskGraph, result) {
+        const tasks = level.map(taskId => this.executeTaskWithQualityGates(taskId, taskGraph)
+            .then(taskResult => {
+            result[taskId] = taskResult;
+            return taskResult;
+        }));
+        await Promise.all(tasks);
+    }
+    async executeHybridLevel(level, taskGraph, result) {
+        const maxParallel = Math.min(level.length, this.config.maxConcurrentTasks);
+        for (let i = 0; i < level.length; i += maxParallel) {
+            const chunk = level.slice(i, i + maxParallel);
+            await this.executeParallelLevel(chunk, taskGraph, result);
+        }
+    }
+    recordPerformanceMetrics(level, strategy, taskCount, executionTime, success) {
+        const key = `${strategy}_${taskCount}`;
+        const existing = this.performanceHistory.get(key) || {
+            totalExecutions: 0,
+            successfulExecutions: 0,
+            averageTime: 0,
+            bestTime: Infinity,
+            worstTime: 0
+        };
+        existing.totalExecutions++;
+        if (success) {
+            existing.successfulExecutions++;
+        }
+        existing.averageTime = (existing.averageTime * (existing.totalExecutions - 1) + executionTime) / existing.totalExecutions;
+        existing.bestTime = Math.min(existing.bestTime, executionTime);
+        existing.worstTime = Math.max(existing.worstTime, executionTime);
+        this.performanceHistory.set(key, existing);
+    }
+    getHistoricalPerformance() {
+        let parallelTotal = 0, parallelSuccess = 0;
+        let hybridTotal = 0, hybridSuccess = 0;
+        for (const [key, metrics] of this.performanceHistory) {
+            if (key.startsWith('parallel_')) {
+                parallelTotal += metrics.totalExecutions;
+                parallelSuccess += metrics.successfulExecutions;
+            }
+            else if (key.startsWith('hybrid_')) {
+                hybridTotal += metrics.totalExecutions;
+                hybridSuccess += metrics.successfulExecutions;
+            }
+        }
+        return {
+            parallelSuccessRate: parallelTotal > 0 ? parallelSuccess / parallelTotal : 0.5,
+            hybridSuccessRate: hybridTotal > 0 ? hybridSuccess / hybridTotal : 0.7
+        };
+    }
+    assessParallelRisk(tasks, taskGraph) {
+        // Implementation similar to HybridExecutionPattern
+        let resourceConflicts = 0;
+        const requiredResources = new Set();
+        for (const taskId of tasks) {
+            const task = taskGraph.getTask(taskId);
+            if (!task)
+                continue;
+            const resources = task.requirements.resources || [];
+            for (const resource of resources) {
+                const resourceKey = `${resource.type}:${resource.metadata?.identifier || 'default'}`;
+                if (requiredResources.has(resourceKey)) {
+                    resourceConflicts++;
+                }
+                requiredResources.add(resourceKey);
+            }
+        }
+        if (resourceConflicts > 2 || tasks.length > 5)
+            return 'high';
+        if (resourceConflicts > 0 || tasks.length > 3)
+            return 'medium';
+        return 'low';
+    }
+}
+exports.AdaptiveExecutionPattern = AdaptiveExecutionPattern;
+//# sourceMappingURL=execution-patterns.js.map

package/dist/coordination/factory.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Factory functions for creating coordination framework components
+ */
+import { CoordinationEngine } from './coordination-engine';
+import { QualityGateManager } from './quality-gates';
+import { CoordinationConfig, QualityGateConfig, TaskSpecification, ProgressListener } from './types';
+/**
+ * Create a coordination engine with sensible defaults
+ */
+export declare function createCoordinationEngine(config?: Partial<CoordinationConfig>): CoordinationEngine;
+/**
+ * Create standard quality gates for general development
+ */
+export declare function createStandardQualityGates(): QualityGateManager;
+/**
+ * Create ServiceNow-specific quality gates
+ */
+export declare function createServiceNowQualityGates(): QualityGateManager;
+/**
+ * Create a progress listener with common logging
+ */
+export declare function createProgressListener(config?: ProgressListenerConfig): ProgressListener;
+/**
+ * Create a task specification builder for common ServiceNow patterns
+ */
+export declare function createServiceNowTaskSpecification(name: string, description: string): TaskSpecificationBuilder;
+/**
+ * Builder pattern for creating task specifications
+ */
+export declare class TaskSpecificationBuilder {
+    private spec;
+    constructor(name: string, description: string);
+    /**
+     * Add a task to the specification
+     */
+    addTask(task: {
+        id: string;
+        name: string;
+        description: string;
+        agentType: string;
+        requirements: any;
+        dependencies?: string[];
+        outputs?: string[];
+        priority?: 'low' | 'medium' | 'high' | 'critical';
+    }): TaskSpecificationBuilder;
+    /**
+     * Add shared context
+     */
+    addContext(key: string, value: any): TaskSpecificationBuilder;
+    /**
+     * Set execution pattern
+     */
+    setExecutionPattern(pattern: 'sequential' | 'parallel' | 'hybrid' | 'auto'): TaskSpecificationBuilder;
+    /**
+     * Add quality gates
+     */
+    addQualityGates(config: QualityGateConfig): TaskSpecificationBuilder;
+    /**
+     * Add ServiceNow widget development tasks
+     */
+    addWidgetDevelopmentTasks(widgetName: string): TaskSpecificationBuilder;
+    /**
+     * Add ServiceNow flow development tasks
+     */
+    addFlowDevelopmentTasks(flowName: string): TaskSpecificationBuilder;
+    /**
+     * Build the final task specification
+     */
+    build(): TaskSpecification;
+}
+/**
+ * Create a complete coordination setup for ServiceNow development
+ */
+export declare function createServiceNowCoordinationSetup(config: {
+    maxConcurrentTasks?: number;
+    enableAdvancedQualityGates?: boolean;
+    memoryTtl?: number;
+    progressLogging?: boolean;
+}): {
+    engine: CoordinationEngine;
+    qualityGates: QualityGateManager;
+    progressListener: ProgressListener;
+    taskBuilder: (name: string, description: string) => TaskSpecificationBuilder;
+};
+interface ProgressListenerConfig {
+    logLevel?: 'debug' | 'info' | 'warn' | 'error';
+    logProgress?: boolean;
+    logTasks?: boolean;
+    logAgents?: boolean;
+    logPerformance?: boolean;
+    customHandler?: (event: string, data: any) => void;
+}
+export {};
+//# sourceMappingURL=factory.d.ts.map