snow-flow 3.0.8 → 3.0.10

package/dist/coordination/execution-patterns.js

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

@@ -1,94 +0,0 @@
-/**
- * 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