snow-flow 3.0.9 → 3.0.13

package/dist/sparc/coordinators/team-coordinator.js

@@ -1,402 +0,0 @@
-"use strict";
-/**
- * Team Coordinator
- * Orchestrates team-based development workflows with intelligent task distribution
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TeamCoordinator = void 0;
-const widget_team_js_1 = require("../teams/widget-team.js");
-const flow_team_js_1 = require("../teams/flow-team.js");
-const application_team_js_1 = require("../teams/application-team.js");
-class TeamCoordinator {
-    constructor() {
-        this.executionPlan = [];
-        this.sharedMemory = new Map();
-    }
-    async executeTeamTask(teamType, task) {
-        console.log(`🎯 Coordinating ${teamType.toUpperCase()} Team Execution`);
-        console.log(`📋 Task: ${task.description}\n`);
-        const startTime = Date.now();
-        try {
-            // Initialize coordination context
-            this.context = await this.initializeContext(teamType, task);
-            // Create project plan using appropriate team
-            const projectPlan = await this.createProjectPlan(teamType, task);
-            // Generate execution plan
-            this.executionPlan = this.generateExecutionPlan(projectPlan, task.options);
-            // Execute with coordination
-            const artifacts = await this.executeWithCoordination(task.options);
-            // Validate quality gates
-            const qualityResults = await this.validateQualityGates();
-            const executionTime = Date.now() - startTime;
-            console.log(`✅ Team execution completed successfully in ${executionTime}ms\n`);
-            return {
-                success: true,
-                teamType: teamType,
-                coordinator: this.getCoordinatorName(teamType),
-                specialists: this.context.activeMembers,
-                artifacts,
-                executionTime,
-                warnings: qualityResults.warnings
-            };
-        }
-        catch (error) {
-            const executionTime = Date.now() - startTime;
-            console.error(`❌ Team coordination failed: ${error}`);
-            return {
-                success: false,
-                teamType: teamType,
-                coordinator: this.getCoordinatorName(teamType),
-                specialists: this.context?.activeMembers || [],
-                artifacts: [],
-                executionTime,
-                errors: [error instanceof Error ? error.message : String(error)]
-            };
-        }
-    }
-    async executeSpecialistTask(specialistType, task) {
-        console.log(`👨‍💻 Coordinating ${specialistType.toUpperCase()} Specialist Execution`);
-        console.log(`📋 Task: ${task.description}\n`);
-        const startTime = Date.now();
-        try {
-            // Initialize specialist context
-            this.context = {
-                teamType: 'specialist',
-                projectPlan: { phases: [], deliverables: [] },
-                activeMembers: [specialistType],
-                sharedMemory: this.sharedMemory,
-                progressTracking: new Map(),
-                qualityGates: this.generateSpecialistQualityGates(specialistType)
-            };
-            // Execute specialist task
-            const artifacts = await this.executeSpecialistWork(specialistType, task);
-            const executionTime = Date.now() - startTime;
-            console.log(`✅ Specialist execution completed successfully in ${executionTime}ms\n`);
-            return {
-                success: true,
-                teamType: 'specialist',
-                coordinator: `${specialistType}Agent`,
-                specialists: [specialistType],
-                artifacts,
-                executionTime
-            };
-        }
-        catch (error) {
-            const executionTime = Date.now() - startTime;
-            console.error(`❌ Specialist execution failed: ${error}`);
-            return {
-                success: false,
-                teamType: 'specialist',
-                coordinator: `${specialistType}Agent`,
-                specialists: [specialistType],
-                artifacts: [],
-                executionTime,
-                errors: [error instanceof Error ? error.message : String(error)]
-            };
-        }
-    }
-    async initializeContext(teamType, task) {
-        console.log('🔧 Initializing coordination context...');
-        const context = {
-            teamType,
-            projectPlan: {},
-            activeMembers: [],
-            sharedMemory: this.sharedMemory,
-            progressTracking: new Map(),
-            qualityGates: this.generateQualityGates(teamType, task.analysis.complexity)
-        };
-        // Store task context in shared memory if enabled
-        if (task.options.sharedMemory !== false) {
-            this.sharedMemory.set('current_task', task.description);
-            this.sharedMemory.set('task_analysis', task.analysis);
-            this.sharedMemory.set('execution_options', task.options);
-        }
-        console.log(`   Team Type: ${teamType}`);
-        console.log(`   Shared Memory: ${task.options.sharedMemory !== false ? 'Enabled' : 'Disabled'}`);
-        console.log(`   Quality Gates: ${context.qualityGates.length}`);
-        return context;
-    }
-    async createProjectPlan(teamType, task) {
-        console.log('📋 Creating project plan...');
-        let projectPlan;
-        switch (teamType.toLowerCase()) {
-            case 'widget':
-                const widgetTeam = new widget_team_js_1.WidgetTeam();
-                projectPlan = widgetTeam.createProjectPlan(task.description, task.analysis);
-                this.context.activeMembers = ['WidgetFrontendAgent', 'WidgetBackendAgent', 'UIUXSpecialistAgent', 'PlatformSpecialistAgent'];
-                break;
-            case 'flow':
-                const flowTeam = new flow_team_js_1.FlowTeam();
-                projectPlan = flowTeam.createProjectPlan(task.description, task.analysis);
-                this.context.activeMembers = ['ProcessSpecialistAgent', 'TriggerSpecialistAgent', 'DataSpecialistAgent', 'SecuritySpecialistAgent'];
-                break;
-            case 'application':
-                const appTeam = new application_team_js_1.ApplicationTeam();
-                projectPlan = appTeam.createProjectPlan(task.description, task.analysis);
-                this.context.activeMembers = ['DatabaseSpecialistAgent', 'LogicSpecialistAgent', 'InterfaceSpecialistAgent', 'SecuritySpecialistAgent'];
-                break;
-            default:
-                throw new Error(`Unknown team type: ${teamType}`);
-        }
-        this.context.projectPlan = projectPlan;
-        console.log(`   Project: ${projectPlan.projectName}`);
-        console.log(`   Duration: ${projectPlan.estimatedDuration}`);
-        console.log(`   Phases: ${projectPlan.phases.length}`);
-        console.log(`   Active Members: ${this.context.activeMembers.length}\n`);
-        return projectPlan;
-    }
-    generateExecutionPlan(projectPlan, options) {
-        console.log('⚙️  Generating execution plan...');
-        const steps = [];
-        let stepCounter = 1;
-        // Convert project phases to execution steps
-        for (const phase of projectPlan.phases) {
-            const stepId = `step_${stepCounter++}`;
-            steps.push({
-                stepId,
-                name: phase.name,
-                description: phase.description,
-                assignedTo: phase.assignedTo.join(', '),
-                dependencies: phase.dependencies || [],
-                estimatedDuration: phase.duration,
-                status: 'pending'
-            });
-        }
-        // Add validation steps if enabled
-        if (options.validation !== false) {
-            steps.push({
-                stepId: `step_${stepCounter++}`,
-                name: 'Quality Validation',
-                description: 'Validate deliverables against quality criteria',
-                assignedTo: 'QualityAssuranceAgent',
-                dependencies: steps.map(s => s.stepId).slice(-2), // Depend on last two steps
-                estimatedDuration: '30min',
-                status: 'pending'
-            });
-        }
-        console.log(`   Generated ${steps.length} execution steps`);
-        console.log(`   Parallel execution: ${options.parallel ? 'Enabled' : 'Disabled'}`);
-        console.log(`   Validation: ${options.validation !== false ? 'Enabled' : 'Disabled'}\n`);
-        return steps;
-    }
-    async executeWithCoordination(options) {
-        console.log('🚀 Executing coordinated team workflow...\n');
-        const artifacts = [];
-        if (options.parallel) {
-            artifacts.push(...await this.executeParallel());
-        }
-        else {
-            artifacts.push(...await this.executeSequential());
-        }
-        return artifacts;
-    }
-    async executeParallel() {
-        console.log('⚡ Executing steps in parallel where possible...');
-        const artifacts = [];
-        const completed = new Set();
-        const inProgress = new Set();
-        while (completed.size < this.executionPlan.length) {
-            // Find steps ready to execute
-            const readySteps = this.executionPlan.filter(step => step.status === 'pending' &&
-                step.dependencies.every(dep => completed.has(dep)));
-            if (readySteps.length === 0) {
-                // Check for blocked steps
-                const blockedSteps = this.executionPlan.filter(step => step.status === 'pending' && !inProgress.has(step.stepId));
-                if (blockedSteps.length > 0) {
-                    console.log(`⚠️  Found ${blockedSteps.length} blocked steps, continuing with available work...`);
-                    break;
-                }
-                // Wait for in-progress steps to complete
-                await new Promise(resolve => setTimeout(resolve, 1000));
-                continue;
-            }
-            // Execute ready steps in parallel
-            const promises = readySteps.map(async (step) => {
-                inProgress.add(step.stepId);
-                step.status = 'in_progress';
-                step.startTime = new Date();
-                console.log(`   🔄 ${step.name} (${step.assignedTo})`);
-                try {
-                    const artifact = await this.executeStep(step);
-                    step.status = 'completed';
-                    step.endTime = new Date();
-                    step.output = artifact;
-                    console.log(`   ✅ ${step.name} completed`);
-                    return artifact;
-                }
-                catch (error) {
-                    step.status = 'failed';
-                    step.errors = [error instanceof Error ? error.message : String(error)];
-                    console.log(`   ❌ ${step.name} failed: ${error}`);
-                    throw error;
-                }
-                finally {
-                    inProgress.delete(step.stepId);
-                    completed.add(step.stepId);
-                }
-            });
-            const stepArtifacts = await Promise.allSettled(promises);
-            stepArtifacts.forEach(result => {
-                if (result.status === 'fulfilled' && result.value) {
-                    artifacts.push(result.value);
-                }
-            });
-        }
-        return artifacts;
-    }
-    async executeSequential() {
-        console.log('📋 Executing steps sequentially...');
-        const artifacts = [];
-        for (const step of this.executionPlan) {
-            // Check dependencies
-            const missingDeps = step.dependencies.filter(dep => !this.executionPlan.find(s => s.stepId === dep && s.status === 'completed'));
-            if (missingDeps.length > 0) {
-                console.log(`⚠️  Skipping ${step.name} - missing dependencies: ${missingDeps.join(', ')}`);
-                step.status = 'blocked';
-                continue;
-            }
-            step.status = 'in_progress';
-            step.startTime = new Date();
-            console.log(`   🔄 ${step.name} (${step.assignedTo})`);
-            try {
-                const artifact = await this.executeStep(step);
-                step.status = 'completed';
-                step.endTime = new Date();
-                step.output = artifact;
-                console.log(`   ✅ ${step.name} completed`);
-                if (artifact) {
-                    artifacts.push(artifact);
-                }
-            }
-            catch (error) {
-                step.status = 'failed';
-                step.errors = [error instanceof Error ? error.message : String(error)];
-                console.log(`   ❌ ${step.name} failed: ${error}`);
-                throw error;
-            }
-        }
-        return artifacts;
-    }
-    async executeStep(step) {
-        // Simulate step execution with realistic timing
-        const duration = this.parseDuration(step.estimatedDuration);
-        await new Promise(resolve => setTimeout(resolve, Math.min(duration, 5000))); // Cap simulation at 5s
-        // Return mock artifact based on step type
-        return {
-            stepId: step.stepId,
-            name: step.name,
-            type: this.inferArtifactType(step.name),
-            assignedTo: step.assignedTo,
-            completedAt: new Date(),
-            quality: 'high'
-        };
-    }
-    async executeSpecialistWork(specialistType, task) {
-        console.log(`🔧 Executing ${specialistType} specialist work...`);
-        // Simulate specialist work
-        await new Promise(resolve => setTimeout(resolve, 2000));
-        return [{
-                type: 'specialist_deliverable',
-                specialist: specialistType,
-                task: task.description,
-                completedAt: new Date(),
-                quality: 'high'
-            }];
-    }
-    generateQualityGates(teamType, complexity) {
-        const gates = [
-            {
-                name: 'Requirements Review',
-                criteria: ['Requirements are clear and complete', 'Stakeholders have approved'],
-                required: true,
-                passed: false,
-                reviewer: 'ArchitectAgent'
-            }
-        ];
-        if (complexity === 'complex') {
-            gates.push({
-                name: 'Architecture Review',
-                criteria: ['Architecture follows best practices', 'Performance requirements met'],
-                required: true,
-                passed: false,
-                reviewer: 'ArchitectAgent'
-            });
-        }
-        gates.push({
-            name: 'Code Quality Review',
-            criteria: ['Code follows standards', 'Security requirements met'],
-            required: true,
-            passed: false,
-            reviewer: 'ReviewerAgent'
-        });
-        return gates;
-    }
-    generateSpecialistQualityGates(specialistType) {
-        return [{
-                name: 'Specialist Deliverable Review',
-                criteria: [`${specialistType} deliverable meets requirements`, 'Quality standards satisfied'],
-                required: true,
-                passed: false,
-                reviewer: `${specialistType}Agent`
-            }];
-    }
-    async validateQualityGates() {
-        console.log('🔍 Validating quality gates...');
-        const warnings = [];
-        let passed = 0;
-        for (const gate of this.context.qualityGates) {
-            // Simulate quality gate validation
-            const success = Math.random() > 0.1; // 90% pass rate
-            gate.passed = success;
-            if (success) {
-                passed++;
-                console.log(`   ✅ ${gate.name} - PASSED`);
-            }
-            else {
-                console.log(`   ⚠️  ${gate.name} - NEEDS ATTENTION`);
-                warnings.push(`Quality gate "${gate.name}" requires attention`);
-            }
-        }
-        console.log(`   Quality Gates: ${passed}/${this.context.qualityGates.length} passed\n`);
-        return { passed, warnings };
-    }
-    getCoordinatorName(teamType) {
-        const coordinatorMap = {
-            'widget': 'WidgetArchitectAgent',
-            'flow': 'FlowArchitectAgent',
-            'application': 'AppArchitectAgent',
-            'adaptive': 'AdaptiveCoordinatorAgent'
-        };
-        return coordinatorMap[teamType.toLowerCase()] || 'TeamCoordinatorAgent';
-    }
-    parseDuration(duration) {
-        // Convert duration string to milliseconds (simplified)
-        const match = duration.match(/(\d+)(min|hour|day)/);
-        if (!match)
-            return 1000;
-        const value = parseInt(match[1]);
-        const unit = match[2];
-        switch (unit) {
-            case 'min': return value * 60 * 1000;
-            case 'hour': return value * 60 * 60 * 1000;
-            case 'day': return value * 24 * 60 * 60 * 1000;
-            default: return 1000;
-        }
-    }
-    inferArtifactType(stepName) {
-        const stepLower = stepName.toLowerCase();
-        if (stepLower.includes('database') || stepLower.includes('schema'))
-            return 'database_artifact';
-        if (stepLower.includes('interface') || stepLower.includes('ui'))
-            return 'ui_artifact';
-        if (stepLower.includes('logic') || stepLower.includes('business'))
-            return 'logic_artifact';
-        if (stepLower.includes('security'))
-            return 'security_artifact';
-        if (stepLower.includes('test'))
-            return 'test_artifact';
-        return 'general_artifact';
-    }
-}
-exports.TeamCoordinator = TeamCoordinator;
-//# sourceMappingURL=team-coordinator.js.map

package/dist/sparc/modes/team-modes.d.ts

@@ -1,33 +0,0 @@
-/**
- * Team SPARC Modes Configuration
- * Defines predefined teams and specialist modes for ServiceNow development
- */
-export interface TeamMode {
-    description: string;
-    team?: string;
-    coordinator: string;
-    specialists: string[];
-    examples: string[];
-    capabilities: string[];
-    dependencies?: string[];
-    estimatedTime?: string;
-    complexity: 'simple' | 'medium' | 'complex';
-}
-export interface SpecialistMode {
-    description: string;
-    specialist: string;
-    examples: string[];
-    capabilities: string[];
-    domain: string;
-    estimatedTime?: string;
-    complexity: 'simple' | 'medium' | 'complex';
-}
-export declare const TEAM_SPARC_MODES: Record<string, TeamMode>;
-export declare const SPECIALIST_SPARC_MODES: Record<string, SpecialistMode>;
-export declare function getTeamMode(teamType: string): TeamMode | undefined;
-export declare function getSpecialistMode(specialistType: string): SpecialistMode | undefined;
-export declare function getAllTeamModes(): Record<string, TeamMode>;
-export declare function getAllSpecialistModes(): Record<string, SpecialistMode>;
-export declare function getTeamCapabilities(teamType: string): string[];
-export declare function getSpecialistCapabilities(specialistType: string): string[];
-//# sourceMappingURL=team-modes.d.ts.map