snow-flow 2.0.4 → 2.0.6

package/dist/coordination/coordination-engine.d.ts

@@ -0,0 +1,41 @@
+import { EventEmitter } from 'eventemitter3';
+import { SharedMemoryManager } from './shared-memory';
+import { QualityGateManager } from './quality-gates';
+import { CoordinationResult, TaskSpecification, BaseTeam, CoordinationConfig, ExecutionPlan } from './types';
+export declare class CoordinationEngine extends EventEmitter {
+    private sharedMemory;
+    private qualityGates;
+    private progressMonitor;
+    private config;
+    constructor(config?: Partial<CoordinationConfig>);
+    coordinateTeamExecution(team: BaseTeam, specification: TaskSpecification): Promise<CoordinationResult>;
+    private initializeSharedContext;
+    private createTaskGraph;
+    private findBestAgent;
+    private setupQualityGates;
+    private executeCoordinatedTasks;
+    private selectExecutionPattern;
+    private selectOptimalPattern;
+    private validateFinalResult;
+    private calculateMetrics;
+    private calculateErrorMetrics;
+    getExecutionPlan(specification: TaskSpecification): Promise<ExecutionPlan>;
+    /**
+     * Create a planning team based on task requirements
+     */
+    private createPlanningTeam;
+    /**
+     * Determine the optimal agent type for a task
+     */
+    private determineAgentType;
+    /**
+     * Assign optimal agent from team for a task
+     */
+    private assignOptimalAgent;
+    getSharedMemory(): SharedMemoryManager;
+    getQualityGateManager(): QualityGateManager;
+    pauseExecution(): Promise<void>;
+    resumeExecution(): Promise<void>;
+    abortExecution(reason: string): Promise<void>;
+}
+//# sourceMappingURL=coordination-engine.d.ts.map

package/dist/coordination/coordination-engine.js

@@ -0,0 +1,324 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoordinationEngine = void 0;
+const eventemitter3_1 = require("eventemitter3");
+const shared_memory_1 = require("./shared-memory");
+const task_dependencies_1 = require("./task-dependencies");
+const quality_gates_1 = require("./quality-gates");
+const progress_monitor_1 = require("./progress-monitor");
+const execution_patterns_1 = require("./execution-patterns");
+const logger_1 = require("../utils/logger");
+class CoordinationEngine extends eventemitter3_1.EventEmitter {
+    constructor(config = {}) {
+        super();
+        this.config = {
+            maxConcurrentTasks: 5,
+            taskTimeout: 300000, // 5 minutes
+            enableRetries: true,
+            maxRetries: 3,
+            enableQualityGates: true,
+            enableProgressMonitoring: true,
+            executionPattern: 'auto',
+            memoryTtl: 3600000, // 1 hour
+            errorRecoveryStrategy: 'retry',
+            ...config
+        };
+        this.sharedMemory = new shared_memory_1.SharedMemoryManager(this.config.memoryTtl);
+        this.qualityGates = new quality_gates_1.QualityGateManager();
+        this.progressMonitor = new progress_monitor_1.ProgressMonitor();
+        logger_1.logger.info('🚀 Coordination Engine initialized', { config: this.config });
+    }
+    async coordinateTeamExecution(team, specification) {
+        const startTime = Date.now();
+        try {
+            logger_1.logger.info('🎯 Starting team coordination', {
+                specification: specification.name,
+                tasks: specification.tasks.length
+            });
+            // Initialize shared context
+            await this.initializeSharedContext(specification);
+            // Create and optimize task dependency graph
+            const taskGraph = await this.createTaskGraph(team, specification);
+            // Setup quality gates
+            await this.setupQualityGates(specification);
+            // Start progress monitoring
+            if (this.config.enableProgressMonitoring) {
+                await this.progressMonitor.startMonitoring(team, taskGraph);
+            }
+            // Execute coordinated tasks
+            const results = await this.executeCoordinatedTasks(team, taskGraph, specification);
+            // Validate final result
+            const finalValidation = await this.validateFinalResult(results, specification);
+            const metrics = this.calculateMetrics(taskGraph, startTime);
+            return {
+                success: true,
+                results,
+                metrics,
+                errors: [],
+                warnings: finalValidation.warnings || []
+            };
+        }
+        catch (error) {
+            logger_1.logger.error('❌ Team coordination failed', { error: error.message });
+            return {
+                success: false,
+                results: {},
+                metrics: this.calculateErrorMetrics(startTime),
+                errors: [error],
+                warnings: []
+            };
+        }
+    }
+    async initializeSharedContext(specification) {
+        logger_1.logger.info('🧠 Initializing shared context');
+        // Store specification in shared memory
+        await this.sharedMemory.store('task_specification', specification);
+        // Initialize shared context variables
+        for (const [key, value] of Object.entries(specification.sharedContext)) {
+            await this.sharedMemory.store(`context_${key}`, value);
+        }
+        // Create coordination namespace
+        await this.sharedMemory.store('coordination_metadata', {
+            startTime: new Date(),
+            totalTasks: specification.tasks.length,
+            executionId: Math.random().toString(36).substr(2, 9)
+        });
+    }
+    async createTaskGraph(team, specification) {
+        logger_1.logger.info('📊 Creating task dependency graph');
+        const taskGraph = new task_dependencies_1.TaskDependencyGraph(this.sharedMemory, this.config);
+        // Add tasks to graph
+        for (const taskDef of specification.tasks) {
+            // Find appropriate agent
+            const agent = this.findBestAgent(team, taskDef);
+            if (!agent) {
+                throw new Error(`No suitable agent found for task: ${taskDef.id} (requires: ${taskDef.agentType})`);
+            }
+            taskGraph.addTask(taskDef.id, agent, taskDef.requirements, taskDef.dependencies);
+        }
+        // Validate graph for circular dependencies
+        await taskGraph.validateGraph();
+        logger_1.logger.info('✅ Task dependency graph created', {
+            totalTasks: specification.tasks.length,
+            maxParallelism: await taskGraph.getMaxParallelism()
+        });
+        return taskGraph;
+    }
+    findBestAgent(team, taskDef) {
+        // Get agents of the required type
+        const candidates = team.getAgentsByType(taskDef.agentType);
+        if (candidates.length === 0) {
+            return null;
+        }
+        // Simple selection: first available agent
+        // TODO: Implement more sophisticated agent selection algorithm
+        return candidates.find(agent => agent.status === 'idle') || candidates[0];
+    }
+    async setupQualityGates(specification) {
+        if (!this.config.enableQualityGates) {
+            return;
+        }
+        logger_1.logger.info('🛡️ Setting up quality gates');
+        for (const gateConfig of specification.qualityGates) {
+            for (const taskId of gateConfig.taskIds) {
+                for (const gate of gateConfig.gates) {
+                    this.qualityGates.addGate(taskId, gate);
+                }
+            }
+        }
+    }
+    async executeCoordinatedTasks(team, taskGraph, specification) {
+        logger_1.logger.info('🚀 Starting coordinated task execution');
+        // Select execution pattern
+        const executionPattern = this.selectExecutionPattern(taskGraph, specification);
+        logger_1.logger.info('📋 Execution pattern selected', { pattern: executionPattern.constructor.name });
+        // Execute tasks
+        const results = await executionPattern.execute(team, taskGraph);
+        // Emit completion event
+        this.emit('coordination:completed', { results, taskGraph });
+        return results;
+    }
+    selectExecutionPattern(taskGraph, specification) {
+        const patternType = specification.executionPattern || this.config.executionPattern;
+        switch (patternType) {
+            case 'sequential':
+                return new execution_patterns_1.SequentialExecutionPattern(this.qualityGates, this.progressMonitor, this.config);
+            case 'parallel':
+                return new execution_patterns_1.ParallelExecutionPattern(this.qualityGates, this.progressMonitor, this.config);
+            case 'hybrid':
+                return new execution_patterns_1.HybridExecutionPattern(this.qualityGates, this.progressMonitor, this.config);
+            case 'auto':
+                // Intelligent pattern selection based on task characteristics
+                return this.selectOptimalPattern(taskGraph);
+            default:
+                return new execution_patterns_1.HybridExecutionPattern(this.qualityGates, this.progressMonitor, this.config);
+        }
+    }
+    selectOptimalPattern(taskGraph) {
+        const complexity = taskGraph.getComplexityScore();
+        const parallelism = taskGraph.getMaxParallelism();
+        if (parallelism > 3 && complexity < 0.7) {
+            logger_1.logger.info('🏃‍♂️ Selected parallel execution pattern');
+            return new execution_patterns_1.ParallelExecutionPattern(this.qualityGates, this.progressMonitor, this.config);
+        }
+        else if (complexity > 0.8) {
+            logger_1.logger.info('🚶‍♂️ Selected sequential execution pattern');
+            return new execution_patterns_1.SequentialExecutionPattern(this.qualityGates, this.progressMonitor, this.config);
+        }
+        else {
+            logger_1.logger.info('🤸‍♂️ Selected hybrid execution pattern');
+            return new execution_patterns_1.HybridExecutionPattern(this.qualityGates, this.progressMonitor, this.config);
+        }
+    }
+    async validateFinalResult(results, specification) {
+        logger_1.logger.info('🔍 Validating final coordination result');
+        const validation = {
+            success: true,
+            warnings: []
+        };
+        // Check if all required tasks completed
+        for (const taskDef of specification.tasks) {
+            if (!results[taskDef.id]) {
+                validation.success = false;
+                validation.warnings.push(`Task ${taskDef.id} did not complete successfully`);
+            }
+        }
+        // Check if all required outputs are present
+        for (const taskDef of specification.tasks) {
+            const taskResult = results[taskDef.id];
+            if (taskResult) {
+                for (const expectedOutput of taskDef.outputs) {
+                    if (!taskResult[expectedOutput]) {
+                        validation.warnings.push(`Task ${taskDef.id} missing expected output: ${expectedOutput}`);
+                    }
+                }
+            }
+        }
+        return validation;
+    }
+    calculateMetrics(taskGraph, startTime) {
+        const endTime = Date.now();
+        const totalTasks = taskGraph.getTotalTasks();
+        const completedTasks = taskGraph.getCompletedTasks();
+        const failedTasks = taskGraph.getFailedTasks();
+        return {
+            totalTasks,
+            completedTasks: completedTasks.length,
+            failedTasks: failedTasks.length,
+            totalExecutionTime: endTime - startTime,
+            averageTaskTime: completedTasks.length > 0 ?
+                completedTasks.reduce((sum, task) => sum + (task.endTime.getTime() - task.startTime.getTime()), 0) / completedTasks.length : 0,
+            concurrentTasks: this.config.maxConcurrentTasks
+        };
+    }
+    calculateErrorMetrics(startTime) {
+        return {
+            totalTasks: 0,
+            completedTasks: 0,
+            failedTasks: 0,
+            totalExecutionTime: Date.now() - startTime,
+            averageTaskTime: 0,
+            concurrentTasks: 0
+        };
+    }
+    // Public API methods
+    async getExecutionPlan(specification) {
+        // Initialize a proper planning team with required agents
+        const planningTeam = this.createPlanningTeam(specification);
+        const taskGraph = new task_dependencies_1.TaskDependencyGraph(this.sharedMemory, this.config);
+        // Add tasks with proper agent assignments for realistic planning
+        for (const taskDef of specification.tasks) {
+            const agent = this.assignOptimalAgent(taskDef, planningTeam);
+            taskGraph.addTask(taskDef.id, agent, taskDef.requirements, taskDef.dependencies);
+        }
+        return await taskGraph.generateExecutionPlan();
+    }
+    /**
+     * Create a planning team based on task requirements
+     */
+    createPlanningTeam(specification) {
+        const agents = new Map();
+        // Analyze tasks to determine required agent types
+        for (const task of specification.tasks) {
+            const requiredType = this.determineAgentType(task);
+            if (!agents.has(requiredType)) {
+                agents.set(requiredType, {
+                    id: `${requiredType}_agent_${Date.now()}`,
+                    type: requiredType,
+                    capabilities: task.requirements || [],
+                    status: 'ready'
+                });
+            }
+        }
+        // Ensure at least one general agent exists
+        if (agents.size === 0) {
+            agents.set('general', {
+                id: `general_agent_${Date.now()}`,
+                type: 'general',
+                capabilities: [],
+                status: 'ready'
+            });
+        }
+        return {
+            agents,
+            id: `planning_team_${Date.now()}`,
+            name: 'Planning Team',
+            type: 'planning'
+        };
+    }
+    /**
+     * Determine the optimal agent type for a task
+     */
+    determineAgentType(task) {
+        const taskType = task.type?.toLowerCase() || '';
+        const requirements = task.requirements || [];
+        if (taskType.includes('widget') || requirements.includes('frontend'))
+            return 'frontend';
+        if (taskType.includes('flow') || requirements.includes('process'))
+            return 'process';
+        if (taskType.includes('backend') || requirements.includes('server'))
+            return 'backend';
+        if (taskType.includes('security') || requirements.includes('security'))
+            return 'security';
+        if (taskType.includes('data') || requirements.includes('database'))
+            return 'data';
+        return 'general'; // Default fallback
+    }
+    /**
+     * Assign optimal agent from team for a task
+     */
+    assignOptimalAgent(task, team) {
+        const requiredType = this.determineAgentType(task);
+        const agent = team.agents.get(requiredType) || team.agents.get('general');
+        if (!agent) {
+            logger_1.logger.warn(`No suitable agent found for task type: ${requiredType}, creating default agent`);
+            return {
+                id: `default_agent_${Date.now()}`,
+                type: 'general',
+                capabilities: [],
+                status: 'ready'
+            };
+        }
+        return agent;
+    }
+    getSharedMemory() {
+        return this.sharedMemory;
+    }
+    getQualityGateManager() {
+        return this.qualityGates;
+    }
+    async pauseExecution() {
+        logger_1.logger.info('⏸️ Pausing coordination execution');
+        this.emit('coordination:paused');
+    }
+    async resumeExecution() {
+        logger_1.logger.info('▶️ Resuming coordination execution');
+        this.emit('coordination:resumed');
+    }
+    async abortExecution(reason) {
+        logger_1.logger.warn('🛑 Aborting coordination execution', { reason });
+        this.emit('coordination:aborted', { reason });
+    }
+}
+exports.CoordinationEngine = CoordinationEngine;
+//# sourceMappingURL=coordination-engine.js.map

package/dist/coordination/coordination.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Unit tests for the Team Coordination Framework
+ */
+import { TaskSpecification } from './types';
+export declare function createTestSpecification(name: string, taskCount?: number): TaskSpecification;
+//# sourceMappingURL=coordination.test.d.ts.map

package/dist/coordination/example.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Comprehensive example of using the Team Coordination Framework
+ * for ServiceNow development workflows
+ */
+import { BaseTeam } from './types';
+/**
+ * Example: ServiceNow Widget Development with Team Coordination
+ */
+declare function exampleWidgetDevelopment(): Promise<void>;
+/**
+ * Example: ServiceNow Flow Development with Parallel Execution
+ */
+declare function exampleFlowDevelopment(): Promise<void>;
+/**
+ * Example: Advanced Coordination with Custom Quality Gates
+ */
+declare function exampleAdvancedCoordination(): Promise<void>;
+/**
+ * Example: Real-time Progress Monitoring
+ */
+declare function exampleProgressMonitoring(): Promise<void>;
+/**
+ * Create a mock team of specialized agents for demonstration
+ */
+declare function createMockTeam(): BaseTeam;
+/**
+ * Run all examples
+ */
+declare function runAllExamples(): Promise<void>;
+export { exampleWidgetDevelopment, exampleFlowDevelopment, exampleAdvancedCoordination, exampleProgressMonitoring, runAllExamples, createMockTeam };
+//# sourceMappingURL=example.d.ts.map