claude-flow 2.7.0 → 2.7.1

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

@@ -1,839 +0,0 @@
-/**
- * Hive Mind Core System
- * Central orchestration and coordination logic
- */
-import EventEmitter from 'events';
-import { MCPToolWrapper } from './mcp-wrapper.js';
-import { PerformanceOptimizer } from './performance-optimizer.js';
-/**
- * HiveMindCore - Main orchestration class
- */
-export class HiveMindCore extends EventEmitter {
-    constructor(config = {}) {
-        super();
-        this.config = {
-            objective: '',
-            name: `hive-${Date.now()}`,
-            queenType: 'strategic',
-            maxWorkers: 8,
-            consensusAlgorithm: 'majority',
-            autoScale: true,
-            encryption: false,
-            memorySize: 100, // MB
-            taskTimeout: 60, // minutes
-            ...config,
-        };
-        this.state = {
-            status: 'initializing',
-            swarmId: null,
-            queen: null,
-            workers: new Map(),
-            tasks: new Map(),
-            memory: new Map(),
-            decisions: new Map(),
-            metrics: {
-                tasksCreated: 0,
-                tasksCompleted: 0,
-                decisionsReached: 0,
-                memoryUsage: 0,
-            },
-        };
-        this.mcpWrapper = new MCPToolWrapper({
-            parallel: true,
-            timeout: this.config.taskTimeout * 60 * 1000,
-        });
-        // Initialize performance optimizer
-        this.performanceOptimizer = new PerformanceOptimizer({
-            enableAsyncQueue: true,
-            enableBatchProcessing: true,
-            enableAutoTuning: true,
-            asyncQueueConcurrency: Math.min(this.config.maxWorkers * 2, 20),
-            batchMaxSize: 50,
-            metricsInterval: 30000,
-        });
-        this._initializeEventHandlers();
-        this._initializePerformanceMonitoring();
-    }
-    /**
-     * Initialize event handlers
-     */
-    _initializeEventHandlers() {
-        this.on('task:created', (task) => {
-            this.state.metrics.tasksCreated++;
-            this._checkAutoScale();
-        });
-        this.on('task:completed', (task) => {
-            this.state.metrics.tasksCompleted++;
-            this._updatePerformanceMetrics();
-        });
-        this.on('task:failed', (data) => {
-            console.warn(`Task failed: ${data.task.id}`, data.error);
-            this._handleTaskFailure(data.task, data.error);
-        });
-        this.on('decision:reached', (decision) => {
-            this.state.metrics.decisionsReached++;
-        });
-        this.on('worker:idle', (workerId) => {
-            this._assignNextTask(workerId);
-        });
-        this.on('error', (error) => {
-            console.error('Hive Mind Error:', error);
-            this._handleError(error);
-        });
-    }
-    /**
-     * Initialize performance monitoring
-     */
-    _initializePerformanceMonitoring() {
-        // Listen to performance optimizer events
-        this.performanceOptimizer.on('auto_tune', (data) => {
-            this.emit('performance:auto_tuned', data);
-        });
-        this.performanceOptimizer.on('error', (error) => {
-            console.error('Performance optimizer error:', error);
-            this.emit('error', { type: 'performance_optimizer_error', error });
-        });
-        // Periodic performance reporting
-        setInterval(() => {
-            const stats = this.performanceOptimizer.getPerformanceStats();
-            this.emit('performance:stats', stats);
-            // Log performance warnings
-            if (parseFloat(stats.asyncQueue.utilization) > 90) {
-                console.warn('High async queue utilization:', stats.asyncQueue.utilization + '%');
-            }
-            if (parseFloat(stats.asyncQueue.successRate) < 95) {
-                console.warn('Low async operation success rate:', stats.asyncQueue.successRate + '%');
-            }
-        }, 60000); // Every minute
-    }
-    /**
-     * Handle task failure with recovery logic
-     */
-    _handleTaskFailure(task, error) {
-        // Update metrics
-        this.state.metrics.tasksFailed = (this.state.metrics.tasksFailed || 0) + 1;
-        // Attempt task retry for recoverable failures
-        if (task.retryCount < 2 && this._isRecoverableError(error)) {
-            task.retryCount = (task.retryCount || 0) + 1;
-            task.status = 'pending';
-            // Find another worker for retry
-            setTimeout(() => {
-                const worker = this._findBestWorker(task);
-                if (worker) {
-                    this._assignTask(worker.id, task.id);
-                }
-            }, 5000); // Wait 5 seconds before retry
-            console.log(`Retrying task ${task.id} (attempt ${task.retryCount})`);
-        }
-    }
-    /**
-     * Check if error is recoverable
-     */
-    _isRecoverableError(error) {
-        const recoverableErrors = ['timeout', 'network', 'temporary', 'connection'];
-        return recoverableErrors.some((type) => error.message.toLowerCase().includes(type));
-    }
-    /**
-     * Initialize the hive mind swarm
-     */
-    async initialize() {
-        try {
-            this.state.status = 'initializing';
-            // Initialize swarm with MCP tools
-            const [swarmInit, memoryInit, neuralInit] = await this.mcpWrapper.initializeSwarm({
-                topology: this._determineTopology(),
-                maxAgents: this.config.maxWorkers + 1, // +1 for queen
-                swarmId: this.config.name,
-            });
-            this.state.swarmId = swarmInit.swarmId;
-            // Store initial configuration in memory
-            await this.mcpWrapper.storeMemory(this.state.swarmId, 'config', this.config, 'system');
-            this.state.status = 'ready';
-            this.emit('initialized', { swarmId: this.state.swarmId });
-            return this.state.swarmId;
-        }
-        catch (error) {
-            this.state.status = 'error';
-            this.emit('error', error);
-            throw error;
-        }
-    }
-    /**
-     * Determine optimal topology based on objective
-     */
-    _determineTopology() {
-        const objective = this.config.objective.toLowerCase();
-        // Heuristic topology selection
-        if (objective.includes('research') || objective.includes('analysis')) {
-            return 'mesh'; // Peer-to-peer for collaborative research
-        }
-        else if (objective.includes('build') || objective.includes('develop')) {
-            return 'hierarchical'; // Clear command structure for development
-        }
-        else if (objective.includes('monitor') || objective.includes('maintain')) {
-            return 'ring'; // Circular for continuous monitoring
-        }
-        else if (objective.includes('coordinate') || objective.includes('orchestrate')) {
-            return 'star'; // Centralized for coordination
-        }
-        return 'hierarchical'; // Default
-    }
-    /**
-     * Spawn the queen coordinator
-     */
-    async spawnQueen(queenData) {
-        const [spawnResult] = await this.mcpWrapper.spawnAgents(['coordinator'], this.state.swarmId);
-        this.state.queen = {
-            id: queenData.id,
-            agentId: spawnResult.agentId,
-            type: this.config.queenType,
-            status: 'active',
-            decisions: 0,
-            tasks: 0,
-        };
-        // Store queen info in memory
-        await this.mcpWrapper.storeMemory(this.state.swarmId, 'queen', this.state.queen, 'system');
-        this.emit('queen:spawned', this.state.queen);
-        return this.state.queen;
-    }
-    /**
-     * Spawn worker agents with batch optimization
-     */
-    async spawnWorkers(workerTypes) {
-        const startTime = Date.now();
-        try {
-            // Batch spawn agents in parallel with optimized chunking
-            const chunkSize = Math.min(workerTypes.length, 5); // Optimal batch size
-            const chunks = [];
-            for (let i = 0; i < workerTypes.length; i += chunkSize) {
-                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)));
-            // Flatten results
-            const spawnResults = allResults.flat();
-            // Batch create worker objects
-            const workers = [];
-            const workerUpdates = [];
-            spawnResults.forEach((result, index) => {
-                const worker = {
-                    id: `worker-${index}`,
-                    agentId: result.agentId,
-                    type: workerTypes[index],
-                    status: 'idle',
-                    tasksCompleted: 0,
-                    currentTask: null,
-                    spawnedAt: Date.now(),
-                    performance: {
-                        avgTaskTime: 0,
-                        successRate: 1.0,
-                    },
-                };
-                workers.push(worker);
-                this.state.workers.set(worker.id, worker);
-                workerUpdates.push({
-                    type: 'worker_spawned',
-                    workerId: worker.id,
-                    workerType: worker.type,
-                    timestamp: worker.spawnedAt,
-                });
-            });
-            // Batch memory operations
-            await Promise.all([
-                this.mcpWrapper.storeMemory(this.state.swarmId, 'workers', workers, 'system'),
-                this.mcpWrapper.storeMemory(this.state.swarmId, 'worker_spawn_batch', {
-                    count: workers.length,
-                    types: workerTypes,
-                    spawnTime: Date.now() - startTime,
-                    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,
-            });
-            return workers;
-        }
-        catch (error) {
-            this.emit('error', {
-                type: 'spawn_batch_failed',
-                error,
-                workerTypes,
-                spawnTime: Date.now() - startTime,
-            });
-            throw error;
-        }
-    }
-    /**
-     * Create and distribute task with performance optimization
-     */
-    async createTask(description, priority = 5, metadata = {}) {
-        const timestamp = Date.now();
-        const randomPart = Math.random().toString(36).substring(2, 11); // Use substring instead of substr
-        const taskId = `task-${timestamp}-${randomPart}`;
-        const createdAt = Date.now();
-        const task = {
-            id: taskId,
-            swarmId: this.state.swarmId,
-            description,
-            priority,
-            status: 'pending',
-            createdAt: new Date(createdAt).toISOString(),
-            assignedTo: null,
-            result: null,
-            metadata: {
-                estimatedDuration: this._estimateTaskDuration(description),
-                complexity: this._analyzeTaskComplexity(description),
-                ...metadata,
-            },
-        };
-        // Parallel operations: task storage, orchestration, and worker finding
-        const [orchestrateResult, bestWorker] = await Promise.all([
-            this.mcpWrapper.orchestrateTask(description, 'adaptive'),
-            this._findBestWorkerAsync(task),
-            // Store task immediately in parallel
-            (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);
-        // Assign task if worker available
-        if (bestWorker) {
-            // Use non-blocking assignment
-            setImmediate(() => this._assignTask(bestWorker.id, task.id));
-        }
-        return task;
-    }
-    /**
-     * Estimate task duration based on description analysis
-     */
-    _estimateTaskDuration(description) {
-        const words = description.toLowerCase().split(/\s+/);
-        const complexityKeywords = {
-            simple: ['list', 'show', 'display', 'get', 'read'],
-            medium: ['create', 'update', 'modify', 'change', 'build'],
-            complex: ['analyze', 'optimize', 'refactor', 'implement', 'design'],
-        };
-        let score = 1;
-        for (const word of words) {
-            if (complexityKeywords.complex.includes(word))
-                score += 3;
-            else if (complexityKeywords.medium.includes(word))
-                score += 2;
-            else if (complexityKeywords.simple.includes(word))
-                score += 1;
-        }
-        return Math.min(score * 5000, 60000); // Cap at 1 minute
-    }
-    /**
-     * Analyze task complexity
-     */
-    _analyzeTaskComplexity(description) {
-        const words = description.toLowerCase().split(/\s+/);
-        const indicators = {
-            high: ['optimize', 'refactor', 'architecture', 'design', 'algorithm'],
-            medium: ['implement', 'build', 'create', 'develop', 'integrate'],
-            low: ['list', 'show', 'get', 'read', 'display'],
-        };
-        for (const [level, keywords] of Object.entries(indicators)) {
-            if (keywords.some((keyword) => words.includes(keyword))) {
-                return level;
-            }
-        }
-        return 'medium';
-    }
-    /**
-     * Find best worker for task (optimized async version)
-     */
-    async _findBestWorkerAsync(task) {
-        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 (cachedWorker)
-                return cachedWorker;
-        }
-        // Enhanced matching algorithm with performance scoring
-        const taskLower = task.description.toLowerCase();
-        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,
-            },
-            tester: { keywords: ['test', 'validate', 'check', 'verify', 'quality', 'qa'], weight: 1.0 },
-            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 },
-        };
-        // Calculate scores for each 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;
-            // Task completion rate
-            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;
-            return {
-                worker,
-                score: totalScore,
-                breakdown: {
-                    keyword: keywordScore,
-                    performance: performanceScore,
-                    completion: completionScore,
-                    weight: typeInfo.weight,
-                },
-            };
-        });
-        // Sort by score and select best
-        workerScores.sort((a, b) => b.score - a.score);
-        const bestMatch = workerScores[0];
-        // Cache the result for future use
-        if (bestMatch.score > 0) {
-            setImmediate(async () => {
-                await this.mcpWrapper.storeMemory(this.state.swarmId, cacheKey, {
-                    workerType: bestMatch.worker.type,
-                    score: bestMatch.score,
-                    timestamp: Date.now(),
-                }, 'cache');
-            });
-        }
-        return bestMatch ? bestMatch.worker : availableWorkers[0];
-    }
-    /**
-     * Synchronous version for backward compatibility
-     */
-    _findBestWorker(task) {
-        const availableWorkers = Array.from(this.state.workers.values()).filter((w) => w.status === 'idle');
-        if (availableWorkers.length === 0) {
-            return null;
-        }
-        // Simplified scoring for sync version
-        const taskLower = task.description.toLowerCase();
-        const priorityMap = {
-            researcher: ['research', 'investigate', 'analyze', 'study'],
-            coder: ['code', 'implement', 'build', 'develop', 'fix', 'create'],
-            analyst: ['analyze', 'data', 'metrics', 'performance', 'report'],
-            tester: ['test', 'validate', 'check', 'verify', 'quality'],
-            architect: ['design', 'architecture', 'structure', 'plan'],
-            reviewer: ['review', 'feedback', 'improve', 'refactor'],
-            optimizer: ['optimize', 'performance', 'speed', 'efficiency'],
-            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 performanceBonus = worker.performance ? worker.performance.successRate * 0.5 : 0;
-            const totalScore = keywordScore + performanceBonus;
-            if (totalScore > bestScore) {
-                bestScore = totalScore;
-                bestWorker = worker;
-            }
-        }
-        return bestWorker || availableWorkers[0];
-    }
-    /**
-     * Assign task to worker
-     */
-    async _assignTask(workerId, taskId) {
-        const worker = this.state.workers.get(workerId);
-        const task = this.state.tasks.get(taskId);
-        if (!worker || !task)
-            return;
-        worker.status = 'busy';
-        worker.currentTask = taskId;
-        task.status = 'in_progress';
-        task.assignedTo = workerId;
-        // Store assignment in memory
-        await this.mcpWrapper.storeMemory(this.state.swarmId, `assignment-${taskId}`, { workerId, taskId, timestamp: Date.now() }, 'task');
-        this.emit('task:assigned', { workerId, taskId });
-        // Simulate task execution
-        this._executeTask(workerId, taskId);
-    }
-    /**
-     * Execute task with performance optimization
-     */
-    async _executeTask(workerId, taskId) {
-        const worker = this.state.workers.get(workerId);
-        const task = this.state.tasks.get(taskId);
-        const startTime = Date.now();
-        try {
-            // Use performance optimizer for async execution
-            const result = await this.performanceOptimizer.optimizeAsyncOperation(async () => {
-                // Simulate task execution based on complexity
-                const baseDuration = {
-                    low: 5000,
-                    medium: 15000,
-                    high: 30000,
-                }[task.metadata?.complexity || 'medium'];
-                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',
-                        });
-                    }, duration);
-                });
-            }, { priority: task.priority });
-            // Update task and worker
-            task.status = 'completed';
-            task.completedAt = new Date().toISOString();
-            task.result = result.result;
-            task.actualDuration = result.processingTime;
-            worker.status = 'idle';
-            worker.currentTask = null;
-            worker.tasksCompleted++;
-            // Update worker performance metrics
-            if (!worker.performance.avgTaskTime) {
-                worker.performance.avgTaskTime = result.processingTime;
-            }
-            else {
-                worker.performance.avgTaskTime =
-                    (worker.performance.avgTaskTime * (worker.tasksCompleted - 1) + result.processingTime) /
-                        worker.tasksCompleted;
-            }
-            // Batch store results for better performance
-            await this.performanceOptimizer.optimizeBatchOperation('task_results', {
-                key: `result-${taskId}`,
-                value: task,
-                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)));
-                return items.map(() => ({ success: true }));
-            });
-            this.emit('task:completed', task);
-            this.emit('worker:idle', workerId);
-        }
-        catch (error) {
-            // Handle task failure
-            task.status = 'failed';
-            task.error = error.message;
-            task.failedAt = new Date().toISOString();
-            worker.status = 'idle';
-            worker.currentTask = null;
-            worker.performance.successRate =
-                (worker.performance.successRate * worker.tasksCompleted) / (worker.tasksCompleted + 1);
-            this.emit('task:failed', { task, error });
-            this.emit('worker:idle', workerId);
-        }
-    }
-    /**
-     * Assign next task to idle worker
-     */
-    _assignNextTask(workerId) {
-        const pendingTasks = Array.from(this.state.tasks.values())
-            .filter((t) => t.status === 'pending')
-            .sort((a, b) => b.priority - a.priority);
-        if (pendingTasks.length > 0) {
-            this._assignTask(workerId, pendingTasks[0].id);
-        }
-    }
-    /**
-     * Build consensus for decision
-     */
-    async buildConsensus(topic, options) {
-        const decision = {
-            id: `decision-${Date.now()}`,
-            swarmId: this.state.swarmId,
-            topic,
-            options,
-            votes: new Map(),
-            algorithm: this.config.consensusAlgorithm,
-            status: 'voting',
-            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) => {
-            const vote = options[Math.floor(Math.random() * options.length)];
-            votes[worker.id] = vote;
-            decision.votes.set(worker.id, vote);
-        });
-        // Queen gets weighted vote
-        const queenVote = options[Math.floor(Math.random() * options.length)];
-        votes['queen'] = queenVote;
-        decision.votes.set('queen', queenVote);
-        // Calculate consensus
-        const result = this._calculateConsensus(decision);
-        decision.result = result.decision;
-        decision.confidence = result.confidence;
-        decision.status = 'completed';
-        // Convert Map to plain object for proper JSON serialization
-        const decisionForStorage = {
-            ...decision,
-            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');
-        this.emit('decision:reached', decision);
-        return decision;
-    }
-    /**
-     * Calculate consensus based on algorithm
-     */
-    _calculateConsensus(decision) {
-        const votes = Array.from(decision.votes.values());
-        const voteCount = {};
-        // Count votes
-        votes.forEach((vote) => {
-            voteCount[vote] = (voteCount[vote] || 0) + 1;
-        });
-        switch (decision.algorithm) {
-            case 'majority':
-                // Simple majority
-                const sorted = Object.entries(voteCount).sort((a, b) => b[1] - a[1]);
-                const winner = sorted[0];
-                return {
-                    decision: winner[0],
-                    confidence: winner[1] / votes.length,
-                };
-            case 'weighted':
-                // Weight queen vote more heavily
-                const queenVote = decision.votes.get('queen');
-                voteCount[queenVote] = (voteCount[queenVote] || 0) + 2; // Queen counts as 3 votes
-                const weightedSorted = Object.entries(voteCount).sort((a, b) => b[1] - a[1]);
-                const weightedWinner = weightedSorted[0];
-                return {
-                    decision: weightedWinner[0],
-                    confidence: weightedWinner[1] / (votes.length + 2),
-                };
-            case 'byzantine':
-                // Requires 2/3 majority
-                const byzantineSorted = Object.entries(voteCount).sort((a, b) => b[1] - a[1]);
-                const byzantineWinner = byzantineSorted[0];
-                const byzantineConfidence = byzantineWinner[1] / votes.length;
-                if (byzantineConfidence >= 0.67) {
-                    return {
-                        decision: byzantineWinner[0],
-                        confidence: byzantineConfidence,
-                    };
-                }
-                else {
-                    return {
-                        decision: 'no_consensus',
-                        confidence: 0,
-                    };
-                }
-            default:
-                return {
-                    decision: 'unknown',
-                    confidence: 0,
-                };
-        }
-    }
-    /**
-     * Check if auto-scaling is needed
-     */
-    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;
-        // Scale up if too many pending tasks
-        if (pendingTasks > idleWorkers * 2 && this.state.workers.size < this.config.maxWorkers) {
-            const newWorkerType = this._determineWorkerType();
-            await this.spawnWorkers([newWorkerType]);
-            console.log(`Auto-scaled: Added ${newWorkerType} worker`);
-        }
-        // Scale down if too many idle workers
-        if (idleWorkers > pendingTasks + 2 && this.state.workers.size > 2) {
-            // TODO: Implement worker removal
-        }
-    }
-    /**
-     * Determine worker type for auto-scaling
-     */
-    _determineWorkerType() {
-        // Analyze pending tasks to determine needed worker type
-        const pendingTasks = Array.from(this.state.tasks.values()).filter((t) => t.status === 'pending');
-        // Simple heuristic based on task descriptions
-        const typeScores = {};
-        pendingTasks.forEach((task) => {
-            const taskLower = task.description.toLowerCase();
-            if (taskLower.includes('code') || taskLower.includes('implement')) {
-                typeScores.coder = (typeScores.coder || 0) + 1;
-            }
-            if (taskLower.includes('test') || taskLower.includes('validate')) {
-                typeScores.tester = (typeScores.tester || 0) + 1;
-            }
-            if (taskLower.includes('analyze') || taskLower.includes('data')) {
-                typeScores.analyst = (typeScores.analyst || 0) + 1;
-            }
-            if (taskLower.includes('research') || taskLower.includes('investigate')) {
-                typeScores.researcher = (typeScores.researcher || 0) + 1;
-            }
-        });
-        // Return type with highest score
-        const sorted = Object.entries(typeScores).sort((a, b) => b[1] - a[1]);
-        return sorted.length > 0 ? sorted[0][0] : 'coder'; // Default to coder
-    }
-    /**
-     * Update performance metrics
-     */
-    async _updatePerformanceMetrics() {
-        // Calculate performance metrics
-        const completionRate = this.state.metrics.tasksCompleted / this.state.metrics.tasksCreated;
-        const avgTasksPerWorker = this.state.metrics.tasksCompleted / this.state.workers.size;
-        // Store metrics in memory
-        await this.mcpWrapper.storeMemory(this.state.swarmId, 'metrics', {
-            ...this.state.metrics,
-            completionRate,
-            avgTasksPerWorker,
-            timestamp: Date.now(),
-        }, 'metrics');
-        // Analyze performance if needed
-        if (this.state.metrics.tasksCompleted % 10 === 0) {
-            await this.mcpWrapper.analyzePerformance(this.state.swarmId);
-        }
-    }
-    /**
-     * Handle errors
-     */
-    _handleError(error) {
-        // Log error to memory
-        this.mcpWrapper
-            .storeMemory(this.state.swarmId, `error-${Date.now()}`, {
-            message: error.message,
-            stack: error.stack,
-            timestamp: Date.now(),
-        }, 'error')
-            .catch(console.error);
-    }
-    /**
-     * Get current status with performance metrics
-     */
-    getStatus() {
-        const tasks = Array.from(this.state.tasks.values());
-        const workers = Array.from(this.state.workers.values());
-        return {
-            swarmId: this.state.swarmId,
-            status: this.state.status,
-            queen: this.state.queen,
-            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,
-            },
-            metrics: {
-                ...this.state.metrics,
-                averageTaskTime: this._calculateAverageTaskTime(tasks),
-                workerEfficiency: this._calculateWorkerEfficiency(workers),
-                throughput: this._calculateThroughput(tasks),
-            },
-            decisions: this.state.decisions.size,
-            performance: this.performanceOptimizer.getPerformanceStats(),
-        };
-    }
-    /**
-     * Calculate average task completion time
-     */
-    _calculateAverageTaskTime(tasks) {
-        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);
-        return Math.round(totalTime / completedTasks.length);
-    }
-    /**
-     * Calculate worker efficiency
-     */
-    _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);
-    }
-    /**
-     * Calculate system throughput (tasks per minute)
-     */
-    _calculateThroughput(tasks) {
-        const completedTasks = tasks.filter((t) => t.status === 'completed' && t.completedAt);
-        if (completedTasks.length < 2)
-            return 0;
-        const firstCompleted = new Date(completedTasks[0].completedAt).getTime();
-        const lastCompleted = new Date(completedTasks[completedTasks.length - 1].completedAt).getTime();
-        const timeSpanMinutes = (lastCompleted - firstCompleted) / (1000 * 60);
-        return timeSpanMinutes > 0 ? (completedTasks.length / timeSpanMinutes).toFixed(2) : 0;
-    }
-    /**
-     * Shutdown hive mind with cleanup
-     */
-    async shutdown() {
-        this.state.status = 'shutting_down';
-        try {
-            // Generate final performance report
-            const performanceReport = this.performanceOptimizer.generatePerformanceReport();
-            // 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'),
-            ]);
-            // Close performance optimizer
-            await this.performanceOptimizer.close();
-            // Destroy swarm
-            await this.mcpWrapper.destroySwarm(this.state.swarmId);
-            this.state.status = 'shutdown';
-            this.emit('shutdown', { performanceReport });
-        }
-        catch (error) {
-            this.emit('error', { type: 'shutdown_failed', error });
-            throw error;
-        }
-    }
-    /**
-     * Get performance insights and recommendations
-     */
-    getPerformanceInsights() {
-        return this.performanceOptimizer.generatePerformanceReport();
-    }
-}
-//# sourceMappingURL=core.js.map