claude-flow 2.0.0-alpha.78 → 2.0.0-alpha.79

package/dist/cli/simple-commands/hive-mind/queen.d.ts

@@ -0,0 +1,235 @@
+/**
+ * QueenCoordinator class
+ */
+export class QueenCoordinator extends EventEmitter<[never]> {
+    constructor(config?: {});
+    config: any;
+    state: {
+        status: string;
+        decisionsCount: number;
+        strategiesExecuted: number;
+        learningData: Map<any, any>;
+        currentStrategy: any;
+        taskQueue: any[];
+        workerAssignments: Map<any, any>;
+    };
+    strategies: {
+        divide_and_conquer: any;
+        parallel_execution: any;
+        sequential_refinement: any;
+        consensus_driven: any;
+        adaptive_learning: any;
+    };
+    /**
+     * Initialize queen coordinator
+     */
+    _initialize(): void;
+    /**
+     * Analyze objective and create strategic plan
+     */
+    analyzeObjective(objective: any): Promise<{
+        objective: any;
+        complexity: string;
+        requiredCapabilities: any[];
+        estimatedTasks: number;
+        recommendedStrategy: string;
+        resourceRequirements: {
+            minWorkers: number;
+            optimalWorkers: number;
+            estimatedTime: number;
+            memoryRequirement: string;
+        };
+    }>;
+    /**
+     * Assess complexity of objective
+     */
+    _assessComplexity(objective: any): "low" | "medium" | "high" | "very_high";
+    /**
+     * Count complexity keywords
+     */
+    _countComplexityKeywords(text: any): number;
+    /**
+     * Identify components in objective
+     */
+    _identifyComponents(objective: any): any[];
+    /**
+     * Identify required capabilities
+     */
+    _identifyRequiredCapabilities(objective: any): any[];
+    /**
+     * Estimate number of tasks
+     */
+    _estimateTaskCount(objective: any): number;
+    /**
+     * Select optimal strategy
+     */
+    _selectStrategy(objective: any): "divide_and_conquer" | "parallel_execution" | "sequential_refinement" | "adaptive_learning" | "consensus_driven";
+    /**
+     * Estimate resource requirements
+     */
+    _estimateResources(objective: any): {
+        minWorkers: number;
+        optimalWorkers: number;
+        estimatedTime: number;
+        memoryRequirement: string;
+    };
+    /**
+     * Create execution plan
+     */
+    createExecutionPlan(analysis: any, workers: any): Promise<any>;
+    /**
+     * Divide and conquer strategy
+     */
+    _divideAndConquerStrategy(analysis: any, workers: any): Promise<{
+        strategy: string;
+        phases: {
+            name: string;
+            tasks: string[];
+            workers: any;
+            parallel: boolean;
+        }[];
+        estimatedDuration: number;
+        parallelism: string;
+    }>;
+    /**
+     * Parallel execution strategy
+     */
+    _parallelExecutionStrategy(analysis: any, workers: any): Promise<{
+        strategy: string;
+        phases: {
+            name: string;
+            tasks: string[];
+            workers: any;
+            parallel: boolean;
+            workerAssignment: {};
+        }[];
+        estimatedDuration: number;
+        parallelism: string;
+    }>;
+    /**
+     * Sequential refinement strategy
+     */
+    _sequentialRefinementStrategy(analysis: any, workers: any): Promise<{
+        strategy: string;
+        phases: {
+            name: string;
+            tasks: string[];
+            workers: any;
+            parallel: boolean;
+            requiresConsensus: boolean;
+        }[];
+        estimatedDuration: number;
+        parallelism: string;
+        iterative: boolean;
+    }>;
+    /**
+     * Consensus-driven strategy
+     */
+    _consensusDrivenStrategy(analysis: any, workers: any): Promise<{
+        strategy: string;
+        phases: any[];
+        estimatedDuration: number;
+        parallelism: string;
+        consensusRequired: boolean;
+    }>;
+    /**
+     * Adaptive learning strategy
+     */
+    _adaptiveLearningStrategy(analysis: any, workers: any): Promise<{
+        strategy: string;
+        phases: ({
+            name: string;
+            tasks: string[];
+            workers: any;
+            parallel: boolean;
+            learning: boolean;
+            applyLearning?: undefined;
+        } | {
+            name: string;
+            tasks: string[];
+            workers: any;
+            parallel: boolean;
+            applyLearning: boolean;
+            learning?: undefined;
+        })[];
+        estimatedDuration: number;
+        parallelism: string;
+        learningEnabled: boolean;
+    }>;
+    /**
+     * Generate component-specific tasks
+     */
+    _generateComponentTasks(component: any): any;
+    /**
+     * Generate all tasks based on analysis
+     */
+    _generateAllTasks(analysis: any): string[];
+    /**
+     * Group workers by type
+     */
+    _groupWorkersByType(workers: any): {};
+    /**
+     * Optimize worker assignment for tasks
+     */
+    _optimizeWorkerAssignment(tasks: any, workerGroups: any): {};
+    /**
+     * Find best worker type for task
+     */
+    _findBestWorkerType(task: any): "researcher" | "coder" | "architect" | "tester" | "optimizer" | "documenter";
+    /**
+     * Identify decision points in objective
+     */
+    _identifyDecisionPoints(analysis: any): string[];
+    /**
+     * Make strategic decision
+     */
+    makeDecision(topic: any, options: any, workerVotes?: {}): Promise<{
+        topic: any;
+        options: any;
+        workerVotes: {};
+        queenVote: any;
+        timestamp: number;
+    }>;
+    /**
+     * Calculate queen's vote
+     */
+    _calculateQueenVote(topic: any, options: any, workerVotes: any): any;
+    /**
+     * Strategic voting logic
+     */
+    _strategicVote(topic: any, options: any): any;
+    /**
+     * Tactical voting logic
+     */
+    _tacticalVote(topic: any, options: any, workerVotes: any): any;
+    /**
+     * Adaptive voting logic
+     */
+    _adaptiveVote(topic: any, options: any, workerVotes: any): any;
+    /**
+     * Calculate final decision with weighted votes
+     */
+    _calculateFinalDecision(decision: any): string;
+    /**
+     * Learn from decision outcomes
+     */
+    _learnFromDecision(decision: any): void;
+    /**
+     * Update decision outcome
+     */
+    updateDecisionOutcome(decisionId: any, success: any, metrics?: {}): void;
+    /**
+     * Get queen status
+     */
+    getStatus(): {
+        type: any;
+        name: any;
+        status: string;
+        decisionsCount: number;
+        strategiesExecuted: number;
+        currentStrategy: any;
+        learningDataSize: number;
+    };
+}
+import EventEmitter from 'events';
+//# sourceMappingURL=queen.d.ts.map

package/dist/cli/simple-commands/hive-mind/queen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queen.d.ts","sourceRoot":"","sources":["../../../../src/cli/simple-commands/hive-mind/queen.js"],"names":[],"mappings":"AA+BA;;GAEG;AACH;IACE,yBA6BC;IA1BC,YAKC;IAED;;;;;;;;MAQC;IAED;;;;;;MAMC;IAKH;;OAEG;IACH,oBAMC;IAED;;OAEG;IACH;;;;;;;;;;;;OAeC;IAED;;OAEG;IACH,2EAaC;IAED;;OAEG;IACH,4CAmBC;IAED;;OAEG;IACH,2CAqBC;IAED;;OAEG;IACH,qDAwBC;IAED;;OAEG;IACH,2CAYC;IAED;;OAEG;IACH,kJAyBC;IAED;;OAEG;IACH;;;;;MAUC;IAED;;OAEG;IACH,+DAaC;IAED;;OAEG;IACH;;;;;;;;;;OA0DC;IAED;;OAEG;IACH;;;;;;;;;;;OAkBC;IAED;;OAEG;IACH;;;;;;;;;;;;OA0BC;IAED;;OAEG;IACH;;;;;;OA2BC;IAED;;OAEG;IACH;;;;;;;;;;;;;;;;;;;;OAoCC;IAED;;OAEG;IACH,6CAmCC;IAED;;OAEG;IACH,2CAgBC;IAED;;OAEG;IACH,sCAWC;IAED;;OAEG;IACH,6DAkBC;IAED;;OAEG;IACH,6GAuBC;IAED;;OAEG;IACH,iDAgCC;IAED;;OAEG;IACH;;;;;;OAsBC;IAED;;OAEG;IACH,qEAiBC;IAED;;OAEG;IACH,8CAYC;IAED;;OAEG;IACH,+DAuBC;IAED;;OAEG;IACH,+DAqBC;IAED;;OAEG;IACH,+CAeC;IAED;;OAEG;IACH,wCAMC;IAED;;OAEG;IACH,yEASC;IAED;;OAEG;IACH;;;;;;;;MAUC;CACF;yBAnyBwB,QAAQ"}