snow-flow 3.0.8 → 3.0.10

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

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

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

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

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