snow-flow 2.0.4 → 2.0.6

package/dist/coordination/example.js

@@ -0,0 +1,394 @@
+"use strict";
+/**
+ * Comprehensive example of using the Team Coordination Framework
+ * for ServiceNow development workflows
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exampleWidgetDevelopment = exampleWidgetDevelopment;
+exports.exampleFlowDevelopment = exampleFlowDevelopment;
+exports.exampleAdvancedCoordination = exampleAdvancedCoordination;
+exports.exampleProgressMonitoring = exampleProgressMonitoring;
+exports.runAllExamples = runAllExamples;
+exports.createMockTeam = createMockTeam;
+const index_1 = require("./index");
+/**
+ * Example: ServiceNow Widget Development with Team Coordination
+ */
+async function exampleWidgetDevelopment() {
+    console.log('🚀 Starting ServiceNow Widget Development Example');
+    // 1. Create ServiceNow coordination setup
+    const { engine, qualityGates, progressListener, taskBuilder } = (0, index_1.createServiceNowCoordinationSetup)({
+        maxConcurrentTasks: 6,
+        enableAdvancedQualityGates: true,
+        progressLogging: true
+    });
+    // 2. Create mock team of specialized agents
+    const team = createMockTeam();
+    // 3. Add progress monitoring
+    const monitor = engine.getSharedMemory();
+    // Subscribe to progress events
+    engine.on('coordination:started', (data) => {
+        console.log('🎯 Coordination started:', data);
+    });
+    engine.on('task:completed', ({ taskId, result }) => {
+        console.log(`✅ Task completed: ${taskId}`);
+    });
+    engine.on('task:failed', ({ taskId, error }) => {
+        console.error(`❌ Task failed: ${taskId}`, error.message);
+    });
+    engine.on('phase:completed', ({ phase, type, progress }) => {
+        console.log(`🏁 Phase ${phase} (${type}) completed - ${Math.round(progress * 100)}% done`);
+    });
+    engine.on('coordination:completed', ({ results, metrics }) => {
+        console.log('🎉 Coordination completed!');
+        console.log('📊 Metrics:', {
+            totalTasks: metrics.totalTasks,
+            completedTasks: metrics.completedTasks,
+            totalTime: `${Math.round(metrics.totalExecutionTime / 1000)}s`,
+            averageTaskTime: `${Math.round(metrics.averageTaskTime / 1000)}s`
+        });
+    });
+    // 4. Build task specification for incident dashboard widget
+    const specification = taskBuilder('incident-dashboard-widget', 'Create a comprehensive incident dashboard widget for ServiceNow')
+        .addWidgetDevelopmentTasks('incident_dashboard')
+        .addContext('servicenow_instance', 'dev123456')
+        .addContext('update_set', 'incident_dashboard_us_001')
+        .addContext('widget_requirements', {
+        type: 'dashboard',
+        data_source: 'incident',
+        refresh_interval: 30,
+        features: ['real-time updates', 'filtering', 'charts']
+    })
+        .setExecutionPattern('hybrid')
+        .build();
+    console.log('📋 Task Specification:', {
+        name: specification.name,
+        tasks: specification.tasks.length,
+        executionPattern: specification.executionPattern
+    });
+    try {
+        // 5. Execute coordination
+        const result = await engine.coordinateTeamExecution(team, specification);
+        if (result.success) {
+            console.log('✅ Widget development completed successfully!');
+            console.log('📦 Deliverables:');
+            Object.entries(result.results).forEach(([taskId, taskResult]) => {
+                console.log(`  - ${taskId}: ${Object.keys(taskResult.outputs || {}).join(', ')}`);
+            });
+        }
+        else {
+            console.error('❌ Widget development failed:', result.errors);
+        }
+    }
+    catch (error) {
+        console.error('💥 Coordination failed:', error.message);
+    }
+}
+/**
+ * Example: ServiceNow Flow Development with Parallel Execution
+ */
+async function exampleFlowDevelopment() {
+    console.log('🚀 Starting ServiceNow Flow Development Example');
+    // Create framework with parallel execution preference
+    const framework = new index_1.CoordinationFramework({
+        maxConcurrentTasks: 8,
+        enableQualityGates: true,
+        executionPattern: 'parallel'
+    });
+    const team = createMockTeam();
+    // Build complex flow specification
+    const specification = (0, index_1.createServiceNowTaskSpecification)('user-provisioning-flow', 'Create comprehensive user provisioning automation flow')
+        .addFlowDevelopmentTasks('user_provisioning_flow')
+        .addTask({
+        id: 'create_approval_step',
+        name: 'Create Approval Step',
+        description: 'Design and implement approval workflow step',
+        agentType: 'workflow-designer',
+        requirements: {
+            inputs: { approvalType: 'manager_approval' },
+            outputs: ['approvalStep', 'approvalLogic'],
+            capabilities: ['workflow', 'approval', 'servicenow']
+        },
+        dependencies: ['design_flow']
+    })
+        .addTask({
+        id: 'integrate_ldap',
+        name: 'Integrate LDAP',
+        description: 'Configure LDAP integration for user data',
+        agentType: 'integration-specialist',
+        requirements: {
+            inputs: { ldapConfig: 'corporate_ldap' },
+            outputs: ['ldapIntegration'],
+            capabilities: ['ldap', 'integration', 'servicenow']
+        },
+        dependencies: ['design_flow']
+    })
+        .addTask({
+        id: 'setup_notifications',
+        name: 'Setup Notifications',
+        description: 'Configure email notifications for the flow',
+        agentType: 'servicenow-specialist',
+        requirements: {
+            inputs: { notificationTemplates: 'standard' },
+            outputs: ['notificationConfig'],
+            capabilities: ['email', 'notifications', 'servicenow']
+        },
+        dependencies: ['implement_flow']
+    })
+        .addContext('servicenow_instance', 'prod12345')
+        .addContext('integration_environment', 'production')
+        .addContext('compliance_level', 'high')
+        .setExecutionPattern('hybrid')
+        .build();
+    try {
+        const result = await framework.coordinate(team, specification);
+        if (result.success) {
+            console.log('✅ Flow development completed successfully!');
+            // Display execution metrics
+            console.log('📊 Execution Metrics:', {
+                parallelTasks: result.metrics.concurrentTasks,
+                efficiency: `${Math.round((result.metrics.completedTasks / result.metrics.totalTasks) * 100)}%`,
+                totalTime: `${Math.round(result.metrics.totalExecutionTime / 1000)}s`
+            });
+        }
+    }
+    catch (error) {
+        console.error('💥 Flow development failed:', error.message);
+    }
+}
+/**
+ * Example: Advanced Coordination with Custom Quality Gates
+ */
+async function exampleAdvancedCoordination() {
+    console.log('🚀 Starting Advanced Coordination Example');
+    const { engine, qualityGates } = (0, index_1.createServiceNowCoordinationSetup)({
+        maxConcurrentTasks: 4,
+        enableAdvancedQualityGates: true
+    });
+    // Add custom quality gate
+    class ComplianceGate {
+        constructor() {
+            this.name = 'SOX Compliance';
+            this.blocking = true;
+        }
+        async validate(result) {
+            const issues = [];
+            let score = 1.0;
+            // Check SOX compliance requirements
+            if (!result.auditTrail) {
+                issues.push('Missing audit trail for SOX compliance');
+                score -= 0.5;
+            }
+            if (!result.accessControls) {
+                issues.push('Missing access controls documentation');
+                score -= 0.3;
+            }
+            if (!result.changeApproval) {
+                issues.push('Missing change approval documentation');
+                score -= 0.4;
+            }
+            return {
+                passed: issues.length === 0,
+                score,
+                error: issues.length > 0 ? issues.join('; ') : undefined,
+                suggestions: [
+                    'Document all changes for audit trail',
+                    'Implement proper access controls',
+                    'Get proper change approval'
+                ]
+            };
+        }
+    }
+    // Add custom gate to quality manager
+    qualityGates.addGate('deploy_production_flow', new ComplianceGate());
+    const team = createMockTeam();
+    const specification = (0, index_1.createServiceNowTaskSpecification)('production-deployment', 'Deploy flow to production with full compliance checks')
+        .addTask({
+        id: 'prepare_deployment',
+        name: 'Prepare Deployment',
+        description: 'Prepare all deployment artifacts',
+        agentType: 'servicenow-specialist',
+        requirements: {
+            outputs: ['deploymentPackage', 'documentation'],
+            capabilities: ['deployment', 'documentation']
+        }
+    })
+        .addTask({
+        id: 'compliance_review',
+        name: 'Compliance Review',
+        description: 'Conduct SOX compliance review',
+        agentType: 'security-auditor',
+        requirements: {
+            outputs: ['complianceReport', 'auditTrail'],
+            capabilities: ['compliance', 'audit', 'security']
+        },
+        dependencies: ['prepare_deployment']
+    })
+        .addTask({
+        id: 'deploy_production_flow',
+        name: 'Deploy to Production',
+        description: 'Deploy flow to production environment',
+        agentType: 'servicenow-specialist',
+        requirements: {
+            outputs: ['deploymentResult', 'accessControls', 'changeApproval'],
+            capabilities: ['deployment', 'production']
+        },
+        dependencies: ['compliance_review']
+    })
+        .addContext('environment', 'production')
+        .addContext('compliance_framework', 'SOX')
+        .setExecutionPattern('sequential') // Sequential for production safety
+        .build();
+    try {
+        const result = await engine.coordinateTeamExecution(team, specification);
+        if (result.success) {
+            console.log('✅ Production deployment completed with full compliance!');
+        }
+        else {
+            console.error('❌ Deployment failed compliance checks:', result.errors);
+        }
+    }
+    catch (error) {
+        console.error('💥 Advanced coordination failed:', error.message);
+    }
+}
+/**
+ * Example: Real-time Progress Monitoring
+ */
+async function exampleProgressMonitoring() {
+    console.log('🚀 Starting Progress Monitoring Example');
+    const framework = new index_1.CoordinationFramework({
+        enableProgressMonitoring: true,
+        maxConcurrentTasks: 5
+    });
+    // Create custom progress listener
+    const progressListener = {
+        onProgress(event, data) {
+            switch (event) {
+                case 'task_progress':
+                    console.log(`📊 Progress: ${data.percentage}% (${data.completed}/${data.total}) - Phase: ${data.currentPhase}`);
+                    if (data.bottlenecks && data.bottlenecks.length > 0) {
+                        console.warn('🚧 Bottlenecks detected:', data.bottlenecks);
+                    }
+                    break;
+                case 'agent_health':
+                    const unhealthyCount = Object.values(data.agents)
+                        .filter((health) => health.status === 'error').length;
+                    if (unhealthyCount > 0) {
+                        console.warn(`⚠️ ${unhealthyCount} agents are unhealthy`);
+                    }
+                    break;
+                case 'performance_metrics':
+                    console.log(`⚡ Performance: Efficiency ${Math.round(data.efficiency * 100)}%, Throughput ${data.throughput.toFixed(2)} tasks/sec`);
+                    break;
+                case 'trend_analysis':
+                    console.log(`📈 Trend: ${data.trend} (${data.progressRate.toFixed(3)} progress/sec)`);
+                    break;
+            }
+        }
+    };
+    // Get framework's progress monitor
+    const monitor = framework['engine'].progressMonitor;
+    monitor.addListener(progressListener);
+    const team = createMockTeam();
+    // Create long-running task specification for monitoring demo
+    const specification = (0, index_1.createServiceNowTaskSpecification)('monitoring-demo', 'Demonstrate progress monitoring capabilities')
+        .addWidgetDevelopmentTasks('monitoring_widget')
+        .addFlowDevelopmentTasks('monitoring_flow')
+        .addContext('monitoring_demo', true)
+        .setExecutionPattern('hybrid')
+        .build();
+    try {
+        const result = await framework.coordinate(team, specification);
+        if (result.success) {
+            console.log('✅ Monitoring demo completed successfully!');
+            // Get detailed progress report
+            const report = await monitor.getDetailedReport();
+            console.log('📋 Final Report:', {
+                overview: report.overview,
+                trends: report.trends,
+                recommendations: report.recommendations
+            });
+        }
+    }
+    catch (error) {
+        console.error('💥 Monitoring demo failed:', error.message);
+    }
+}
+/**
+ * Create a mock team of specialized agents for demonstration
+ */
+function createMockTeam() {
+    const agents = new Map();
+    // Create different types of agents
+    const agentConfigs = [
+        { id: 'analyst-001', name: 'Sarah (Analyst)', type: 'analyst', capabilities: ['analysis', 'requirements', 'design'] },
+        { id: 'ui-builder-001', name: 'Mike (UI Builder)', type: 'ui-builder', capabilities: ['html', 'css', 'javascript', 'ui-design'] },
+        { id: 'coder-001', name: 'Alex (Developer)', type: 'coder', capabilities: ['javascript', 'servicenow', 'backend', 'frontend'] },
+        { id: 'coder-002', name: 'Emma (Developer)', type: 'coder', capabilities: ['javascript', 'servicenow', 'integration'] },
+        { id: 'snow-specialist-001', name: 'David (ServiceNow)', type: 'servicenow-specialist', capabilities: ['servicenow', 'deployment', 'configuration'] },
+        { id: 'workflow-designer-001', name: 'Lisa (Workflow)', type: 'workflow-designer', capabilities: ['workflow', 'flow-designer', 'automation'] },
+        { id: 'tester-001', name: 'James (Tester)', type: 'tester', capabilities: ['testing', 'qa', 'servicenow'] },
+        { id: 'security-auditor-001', name: 'Rachel (Security)', type: 'security-auditor', capabilities: ['security', 'compliance', 'audit'] },
+        { id: 'integration-specialist-001', name: 'Tom (Integration)', type: 'integration-specialist', capabilities: ['integration', 'api', 'ldap'] }
+    ];
+    agentConfigs.forEach(config => {
+        const agent = {
+            id: config.id,
+            name: config.name,
+            type: config.type,
+            status: 'idle',
+            capabilities: config.capabilities,
+            metadata: { specialized: true },
+            createdAt: new Date(),
+            lastActivity: new Date()
+        };
+        agents.set(config.id, agent);
+    });
+    // Create team implementation
+    const team = {
+        agents,
+        getAgent(id) {
+            return agents.get(id);
+        },
+        addAgent(agent) {
+            agents.set(agent.id, agent);
+        },
+        removeAgent(id) {
+            agents.delete(id);
+        },
+        getAvailableAgents() {
+            return Array.from(agents.values()).filter(agent => agent.status === 'idle');
+        },
+        getAgentsByType(type) {
+            return Array.from(agents.values()).filter(agent => agent.type === type);
+        }
+    };
+    console.log(`👥 Created mock team with ${agents.size} specialized agents`);
+    return team;
+}
+/**
+ * Run all examples
+ */
+async function runAllExamples() {
+    console.log('🎬 Starting Team Coordination Framework Examples\n');
+    try {
+        await exampleWidgetDevelopment();
+        console.log('\n' + '='.repeat(80) + '\n');
+        await exampleFlowDevelopment();
+        console.log('\n' + '='.repeat(80) + '\n');
+        await exampleAdvancedCoordination();
+        console.log('\n' + '='.repeat(80) + '\n');
+        await exampleProgressMonitoring();
+        console.log('\n' + '='.repeat(80) + '\n');
+        console.log('🎉 All examples completed successfully!');
+    }
+    catch (error) {
+        console.error('💥 Example execution failed:', error.message);
+    }
+}
+// Run examples if called directly
+if (require.main === module) {
+    runAllExamples().catch(console.error);
+}
+//# sourceMappingURL=example.js.map

package/dist/coordination/execution-patterns.d.ts

@@ -0,0 +1,43 @@
+import { EventEmitter } from 'eventemitter3';
+import { BaseTeam, CoordinationConfig } from './types';
+import { TaskDependencyGraph } from './task-dependencies';
+import { QualityGateManager } from './quality-gates';
+import { ProgressMonitor } from './progress-monitor';
+export declare abstract class ExecutionPattern extends EventEmitter {
+    protected qualityGates: QualityGateManager;
+    protected progressMonitor: ProgressMonitor;
+    protected config: CoordinationConfig;
+    constructor(qualityGates: QualityGateManager, progressMonitor: ProgressMonitor, config: CoordinationConfig);
+    abstract execute(team: BaseTeam, taskGraph: TaskDependencyGraph): Promise<Record<string, any>>;
+    protected executeTaskWithQualityGates(taskId: string, taskGraph: TaskDependencyGraph): Promise<any>;
+    protected waitForAvailableSlot(currentTasks: Set<string>): Promise<void>;
+}
+export declare class SequentialExecutionPattern extends ExecutionPattern {
+    execute(team: BaseTeam, taskGraph: TaskDependencyGraph): Promise<Record<string, any>>;
+    private getSequentialOrder;
+}
+export declare class ParallelExecutionPattern extends ExecutionPattern {
+    execute(team: BaseTeam, taskGraph: TaskDependencyGraph): Promise<Record<string, any>>;
+}
+export declare class HybridExecutionPattern extends ExecutionPattern {
+    execute(team: BaseTeam, taskGraph: TaskDependencyGraph): Promise<Record<string, any>>;
+    private optimizeExecutionPlan;
+    private optimizeLargeLevel;
+    private executeParallelPhase;
+    private executeSequentialPhase;
+    private estimateTaskDuration;
+    private assessParallelRisk;
+}
+export declare class AdaptiveExecutionPattern extends ExecutionPattern {
+    private performanceHistory;
+    execute(team: BaseTeam, taskGraph: TaskDependencyGraph): Promise<Record<string, any>>;
+    private adaptStrategy;
+    private calculateLevelComplexity;
+    private executeSequentialLevel;
+    private executeParallelLevel;
+    private executeHybridLevel;
+    private recordPerformanceMetrics;
+    private getHistoricalPerformance;
+    private assessParallelRisk;
+}
+//# sourceMappingURL=execution-patterns.d.ts.map