claude-flow 2.0.0-alpha.61 → 2.0.0-alpha.62

package/dist/cli/simple-commands/hive-mind/core.js

@@ -21,7 +21,7 @@ export class HiveMindCore extends EventEmitter {
             encryption: false,
             memorySize: 100, // MB
             taskTimeout: 60, // minutes
-            ...config
+            ...config,
         };
         this.state = {
             status: 'initializing',
@@ -35,12 +35,12 @@ export class HiveMindCore extends EventEmitter {
                 tasksCreated: 0,
                 tasksCompleted: 0,
                 decisionsReached: 0,
-                memoryUsage: 0
-            }
+                memoryUsage: 0,
+            },
         };
         this.mcpWrapper = new MCPToolWrapper({
             parallel: true,
-            timeout: this.config.taskTimeout * 60 * 1000
+            timeout: this.config.taskTimeout * 60 * 1000,
         });
         // Initialize performance optimizer
         this.performanceOptimizer = new PerformanceOptimizer({
@@ -49,7 +49,7 @@ export class HiveMindCore extends EventEmitter {
             enableAutoTuning: true,
             asyncQueueConcurrency: Math.min(this.config.maxWorkers * 2, 20),
             batchMaxSize: 50,
-            metricsInterval: 30000
+            metricsInterval: 30000,
         });
         this._initializeEventHandlers();
         this._initializePerformanceMonitoring();
@@ -131,13 +131,8 @@ export class HiveMindCore extends EventEmitter {
      * Check if error is recoverable
      */
     _isRecoverableError(error) {
-        const recoverableErrors = [
-            'timeout',
-            'network',
-            'temporary',
-            'connection'
-        ];
-        return recoverableErrors.some(type => error.message.toLowerCase().includes(type));
+        const recoverableErrors = ['timeout', 'network', 'temporary', 'connection'];
+        return recoverableErrors.some((type) => error.message.toLowerCase().includes(type));
     }
     /**
      * Initialize the hive mind swarm
@@ -149,7 +144,7 @@ export class HiveMindCore extends EventEmitter {
             const [swarmInit, memoryInit, neuralInit] = await this.mcpWrapper.initializeSwarm({
                 topology: this._determineTopology(),
                 maxAgents: this.config.maxWorkers + 1, // +1 for queen
-                swarmId: this.config.name
+                swarmId: this.config.name,
             });
             this.state.swarmId = swarmInit.swarmId;
             // Store initial configuration in memory
@@ -195,7 +190,7 @@ export class HiveMindCore extends EventEmitter {
             type: this.config.queenType,
             status: 'active',
             decisions: 0,
-            tasks: 0
+            tasks: 0,
         };
         // Store queen info in memory
         await this.mcpWrapper.storeMemory(this.state.swarmId, 'queen', this.state.queen, 'system');
@@ -215,7 +210,7 @@ export class HiveMindCore extends EventEmitter {
                 chunks.push(workerTypes.slice(i, i + chunkSize));
             }
             // Process chunks in parallel with Promise.all
-            const allResults = await Promise.all(chunks.map(chunk => this.mcpWrapper.spawnAgents(chunk, this.state.swarmId)));
+            const allResults = await Promise.all(chunks.map((chunk) => this.mcpWrapper.spawnAgents(chunk, this.state.swarmId)));
             // Flatten results
             const spawnResults = allResults.flat();
             // Batch create worker objects
@@ -232,8 +227,8 @@ export class HiveMindCore extends EventEmitter {
                     spawnedAt: Date.now(),
                     performance: {
                         avgTaskTime: 0,
-                        successRate: 1.0
-                    }
+                        successRate: 1.0,
+                    },
                 };
                 workers.push(worker);
                 this.state.workers.set(worker.id, worker);
@@ -241,7 +236,7 @@ export class HiveMindCore extends EventEmitter {
                     type: 'worker_spawned',
                     workerId: worker.id,
                     workerType: worker.type,
-                    timestamp: worker.spawnedAt
+                    timestamp: worker.spawnedAt,
                 });
             });
             // Batch memory operations
@@ -251,15 +246,15 @@ export class HiveMindCore extends EventEmitter {
                     count: workers.length,
                     types: workerTypes,
                     spawnTime: Date.now() - startTime,
-                    updates: workerUpdates
-                }, 'metrics')
+                    updates: workerUpdates,
+                }, 'metrics'),
             ]);
             // Emit batch completion event
             this.emit('workers:spawned', {
                 count: this.state.workers.size,
                 batchSize: workers.length,
                 spawnTime: Date.now() - startTime,
-                workers: workers
+                workers: workers,
             });
             return workers;
         }
@@ -268,7 +263,7 @@ export class HiveMindCore extends EventEmitter {
                 type: 'spawn_batch_failed',
                 error,
                 workerTypes,
-                spawnTime: Date.now() - startTime
+                spawnTime: Date.now() - startTime,
             });
             throw error;
         }
@@ -293,8 +288,8 @@ export class HiveMindCore extends EventEmitter {
             metadata: {
                 estimatedDuration: this._estimateTaskDuration(description),
                 complexity: this._analyzeTaskComplexity(description),
-                ...metadata
-            }
+                ...metadata,
+            },
         };
         // Parallel operations: task storage, orchestration, and worker finding
         const [orchestrateResult, bestWorker] = await Promise.all([
@@ -304,7 +299,7 @@ export class HiveMindCore extends EventEmitter {
             (async () => {
                 this.state.tasks.set(task.id, task);
                 await this.mcpWrapper.storeMemory(this.state.swarmId, `task-${task.id}`, task, 'task');
-            })()
+            })(),
         ]);
         task.orchestrationId = orchestrateResult[0].taskId;
         this.emit('task:created', task);
@@ -323,7 +318,7 @@ export class HiveMindCore extends EventEmitter {
         const complexityKeywords = {
             simple: ['list', 'show', 'display', 'get', 'read'],
             medium: ['create', 'update', 'modify', 'change', 'build'],
-            complex: ['analyze', 'optimize', 'refactor', 'implement', 'design']
+            complex: ['analyze', 'optimize', 'refactor', 'implement', 'design'],
         };
         let score = 1;
         for (const word of words) {
@@ -344,10 +339,10 @@ export class HiveMindCore extends EventEmitter {
         const indicators = {
             high: ['optimize', 'refactor', 'architecture', 'design', 'algorithm'],
             medium: ['implement', 'build', 'create', 'develop', 'integrate'],
-            low: ['list', 'show', 'get', 'read', 'display']
+            low: ['list', 'show', 'get', 'read', 'display'],
         };
         for (const [level, keywords] of Object.entries(indicators)) {
-            if (keywords.some(keyword => words.includes(keyword))) {
+            if (keywords.some((keyword) => words.includes(keyword))) {
                 return level;
             }
         }
@@ -357,16 +352,16 @@ export class HiveMindCore extends EventEmitter {
      * Find best worker for task (optimized async version)
      */
     async _findBestWorkerAsync(task) {
-        const availableWorkers = Array.from(this.state.workers.values())
-            .filter(w => w.status === 'idle');
+        const availableWorkers = Array.from(this.state.workers.values()).filter((w) => w.status === 'idle');
         if (availableWorkers.length === 0) {
             return null;
         }
         // Use cached analysis if available
         const cacheKey = `worker_match_${task.description.substring(0, 50)}`;
         const cachedMatch = await this.mcpWrapper.retrieveMemory(this.state.swarmId, cacheKey);
-        if (cachedMatch && cachedMatch.timestamp > Date.now() - 300000) { // 5 min cache
-            const cachedWorker = availableWorkers.find(w => w.type === cachedMatch.workerType);
+        if (cachedMatch && cachedMatch.timestamp > Date.now() - 300000) {
+            // 5 min cache
+            const cachedWorker = availableWorkers.find((w) => w.type === cachedMatch.workerType);
             if (cachedWorker)
                 return cachedWorker;
         }
@@ -375,33 +370,48 @@ export class HiveMindCore extends EventEmitter {
         const taskWords = taskLower.split(/\s+/);
         // Enhanced priority mapping with weights
         const priorityMap = {
-            researcher: { keywords: ['research', 'investigate', 'analyze', 'study', 'explore'], weight: 1.2 },
-            coder: { keywords: ['code', 'implement', 'build', 'develop', 'fix', 'create', 'program'], weight: 1.0 },
-            analyst: { keywords: ['analyze', 'data', 'metrics', 'performance', 'report', 'statistics'], weight: 1.1 },
+            researcher: {
+                keywords: ['research', 'investigate', 'analyze', 'study', 'explore'],
+                weight: 1.2,
+            },
+            coder: {
+                keywords: ['code', 'implement', 'build', 'develop', 'fix', 'create', 'program'],
+                weight: 1.0,
+            },
+            analyst: {
+                keywords: ['analyze', 'data', 'metrics', 'performance', 'report', 'statistics'],
+                weight: 1.1,
+            },
             tester: { keywords: ['test', 'validate', 'check', 'verify', 'quality', 'qa'], weight: 1.0 },
-            architect: { keywords: ['design', 'architecture', 'structure', 'plan', 'system'], weight: 1.3 },
+            architect: {
+                keywords: ['design', 'architecture', 'structure', 'plan', 'system'],
+                weight: 1.3,
+            },
             reviewer: { keywords: ['review', 'feedback', 'improve', 'refactor', 'audit'], weight: 1.0 },
-            optimizer: { keywords: ['optimize', 'performance', 'speed', 'efficiency', 'enhance'], weight: 1.4 },
-            documenter: { keywords: ['document', 'explain', 'write', 'describe', 'manual'], weight: 0.9 }
+            optimizer: {
+                keywords: ['optimize', 'performance', 'speed', 'efficiency', 'enhance'],
+                weight: 1.4,
+            },
+            documenter: { keywords: ['document', 'explain', 'write', 'describe', 'manual'], weight: 0.9 },
         };
         // Calculate scores for each worker
-        const workerScores = availableWorkers.map(worker => {
+        const workerScores = availableWorkers.map((worker) => {
             const typeInfo = priorityMap[worker.type] || { keywords: [], weight: 1.0 };
             // Keyword matching score
             const keywordScore = typeInfo.keywords.reduce((score, keyword) => {
                 return score + (taskWords.includes(keyword) ? 1 : 0);
             }, 0);
             // Performance history score
-            const performanceScore = worker.performance ?
-                (worker.performance.successRate * 0.5 + (1 / (worker.performance.avgTaskTime + 1)) * 0.5) : 0.5;
+            const performanceScore = worker.performance
+                ? worker.performance.successRate * 0.5 + (1 / (worker.performance.avgTaskTime + 1)) * 0.5
+                : 0.5;
             // Task completion rate
-            const completionScore = worker.tasksCompleted > 0 ?
-                Math.min(worker.tasksCompleted / 10, 1) : 0;
+            const completionScore = worker.tasksCompleted > 0 ? Math.min(worker.tasksCompleted / 10, 1) : 0;
             // Combined score
             const totalScore = (keywordScore * 2 + // Keyword relevance
                 performanceScore * 1.5 + // Historical performance
-                completionScore * 1.0 // Experience
-            ) * typeInfo.weight;
+                completionScore * 1.0) * // Experience
+                typeInfo.weight;
             return {
                 worker,
                 score: totalScore,
@@ -409,8 +419,8 @@ export class HiveMindCore extends EventEmitter {
                     keyword: keywordScore,
                     performance: performanceScore,
                     completion: completionScore,
-                    weight: typeInfo.weight
-                }
+                    weight: typeInfo.weight,
+                },
             };
         });
         // Sort by score and select best
@@ -422,7 +432,7 @@ export class HiveMindCore extends EventEmitter {
                 await this.mcpWrapper.storeMemory(this.state.swarmId, cacheKey, {
                     workerType: bestMatch.worker.type,
                     score: bestMatch.score,
-                    timestamp: Date.now()
+                    timestamp: Date.now(),
                 }, 'cache');
             });
         }
@@ -432,8 +442,7 @@ export class HiveMindCore extends EventEmitter {
      * Synchronous version for backward compatibility
      */
     _findBestWorker(task) {
-        const availableWorkers = Array.from(this.state.workers.values())
-            .filter(w => w.status === 'idle');
+        const availableWorkers = Array.from(this.state.workers.values()).filter((w) => w.status === 'idle');
         if (availableWorkers.length === 0) {
             return null;
         }
@@ -447,13 +456,13 @@ export class HiveMindCore extends EventEmitter {
             architect: ['design', 'architecture', 'structure', 'plan'],
             reviewer: ['review', 'feedback', 'improve', 'refactor'],
             optimizer: ['optimize', 'performance', 'speed', 'efficiency'],
-            documenter: ['document', 'explain', 'write', 'describe']
+            documenter: ['document', 'explain', 'write', 'describe'],
         };
         let bestWorker = null;
         let bestScore = 0;
         for (const worker of availableWorkers) {
             const keywords = priorityMap[worker.type] || [];
-            const keywordScore = keywords.filter(k => taskLower.includes(k)).length;
+            const keywordScore = keywords.filter((k) => taskLower.includes(k)).length;
             const performanceBonus = worker.performance ? worker.performance.successRate * 0.5 : 0;
             const totalScore = keywordScore + performanceBonus;
             if (totalScore > bestScore) {
@@ -495,16 +504,16 @@ export class HiveMindCore extends EventEmitter {
                 const baseDuration = {
                     low: 5000,
                     medium: 15000,
-                    high: 30000
+                    high: 30000,
                 }[task.metadata?.complexity || 'medium'];
-                const duration = baseDuration + (Math.random() * baseDuration * 0.5);
+                const duration = baseDuration + Math.random() * baseDuration * 0.5;
                 return new Promise((resolve) => {
                     setTimeout(() => {
                         resolve({
                             status: 'completed',
                             result: `Task completed by ${worker.type} worker`,
                             processingTime: Date.now() - startTime,
-                            complexity: task.metadata?.complexity || 'medium'
+                            complexity: task.metadata?.complexity || 'medium',
                         });
                     }, duration);
                 });
@@ -530,10 +539,10 @@ export class HiveMindCore extends EventEmitter {
             await this.performanceOptimizer.optimizeBatchOperation('task_results', {
                 key: `result-${taskId}`,
                 value: task,
-                type: 'result'
+                type: 'result',
             }, async (items) => {
                 // Batch store all results
-                await Promise.all(items.map(item => this.mcpWrapper.storeMemory(this.state.swarmId, item.key, item.value, item.type)));
+                await Promise.all(items.map((item) => this.mcpWrapper.storeMemory(this.state.swarmId, item.key, item.value, item.type)));
                 return items.map(() => ({ success: true }));
             });
             this.emit('task:completed', task);
@@ -557,7 +566,7 @@ export class HiveMindCore extends EventEmitter {
      */
     _assignNextTask(workerId) {
         const pendingTasks = Array.from(this.state.tasks.values())
-            .filter(t => t.status === 'pending')
+            .filter((t) => t.status === 'pending')
             .sort((a, b) => b.priority - a.priority);
         if (pendingTasks.length > 0) {
             this._assignTask(workerId, pendingTasks[0].id);
@@ -575,14 +584,14 @@ export class HiveMindCore extends EventEmitter {
             votes: new Map(),
             algorithm: this.config.consensusAlgorithm,
             status: 'voting',
-            createdAt: new Date().toISOString()
+            createdAt: new Date().toISOString(),
         };
         this.state.decisions.set(decision.id, decision);
         // Simulate voting process
         const workers = Array.from(this.state.workers.values());
         const votes = {};
         // Each worker votes
-        workers.forEach(worker => {
+        workers.forEach((worker) => {
             const vote = options[Math.floor(Math.random() * options.length)];
             votes[worker.id] = vote;
             decision.votes.set(worker.id, vote);
@@ -599,7 +608,7 @@ export class HiveMindCore extends EventEmitter {
         // Convert Map to plain object for proper JSON serialization
         const decisionForStorage = {
             ...decision,
-            votes: decision.votes instanceof Map ? Object.fromEntries(decision.votes) : decision.votes
+            votes: decision.votes instanceof Map ? Object.fromEntries(decision.votes) : decision.votes,
         };
         // Store decision in memory
         await this.mcpWrapper.storeMemory(this.state.swarmId, `decision-${decision.id}`, decisionForStorage, 'consensus');
@@ -613,7 +622,7 @@ export class HiveMindCore extends EventEmitter {
         const votes = Array.from(decision.votes.values());
         const voteCount = {};
         // Count votes
-        votes.forEach(vote => {
+        votes.forEach((vote) => {
             voteCount[vote] = (voteCount[vote] || 0) + 1;
         });
         switch (decision.algorithm) {
@@ -623,7 +632,7 @@ export class HiveMindCore extends EventEmitter {
                 const winner = sorted[0];
                 return {
                     decision: winner[0],
-                    confidence: winner[1] / votes.length
+                    confidence: winner[1] / votes.length,
                 };
             case 'weighted':
                 // Weight queen vote more heavily
@@ -633,7 +642,7 @@ export class HiveMindCore extends EventEmitter {
                 const weightedWinner = weightedSorted[0];
                 return {
                     decision: weightedWinner[0],
-                    confidence: weightedWinner[1] / (votes.length + 2)
+                    confidence: weightedWinner[1] / (votes.length + 2),
                 };
             case 'byzantine':
                 // Requires 2/3 majority
@@ -643,19 +652,19 @@ export class HiveMindCore extends EventEmitter {
                 if (byzantineConfidence >= 0.67) {
                     return {
                         decision: byzantineWinner[0],
-                        confidence: byzantineConfidence
+                        confidence: byzantineConfidence,
                     };
                 }
                 else {
                     return {
                         decision: 'no_consensus',
-                        confidence: 0
+                        confidence: 0,
                     };
                 }
             default:
                 return {
                     decision: 'unknown',
-                    confidence: 0
+                    confidence: 0,
                 };
         }
     }
@@ -665,10 +674,8 @@ export class HiveMindCore extends EventEmitter {
     async _checkAutoScale() {
         if (!this.config.autoScale)
             return;
-        const pendingTasks = Array.from(this.state.tasks.values())
-            .filter(t => t.status === 'pending').length;
-        const idleWorkers = Array.from(this.state.workers.values())
-            .filter(w => w.status === 'idle').length;
+        const pendingTasks = Array.from(this.state.tasks.values()).filter((t) => t.status === 'pending').length;
+        const idleWorkers = Array.from(this.state.workers.values()).filter((w) => w.status === 'idle').length;
         // Scale up if too many pending tasks
         if (pendingTasks > idleWorkers * 2 && this.state.workers.size < this.config.maxWorkers) {
             const newWorkerType = this._determineWorkerType();
@@ -685,11 +692,10 @@ export class HiveMindCore extends EventEmitter {
      */
     _determineWorkerType() {
         // Analyze pending tasks to determine needed worker type
-        const pendingTasks = Array.from(this.state.tasks.values())
-            .filter(t => t.status === 'pending');
+        const pendingTasks = Array.from(this.state.tasks.values()).filter((t) => t.status === 'pending');
         // Simple heuristic based on task descriptions
         const typeScores = {};
-        pendingTasks.forEach(task => {
+        pendingTasks.forEach((task) => {
             const taskLower = task.description.toLowerCase();
             if (taskLower.includes('code') || taskLower.includes('implement')) {
                 typeScores.coder = (typeScores.coder || 0) + 1;
@@ -720,7 +726,7 @@ export class HiveMindCore extends EventEmitter {
             ...this.state.metrics,
             completionRate,
             avgTasksPerWorker,
-            timestamp: Date.now()
+            timestamp: Date.now(),
         }, 'metrics');
         // Analyze performance if needed
         if (this.state.metrics.tasksCompleted % 10 === 0) {
@@ -732,11 +738,13 @@ export class HiveMindCore extends EventEmitter {
      */
     _handleError(error) {
         // Log error to memory
-        this.mcpWrapper.storeMemory(this.state.swarmId, `error-${Date.now()}`, {
+        this.mcpWrapper
+            .storeMemory(this.state.swarmId, `error-${Date.now()}`, {
             message: error.message,
             stack: error.stack,
-            timestamp: Date.now()
-        }, 'error').catch(console.error);
+            timestamp: Date.now(),
+        }, 'error')
+            .catch(console.error);
     }
     /**
      * Get current status with performance metrics
@@ -751,26 +759,26 @@ export class HiveMindCore extends EventEmitter {
             workers: workers,
             tasks: {
                 total: this.state.tasks.size,
-                pending: tasks.filter(t => t.status === 'pending').length,
-                inProgress: tasks.filter(t => t.status === 'in_progress').length,
-                completed: tasks.filter(t => t.status === 'completed').length,
-                failed: tasks.filter(t => t.status === 'failed').length
+                pending: tasks.filter((t) => t.status === 'pending').length,
+                inProgress: tasks.filter((t) => t.status === 'in_progress').length,
+                completed: tasks.filter((t) => t.status === 'completed').length,
+                failed: tasks.filter((t) => t.status === 'failed').length,
             },
             metrics: {
                 ...this.state.metrics,
                 averageTaskTime: this._calculateAverageTaskTime(tasks),
                 workerEfficiency: this._calculateWorkerEfficiency(workers),
-                throughput: this._calculateThroughput(tasks)
+                throughput: this._calculateThroughput(tasks),
             },
             decisions: this.state.decisions.size,
-            performance: this.performanceOptimizer.getPerformanceStats()
+            performance: this.performanceOptimizer.getPerformanceStats(),
         };
     }
     /**
      * Calculate average task completion time
      */
     _calculateAverageTaskTime(tasks) {
-        const completedTasks = tasks.filter(t => t.status === 'completed' && t.actualDuration);
+        const completedTasks = tasks.filter((t) => t.status === 'completed' && t.actualDuration);
         if (completedTasks.length === 0)
             return 0;
         const totalTime = completedTasks.reduce((sum, task) => sum + task.actualDuration, 0);
@@ -782,14 +790,14 @@ export class HiveMindCore extends EventEmitter {
     _calculateWorkerEfficiency(workers) {
         if (workers.length === 0)
             return 0;
-        const efficiencies = workers.map(worker => worker.performance?.successRate || 1.0);
-        return (efficiencies.reduce((sum, eff) => sum + eff, 0) / workers.length * 100).toFixed(2);
+        const efficiencies = workers.map((worker) => worker.performance?.successRate || 1.0);
+        return ((efficiencies.reduce((sum, eff) => sum + eff, 0) / workers.length) * 100).toFixed(2);
     }
     /**
      * Calculate system throughput (tasks per minute)
      */
     _calculateThroughput(tasks) {
-        const completedTasks = tasks.filter(t => t.status === 'completed' && t.completedAt);
+        const completedTasks = tasks.filter((t) => t.status === 'completed' && t.completedAt);
         if (completedTasks.length < 2)
             return 0;
         const firstCompleted = new Date(completedTasks[0].completedAt).getTime();
@@ -808,7 +816,7 @@ export class HiveMindCore extends EventEmitter {
             // Save final state and performance report
             await Promise.all([
                 this.mcpWrapper.storeMemory(this.state.swarmId, 'final_state', this.getStatus(), 'system'),
-                this.mcpWrapper.storeMemory(this.state.swarmId, 'final_performance_report', performanceReport, 'metrics')
+                this.mcpWrapper.storeMemory(this.state.swarmId, 'final_performance_report', performanceReport, 'metrics'),
             ]);
             // Close performance optimizer
             await this.performanceOptimizer.close();