snow-flow 2.0.4 → 2.0.6

package/dist/coordination/factory.js

@@ -0,0 +1,433 @@
+"use strict";
+/**
+ * Factory functions for creating coordination framework components
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskSpecificationBuilder = void 0;
+exports.createCoordinationEngine = createCoordinationEngine;
+exports.createStandardQualityGates = createStandardQualityGates;
+exports.createServiceNowQualityGates = createServiceNowQualityGates;
+exports.createProgressListener = createProgressListener;
+exports.createServiceNowTaskSpecification = createServiceNowTaskSpecification;
+exports.createServiceNowCoordinationSetup = createServiceNowCoordinationSetup;
+const coordination_engine_1 = require("./coordination-engine");
+const quality_gates_1 = require("./quality-gates");
+const logger_1 = require("../utils/logger");
+/**
+ * Create a coordination engine with sensible defaults
+ */
+function createCoordinationEngine(config = {}) {
+    const defaultConfig = {
+        maxConcurrentTasks: 5,
+        taskTimeout: 300000, // 5 minutes
+        enableRetries: true,
+        maxRetries: 3,
+        enableQualityGates: true,
+        enableProgressMonitoring: true,
+        executionPattern: 'auto',
+        memoryTtl: 3600000, // 1 hour
+        errorRecoveryStrategy: 'retry'
+    };
+    const finalConfig = { ...defaultConfig, ...config };
+    logger_1.logger.info('🏭 Creating coordination engine', { config: finalConfig });
+    return new coordination_engine_1.CoordinationEngine(finalConfig);
+}
+/**
+ * Create standard quality gates for general development
+ */
+function createStandardQualityGates() {
+    const manager = new quality_gates_1.QualityGateManager({
+        enableBlocking: true,
+        enableScoring: true,
+        minPassingScore: 0.7,
+        enableMetrics: true,
+        timeoutMs: 30000
+    });
+    // Add standard gates
+    const codeGate = new quality_gates_1.CodeQualityGate({
+        maxComplexity: 10,
+        minCoverage: 80,
+        requireDocumentation: true,
+        blocking: true
+    });
+    const securityGate = new quality_gates_1.SecurityGate({
+        checkInjection: true,
+        checkXSS: true,
+        checkSecrets: true,
+        checkAuth: true
+    });
+    const performanceGate = new quality_gates_1.PerformanceGate({
+        maxResponseTime: 5000,
+        maxMemoryUsage: 100,
+        blocking: false
+    });
+    logger_1.logger.info('🛡️ Created standard quality gates', {
+        gates: ['code_quality', 'security', 'performance']
+    });
+    return manager;
+}
+/**
+ * Create ServiceNow-specific quality gates
+ */
+function createServiceNowQualityGates() {
+    const manager = new quality_gates_1.QualityGateManager({
+        enableBlocking: true,
+        enableScoring: true,
+        minPassingScore: 0.8,
+        enableMetrics: true,
+        timeoutMs: 45000 // Longer timeout for ServiceNow operations
+    });
+    // ServiceNow specific gates
+    const snowGate = new quality_gates_1.ServiceNowGate({
+        checkScope: true,
+        checkUpdateSet: true,
+        checkNaming: true,
+        checkDependencies: true,
+        blocking: true
+    });
+    const businessGate = new quality_gates_1.BusinessLogicGate({
+        checkRequirements: true,
+        checkOutputs: true,
+        checkErrorHandling: true,
+        blocking: true
+    });
+    const codeGate = new quality_gates_1.CodeQualityGate({
+        maxComplexity: 15, // Slightly higher for ServiceNow scripts
+        minCoverage: 70, // Slightly lower due to ServiceNow testing constraints
+        requireDocumentation: true,
+        blocking: true
+    });
+    const securityGate = new quality_gates_1.SecurityGate({
+        checkInjection: true,
+        checkXSS: true,
+        checkSecrets: true,
+        checkAuth: true,
+        checkPermissions: true // Important for ServiceNow
+    });
+    logger_1.logger.info('🛡️ Created ServiceNow quality gates', {
+        gates: ['servicenow_compliance', 'business_logic', 'code_quality', 'security']
+    });
+    return manager;
+}
+/**
+ * Create a progress listener with common logging
+ */
+function createProgressListener(config = {}) {
+    const { logLevel = 'info', logProgress = true, logTasks = true, logAgents = false, logPerformance = false, customHandler } = config;
+    return {
+        onProgress(event, data) {
+            try {
+                // Custom handler takes precedence
+                if (customHandler) {
+                    customHandler(event, data);
+                    return;
+                }
+                // Standard logging based on event type and configuration
+                switch (event) {
+                    case 'task_progress':
+                        if (logProgress) {
+                            logger_1.logger[logLevel]('📊 Progress Update', {
+                                completed: data.completed,
+                                total: data.total,
+                                percentage: data.percentage,
+                                phase: data.currentPhase
+                            });
+                        }
+                        break;
+                    case 'task:completed':
+                        if (logTasks) {
+                            logger_1.logger[logLevel]('✅ Task Completed', {
+                                taskId: data.taskId,
+                                progress: `${Math.round(data.progress * 100)}%`
+                            });
+                        }
+                        break;
+                    case 'task:failed':
+                        if (logTasks) {
+                            logger_1.logger.error('❌ Task Failed', {
+                                taskId: data.taskId,
+                                error: data.error?.message
+                            });
+                        }
+                        break;
+                    case 'agent_health':
+                        if (logAgents) {
+                            const unhealthy = Object.entries(data.agents)
+                                .filter(([, health]) => health.status === 'error').length;
+                            if (unhealthy > 0) {
+                                logger_1.logger.warn('⚠️ Agent Health Issue', {
+                                    unhealthyAgents: unhealthy,
+                                    totalAgents: Object.keys(data.agents).length
+                                });
+                            }
+                        }
+                        break;
+                    case 'performance_metrics':
+                        if (logPerformance) {
+                            logger_1.logger[logLevel]('⚡ Performance Metrics', {
+                                efficiency: `${Math.round(data.efficiency * 100)}%`,
+                                throughput: data.throughput.toFixed(2),
+                                averageTime: `${Math.round(data.averageTaskTime / 1000)}s`
+                            });
+                        }
+                        break;
+                    case 'bottlenecks_detected':
+                        logger_1.logger.warn('🚧 Bottlenecks Detected', {
+                            count: data.bottlenecks?.length || 0,
+                            types: data.bottlenecks?.map((b) => b.type) || []
+                        });
+                        break;
+                    case 'memory:high_usage':
+                        logger_1.logger.warn('🧠 High Memory Usage', {
+                            usage: `${Math.round(data.usage)}%`
+                        });
+                        break;
+                    default:
+                        // Log unknown events at debug level
+                        logger_1.logger.debug('📡 Coordination Event', { event, data });
+                }
+            }
+            catch (error) {
+                logger_1.logger.error('❌ Progress listener error', {
+                    event,
+                    error: error.message
+                });
+            }
+        }
+    };
+}
+/**
+ * Create a task specification builder for common ServiceNow patterns
+ */
+function createServiceNowTaskSpecification(name, description) {
+    return new TaskSpecificationBuilder(name, description);
+}
+/**
+ * Builder pattern for creating task specifications
+ */
+class TaskSpecificationBuilder {
+    constructor(name, description) {
+        this.spec = {
+            name,
+            description,
+            tasks: [],
+            sharedContext: {},
+            qualityGates: [],
+            executionPattern: 'auto'
+        };
+    }
+    /**
+     * Add a task to the specification
+     */
+    addTask(task) {
+        this.spec.tasks.push({
+            id: task.id,
+            name: task.name,
+            description: task.description,
+            agentType: task.agentType,
+            requirements: task.requirements,
+            dependencies: task.dependencies || [],
+            outputs: task.outputs || [],
+            priority: task.priority || 'medium'
+        });
+        return this;
+    }
+    /**
+     * Add shared context
+     */
+    addContext(key, value) {
+        this.spec.sharedContext[key] = value;
+        return this;
+    }
+    /**
+     * Set execution pattern
+     */
+    setExecutionPattern(pattern) {
+        this.spec.executionPattern = pattern;
+        return this;
+    }
+    /**
+     * Add quality gates
+     */
+    addQualityGates(config) {
+        this.spec.qualityGates.push(config);
+        return this;
+    }
+    /**
+     * Add ServiceNow widget development tasks
+     */
+    addWidgetDevelopmentTasks(widgetName) {
+        return this
+            .addTask({
+            id: 'analyze_requirements',
+            name: 'Analyze Requirements',
+            description: 'Analyze widget requirements and design specifications',
+            agentType: 'analyst',
+            requirements: {
+                inputs: { widgetSpec: widgetName },
+                outputs: ['requirements', 'design'],
+                capabilities: ['analysis', 'design']
+            }
+        })
+            .addTask({
+            id: 'create_widget_template',
+            name: 'Create Widget Template',
+            description: 'Create HTML template for the widget',
+            agentType: 'ui-builder',
+            requirements: {
+                inputs: {},
+                outputs: ['template', 'css'],
+                capabilities: ['html', 'css', 'servicenow']
+            },
+            dependencies: ['analyze_requirements']
+        })
+            .addTask({
+            id: 'implement_client_script',
+            name: 'Implement Client Script',
+            description: 'Implement client-side JavaScript functionality',
+            agentType: 'coder',
+            requirements: {
+                inputs: {},
+                outputs: ['clientScript'],
+                capabilities: ['javascript', 'servicenow', 'frontend']
+            },
+            dependencies: ['create_widget_template']
+        })
+            .addTask({
+            id: 'implement_server_script',
+            name: 'Implement Server Script',
+            description: 'Implement server-side logic and data access',
+            agentType: 'coder',
+            requirements: {
+                inputs: {},
+                outputs: ['serverScript'],
+                capabilities: ['javascript', 'servicenow', 'backend']
+            },
+            dependencies: ['analyze_requirements']
+        })
+            .addTask({
+            id: 'deploy_widget',
+            name: 'Deploy Widget',
+            description: 'Deploy widget to ServiceNow instance',
+            agentType: 'servicenow-specialist',
+            requirements: {
+                inputs: {},
+                outputs: ['deploymentResult'],
+                capabilities: ['servicenow', 'deployment']
+            },
+            dependencies: ['implement_client_script', 'implement_server_script']
+        })
+            .addTask({
+            id: 'test_widget',
+            name: 'Test Widget',
+            description: 'Test widget functionality and integration',
+            agentType: 'tester',
+            requirements: {
+                inputs: {},
+                outputs: ['testResults'],
+                capabilities: ['testing', 'servicenow']
+            },
+            dependencies: ['deploy_widget']
+        });
+    }
+    /**
+     * Add ServiceNow flow development tasks
+     */
+    addFlowDevelopmentTasks(flowName) {
+        return this
+            .addTask({
+            id: 'design_flow',
+            name: 'Design Flow',
+            description: 'Design flow structure and logic',
+            agentType: 'workflow-designer',
+            requirements: {
+                inputs: { flowSpec: flowName },
+                outputs: ['flowDesign', 'flowSteps'],
+                capabilities: ['workflow', 'design', 'servicenow']
+            }
+        })
+            .addTask({
+            id: 'implement_flow',
+            name: 'Implement Flow',
+            description: 'Implement flow using ServiceNow Flow Designer',
+            agentType: 'servicenow-specialist',
+            requirements: {
+                inputs: {},
+                outputs: ['flowDefinition'],
+                capabilities: ['servicenow', 'flow-designer', 'automation']
+            },
+            dependencies: ['design_flow']
+        })
+            .addTask({
+            id: 'test_flow',
+            name: 'Test Flow',
+            description: 'Test flow execution with mock data',
+            agentType: 'tester',
+            requirements: {
+                inputs: {},
+                outputs: ['testResults'],
+                capabilities: ['testing', 'servicenow', 'automation']
+            },
+            dependencies: ['implement_flow']
+        });
+    }
+    /**
+     * Build the final task specification
+     */
+    build() {
+        // Add default quality gates if none specified
+        if (this.spec.qualityGates.length === 0) {
+            this.spec.qualityGates.push({
+                name: 'default_gates',
+                taskIds: this.spec.tasks.map(t => t.id),
+                gates: [] // Will be populated by createServiceNowQualityGates()
+            });
+        }
+        logger_1.logger.info('🏗️ Built task specification', {
+            name: this.spec.name,
+            tasks: this.spec.tasks.length,
+            qualityGates: this.spec.qualityGates.length
+        });
+        return { ...this.spec };
+    }
+}
+exports.TaskSpecificationBuilder = TaskSpecificationBuilder;
+/**
+ * Create a complete coordination setup for ServiceNow development
+ */
+function createServiceNowCoordinationSetup(config) {
+    const { maxConcurrentTasks = 5, enableAdvancedQualityGates = true, memoryTtl = 3600000, progressLogging = true } = config;
+    // Create coordination engine
+    const engine = createCoordinationEngine({
+        maxConcurrentTasks,
+        enableQualityGates: enableAdvancedQualityGates,
+        memoryTtl,
+        executionPattern: 'hybrid'
+    });
+    // Create quality gates
+    const qualityGates = enableAdvancedQualityGates
+        ? createServiceNowQualityGates()
+        : createStandardQualityGates();
+    // Create progress listener
+    const progressListener = createProgressListener({
+        logLevel: 'info',
+        logProgress: progressLogging,
+        logTasks: progressLogging,
+        logAgents: true,
+        logPerformance: true
+    });
+    // Task builder factory
+    const taskBuilder = (name, description) => createServiceNowTaskSpecification(name, description);
+    logger_1.logger.info('🚀 ServiceNow coordination setup created', {
+        maxConcurrentTasks,
+        advancedQualityGates: enableAdvancedQualityGates,
+        progressLogging
+    });
+    return {
+        engine,
+        qualityGates,
+        progressListener,
+        taskBuilder
+    };
+}
+//# sourceMappingURL=factory.js.map

package/dist/coordination/index.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Team Coordination Framework
+ *
+ * A comprehensive framework for managing communication, dependencies, and quality gates
+ * between specialized agents in ServiceNow development workflows.
+ */
+export { CoordinationEngine } from './coordination-engine';
+export { SharedMemoryManager } from './shared-memory';
+export { TaskDependencyGraph } from './task-dependencies';
+export { QualityGateManager, CodeQualityGate, SecurityGate, PerformanceGate, ServiceNowGate, BusinessLogicGate } from './quality-gates';
+export { ExecutionPattern, SequentialExecutionPattern, ParallelExecutionPattern, HybridExecutionPattern, AdaptiveExecutionPattern } from './execution-patterns';
+export { ProgressMonitor } from './progress-monitor';
+export * from './types';
+export { createCoordinationEngine, createStandardQualityGates, createServiceNowQualityGates, createProgressListener } from './factory';
+/**
+ * Main coordination framework entry point
+ *
+ * Example usage:
+ * ```typescript
+ * import { CoordinationFramework } from './coordination';
+ *
+ * const framework = new CoordinationFramework({
+ *   maxConcurrentTasks: 5,
+ *   enableQualityGates: true,
+ *   executionPattern: 'hybrid'
+ * });
+ *
+ * const result = await framework.coordinate(team, specification);
+ * ```
+ */
+export declare class CoordinationFramework {
+    private engine;
+    constructor(config?: Partial<import('./types').CoordinationConfig>);
+    /**
+     * Coordinate team execution of a task specification
+     */
+    coordinate(team: import('./types').BaseTeam, specification: import('./types').TaskSpecification): Promise<import('./types').CoordinationResult>;
+    /**
+     * Get execution plan without executing
+     */
+    plan(specification: import('./types').TaskSpecification): Promise<import('./types').ExecutionPlan>;
+    /**
+     * Access the shared memory manager
+     */
+    getSharedMemory(): SharedMemoryManager;
+    /**
+     * Access the quality gate manager
+     */
+    getQualityGates(): QualityGateManager;
+    /**
+     * Pause execution
+     */
+    pause(): Promise<void>;
+    /**
+     * Resume execution
+     */
+    resume(): Promise<void>;
+    /**
+     * Abort execution
+     */
+    abort(reason: string): Promise<void>;
+    /**
+     * Subscribe to coordination events
+     */
+    on(event: string, listener: (...args: any[]) => void): void;
+    /**
+     * Remove event listener
+     */
+    off(event: string, listener: (...args: any[]) => void): void;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/coordination/index.js

@@ -0,0 +1,135 @@
+"use strict";
+/**
+ * Team Coordination Framework
+ *
+ * A comprehensive framework for managing communication, dependencies, and quality gates
+ * between specialized agents in ServiceNow development workflows.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoordinationFramework = exports.createProgressListener = exports.createServiceNowQualityGates = exports.createStandardQualityGates = exports.createCoordinationEngine = exports.ProgressMonitor = exports.AdaptiveExecutionPattern = exports.HybridExecutionPattern = exports.ParallelExecutionPattern = exports.SequentialExecutionPattern = exports.ExecutionPattern = exports.BusinessLogicGate = exports.ServiceNowGate = exports.PerformanceGate = exports.SecurityGate = exports.CodeQualityGate = exports.QualityGateManager = exports.TaskDependencyGraph = exports.SharedMemoryManager = exports.CoordinationEngine = void 0;
+// Core coordination engine
+var coordination_engine_1 = require("./coordination-engine");
+Object.defineProperty(exports, "CoordinationEngine", { enumerable: true, get: function () { return coordination_engine_1.CoordinationEngine; } });
+// Shared memory management
+var shared_memory_1 = require("./shared-memory");
+Object.defineProperty(exports, "SharedMemoryManager", { enumerable: true, get: function () { return shared_memory_1.SharedMemoryManager; } });
+// Task dependency management
+var task_dependencies_1 = require("./task-dependencies");
+Object.defineProperty(exports, "TaskDependencyGraph", { enumerable: true, get: function () { return task_dependencies_1.TaskDependencyGraph; } });
+// Quality gates system
+var quality_gates_1 = require("./quality-gates");
+Object.defineProperty(exports, "QualityGateManager", { enumerable: true, get: function () { return quality_gates_1.QualityGateManager; } });
+Object.defineProperty(exports, "CodeQualityGate", { enumerable: true, get: function () { return quality_gates_1.CodeQualityGate; } });
+Object.defineProperty(exports, "SecurityGate", { enumerable: true, get: function () { return quality_gates_1.SecurityGate; } });
+Object.defineProperty(exports, "PerformanceGate", { enumerable: true, get: function () { return quality_gates_1.PerformanceGate; } });
+Object.defineProperty(exports, "ServiceNowGate", { enumerable: true, get: function () { return quality_gates_1.ServiceNowGate; } });
+Object.defineProperty(exports, "BusinessLogicGate", { enumerable: true, get: function () { return quality_gates_1.BusinessLogicGate; } });
+// Execution patterns
+var execution_patterns_1 = require("./execution-patterns");
+Object.defineProperty(exports, "ExecutionPattern", { enumerable: true, get: function () { return execution_patterns_1.ExecutionPattern; } });
+Object.defineProperty(exports, "SequentialExecutionPattern", { enumerable: true, get: function () { return execution_patterns_1.SequentialExecutionPattern; } });
+Object.defineProperty(exports, "ParallelExecutionPattern", { enumerable: true, get: function () { return execution_patterns_1.ParallelExecutionPattern; } });
+Object.defineProperty(exports, "HybridExecutionPattern", { enumerable: true, get: function () { return execution_patterns_1.HybridExecutionPattern; } });
+Object.defineProperty(exports, "AdaptiveExecutionPattern", { enumerable: true, get: function () { return execution_patterns_1.AdaptiveExecutionPattern; } });
+// Progress monitoring
+var progress_monitor_1 = require("./progress-monitor");
+Object.defineProperty(exports, "ProgressMonitor", { enumerable: true, get: function () { return progress_monitor_1.ProgressMonitor; } });
+// Type definitions
+__exportStar(require("./types"), exports);
+// Convenience factory functions
+var factory_1 = require("./factory");
+Object.defineProperty(exports, "createCoordinationEngine", { enumerable: true, get: function () { return factory_1.createCoordinationEngine; } });
+Object.defineProperty(exports, "createStandardQualityGates", { enumerable: true, get: function () { return factory_1.createStandardQualityGates; } });
+Object.defineProperty(exports, "createServiceNowQualityGates", { enumerable: true, get: function () { return factory_1.createServiceNowQualityGates; } });
+Object.defineProperty(exports, "createProgressListener", { enumerable: true, get: function () { return factory_1.createProgressListener; } });
+/**
+ * Main coordination framework entry point
+ *
+ * Example usage:
+ * ```typescript
+ * import { CoordinationFramework } from './coordination';
+ *
+ * const framework = new CoordinationFramework({
+ *   maxConcurrentTasks: 5,
+ *   enableQualityGates: true,
+ *   executionPattern: 'hybrid'
+ * });
+ *
+ * const result = await framework.coordinate(team, specification);
+ * ```
+ */
+class CoordinationFramework {
+    constructor(config = {}) {
+        this.engine = new CoordinationEngine(config);
+    }
+    /**
+     * Coordinate team execution of a task specification
+     */
+    async coordinate(team, specification) {
+        return await this.engine.coordinateTeamExecution(team, specification);
+    }
+    /**
+     * Get execution plan without executing
+     */
+    async plan(specification) {
+        return await this.engine.getExecutionPlan(specification);
+    }
+    /**
+     * Access the shared memory manager
+     */
+    getSharedMemory() {
+        return this.engine.getSharedMemory();
+    }
+    /**
+     * Access the quality gate manager
+     */
+    getQualityGates() {
+        return this.engine.getQualityGateManager();
+    }
+    /**
+     * Pause execution
+     */
+    async pause() {
+        return await this.engine.pauseExecution();
+    }
+    /**
+     * Resume execution
+     */
+    async resume() {
+        return await this.engine.resumeExecution();
+    }
+    /**
+     * Abort execution
+     */
+    async abort(reason) {
+        return await this.engine.abortExecution(reason);
+    }
+    /**
+     * Subscribe to coordination events
+     */
+    on(event, listener) {
+        this.engine.on(event, listener);
+    }
+    /**
+     * Remove event listener
+     */
+    off(event, listener) {
+        this.engine.off(event, listener);
+    }
+}
+exports.CoordinationFramework = CoordinationFramework;
+//# sourceMappingURL=index.js.map