claude-flow 2.0.0-alpha.70 → 2.0.0-alpha.72

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

@@ -1,697 +0,0 @@
-/**
- * Queen Coordinator for Hive Mind System
- * Strategic decision-making and swarm coordination
- */
-import EventEmitter from 'events';
-/**
- * Queen types and their characteristics
- */
-const QUEEN_TYPES = {
-    strategic: {
-        name: 'Strategic Queen',
-        traits: ['long-term planning', 'resource optimization', 'goal alignment'],
-        decisionWeight: 3,
-        consensusThreshold: 0.6,
-    },
-    tactical: {
-        name: 'Tactical Queen',
-        traits: ['task prioritization', 'workflow optimization', 'rapid response'],
-        decisionWeight: 2,
-        consensusThreshold: 0.5,
-    },
-    adaptive: {
-        name: 'Adaptive Queen',
-        traits: ['learning', 'pattern recognition', 'strategy evolution'],
-        decisionWeight: 2.5,
-        consensusThreshold: 0.55,
-    },
-};
-/**
- * QueenCoordinator class
- */
-export class QueenCoordinator extends EventEmitter {
-    constructor(config = {}) {
-        super();
-        this.config = {
-            swarmId: config.swarmId,
-            type: config.type || 'strategic',
-            objective: config.objective || '',
-            ...QUEEN_TYPES[config.type || 'strategic'],
-        };
-        this.state = {
-            status: 'initializing',
-            decisionsCount: 0,
-            strategiesExecuted: 0,
-            learningData: new Map(),
-            currentStrategy: null,
-            taskQueue: [],
-            workerAssignments: new Map(),
-        };
-        this.strategies = {
-            divide_and_conquer: this._divideAndConquerStrategy.bind(this),
-            parallel_execution: this._parallelExecutionStrategy.bind(this),
-            sequential_refinement: this._sequentialRefinementStrategy.bind(this),
-            consensus_driven: this._consensusDrivenStrategy.bind(this),
-            adaptive_learning: this._adaptiveLearningStrategy.bind(this),
-        };
-        this._initialize();
-    }
-    /**
-     * Initialize queen coordinator
-     */
-    _initialize() {
-        this.state.status = 'active';
-        this.emit('queen:initialized', {
-            type: this.config.type,
-            traits: this.config.traits,
-        });
-    }
-    /**
-     * Analyze objective and create strategic plan
-     */
-    async analyzeObjective(objective) {
-        const analysis = {
-            objective,
-            complexity: this._assessComplexity(objective),
-            requiredCapabilities: this._identifyRequiredCapabilities(objective),
-            estimatedTasks: this._estimateTaskCount(objective),
-            recommendedStrategy: this._selectStrategy(objective),
-            resourceRequirements: this._estimateResources(objective),
-        };
-        // Store analysis for learning
-        this.state.learningData.set('objective_analysis', analysis);
-        this.emit('objective:analyzed', analysis);
-        return analysis;
-    }
-    /**
-     * Assess complexity of objective
-     */
-    _assessComplexity(objective) {
-        const complexityFactors = {
-            length: objective.length > 100 ? 2 : 1,
-            keywords: this._countComplexityKeywords(objective),
-            components: this._identifyComponents(objective).length,
-        };
-        const score = Object.values(complexityFactors).reduce((a, b) => a + b, 0);
-        if (score <= 3)
-            return 'low';
-        if (score <= 6)
-            return 'medium';
-        if (score <= 9)
-            return 'high';
-        return 'very_high';
-    }
-    /**
-     * Count complexity keywords
-     */
-    _countComplexityKeywords(text) {
-        const complexKeywords = [
-            'complex',
-            'advanced',
-            'enterprise',
-            'distributed',
-            'scalable',
-            'microservices',
-            'architecture',
-            'integration',
-            'optimization',
-            'security',
-            'performance',
-            'concurrent',
-            'real-time',
-        ];
-        const lowerText = text.toLowerCase();
-        return complexKeywords.filter((keyword) => lowerText.includes(keyword)).length;
-    }
-    /**
-     * Identify components in objective
-     */
-    _identifyComponents(objective) {
-        const components = [];
-        const componentKeywords = {
-            backend: ['api', 'server', 'backend', 'database', 'service'],
-            frontend: ['ui', 'frontend', 'interface', 'client', 'web'],
-            data: ['database', 'data', 'storage', 'cache', 'persistence'],
-            auth: ['auth', 'security', 'login', 'permission', 'access'],
-            testing: ['test', 'quality', 'validation', 'verify'],
-            deployment: ['deploy', 'ci/cd', 'docker', 'kubernetes'],
-            monitoring: ['monitor', 'logging', 'metrics', 'observability'],
-        };
-        const lowerObjective = objective.toLowerCase();
-        Object.entries(componentKeywords).forEach(([component, keywords]) => {
-            if (keywords.some((keyword) => lowerObjective.includes(keyword))) {
-                components.push(component);
-            }
-        });
-        return components;
-    }
-    /**
-     * Identify required capabilities
-     */
-    _identifyRequiredCapabilities(objective) {
-        const capabilities = new Set();
-        const components = this._identifyComponents(objective);
-        // Map components to capabilities
-        const capabilityMap = {
-            backend: ['coder', 'architect', 'tester'],
-            frontend: ['coder', 'tester', 'reviewer'],
-            data: ['architect', 'analyst', 'optimizer'],
-            auth: ['architect', 'coder', 'tester'],
-            testing: ['tester', 'reviewer'],
-            deployment: ['architect', 'optimizer'],
-            monitoring: ['analyst', 'optimizer'],
-        };
-        components.forEach((component) => {
-            const caps = capabilityMap[component] || [];
-            caps.forEach((cap) => capabilities.add(cap));
-        });
-        // Always include researcher for initial analysis
-        capabilities.add('researcher');
-        return Array.from(capabilities);
-    }
-    /**
-     * Estimate number of tasks
-     */
-    _estimateTaskCount(objective) {
-        const complexity = this._assessComplexity(objective);
-        const components = this._identifyComponents(objective).length;
-        const baseTaskCount = {
-            low: 5,
-            medium: 10,
-            high: 20,
-            very_high: 30,
-        };
-        return baseTaskCount[complexity] + components * 3;
-    }
-    /**
-     * Select optimal strategy
-     */
-    _selectStrategy(objective) {
-        const complexity = this._assessComplexity(objective);
-        const components = this._identifyComponents(objective);
-        // Strategy selection heuristics
-        if (components.length > 3 && complexity !== 'low') {
-            return 'divide_and_conquer';
-        }
-        if (objective.toLowerCase().includes('parallel') || components.length > 5) {
-            return 'parallel_execution';
-        }
-        if (objective.toLowerCase().includes('iterative') ||
-            objective.toLowerCase().includes('refine')) {
-            return 'sequential_refinement';
-        }
-        if (this.config.type === 'adaptive') {
-            return 'adaptive_learning';
-        }
-        return 'consensus_driven'; // Default
-    }
-    /**
-     * Estimate resource requirements
-     */
-    _estimateResources(objective) {
-        const complexity = this._assessComplexity(objective);
-        const taskCount = this._estimateTaskCount(objective);
-        return {
-            minWorkers: Math.min(3, Math.ceil(taskCount / 10)),
-            optimalWorkers: Math.min(8, Math.ceil(taskCount / 5)),
-            estimatedTime: taskCount * 5, // minutes
-            memoryRequirement: complexity === 'very_high' ? 'high' : 'medium',
-        };
-    }
-    /**
-     * Create execution plan
-     */
-    async createExecutionPlan(analysis, workers) {
-        const strategy = this.strategies[analysis.recommendedStrategy];
-        if (!strategy) {
-            throw new Error(`Unknown strategy: ${analysis.recommendedStrategy}`);
-        }
-        const plan = await strategy(analysis, workers);
-        this.state.currentStrategy = analysis.recommendedStrategy;
-        this.state.strategiesExecuted++;
-        this.emit('plan:created', plan);
-        return plan;
-    }
-    /**
-     * Divide and conquer strategy
-     */
-    async _divideAndConquerStrategy(analysis, workers) {
-        const components = this._identifyComponents(analysis.objective);
-        const phases = [];
-        // Phase 1: Research and planning
-        phases.push({
-            name: 'Research and Planning',
-            tasks: [
-                'Research best practices and patterns',
-                'Analyze requirements and constraints',
-                'Create high-level architecture design',
-            ],
-            workers: workers.filter((w) => ['researcher', 'architect'].includes(w.type)),
-            parallel: true,
-        });
-        // Phase 2: Component development
-        components.forEach((component) => {
-            phases.push({
-                name: `Develop ${component}`,
-                tasks: this._generateComponentTasks(component),
-                workers: workers.filter((w) => ['coder', 'architect'].includes(w.type)),
-                parallel: true,
-            });
-        });
-        // Phase 3: Integration and testing
-        phases.push({
-            name: 'Integration and Testing',
-            tasks: [
-                'Integrate components',
-                'Write integration tests',
-                'Perform end-to-end testing',
-                'Fix integration issues',
-            ],
-            workers: workers.filter((w) => ['coder', 'tester'].includes(w.type)),
-            parallel: false,
-        });
-        // Phase 4: Optimization and documentation
-        phases.push({
-            name: 'Optimization and Documentation',
-            tasks: [
-                'Optimize performance',
-                'Document architecture',
-                'Create user documentation',
-                'Prepare deployment guide',
-            ],
-            workers: workers.filter((w) => ['optimizer', 'documenter'].includes(w.type)),
-            parallel: true,
-        });
-        return {
-            strategy: 'divide_and_conquer',
-            phases,
-            estimatedDuration: phases.length * 15, // minutes
-            parallelism: 'high',
-        };
-    }
-    /**
-     * Parallel execution strategy
-     */
-    async _parallelExecutionStrategy(analysis, workers) {
-        const tasks = this._generateAllTasks(analysis);
-        const workerGroups = this._groupWorkersByType(workers);
-        return {
-            strategy: 'parallel_execution',
-            phases: [
-                {
-                    name: 'Parallel Execution',
-                    tasks: tasks,
-                    workers: workers,
-                    parallel: true,
-                    workerAssignment: this._optimizeWorkerAssignment(tasks, workerGroups),
-                },
-            ],
-            estimatedDuration: Math.ceil(tasks.length / workers.length) * 10,
-            parallelism: 'maximum',
-        };
-    }
-    /**
-     * Sequential refinement strategy
-     */
-    async _sequentialRefinementStrategy(analysis, workers) {
-        const iterations = 3;
-        const phases = [];
-        for (let i = 0; i < iterations; i++) {
-            phases.push({
-                name: `Iteration ${i + 1}`,
-                tasks: [
-                    `Design iteration ${i + 1}`,
-                    `Implement features for iteration ${i + 1}`,
-                    `Test iteration ${i + 1}`,
-                    `Review and refine iteration ${i + 1}`,
-                ],
-                workers: workers,
-                parallel: false,
-                requiresConsensus: true,
-            });
-        }
-        return {
-            strategy: 'sequential_refinement',
-            phases,
-            estimatedDuration: phases.length * 20,
-            parallelism: 'low',
-            iterative: true,
-        };
-    }
-    /**
-     * Consensus-driven strategy
-     */
-    async _consensusDrivenStrategy(analysis, workers) {
-        const decisionPoints = this._identifyDecisionPoints(analysis);
-        const phases = [];
-        decisionPoints.forEach((decision, index) => {
-            phases.push({
-                name: `Decision Phase ${index + 1}: ${decision}`,
-                tasks: [
-                    `Research options for ${decision}`,
-                    `Analyze trade-offs`,
-                    `Build consensus on approach`,
-                    `Implement chosen solution`,
-                ],
-                workers: workers,
-                parallel: index === 0, // Only first phase in parallel
-                requiresConsensus: true,
-                consensusThreshold: this.config.consensusThreshold,
-            });
-        });
-        return {
-            strategy: 'consensus_driven',
-            phases,
-            estimatedDuration: phases.length * 25,
-            parallelism: 'medium',
-            consensusRequired: true,
-        };
-    }
-    /**
-     * Adaptive learning strategy
-     */
-    async _adaptiveLearningStrategy(analysis, workers) {
-        const learningPhases = [
-            {
-                name: 'Exploration Phase',
-                tasks: [
-                    'Explore multiple approaches',
-                    'Experiment with different solutions',
-                    'Collect performance metrics',
-                ],
-                workers: workers,
-                parallel: true,
-                learning: true,
-            },
-            {
-                name: 'Analysis Phase',
-                tasks: ['Analyze results', 'Identify patterns', 'Select best approaches'],
-                workers: workers.filter((w) => ['analyst', 'researcher'].includes(w.type)),
-                parallel: false,
-                learning: true,
-            },
-            {
-                name: 'Implementation Phase',
-                tasks: ['Implement optimized solution', 'Apply learned patterns', 'Validate improvements'],
-                workers: workers,
-                parallel: true,
-                applyLearning: true,
-            },
-        ];
-        return {
-            strategy: 'adaptive_learning',
-            phases: learningPhases,
-            estimatedDuration: 45,
-            parallelism: 'adaptive',
-            learningEnabled: true,
-        };
-    }
-    /**
-     * Generate component-specific tasks
-     */
-    _generateComponentTasks(component) {
-        const taskTemplates = {
-            backend: [
-                'Design API endpoints',
-                'Implement business logic',
-                'Set up database models',
-                'Create API tests',
-            ],
-            frontend: [
-                'Design UI components',
-                'Implement user interface',
-                'Add interactivity',
-                'Create UI tests',
-            ],
-            data: [
-                'Design data schema',
-                'Implement data access layer',
-                'Set up caching',
-                'Optimize queries',
-            ],
-            auth: [
-                'Design authentication flow',
-                'Implement auth middleware',
-                'Add authorization checks',
-                'Test security',
-            ],
-        };
-        return (taskTemplates[component] || [
-            `Design ${component}`,
-            `Implement ${component}`,
-            `Test ${component}`,
-        ]);
-    }
-    /**
-     * Generate all tasks based on analysis
-     */
-    _generateAllTasks(analysis) {
-        const tasks = [];
-        const components = this._identifyComponents(analysis.objective);
-        // Add general tasks
-        tasks.push('Analyze requirements', 'Design architecture', 'Set up project structure');
-        // Add component tasks
-        components.forEach((component) => {
-            tasks.push(...this._generateComponentTasks(component));
-        });
-        // Add integration tasks
-        tasks.push('Integrate components', 'Write tests', 'Document solution');
-        return tasks;
-    }
-    /**
-     * Group workers by type
-     */
-    _groupWorkersByType(workers) {
-        const groups = {};
-        workers.forEach((worker) => {
-            if (!groups[worker.type]) {
-                groups[worker.type] = [];
-            }
-            groups[worker.type].push(worker);
-        });
-        return groups;
-    }
-    /**
-     * Optimize worker assignment for tasks
-     */
-    _optimizeWorkerAssignment(tasks, workerGroups) {
-        const assignments = {};
-        tasks.forEach((task) => {
-            const bestWorkerType = this._findBestWorkerType(task);
-            const availableWorkers = workerGroups[bestWorkerType] || [];
-            if (availableWorkers.length > 0) {
-                // Round-robin assignment within type
-                const workerIndex = Object.keys(assignments).filter((t) => assignments[t].type === bestWorkerType).length %
-                    availableWorkers.length;
-                assignments[task] = availableWorkers[workerIndex];
-            }
-        });
-        return assignments;
-    }
-    /**
-     * Find best worker type for task
-     */
-    _findBestWorkerType(task) {
-        const taskLower = task.toLowerCase();
-        if (taskLower.includes('research') || taskLower.includes('analyze')) {
-            return 'researcher';
-        }
-        if (taskLower.includes('design') || taskLower.includes('architect')) {
-            return 'architect';
-        }
-        if (taskLower.includes('implement') || taskLower.includes('code')) {
-            return 'coder';
-        }
-        if (taskLower.includes('test') || taskLower.includes('validate')) {
-            return 'tester';
-        }
-        if (taskLower.includes('optimize') || taskLower.includes('performance')) {
-            return 'optimizer';
-        }
-        if (taskLower.includes('document') || taskLower.includes('write')) {
-            return 'documenter';
-        }
-        return 'coder'; // Default
-    }
-    /**
-     * Identify decision points in objective
-     */
-    _identifyDecisionPoints(analysis) {
-        const decisionKeywords = [
-            'choose',
-            'select',
-            'decide',
-            'option',
-            'approach',
-            'strategy',
-            'method',
-            'solution',
-            'alternative',
-        ];
-        const decisions = [];
-        const components = this._identifyComponents(analysis.objective);
-        // Architecture decisions
-        if (components.length > 2) {
-            decisions.push('Architecture pattern selection');
-        }
-        // Technology decisions
-        components.forEach((component) => {
-            decisions.push(`Technology stack for ${component}`);
-        });
-        // Implementation decisions
-        if (analysis.complexity !== 'low') {
-            decisions.push('Implementation approach');
-        }
-        return decisions;
-    }
-    /**
-     * Make strategic decision
-     */
-    async makeDecision(topic, options, workerVotes = {}) {
-        const decision = {
-            topic,
-            options,
-            workerVotes,
-            queenVote: this._calculateQueenVote(topic, options, workerVotes),
-            timestamp: Date.now(),
-        };
-        // Calculate final decision with queen's weighted vote
-        const finalDecision = this._calculateFinalDecision(decision);
-        decision.result = finalDecision;
-        this.state.decisionsCount++;
-        // Learn from decision
-        if (this.config.type === 'adaptive') {
-            this._learnFromDecision(decision);
-        }
-        this.emit('decision:made', decision);
-        return decision;
-    }
-    /**
-     * Calculate queen's vote
-     */
-    _calculateQueenVote(topic, options, workerVotes) {
-        // Strategic queen focuses on long-term impact
-        if (this.config.type === 'strategic') {
-            return this._strategicVote(topic, options);
-        }
-        // Tactical queen focuses on immediate efficiency
-        if (this.config.type === 'tactical') {
-            return this._tacticalVote(topic, options, workerVotes);
-        }
-        // Adaptive queen learns from past decisions
-        if (this.config.type === 'adaptive') {
-            return this._adaptiveVote(topic, options, workerVotes);
-        }
-        return options[0]; // Default
-    }
-    /**
-     * Strategic voting logic
-     */
-    _strategicVote(topic, options) {
-        // Prefer options that mention long-term benefits
-        const strategicKeywords = ['scalable', 'maintainable', 'extensible', 'future'];
-        for (const option of options) {
-            const optionLower = option.toLowerCase();
-            if (strategicKeywords.some((keyword) => optionLower.includes(keyword))) {
-                return option;
-            }
-        }
-        return options[0];
-    }
-    /**
-     * Tactical voting logic
-     */
-    _tacticalVote(topic, options, workerVotes) {
-        // Follow majority if consensus is strong
-        const voteCounts = {};
-        Object.values(workerVotes).forEach((vote) => {
-            voteCounts[vote] = (voteCounts[vote] || 0) + 1;
-        });
-        const sorted = Object.entries(voteCounts).sort((a, b) => b[1] - a[1]);
-        if (sorted.length > 0 && sorted[0][1] > Object.keys(workerVotes).length * 0.6) {
-            return sorted[0][0];
-        }
-        // Otherwise, prefer quick implementation
-        const tacticalKeywords = ['simple', 'quick', 'fast', 'efficient'];
-        for (const option of options) {
-            const optionLower = option.toLowerCase();
-            if (tacticalKeywords.some((keyword) => optionLower.includes(keyword))) {
-                return option;
-            }
-        }
-        return options[0];
-    }
-    /**
-     * Adaptive voting logic
-     */
-    _adaptiveVote(topic, options, workerVotes) {
-        // Check if we've seen similar decisions before
-        const similarDecisions = Array.from(this.state.learningData.entries()).filter(([key, value]) => key.includes('decision') && value.topic.includes(topic));
-        if (similarDecisions.length > 0) {
-            // Use learned preferences
-            const successfulOptions = similarDecisions
-                .filter(([_, decision]) => decision.success)
-                .map(([_, decision]) => decision.result);
-            for (const option of options) {
-                if (successfulOptions.includes(option)) {
-                    return option;
-                }
-            }
-        }
-        // Otherwise, explore new option
-        return options[Math.floor(Math.random() * options.length)];
-    }
-    /**
-     * Calculate final decision with weighted votes
-     */
-    _calculateFinalDecision(decision) {
-        const voteCounts = {};
-        // Count worker votes
-        Object.values(decision.workerVotes).forEach((vote) => {
-            voteCounts[vote] = (voteCounts[vote] || 0) + 1;
-        });
-        // Add queen's weighted vote
-        voteCounts[decision.queenVote] =
-            (voteCounts[decision.queenVote] || 0) + this.config.decisionWeight;
-        // Find winner
-        const sorted = Object.entries(voteCounts).sort((a, b) => b[1] - a[1]);
-        return sorted[0][0];
-    }
-    /**
-     * Learn from decision outcomes
-     */
-    _learnFromDecision(decision) {
-        const key = `decision-${this.state.decisionsCount}`;
-        this.state.learningData.set(key, {
-            ...decision,
-            success: true, // Will be updated based on outcome
-        });
-    }
-    /**
-     * Update decision outcome
-     */
-    updateDecisionOutcome(decisionId, success, metrics = {}) {
-        const key = `decision-${decisionId}`;
-        const decision = this.state.learningData.get(key);
-        if (decision) {
-            decision.success = success;
-            decision.metrics = metrics;
-            this.emit('learning:updated', { decisionId, success, metrics });
-        }
-    }
-    /**
-     * Get queen status
-     */
-    getStatus() {
-        return {
-            type: this.config.type,
-            name: this.config.name,
-            status: this.state.status,
-            decisionsCount: this.state.decisionsCount,
-            strategiesExecuted: this.state.strategiesExecuted,
-            currentStrategy: this.state.currentStrategy,
-            learningDataSize: this.state.learningData.size,
-        };
-    }
-}
-//# sourceMappingURL=queen.js.map