claude-flow-novice 2.0.0 → 2.0.1

package/.claude-flow-novice/dist/src/cfn-loop/meta-coordinator.js

@@ -0,0 +1,538 @@
+/**
+ * Meta-Coordinator - Sprint 4.1: Parallel Sprint Coordination
+ *
+ * Spawns and monitors multiple sprint coordinators for independent sprint groups.
+ * Aggregates Loop 4 Product Owner decisions and handles sprint failures/retries.
+ *
+ * Features:
+ * - Spawn N sprint coordinators for parallel execution
+ * - Monitor progress via Redis pub/sub
+ * - Aggregate confidence scores across all sprints
+ * - Handle failures with targeted retries
+ * - Coordinate Loop 4 Product Owner decisions
+ * - Integration with existing SprintOrchestrator
+ *
+ * Architecture:
+ * Meta-Coordinator → Sprint Coordinators → CFN Loop → Agents
+ *
+ * @module cfn-loop/meta-coordinator
+ */ function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+import { EventEmitter } from "events";
+import { Logger } from "../core/logger.js";
+import { SprintOrchestrator } from "./sprint-orchestrator.js";
+import { createRedisPubSubHelper, REDIS_CHANNELS } from "./redis-pubsub-helpers.js";
+// ===== META-COORDINATOR =====
+/**
+ * Meta-Coordinator for parallel sprint coordination
+ *
+ * Spawns multiple SprintOrchestrator instances and monitors their progress
+ * through Redis pub/sub coordination.
+ */ export class MetaCoordinator extends EventEmitter {
+    /**
+   * Initialize meta-coordinator and validate sprint groups
+   */ async initialize() {
+        this.logger.info('Initializing Meta-Coordinator', {
+            epicId: this.config.epicId,
+            groups: this.config.sprintGroups.length
+        });
+        // Validate sprint groups
+        this.validateSprintGroups();
+        // Subscribe to coordination events
+        await this.subscribeToCoordinationEvents();
+        this.logger.info('Meta-Coordinator ready', {
+            epicId: this.config.epicId,
+            validatedGroups: this.config.sprintGroups.length
+        });
+        this.emit('initialized', {
+            epicId: this.config.epicId,
+            totalGroups: this.config.sprintGroups.length
+        });
+    }
+    /**
+   * Execute all sprint groups with parallel coordination
+   */ async execute() {
+        this.startTime = Date.now();
+        this.logger.info('Starting meta-coordination', {
+            epicId: this.config.epicId,
+            totalGroups: this.config.sprintGroups.length
+        });
+        this.emit('execution:started', {
+            epicId: this.config.epicId,
+            timestamp: Date.now()
+        });
+        try {
+            // Sort groups by priority (highest first)
+            const sortedGroups = [
+                ...this.config.sprintGroups
+            ].sort((a, b)=>b.priority - a.priority);
+            // Execute groups respecting dependencies and parallelism
+            await this.executeGroupsWithDependencies(sortedGroups);
+            // Generate final result
+            const result = this.generateMetaCoordinationResult();
+            this.emit('execution:completed', result);
+            return result;
+        } catch (error) {
+            this.logger.error('Meta-coordination failed', {
+                epicId: this.config.epicId,
+                error: error instanceof Error ? error.message : String(error)
+            });
+            throw error;
+        }
+    }
+    /**
+   * Execute sprint groups respecting dependencies and parallelism limits
+   */ async executeGroupsWithDependencies(groups) {
+        const pendingGroups = new Set(groups.map((g)=>g.groupId));
+        while(pendingGroups.size > 0){
+            // Find groups ready to execute (dependencies satisfied)
+            const readyGroups = groups.filter((group)=>{
+                if (!pendingGroups.has(group.groupId)) {
+                    return false; // Already processed
+                }
+                // Check if all dependencies are completed
+                return group.dependencies.every((depId)=>this.completedGroups.has(depId));
+            });
+            if (readyGroups.length === 0 && pendingGroups.size > 0) {
+                // Deadlock or failure - no groups can proceed
+                const remaining = Array.from(pendingGroups);
+                this.logger.error('Coordination deadlock detected', {
+                    epicId: this.config.epicId,
+                    pendingGroups: remaining,
+                    completedGroups: Array.from(this.completedGroups),
+                    failedGroups: Array.from(this.failedGroups)
+                });
+                throw new Error(`Coordination deadlock: ${remaining.length} groups cannot proceed due to dependency failures`);
+            }
+            // Launch coordinators up to parallel limit
+            const availableSlots = this.config.maxParallelCoordinators - this.activeCoordinators.size;
+            const groupsToLaunch = readyGroups.slice(0, availableSlots);
+            this.logger.info('Launching sprint coordinators', {
+                epicId: this.config.epicId,
+                groupCount: groupsToLaunch.length,
+                activeCoordinators: this.activeCoordinators.size,
+                availableSlots
+            });
+            // Launch coordinators in parallel
+            const launchPromises = groupsToLaunch.map((group)=>this.launchCoordinator(group));
+            // Wait for at least one coordinator to complete
+            await Promise.race(launchPromises);
+            // Wait a bit to allow other coordinators to complete
+            await this.sleep(100);
+            // Remove completed/failed groups from pending
+            for (const group of readyGroups){
+                if (this.completedGroups.has(group.groupId) || this.failedGroups.has(group.groupId)) {
+                    pendingGroups.delete(group.groupId);
+                }
+            }
+        }
+        // Wait for all remaining active coordinators to complete
+        await this.waitForAllCoordinators();
+    }
+    /**
+   * Launch a sprint coordinator for a group
+   */ async launchCoordinator(group) {
+        const coordinatorId = `coordinator-${group.groupId}`;
+        this.logger.info('Launching sprint coordinator', {
+            coordinatorId,
+            groupId: group.groupId,
+            sprintCount: group.sprints.length
+        });
+        try {
+            // Create SprintOrchestrator configuration
+            const orchestratorConfig = {
+                epicId: this.config.epicId,
+                sprints: group.sprints,
+                globalSprintResults: this.globalSprintResults,
+                defaultMaxRetries: 10,
+                enableParallelExecution: false,
+                loopConfig: this.config.loopConfig,
+                memoryConfig: {
+                    enabled: true,
+                    namespace: `epic/${this.config.epicId}/group-${group.groupId}`
+                }
+            };
+            // Create orchestrator instance
+            const orchestrator = new SprintOrchestrator(orchestratorConfig);
+            // Initialize orchestrator
+            await orchestrator.initialize();
+            // Register coordinator instance
+            const instance = {
+                coordinatorId,
+                group,
+                orchestrator,
+                status: 'running',
+                startTime: Date.now()
+            };
+            this.coordinators.set(coordinatorId, instance);
+            this.activeCoordinators.add(coordinatorId);
+            // Publish sprint start event via Redis pub/sub (CRITICAL: Rule #19)
+            await this.pubSubHelper.publishSprintStart(group.groupId, coordinatorId, group.dependencies);
+            // Also publish to local coordination channel for backward compatibility
+            await this.publishProgress({
+                coordinatorId,
+                groupId: group.groupId,
+                type: 'started',
+                timestamp: Date.now()
+            });
+            // Execute orchestrator (asynchronously)
+            this.executeOrchestrator(instance).then(()=>{
+                this.logger.info('Coordinator completed successfully', {
+                    coordinatorId,
+                    groupId: group.groupId
+                });
+            }).catch((error)=>{
+                this.logger.error('Coordinator failed', {
+                    coordinatorId,
+                    groupId: group.groupId,
+                    error: error instanceof Error ? error.message : String(error)
+                });
+            });
+        } catch (error) {
+            this.logger.error('Failed to launch coordinator', {
+                coordinatorId,
+                groupId: group.groupId,
+                error: error instanceof Error ? error.message : String(error)
+            });
+            this.failedGroups.add(group.groupId);
+            throw error;
+        }
+    }
+    /**
+   * Execute sprint orchestrator and handle result
+   */ async executeOrchestrator(instance) {
+        try {
+            // Execute epic
+            const result = await instance.orchestrator.executeEpic();
+            // Update instance
+            instance.status = result.success ? 'completed' : 'failed';
+            instance.endTime = Date.now();
+            instance.result = result;
+            // Mark group as completed or failed
+            if (result.success) {
+                this.completedGroups.add(instance.group.groupId);
+                // Publish sprint complete event via Redis pub/sub (CRITICAL: Rule #19)
+                await this.pubSubHelper.publishSprintComplete(instance.group.groupId, result.statistics.averageConfidence, 'DEFER' // Product Owner decision from Loop 4
+                );
+                await this.publishProgress({
+                    coordinatorId: instance.coordinatorId,
+                    groupId: instance.group.groupId,
+                    type: 'group_completed',
+                    confidence: result.statistics.averageConfidence,
+                    timestamp: Date.now()
+                });
+            } else {
+                this.failedGroups.add(instance.group.groupId);
+                // Publish sprint failed event via Redis pub/sub (CRITICAL: Rule #19)
+                await this.pubSubHelper.publishSprintFailed(instance.group.groupId, result.failedSprints.join(', '));
+                await this.publishProgress({
+                    coordinatorId: instance.coordinatorId,
+                    groupId: instance.group.groupId,
+                    type: 'group_failed',
+                    timestamp: Date.now()
+                });
+            }
+            // Remove from active set
+            this.activeCoordinators.delete(instance.coordinatorId);
+            this.logger.info('Orchestrator execution completed', {
+                coordinatorId: instance.coordinatorId,
+                groupId: instance.group.groupId,
+                success: result.success,
+                completedSprints: result.completedSprints.length,
+                failedSprints: result.failedSprints.length
+            });
+        } catch (error) {
+            instance.status = 'failed';
+            instance.endTime = Date.now();
+            instance.error = error instanceof Error ? error : new Error(String(error));
+            this.failedGroups.add(instance.group.groupId);
+            this.activeCoordinators.delete(instance.coordinatorId);
+            this.logger.error('Orchestrator execution failed', {
+                coordinatorId: instance.coordinatorId,
+                groupId: instance.group.groupId,
+                error: error instanceof Error ? error.message : String(error)
+            });
+            throw error;
+        }
+    }
+    /**
+   * Wait for all active coordinators to complete
+   */ async waitForAllCoordinators() {
+        while(this.activeCoordinators.size > 0){
+            this.logger.debug('Waiting for active coordinators', {
+                active: this.activeCoordinators.size,
+                completed: this.completedGroups.size,
+                failed: this.failedGroups.size
+            });
+            await this.sleep(500);
+        }
+    }
+    /**
+   * Generate meta-coordination result
+   */ generateMetaCoordinationResult() {
+        const coordinatorResults = new Map();
+        let totalSprints = 0;
+        const completedSprints = [];
+        const failedSprints = [];
+        let totalConfidence = 0;
+        let confidenceCount = 0;
+        // Aggregate results from all coordinators
+        for (const instance of this.coordinators.values()){
+            if (instance.result) {
+                coordinatorResults.set(instance.coordinatorId, instance.result);
+                totalSprints += instance.result.totalSprints;
+                completedSprints.push(...instance.result.completedSprints);
+                failedSprints.push(...instance.result.failedSprints);
+                // Aggregate confidence
+                totalConfidence += instance.result.statistics.averageConfidence;
+                confidenceCount++;
+            }
+        }
+        const aggregatedConfidence = confidenceCount > 0 ? totalConfidence / confidenceCount : 0;
+        return {
+            success: this.failedGroups.size === 0,
+            epicId: this.config.epicId,
+            totalGroups: this.config.sprintGroups.length,
+            completedGroups: Array.from(this.completedGroups),
+            failedGroups: Array.from(this.failedGroups),
+            aggregatedConfidence,
+            totalSprints,
+            completedSprints,
+            failedSprints,
+            totalDuration: Date.now() - this.startTime,
+            coordinatorResults,
+            timestamp: Date.now()
+        };
+    }
+    /**
+   * Validate sprint groups for dependency cycles and conflicts
+   */ validateSprintGroups() {
+        this.logger.info('Validating sprint groups', {
+            groupCount: this.config.sprintGroups.length
+        });
+        // Check for duplicate group IDs
+        const groupIds = new Set();
+        for (const group of this.config.sprintGroups){
+            if (groupIds.has(group.groupId)) {
+                throw new Error(`Duplicate group ID: ${group.groupId}`);
+            }
+            groupIds.add(group.groupId);
+        }
+        // Check for invalid dependencies
+        for (const group of this.config.sprintGroups){
+            for (const depId of group.dependencies){
+                if (!groupIds.has(depId)) {
+                    throw new Error(`Invalid dependency in group ${group.groupId}: ${depId} does not exist`);
+                }
+            }
+        }
+        // Detect dependency cycles
+        this.detectDependencyCycles();
+        this.logger.info('Sprint groups validated successfully', {
+            totalGroups: groupIds.size
+        });
+    }
+    /**
+   * Detect dependency cycles in sprint groups
+   */ detectDependencyCycles() {
+        const visited = new Set();
+        const recStack = new Set();
+        const dfs = (groupId, path)=>{
+            if (recStack.has(groupId)) {
+                const cycle = [
+                    ...path,
+                    groupId
+                ];
+                throw new Error(`Dependency cycle detected: ${cycle.join(' → ')}`);
+            }
+            if (visited.has(groupId)) {
+                return;
+            }
+            visited.add(groupId);
+            recStack.add(groupId);
+            const group = this.config.sprintGroups.find((g)=>g.groupId === groupId);
+            if (group) {
+                for (const depId of group.dependencies){
+                    dfs(depId, [
+                        ...path,
+                        groupId
+                    ]);
+                }
+            }
+            recStack.delete(groupId);
+        };
+        for (const group of this.config.sprintGroups){
+            if (!visited.has(group.groupId)) {
+                dfs(group.groupId, []);
+            }
+        }
+    }
+    /**
+   * Subscribe to coordination events via Redis pub/sub
+   *
+   * CRITICAL (Rule #19): ALL coordinator communication MUST use Redis pub/sub
+   */ async subscribeToCoordinationEvents() {
+        this.logger.info('Subscribing to coordination events', {
+            channel: this.COORDINATION_CHANNEL,
+            sprintCoordinationChannel: REDIS_CHANNELS.SPRINT_COORDINATION,
+            agentLifecycleChannel: REDIS_CHANNELS.AGENT_LIFECYCLE
+        });
+        // Subscribe to sprint coordination events
+        await this.pubSubHelper.subscribeToSprintCoordination(async (event)=>{
+            this.logger.debug('Sprint coordination event received', {
+                type: event.type,
+                sprintId: event.sprintId,
+                coordinatorId: event.coordinatorId
+            });
+            // Handle sprint lifecycle events
+            if (event.type === 'sprint:complete') {
+                this.logger.info('Sprint completed event', {
+                    sprintId: event.sprintId,
+                    consensus: event.consensus,
+                    decision: event.decision
+                });
+            // Mark group as completed (if not already marked)
+            // This provides redundancy with direct orchestrator monitoring
+            } else if (event.type === 'sprint:failed') {
+                this.logger.error('Sprint failed event', {
+                    sprintId: event.sprintId
+                });
+            }
+        });
+        // Subscribe to agent lifecycle events for monitoring
+        await this.pubSubHelper.subscribeToAgentLifecycle(async (event)=>{
+            this.logger.debug('Agent lifecycle event received', {
+                type: event.type,
+                agentId: event.agentId,
+                sprintId: event.sprintId,
+                role: event.role
+            });
+            // Monitor agent spawning and completion for coordination metrics
+            if (event.type === 'agent:spawned') {
+                this.emit('agent:spawned', event);
+            } else if (event.type === 'agent:completed') {
+                this.emit('agent:completed', event);
+            } else if (event.type === 'agent:failed') {
+                this.emit('agent:failed', event);
+            }
+        });
+        this.logger.info('Subscribed to all coordination channels');
+    }
+    /**
+   * Publish progress update to Redis
+   */ async publishProgress(update) {
+        try {
+            const message = JSON.stringify(update);
+            await this.redis.publish(this.COORDINATION_CHANNEL, message);
+            this.logger.debug('Progress update published', {
+                coordinatorId: update.coordinatorId,
+                groupId: update.groupId,
+                type: update.type
+            });
+            this.emit('progress', update);
+        } catch (error) {
+            this.logger.warn('Failed to publish progress update', {
+                error: error instanceof Error ? error.message : String(error)
+            });
+        }
+    }
+    /**
+   * Get coordination statistics
+   */ getStatistics() {
+        return {
+            epicId: this.config.epicId,
+            totalGroups: this.config.sprintGroups.length,
+            completedGroups: this.completedGroups.size,
+            failedGroups: this.failedGroups.size,
+            activeCoordinators: this.activeCoordinators.size,
+            duration: this.startTime > 0 ? Date.now() - this.startTime : 0
+        };
+    }
+    /**
+   * Shutdown meta-coordinator and all child coordinators
+   */ async shutdown() {
+        this.logger.info('Shutting down Meta-Coordinator', {
+            epicId: this.config.epicId
+        });
+        // Shutdown all orchestrators
+        for (const instance of this.coordinators.values()){
+            try {
+                await instance.orchestrator.shutdown();
+            } catch (error) {
+                this.logger.warn('Error shutting down orchestrator', {
+                    coordinatorId: instance.coordinatorId,
+                    error: error instanceof Error ? error.message : String(error)
+                });
+            }
+        }
+        this.removeAllListeners();
+    }
+    /**
+   * Sleep utility
+   */ sleep(ms) {
+        return new Promise((resolve)=>setTimeout(resolve, ms));
+    }
+    constructor(config){
+        super(), _define_property(this, "logger", void 0), _define_property(this, "config", void 0), _define_property(this, "redis", void 0), _define_property(this, "pubSubHelper", void 0), // Coordinator instances
+        _define_property(this, "coordinators", new Map()), _define_property(this, "activeCoordinators", new Set()), _define_property(this, "completedGroups", new Set()), _define_property(this, "failedGroups", new Set()), // Global sprint results (shared across all coordinators)
+        _define_property(this, "globalSprintResults", void 0), // Timing
+        _define_property(this, "startTime", 0), // Redis pub/sub channel
+        _define_property(this, "COORDINATION_CHANNEL", 'cfn:meta:coordination');
+        // Validate and set defaults
+        this.config = {
+            epicId: config.epicId,
+            sprintGroups: config.sprintGroups,
+            redisClient: config.redisClient,
+            maxParallelCoordinators: config.maxParallelCoordinators || 5,
+            globalSprintResults: config.globalSprintResults,
+            loopConfig: config.loopConfig || {
+                maxLoop2Iterations: 10,
+                maxLoop3Iterations: 10,
+                confidenceThreshold: 0.75,
+                consensusThreshold: 0.90
+            }
+        };
+        this.redis = config.redisClient;
+        // Initialize global sprint results (shared state)
+        this.globalSprintResults = config.globalSprintResults || new Map();
+        // Initialize logger
+        const loggerConfig = process.env.CLAUDE_FLOW_ENV === 'test' ? {
+            level: 'error',
+            format: 'json',
+            destination: 'console'
+        } : {
+            level: 'info',
+            format: 'json',
+            destination: 'console'
+        };
+        this.logger = new Logger(loggerConfig, {
+            component: 'MetaCoordinator'
+        });
+        // Initialize Redis pub/sub helper
+        this.pubSubHelper = createRedisPubSubHelper(this.redis, loggerConfig);
+        this.logger.info('Meta-Coordinator initialized', {
+            epicId: this.config.epicId,
+            groupCount: this.config.sprintGroups.length,
+            maxParallel: this.config.maxParallelCoordinators
+        });
+    }
+}
+// ===== FACTORY FUNCTION =====
+/**
+ * Create Meta-Coordinator instance
+ */ export function createMetaCoordinator(config) {
+    return new MetaCoordinator(config);
+}
+// ===== EXPORTS =====
+export default MetaCoordinator;

package/.claude-flow-novice/dist/src/cfn-loop/modes/enterprise-mode.js

@@ -0,0 +1,132 @@
+/**
+ * Enterprise Mode Configuration
+ *
+ * Quality-focused CFN Loop mode for production-grade enterprise systems.
+ *
+ * Characteristics:
+ * - Higher thresholds (Gate: 0.75, Consensus: 0.95)
+ * - More iterations (Max Loop2: 15, Max Loop3: 15)
+ * - Loop 0.5: Planning consensus (3 architects vote on ADRs/diagrams)
+ * - 4 validators (comprehensive team)
+ * - 4-person product owner board with weighted voting
+ * - No skipped validations (full quality checks)
+ * - Prioritize quality, security, scalability, accessibility
+ *
+ * @module cfn-loop/modes/enterprise-mode
+ */ /**
+ * Product owner team roles with weights
+ *
+ * Weights from DESIGN_CONSENSUS_MULTI_STAKEHOLDER_ARCHITECTURE.md:780-786
+ * - CTO: 30% (strategic decisions)
+ * - Product Owner: 30% (business value)
+ * - Power User: 20% (usability)
+ * - Accessibility User: 20% (WCAG compliance)
+ */ const enterpriseProductOwnerRoles = [
+    {
+        name: 'cto',
+        weight: 0.30
+    },
+    {
+        name: 'product-owner',
+        weight: 0.30
+    },
+    {
+        name: 'user-power',
+        weight: 0.20
+    },
+    {
+        name: 'user-accessibility',
+        weight: 0.20
+    }
+];
+/**
+ * Enterprise mode configuration
+ *
+ * Optimized for:
+ * - Production-grade quality
+ * - Enterprise security standards
+ * - Full accessibility compliance (WCAG)
+ * - Scalability and performance
+ * - Comprehensive documentation
+ */ export const enterpriseMode = {
+    name: 'enterprise',
+    // Higher confidence thresholds for quality
+    gateThreshold: 0.75,
+    consensusThreshold: 0.95,
+    // Extended iteration limits
+    maxLoop2Iterations: 15,
+    maxLoop3Iterations: 15,
+    // Comprehensive validator team
+    validatorCount: 4,
+    validatorTypes: [
+        'code-quality-validator',
+        'security-specialist',
+        'perf-analyzer',
+        'tester'
+    ],
+    // Product owner board (4-person team)
+    productOwnerStructure: 'team',
+    // No skipped validations (full enterprise checks)
+    skipValidations: [],
+    // Special instructions for enterprise mindset
+    specialInstructions: `
+# Enterprise Mode - Quality-Focused Development
+
+You are working in **Enterprise Mode**. Priorities:
+
+1. **Enterprise-Grade Quality**
+   - Production-ready architecture
+   - Comprehensive error handling
+   - Full test coverage (>90%)
+   - Complete documentation
+
+2. **Security & Compliance**
+   - Security audit required
+   - WCAG 2.1 AA accessibility compliance
+   - Data protection (GDPR/SOC2)
+   - Vulnerability scanning
+
+3. **Scalability & Performance**
+   - Designed for scale (1000+ concurrent users)
+   - Performance benchmarks required
+   - Load testing and optimization
+   - Monitoring and observability
+
+4. **Team Consensus Required**
+   - All decisions require board approval
+   - CTO: Strategic alignment
+   - Product Owner: Business value
+   - Power User: Usability validation
+   - Accessibility User: WCAG compliance
+
+**Remember:** This is enterprise mode. Quality, security, and accessibility are non-negotiable.
+  `.trim(),
+    // Loop 0.5: Planning consensus (3 architects)
+    planningConsensus: {
+        enabled: true,
+        architectTypes: [
+            'architect',
+            'system-architect',
+            'security-specialist'
+        ],
+        threshold: 0.85
+    },
+    // Loop 4: Product owner board with weighted voting
+    productOwnerTeam: {
+        roles: enterpriseProductOwnerRoles,
+        votingAlgorithm: 'weighted-confidence'
+    }
+};
+/**
+ * Get Enterprise mode configuration
+ */ export function getEnterpriseMode() {
+    return enterpriseMode;
+}
+/**
+ * Get product owner roles for Enterprise mode
+ */ export function getEnterpriseProductOwnerRoles() {
+    return [
+        ...enterpriseProductOwnerRoles
+    ];
+}
+export default enterpriseMode;