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

package/src/cli/commands/hive.ts

@@ -37,7 +37,7 @@ export async function hiveAction(ctx: CommandContext) {
 
   const objective = ctx.args.join(' ').trim();
   if (!objective) {
-    error("Usage: hive <objective> [options]");
+    error('Usage: hive <objective> [options]');
     showHiveHelp();
     return;
   }
@@ -52,11 +52,11 @@ export async function hiveAction(ctx: CommandContext) {
     background: Boolean(ctx.flags.background) || false,
     memoryNamespace: String(ctx.flags['memory-namespace']) || 'hive',
     qualityThreshold: Number(ctx.flags['quality-threshold']) || 0.8,
-    sparc: ctx.flags.sparc !== false
+    sparc: ctx.flags.sparc !== false,
   };
 
   const hiveId = generateId('hive');
-  
+
   success(`🐝 Initializing Hive Mind: ${hiveId}`);
   console.log(`👑 Queen Genesis coordinating...`);
   console.log(`📋 Objective: ${objective}`);
@@ -74,7 +74,7 @@ export async function hiveAction(ctx: CommandContext) {
       enableWorkStealing: true,
       enableCircuitBreaker: true,
       memoryNamespace: options.memoryNamespace,
-      coordinationStrategy: 'distributed'
+      coordinationStrategy: 'distributed',
     });
 
     // Initialize Hive memory
@@ -82,35 +82,36 @@ export async function hiveAction(ctx: CommandContext) {
       namespace: options.memoryNamespace,
       enableDistribution: true,
       enableKnowledgeBase: true,
-      persistencePath: `./hive-runs/${hiveId}/memory`
+      persistencePath: `./hive-runs/${hiveId}/memory`,
     });
 
     await coordinator.start();
     await memory.initialize();
 
     // Create Queen Genesis
-    const queenId = await coordinator.registerAgent(
-      'Queen-Genesis',
-      'coordinator',
-      ['orchestration', 'consensus', 'decision-making', 'delegation']
-    );
+    const queenId = await coordinator.registerAgent('Queen-Genesis', 'coordinator', [
+      'orchestration',
+      'consensus',
+      'decision-making',
+      'delegation',
+    ]);
 
     // Create specialized agents based on topology
     const agents = await spawnHiveAgents(coordinator, options);
-    
+
     // Store Hive configuration
     await memory.store(`hive/${hiveId}/config`, {
       hiveId,
       objective,
       options,
       queenId,
-      agents: agents.map(a => a.id),
-      startTime: new Date().toISOString()
+      agents: agents.map((a) => a.id),
+      startTime: new Date().toISOString(),
     });
 
     // Create objective with Hive consensus
     const objectiveId = await coordinator.createObjective(objective, 'development');
-    
+
     // Execute with consensus mechanisms
     if (options.sparc) {
       info('🧪 SPARC methodology enabled - full TDD workflow');
@@ -127,41 +128,43 @@ export async function hiveAction(ctx: CommandContext) {
       console.log(`  - Decisions Made: ${(status as any).customMetrics?.decisions || 0}`);
       console.log(`  - Tasks Completed: ${status.tasks.completed}`);
       console.log(`  - Quality Score: ${(status as any).customMetrics?.qualityScore || 0}%`);
-      
+
       success(`✅ Hive Mind ${hiveId} completed successfully`);
     }
-
   } catch (err) {
     error(`Hive Mind error: ${(err as Error).message}`);
   }
 }
 
-async function spawnHiveAgents(coordinator: SwarmCoordinator, options: HiveOptions): Promise<HiveAgent[]> {
+async function spawnHiveAgents(
+  coordinator: SwarmCoordinator,
+  options: HiveOptions,
+): Promise<HiveAgent[]> {
   const agents: HiveAgent[] = [];
-  
+
   // Define agent types based on topology
   const agentConfigs = getAgentConfigsForTopology(options.topology);
-  
+
   for (let i = 0; i < Math.min(options.maxAgents - 1, agentConfigs.length); i++) {
     const config = agentConfigs[i % agentConfigs.length];
     const agentId = await coordinator.registerAgent(
       `${config.type}-${i + 1}`,
       config.role as any,
-      config.capabilities
+      config.capabilities,
     );
-    
+
     agents.push({
       id: agentId,
       type: config.type as any,
       role: config.role,
       capabilities: config.capabilities,
       status: 'idle',
-      votes: new Map()
+      votes: new Map(),
     });
-    
+
     console.log(`  🐝 Spawned ${config.type} agent: ${agentId}`);
   }
-  
+
   return agents;
 }
 
@@ -169,30 +172,58 @@ function getAgentConfigsForTopology(topology: string) {
   switch (topology) {
     case 'hierarchical':
       return [
-        { type: 'architect', role: 'architect', capabilities: ['design', 'planning', 'architecture'] },
+        {
+          type: 'architect',
+          role: 'architect',
+          capabilities: ['design', 'planning', 'architecture'],
+        },
         { type: 'worker', role: 'coder', capabilities: ['implementation', 'coding', 'testing'] },
         { type: 'worker', role: 'analyst', capabilities: ['analysis', 'optimization', 'metrics'] },
-        { type: 'scout', role: 'researcher', capabilities: ['research', 'exploration', 'discovery'] },
-        { type: 'guardian', role: 'reviewer', capabilities: ['review', 'quality', 'validation'] }
+        {
+          type: 'scout',
+          role: 'researcher',
+          capabilities: ['research', 'exploration', 'discovery'],
+        },
+        { type: 'guardian', role: 'reviewer', capabilities: ['review', 'quality', 'validation'] },
       ];
     case 'mesh':
       return [
         { type: 'worker', role: 'generalist', capabilities: ['coding', 'analysis', 'research'] },
-        { type: 'worker', role: 'specialist', capabilities: ['optimization', 'architecture', 'testing'] },
+        {
+          type: 'worker',
+          role: 'specialist',
+          capabilities: ['optimization', 'architecture', 'testing'],
+        },
         { type: 'scout', role: 'explorer', capabilities: ['discovery', 'research', 'innovation'] },
-        { type: 'guardian', role: 'validator', capabilities: ['validation', 'quality', 'security'] }
+        {
+          type: 'guardian',
+          role: 'validator',
+          capabilities: ['validation', 'quality', 'security'],
+        },
       ];
     case 'ring':
       return [
-        { type: 'worker', role: 'processor', capabilities: ['processing', 'transformation', 'execution'] },
+        {
+          type: 'worker',
+          role: 'processor',
+          capabilities: ['processing', 'transformation', 'execution'],
+        },
         { type: 'worker', role: 'analyzer', capabilities: ['analysis', 'metrics', 'insights'] },
-        { type: 'worker', role: 'builder', capabilities: ['building', 'implementation', 'integration'] }
+        {
+          type: 'worker',
+          role: 'builder',
+          capabilities: ['building', 'implementation', 'integration'],
+        },
       ];
     case 'star':
       return [
-        { type: 'worker', role: 'executor', capabilities: ['execution', 'implementation', 'delivery'] },
+        {
+          type: 'worker',
+          role: 'executor',
+          capabilities: ['execution', 'implementation', 'delivery'],
+        },
         { type: 'scout', role: 'sensor', capabilities: ['monitoring', 'detection', 'alerting'] },
-        { type: 'architect', role: 'planner', capabilities: ['planning', 'design', 'strategy'] }
+        { type: 'architect', role: 'planner', capabilities: ['planning', 'design', 'strategy'] },
       ];
     default:
       return [];
@@ -204,20 +235,26 @@ async function executeHive(
   memory: SwarmMemoryManager,
   objectiveId: string,
   agents: HiveAgent[],
-  options: HiveOptions
+  options: HiveOptions,
 ) {
   // Phase 1: Task decomposition with consensus
   console.log('\n🧩 Phase 1: Task Decomposition');
-  const tasks = await decomposeWithConsensus(coordinator, memory, options.objective, agents, options);
-  
+  const tasks = await decomposeWithConsensus(
+    coordinator,
+    memory,
+    options.objective,
+    agents,
+    options,
+  );
+
   // Phase 2: Task assignment with voting
   console.log('\n🗳️ Phase 2: Task Assignment');
   const assignments = await assignTasksWithVoting(coordinator, memory, tasks, agents, options);
-  
+
   // Phase 3: Parallel execution with monitoring
   console.log('\n⚡ Phase 3: Parallel Execution');
   await executeTasksWithMonitoring(coordinator, memory, assignments, agents, options);
-  
+
   // Phase 4: Result aggregation with quality checks
   console.log('\n📊 Phase 4: Result Aggregation');
   await aggregateResultsWithQuality(coordinator, memory, objectiveId, agents, options);
@@ -228,43 +265,43 @@ async function executeSparcHive(
   memory: SwarmMemoryManager,
   objectiveId: string,
   agents: HiveAgent[],
-  options: HiveOptions
+  options: HiveOptions,
 ) {
   console.log('\n🧪 SPARC Hive Execution Mode');
-  
+
   // S: Specification with consensus
   console.log('\n📋 S - Specification Phase');
   await conductConsensusRound(memory, agents, 'specification', {
     task: 'Define requirements and acceptance criteria',
-    objective: options.objective
+    objective: options.objective,
   });
-  
+
   // P: Pseudocode with voting
   console.log('\n🧮 P - Pseudocode Phase');
   await conductConsensusRound(memory, agents, 'pseudocode', {
     task: 'Design algorithms and data structures',
-    objective: options.objective
+    objective: options.objective,
   });
-  
+
   // A: Architecture with review
   console.log('\n🏗️ A - Architecture Phase');
   await conductConsensusRound(memory, agents, 'architecture', {
     task: 'Design system architecture',
-    objective: options.objective
+    objective: options.objective,
   });
-  
+
   // R: Refinement with TDD
   console.log('\n♻️ R - Refinement Phase (TDD)');
   await conductConsensusRound(memory, agents, 'refinement', {
     task: 'Implement with test-driven development',
-    objective: options.objective
+    objective: options.objective,
   });
-  
+
   // C: Completion with validation
   console.log('\n✅ C - Completion Phase');
   await conductConsensusRound(memory, agents, 'completion', {
     task: 'Integrate and validate solution',
-    objective: options.objective
+    objective: options.objective,
   });
 }
 
@@ -272,38 +309,38 @@ async function conductConsensusRound(
   memory: SwarmMemoryManager,
   agents: HiveAgent[],
   phase: string,
-  context: any
+  context: any,
 ) {
   const roundId = generateId('round');
-  
+
   // Store round context
   await memory.store(`consensus/${roundId}/context`, {
     phase,
     context,
-    agents: agents.map(a => a.id),
-    timestamp: new Date().toISOString()
+    agents: agents.map((a) => a.id),
+    timestamp: new Date().toISOString(),
   });
-  
+
   // Simulate voting
   const votes = new Map<string, boolean>();
-  agents.forEach(agent => {
+  agents.forEach((agent) => {
     const vote = Math.random() > 0.2; // 80% approval rate
     votes.set(agent.id, vote);
     console.log(`  🗳️ ${agent.type}-${agent.id}: ${vote ? '✅ Approve' : '❌ Reject'}`);
   });
-  
+
   // Calculate consensus
-  const approvals = Array.from(votes.values()).filter(v => v).length;
+  const approvals = Array.from(votes.values()).filter((v) => v).length;
   const consensus = approvals / agents.length;
-  
+
   console.log(`  📊 Consensus: ${(consensus * 100).toFixed(1)}% (${approvals}/${agents.length})`);
-  
+
   // Store results
   await memory.store(`consensus/${roundId}/results`, {
     votes: Object.fromEntries(votes),
     consensus,
     approved: consensus >= 0.5,
-    timestamp: new Date().toISOString()
+    timestamp: new Date().toISOString(),
   });
 }
 
@@ -312,7 +349,7 @@ async function decomposeWithConsensus(
   memory: SwarmMemoryManager,
   objective: string,
   agents: HiveAgent[],
-  options: HiveOptions
+  options: HiveOptions,
 ): Promise<any[]> {
   // Queen proposes task decomposition
   const proposedTasks = [
@@ -320,20 +357,21 @@ async function decomposeWithConsensus(
     { type: 'design', description: `Design solution architecture` },
     { type: 'implementation', description: `Implement core functionality` },
     { type: 'testing', description: `Test and validate solution` },
-    { type: 'documentation', description: `Document the implementation` }
+    { type: 'documentation', description: `Document the implementation` },
   ];
-  
+
   // Agents vote on task breakdown
   console.log('  👑 Queen proposes task breakdown...');
   console.log('  🗳️ Agents voting on tasks...');
-  
+
   // Simulate consensus
-  const approved = options.consensus === 'unanimous' ? 
-    agents.length === agents.length : // All must agree
-    agents.length > agents.length / 2; // Simple majority
-    
+  const approved =
+    options.consensus === 'unanimous'
+      ? agents.length === agents.length // All must agree
+      : agents.length > agents.length / 2; // Simple majority
+
   console.log(`  ✅ Task breakdown ${approved ? 'approved' : 'rejected'}`);
-  
+
   return proposedTasks;
 }
 
@@ -342,41 +380,43 @@ async function assignTasksWithVoting(
   memory: SwarmMemoryManager,
   tasks: any[],
   agents: HiveAgent[],
-  options: HiveOptions
+  options: HiveOptions,
 ): Promise<Map<string, string>> {
   const assignments = new Map<string, string>();
-  
+
   for (const task of tasks) {
     // Agents bid on tasks based on capabilities
-    const bids = agents.map(agent => ({
-      agent,
-      score: calculateBidScore(agent, task)
-    })).sort((a, b) => b.score - a.score);
-    
+    const bids = agents
+      .map((agent) => ({
+        agent,
+        score: calculateBidScore(agent, task),
+      }))
+      .sort((a, b) => b.score - a.score);
+
     // Assign to highest bidder
     const winner = bids[0].agent;
     assignments.set(task.description, winner.id);
-    
+
     console.log(`  📌 ${task.type} → ${winner.type}-${winner.id} (score: ${bids[0].score})`);
   }
-  
+
   return assignments;
 }
 
 function calculateBidScore(agent: HiveAgent, task: any): number {
   // Calculate how well agent capabilities match task requirements
   let score = 0;
-  
+
   // Type matching
   if (task.type === 'analysis' && agent.capabilities.includes('analysis')) score += 3;
   if (task.type === 'design' && agent.capabilities.includes('architecture')) score += 3;
   if (task.type === 'implementation' && agent.capabilities.includes('coding')) score += 3;
   if (task.type === 'testing' && agent.capabilities.includes('testing')) score += 3;
   if (task.type === 'documentation' && agent.capabilities.includes('documentation')) score += 2;
-  
+
   // Add random factor for variety
   score += Math.random() * 2;
-  
+
   return score;
 }
 
@@ -385,29 +425,29 @@ async function executeTasksWithMonitoring(
   memory: SwarmMemoryManager,
   assignments: Map<string, string>,
   agents: HiveAgent[],
-  options: HiveOptions
+  options: HiveOptions,
 ) {
   const executions = Array.from(assignments.entries()).map(async ([task, agentId]) => {
-    const agent = agents.find(a => a.id === agentId)!;
+    const agent = agents.find((a) => a.id === agentId)!;
     agent.status = 'executing';
-    
+
     console.log(`  ⚡ ${agent.type}-${agent.id} executing: ${task}`);
-    
+
     // Simulate execution
-    await new Promise(resolve => setTimeout(resolve, 1000 + Math.random() * 2000));
-    
+    await new Promise((resolve) => setTimeout(resolve, 1000 + Math.random() * 2000));
+
     agent.status = 'idle';
     console.log(`  ✅ ${agent.type}-${agent.id} completed: ${task}`);
-    
+
     // Store execution result
     await memory.store(`execution/${agentId}/${Date.now()}`, {
       task,
       agent: agent.id,
       status: 'completed',
-      timestamp: new Date().toISOString()
+      timestamp: new Date().toISOString(),
     });
   });
-  
+
   await Promise.all(executions);
 }
 
@@ -416,7 +456,7 @@ async function aggregateResultsWithQuality(
   memory: SwarmMemoryManager,
   objectiveId: string,
   agents: HiveAgent[],
-  options: HiveOptions
+  options: HiveOptions,
 ) {
   // Collect all execution results
   const results = [];
@@ -425,21 +465,21 @@ async function aggregateResultsWithQuality(
     const executions = await memory.search(pattern, 10);
     results.push(...executions);
   }
-  
+
   // Calculate quality score
   const qualityScore = Math.min(100, 75 + Math.random() * 25);
-  
+
   console.log(`  📊 Quality Score: ${qualityScore.toFixed(1)}%`);
   console.log(`  ✅ Threshold: ${options.qualityThreshold * 100}%`);
   console.log(`  ${qualityScore >= options.qualityThreshold * 100 ? '✅ PASSED' : '❌ FAILED'}`);
-  
+
   // Store aggregated results
   await memory.store(`hive/${objectiveId}/results`, {
     objective: options.objective,
     executionCount: results.length,
     qualityScore,
     passed: qualityScore >= options.qualityThreshold * 100,
-    timestamp: new Date().toISOString()
+    timestamp: new Date().toISOString(),
   });
 }
 
@@ -499,4 +539,4 @@ FEATURES:
 
 For more info: https://github.com/ruvnet/claude-code-flow/docs/hive.md
 `);
-}
+}

package/src/cli/commands/hook-types.ts

@@ -120,7 +120,7 @@ export interface TelemetryOptions extends BaseHookOptions {
   tags?: string[];
 }
 
-export type HookType = 
+export type HookType =
   | 'pre-task'
   | 'post-task'
   | 'pre-edit'
@@ -145,4 +145,4 @@ export interface HookResult {
 
 export interface HookCommandOptions {
   args: string[];
-}
+}

package/src/cli/commands/hook-validator.ts

@@ -15,12 +15,12 @@ export interface ValidationResult {
  */
 export function validateHookParams(
   hookType: HookType,
-  params: Record<string, any>
+  params: Record<string, any>,
 ): ValidationResult {
   const result: ValidationResult = {
     valid: true,
     errors: [],
-    warnings: []
+    warnings: [],
   };
 
   // Common validations
@@ -153,7 +153,11 @@ export function validateHookParams(
     result.warnings.push('--load-previous without --session-id may load unexpected data');
   }
 
-  if (hookType === 'post-edit' && params.format && !params.file?.match(/\.(js|ts|jsx|tsx|py|java|cpp|cs)$/)) {
+  if (
+    hookType === 'post-edit' &&
+    params.format &&
+    !params.file?.match(/\.(js|ts|jsx|tsx|py|java|cpp|cs)$/)
+  ) {
     result.warnings.push('--format may not work correctly for this file type');
   }
 
@@ -188,4 +192,4 @@ export function sanitizeHookParams(params: Record<string, any>): Record<string,
   }
 
   return sanitized;
-}
+}