claude-flow-novice 2.0.4 → 2.0.5

package/dist/src/swarm/claude-flow-executor.js

@@ -1,229 +0,0 @@
-/**
- * Claude Flow SPARC Executor
- * Executes tasks using the full claude-flow-novice SPARC system in non-interactive mode
- */ 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 { Logger } from "../core/logger.js";
-import { spawn } from "node:child_process";
-import { getClaudeFlowBin } from "../utils/paths.js";
-export class ClaudeFlowExecutor {
-    async executeTask(task, agent, targetDir) {
-        this.logger.info('Executing task with Claude Flow SPARC', {
-            taskId: task.id.id,
-            taskName: task.name,
-            agentType: agent.type,
-            targetDir
-        });
-        const startTime = Date.now();
-        try {
-            // Determine the SPARC mode based on task type and agent type
-            const sparcMode = this.determineSparcMode(task, agent);
-            // Build the command
-            const command = this.buildSparcCommand(task, sparcMode, targetDir);
-            this.logger.info('Executing SPARC command', {
-                mode: sparcMode,
-                command: command.join(' ')
-            });
-            // Execute the command
-            const result = await this.executeCommand(command);
-            const endTime = Date.now();
-            const executionTime = endTime - startTime;
-            return {
-                output: result.output,
-                artifacts: result.artifacts || {},
-                metadata: {
-                    executionTime,
-                    sparcMode,
-                    command: command.join(' '),
-                    exitCode: result.exitCode,
-                    quality: 0.95,
-                    completeness: 0.9
-                },
-                error: result.error
-            };
-        } catch (error) {
-            this.logger.error('Failed to execute Claude Flow SPARC command', {
-                error: error instanceof Error ? error.message : String(error),
-                taskId: task.id.id
-            });
-            return {
-                output: '',
-                artifacts: {},
-                metadata: {
-                    executionTime: Date.now() - startTime,
-                    quality: 0,
-                    completeness: 0
-                },
-                error: error instanceof Error ? error.message : String(error)
-            };
-        }
-    }
-    determineSparcMode(task, agent) {
-        // Map task types and agent types to SPARC modes
-        const modeMap = {
-            // Task type mappings
-            coding: 'code',
-            testing: 'tdd',
-            analysis: 'spec-pseudocode',
-            documentation: 'docs-writer',
-            research: 'spec-pseudocode',
-            review: 'refinement-optimization-mode',
-            deployment: 'devops',
-            optimization: 'refinement-optimization-mode',
-            integration: 'integration',
-            // Agent type overrides
-            coder: 'code',
-            tester: 'tdd',
-            analyst: 'spec-pseudocode',
-            documenter: 'docs-writer',
-            reviewer: 'refinement-optimization-mode',
-            researcher: 'spec-pseudocode',
-            coordinator: 'architect'
-        };
-        // Check for specific keywords in task description
-        const description = task.description.toLowerCase();
-        if (description.includes('architecture') || description.includes('design')) {
-            return 'architect';
-        }
-        if (description.includes('security')) {
-            return 'security-review';
-        }
-        if (description.includes('debug')) {
-            return 'debug';
-        }
-        if (description.includes('test')) {
-            return 'tdd';
-        }
-        if (description.includes('document')) {
-            return 'docs-writer';
-        }
-        if (description.includes('integrate')) {
-            return 'integration';
-        }
-        // Use agent type first, then task type
-        return modeMap[agent.type] || modeMap[task.type] || 'code';
-    }
-    buildSparcCommand(task, mode, targetDir) {
-        const command = [
-            this.claudeFlowPath,
-            'sparc',
-            'run',
-            mode,
-            `"${this.formatTaskDescription(task)}"`
-        ];
-        // Add options
-        if (targetDir) {
-            command.push('--target-dir', targetDir);
-        }
-        if (this.verbose) {
-            command.push('--verbose');
-        }
-        // Add non-interactive flag
-        command.push('--non-interactive');
-        // Add auto-confirm flag
-        command.push('--yes');
-        return command;
-    }
-    formatTaskDescription(task) {
-        // Format the task description for SPARC command
-        let description = task.description;
-        // If the task has specific instructions, include them
-        if (task.instructions && task.instructions !== task.description) {
-            description = `${task.description}. ${task.instructions}`;
-        }
-        // Add context if available
-        if (task.context?.targetDir) {
-            description += ` in ${task.context.targetDir}`;
-        }
-        return description.replace(/"/g, '\\"');
-    }
-    async executeCommand(command) {
-        return new Promise((resolve, reject)=>{
-            const [cmd, ...args] = command;
-            const proc = spawn(cmd, args, {
-                shell: true,
-                env: {
-                    ...process.env,
-                    CLAUDE_FLOW_NON_INTERACTIVE: 'true',
-                    CLAUDE_FLOW_AUTO_CONFIRM: 'true'
-                }
-            });
-            let stdout = '';
-            let stderr = '';
-            const artifacts = {};
-            proc.stdout.on('data', (data)=>{
-                const chunk = data.toString();
-                stdout += chunk;
-                // Parse artifacts from output
-                const artifactMatch = chunk.match(/Created file: (.+)/g);
-                if (artifactMatch) {
-                    artifactMatch.forEach((match)=>{
-                        const filePath = match.replace('Created file: ', '').trim();
-                        artifacts[filePath] = true;
-                    });
-                }
-            });
-            proc.stderr.on('data', (data)=>{
-                stderr += data.toString();
-            });
-            proc.on('close', (code)=>{
-                clearTimeout(timeoutId); // Clear timeout when process completes
-                if (code === 0) {
-                    resolve({
-                        output: stdout,
-                        artifacts,
-                        exitCode: code,
-                        error: null
-                    });
-                } else {
-                    resolve({
-                        output: stdout,
-                        artifacts,
-                        exitCode: code,
-                        error: stderr || `Command exited with code ${code}`
-                    });
-                }
-            });
-            proc.on('error', (err)=>{
-                reject(err);
-            });
-            // Handle timeout - configurable for SPARC operations
-            const timeoutMs = this.timeoutMinutes * 60 * 1000;
-            const timeoutId = setTimeout(()=>{
-                proc.kill('SIGTERM');
-                reject(new Error('Command execution timeout'));
-            }, timeoutMs);
-        });
-    }
-    constructor(config = {}){
-        _define_property(this, "logger", void 0);
-        _define_property(this, "claudeFlowPath", void 0);
-        _define_property(this, "enableSparc", void 0);
-        _define_property(this, "verbose", void 0);
-        _define_property(this, "timeoutMinutes", void 0);
-        this.logger = config.logger || new Logger({
-            level: 'info',
-            format: 'text',
-            destination: 'console'
-        }, {
-            component: 'ClaudeFlowExecutor'
-        });
-        this.claudeFlowPath = config.claudeFlowPath || getClaudeFlowBin();
-        this.enableSparc = config.enableSparc ?? true;
-        this.verbose = config.verbose ?? false;
-        this.timeoutMinutes = config.timeoutMinutes ?? 59;
-    }
-}
-// Export for use in swarm coordinator
-export default ClaudeFlowExecutor;

package/dist/src/swarm/consensus-coordinator.js

@@ -1,475 +0,0 @@
-/**
- * Consensus Coordinator
- * Implements distributed consensus protocols for agent coordination decisions
- *
- * Supported Protocols:
- * - Raft: Leader-based consensus for coordination decisions
- * - PBFT: Byzantine fault tolerance for untrusted agents
- * - Quorum: Simple majority voting for basic decisions
- *
- * Performance Target: <10ms consensus latency for 100+ agents
- */ 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 "node:events";
-import { performance } from "perf_hooks";
-import { Logger } from "../core/logger.js";
-export class ConsensusCoordinator extends EventEmitter {
-    initialize() {
-        // Start background processes based on protocol
-        if (this.config.protocol === 'raft') {
-            this.startRaftProtocol();
-        }
-        this.logger.info('Consensus coordinator initialized', {
-            protocol: this.config.protocol,
-            timeout: this.config.timeout
-        });
-    }
-    /**
-   * Register an agent in the consensus group
-   */ registerAgent(agentId) {
-        this.agents.add(agentId);
-        this.agentStates.set(agentId, 'active');
-        // Update quorum size if not explicitly set
-        if (!this.config.quorumSize) {
-            this.config.quorumSize = this.calculateQuorumSize();
-        }
-        this.logger.debug('Agent registered for consensus', {
-            agentId,
-            totalAgents: this.agents.size,
-            quorumSize: this.config.quorumSize
-        });
-        this.emit('agent:registered', agentId);
-    }
-    /**
-   * Unregister an agent from the consensus group
-   */ unregisterAgent(agentId) {
-        this.agents.delete(agentId);
-        this.agentStates.delete(agentId);
-        // Update quorum size
-        this.config.quorumSize = this.calculateQuorumSize();
-        this.logger.debug('Agent unregistered from consensus', {
-            agentId,
-            totalAgents: this.agents.size,
-            quorumSize: this.config.quorumSize
-        });
-        this.emit('agent:unregistered', agentId);
-    }
-    /**
-   * Propose a decision for consensus
-   */ async propose(proposal) {
-        const consensusStart = performance.now();
-        this.logger.info('Consensus proposal initiated', {
-            proposalId: proposal.id,
-            type: proposal.type,
-            protocol: this.config.protocol
-        });
-        try {
-            let result;
-            switch(this.config.protocol){
-                case 'raft':
-                    result = await this.raftConsensus(proposal);
-                    break;
-                case 'pbft':
-                    result = await this.pbftConsensus(proposal);
-                    break;
-                case 'quorum':
-                    result = await this.quorumConsensus(proposal);
-                    break;
-                case 'fast-paxos':
-                    result = await this.fastPaxosConsensus(proposal);
-                    break;
-                default:
-                    throw new Error(`Unsupported consensus protocol: ${this.config.protocol}`);
-            }
-            // Record metrics
-            const consensusTime = performance.now() - consensusStart;
-            this.recordConsensusMetrics(result, consensusTime);
-            this.logger.info('Consensus reached', {
-                proposalId: proposal.id,
-                decision: result.decision,
-                consensusTime: `${consensusTime.toFixed(2)}ms`,
-                participationRate: `${(result.participationRate * 100).toFixed(1)}%`
-            });
-            this.emit('consensus:reached', result);
-            return result;
-        } catch (error) {
-            this.logger.error('Consensus failed', {
-                proposalId: proposal.id,
-                error: error instanceof Error ? error.message : String(error)
-            });
-            throw error;
-        }
-    }
-    /**
-   * Raft consensus implementation
-   */ async raftConsensus(proposal) {
-        // Only leader can propose in Raft
-        if (this.raftState.role !== 'leader') {
-            if (this.raftState.leaderId) {
-                // Forward to leader
-                this.logger.debug('Forwarding proposal to leader', {
-                    leaderId: this.raftState.leaderId
-                });
-            } else {
-                // No leader, trigger election
-                await this.startLeaderElection();
-            }
-        }
-        // Append to log
-        const logEntry = {
-            term: this.raftState.currentTerm,
-            command: proposal
-        };
-        this.raftState.log.push(logEntry);
-        // Replicate to followers
-        const votes = await this.replicateToFollowers(logEntry);
-        // Check if majority acknowledged
-        const quorum = Math.floor(this.agents.size / 2) + 1;
-        const approvals = votes.filter((v)=>v.decision === 'approve').length;
-        const decision = approvals >= quorum ? 'approved' : 'rejected';
-        const consensusTime = performance.now();
-        return {
-            proposalId: proposal.id,
-            decision,
-            votes,
-            consensusTime,
-            participationRate: votes.length / this.agents.size
-        };
-    }
-    /**
-   * PBFT (Practical Byzantine Fault Tolerance) consensus
-   */ async pbftConsensus(proposal) {
-        const startTime = performance.now();
-        const deadline = Date.now() + this.config.timeout;
-        // Phase 1: Pre-prepare (leader broadcasts proposal)
-        this.logger.debug('PBFT Pre-prepare phase', {
-            proposalId: proposal.id
-        });
-        // Phase 2: Prepare (agents exchange prepare messages)
-        const prepareVotes = await this.collectVotes(proposal, 'prepare', deadline);
-        // Check if we have enough prepare votes (2f + 1 where f is max faulty)
-        const f = this.config.byzantineTolerance || 1;
-        const minVotes = 2 * f + 1;
-        if (prepareVotes.length < minVotes) {
-            return {
-                proposalId: proposal.id,
-                decision: 'timeout',
-                votes: prepareVotes,
-                consensusTime: performance.now() - startTime,
-                participationRate: prepareVotes.length / this.agents.size
-            };
-        }
-        // Phase 3: Commit (agents exchange commit messages)
-        const commitVotes = await this.collectVotes(proposal, 'commit', deadline);
-        const approvals = commitVotes.filter((v)=>v.decision === 'approve').length;
-        const decision = approvals >= minVotes ? 'approved' : 'rejected';
-        return {
-            proposalId: proposal.id,
-            decision,
-            votes: commitVotes,
-            consensusTime: performance.now() - startTime,
-            participationRate: commitVotes.length / this.agents.size
-        };
-    }
-    /**
-   * Simple quorum-based consensus
-   */ async quorumConsensus(proposal) {
-        const startTime = performance.now();
-        const deadline = Date.now() + this.config.timeout;
-        // Broadcast proposal to all agents
-        const votes = await this.collectVotes(proposal, 'vote', deadline);
-        // Count votes
-        const approvals = votes.filter((v)=>v.decision === 'approve').length;
-        const rejections = votes.filter((v)=>v.decision === 'reject').length;
-        const quorumSize = this.config.quorumSize || Math.floor(this.agents.size / 2) + 1;
-        let decision;
-        if (approvals >= quorumSize) {
-            decision = 'approved';
-        } else if (rejections >= quorumSize) {
-            decision = 'rejected';
-        } else {
-            decision = 'timeout';
-        }
-        return {
-            proposalId: proposal.id,
-            decision,
-            votes,
-            consensusTime: performance.now() - startTime,
-            participationRate: votes.length / this.agents.size
-        };
-    }
-    /**
-   * Fast Paxos consensus (optimized for low latency)
-   */ async fastPaxosConsensus(proposal) {
-        const startTime = performance.now();
-        const deadline = Date.now() + this.config.timeout;
-        // Fast path: Try to reach consensus in one round
-        const votes = await this.collectVotes(proposal, 'fast-vote', deadline);
-        const quorumSize = Math.floor(this.agents.size * 0.75); // 3/4 majority for fast path
-        const approvals = votes.filter((v)=>v.decision === 'approve').length;
-        if (approvals >= quorumSize) {
-            // Fast path succeeded
-            return {
-                proposalId: proposal.id,
-                decision: 'approved',
-                votes,
-                consensusTime: performance.now() - startTime,
-                participationRate: votes.length / this.agents.size
-            };
-        }
-        // Fall back to classic Paxos (two-phase)
-        this.logger.debug('Fast path failed, falling back to classic Paxos', {
-            proposalId: proposal.id
-        });
-        // Prepare phase
-        const prepareVotes = await this.collectVotes(proposal, 'prepare', deadline);
-        // Accept phase
-        const acceptVotes = await this.collectVotes(proposal, 'accept', deadline);
-        const majoritySize = Math.floor(this.agents.size / 2) + 1;
-        const finalApprovals = acceptVotes.filter((v)=>v.decision === 'approve').length;
-        return {
-            proposalId: proposal.id,
-            decision: finalApprovals >= majoritySize ? 'approved' : 'rejected',
-            votes: acceptVotes,
-            consensusTime: performance.now() - startTime,
-            participationRate: acceptVotes.length / this.agents.size
-        };
-    }
-    /**
-   * Collect votes from agents
-   */ async collectVotes(proposal, phase, deadline) {
-        const votes = [];
-        const proposalData = {
-            proposal,
-            votes: new Map(),
-            deadline,
-            startTime: Date.now()
-        };
-        this.activeProposals.set(proposal.id, proposalData);
-        // In production, this would send messages to actual agents
-        // For now, simulate voting behavior
-        const activeAgents = Array.from(this.agents).filter((agentId)=>this.agentStates.get(agentId) === 'active');
-        await Promise.all(activeAgents.map(async (agentId)=>{
-            // Simulate network latency (0-5ms)
-            await new Promise((resolve)=>setTimeout(resolve, Math.random() * 5));
-            if (Date.now() > deadline) {
-                return; // Timeout
-            }
-            // Simulate voting (in production, agents would make actual decisions)
-            const vote = {
-                proposalId: proposal.id,
-                voter: agentId,
-                decision: Math.random() > 0.1 ? 'approve' : 'reject',
-                timestamp: Date.now()
-            };
-            votes.push(vote);
-            proposalData.votes.set(agentId, vote);
-        }));
-        this.activeProposals.delete(proposal.id);
-        return votes;
-    }
-    /**
-   * Start Raft leader election
-   */ async startLeaderElection() {
-        this.raftState.currentTerm++;
-        this.raftState.role = 'candidate';
-        this.raftState.votedFor = 'self'; // Vote for self
-        this.logger.info('Starting leader election', {
-            term: this.raftState.currentTerm
-        });
-        // Request votes from other agents
-        const votes = await this.requestVotes();
-        const majority = Math.floor(this.agents.size / 2) + 1;
-        const approvals = votes.filter((v)=>v.decision === 'approve').length + 1; // +1 for self vote
-        if (approvals >= majority) {
-            // Won election
-            this.raftState.role = 'leader';
-            this.raftState.leaderId = 'self';
-            this.logger.info('Elected as leader', {
-                term: this.raftState.currentTerm,
-                votes: approvals
-            });
-            this.emit('leader:elected', {
-                term: this.raftState.currentTerm
-            });
-        } else {
-            // Lost election
-            this.raftState.role = 'follower';
-            this.logger.debug('Leader election failed', {
-                term: this.raftState.currentTerm,
-                votes: approvals
-            });
-        }
-    }
-    /**
-   * Request votes from agents (Raft)
-   */ async requestVotes() {
-        const votes = [];
-        // In production, send RequestVote RPCs
-        // For now, simulate responses
-        for (const agentId of this.agents){
-            const vote = {
-                proposalId: `election-${this.raftState.currentTerm}`,
-                voter: agentId,
-                decision: Math.random() > 0.3 ? 'approve' : 'reject',
-                timestamp: Date.now()
-            };
-            votes.push(vote);
-        }
-        return votes;
-    }
-    /**
-   * Replicate log entries to followers (Raft)
-   */ async replicateToFollowers(logEntry) {
-        const votes = [];
-        // In production, send AppendEntries RPCs
-        // For now, simulate responses
-        for (const agentId of this.agents){
-            const vote = {
-                proposalId: `replication-${this.raftState.currentTerm}`,
-                voter: agentId,
-                decision: 'approve',
-                timestamp: Date.now()
-            };
-            votes.push(vote);
-        }
-        return votes;
-    }
-    /**
-   * Calculate required quorum size
-   */ calculateQuorumSize() {
-        switch(this.config.protocol){
-            case 'pbft':
-                // PBFT requires 2f + 1 where f is max faulty
-                const f = this.config.byzantineTolerance || 1;
-                return 2 * f + 1;
-            case 'raft':
-            case 'quorum':
-            case 'fast-paxos':
-            default:
-                // Simple majority
-                return Math.floor(this.agents.size / 2) + 1;
-        }
-    }
-    /**
-   * Record consensus metrics
-   */ recordConsensusMetrics(result, consensusTime) {
-        this.metrics.totalProposals++;
-        if (result.decision === 'approved') {
-            this.metrics.approvedProposals++;
-        } else if (result.decision === 'rejected') {
-            this.metrics.rejectedProposals++;
-        } else {
-            this.metrics.timedOutProposals++;
-        }
-        this.metrics.consensusTimes.push(consensusTime);
-        if (this.metrics.consensusTimes.length > 1000) {
-            this.metrics.consensusTimes = this.metrics.consensusTimes.slice(-1000);
-        }
-        this.metrics.avgConsensusTime = this.metrics.consensusTimes.reduce((a, b)=>a + b, 0) / this.metrics.consensusTimes.length;
-        this.metrics.avgParticipationRate = (this.metrics.avgParticipationRate * (this.metrics.totalProposals - 1) + result.participationRate) / this.metrics.totalProposals;
-    }
-    /**
-   * Get consensus metrics
-   */ getMetrics() {
-        return {
-            ...this.metrics,
-            activeAgents: Array.from(this.agentStates.values()).filter((s)=>s === 'active').length,
-            totalAgents: this.agents.size,
-            quorumSize: this.config.quorumSize,
-            protocol: this.config.protocol,
-            raftState: this.config.protocol === 'raft' ? {
-                term: this.raftState.currentTerm,
-                role: this.raftState.role,
-                leaderId: this.raftState.leaderId
-            } : undefined
-        };
-    }
-    /**
-   * Start Raft protocol background processes
-   */ startRaftProtocol() {
-        // Heartbeat mechanism for leader
-        setInterval(()=>{
-            if (this.raftState.role === 'leader') {
-                this.sendHeartbeats();
-            }
-        }, 1000); // Send heartbeats every 1s
-        // Election timeout for followers
-        setInterval(()=>{
-            if (this.raftState.role === 'follower' && !this.raftState.leaderId) {
-                // No heartbeat from leader, start election
-                this.startLeaderElection();
-            }
-        }, 5000); // Check every 5s
-    }
-    /**
-   * Send heartbeats to followers (Raft)
-   */ sendHeartbeats() {
-        // In production, send AppendEntries RPCs with no entries
-        this.emit('heartbeat:sent', {
-            term: this.raftState.currentTerm
-        });
-    }
-    /**
-   * Shutdown consensus coordinator
-   */ shutdown() {
-        this.agents.clear();
-        this.agentStates.clear();
-        this.activeProposals.clear();
-        this.logger.info('Consensus coordinator shut down');
-    }
-    constructor(config = {}){
-        super(), _define_property(this, "logger", void 0), _define_property(this, "config", void 0), // Agent registry
-        _define_property(this, "agents", new Set()), _define_property(this, "agentStates", new Map()), // Raft state (for raft protocol)
-        _define_property(this, "raftState", {
-            currentTerm: 0,
-            votedFor: null,
-            role: 'follower',
-            leaderId: null,
-            log: [],
-            commitIndex: 0,
-            lastApplied: 0
-        }), // Consensus tracking
-        _define_property(this, "activeProposals", new Map()), // Performance metrics
-        _define_property(this, "metrics", {
-            totalProposals: 0,
-            approvedProposals: 0,
-            rejectedProposals: 0,
-            timedOutProposals: 0,
-            avgConsensusTime: 0,
-            consensusTimes: [],
-            avgParticipationRate: 0
-        });
-        this.config = {
-            protocol: config.protocol || 'quorum',
-            quorumSize: config.quorumSize,
-            timeout: config.timeout || 5000,
-            maxRetries: config.maxRetries || 3,
-            byzantineTolerance: config.byzantineTolerance || 1
-        };
-        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: 'ConsensusCoordinator'
-        });
-        this.initialize();
-    }
-}