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

package/src/cli/commands/hive-mind/wizard.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 /**
  * Hive Mind Interactive Wizard
- * 
+ *
  * Interactive setup and management wizard for Hive Mind swarms
  * with guided workflows and visual feedback.
  */
@@ -15,7 +15,7 @@ import { HiveMind } from '../../../hive-mind/core/HiveMind.js';
 import { DatabaseManager } from '../../../hive-mind/core/DatabaseManager.js';
 import { formatSuccess, formatError, formatInfo, formatWarning } from '../../formatter.js';
 
-type WizardAction = 
+type WizardAction =
   | 'create_swarm'
   | 'manage_agents'
   | 'submit_task'
@@ -35,12 +35,12 @@ export const wizardCommand = new Command('wizard')
       if (!options.skipIntro) {
         await showIntro();
       }
-      
+
       // Main wizard loop
       let exit = false;
       while (!exit) {
         const action = await selectAction();
-        
+
         switch (action) {
           case 'create_swarm':
             await createSwarmWizard();
@@ -70,21 +70,24 @@ export const wizardCommand = new Command('wizard')
             exit = true;
             break;
         }
-        
+
         if (!exit) {
-          await inquirer.prompt([{
-            type: 'confirm',
-            name: 'continue',
-            message: 'Continue with another action?',
-            default: true
-          }]).then(answers => {
-            exit = !answers.continue;
-          });
+          await inquirer
+            .prompt([
+              {
+                type: 'confirm',
+                name: 'continue',
+                message: 'Continue with another action?',
+                default: true,
+              },
+            ])
+            .then((answers) => {
+              exit = !answers.continue;
+            });
         }
       }
-      
+
       console.log('\n' + chalk.bold.yellow('👋 Thank you for using Hive Mind!'));
-      
     } catch (error) {
       console.error(formatError('Wizard error: ' + (error as Error).message));
       process.exit(1);
@@ -96,56 +99,58 @@ async function showIntro() {
   const title = figlet.textSync('Hive Mind', {
     font: 'Big',
     horizontalLayout: 'default',
-    verticalLayout: 'default'
+    verticalLayout: 'default',
   });
-  
+
   console.log(gradient.rainbow(title));
   console.log(chalk.bold.yellow('\n🐝 Welcome to the Hive Mind Interactive Wizard! 🐝\n'));
   console.log(chalk.gray('Collective intelligence for autonomous task orchestration\n'));
-  
-  await new Promise(resolve => setTimeout(resolve, 2000));
+
+  await new Promise((resolve) => setTimeout(resolve, 2000));
 }
 
 async function selectAction(): Promise<WizardAction> {
   const db = await DatabaseManager.getInstance();
   const activeSwarm = await db.getActiveSwarmId();
-  
+
   console.log('\n' + chalk.bold('🎯 What would you like to do?'));
   if (activeSwarm) {
     console.log(chalk.gray(`Active swarm: ${activeSwarm}`));
   }
-  
-  const { action } = await inquirer.prompt([{
-    type: 'list',
-    name: 'action',
-    message: 'Select an action:',
-    choices: [
-      { name: '🆕 Create New Swarm', value: 'create_swarm' },
-      { name: '🤖 Manage Agents', value: 'manage_agents', disabled: !activeSwarm },
-      { name: '📋 Submit Task', value: 'submit_task', disabled: !activeSwarm },
-      { name: '📊 View Status', value: 'view_status', disabled: !activeSwarm },
-      { name: '💾 Configure Memory', value: 'configure_memory', disabled: !activeSwarm },
-      { name: '🎮 Run Simulation', value: 'run_simulation', disabled: !activeSwarm },
-      { name: '📤 Export Data', value: 'export_data', disabled: !activeSwarm },
-      { name: '🔄 Switch Swarm', value: 'switch_swarm' },
-      new inquirer.Separator(),
-      { name: '🚪 Exit', value: 'exit' }
-    ]
-  }]);
-  
+
+  const { action } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'action',
+      message: 'Select an action:',
+      choices: [
+        { name: '🆕 Create New Swarm', value: 'create_swarm' },
+        { name: '🤖 Manage Agents', value: 'manage_agents', disabled: !activeSwarm },
+        { name: '📋 Submit Task', value: 'submit_task', disabled: !activeSwarm },
+        { name: '📊 View Status', value: 'view_status', disabled: !activeSwarm },
+        { name: '💾 Configure Memory', value: 'configure_memory', disabled: !activeSwarm },
+        { name: '🎮 Run Simulation', value: 'run_simulation', disabled: !activeSwarm },
+        { name: '📤 Export Data', value: 'export_data', disabled: !activeSwarm },
+        { name: '🔄 Switch Swarm', value: 'switch_swarm' },
+        new inquirer.Separator(),
+        { name: '🚪 Exit', value: 'exit' },
+      ],
+    },
+  ]);
+
   return action;
 }
 
 async function createSwarmWizard() {
   console.log('\n' + chalk.bold('🆕 Create New Hive Mind Swarm'));
-  
+
   const answers = await inquirer.prompt([
     {
       type: 'input',
       name: 'name',
       message: 'Swarm name:',
       default: `hive-mind-${Date.now()}`,
-      validate: (input) => input.length > 0 || 'Name is required'
+      validate: (input) => input.length > 0 || 'Name is required',
     },
     {
       type: 'list',
@@ -155,8 +160,8 @@ async function createSwarmWizard() {
         { name: '🏛️ Hierarchical - Queen-led with clear command structure', value: 'hierarchical' },
         { name: '🕸️ Mesh - Fully connected peer-to-peer network', value: 'mesh' },
         { name: '🔄 Ring - Circular communication pattern', value: 'ring' },
-        { name: '⭐ Star - Central hub with radiating connections', value: 'star' }
-      ]
+        { name: '⭐ Star - Central hub with radiating connections', value: 'star' },
+      ],
     },
     {
       type: 'list',
@@ -164,46 +169,48 @@ async function createSwarmWizard() {
       message: 'Queen coordination mode:',
       choices: [
         { name: '👑 Centralized - Single Queen controls all decisions', value: 'centralized' },
-        { name: '🤝 Distributed - Multiple Queens share leadership', value: 'distributed' }
-      ]
+        { name: '🤝 Distributed - Multiple Queens share leadership', value: 'distributed' },
+      ],
     },
     {
       type: 'number',
       name: 'maxAgents',
       message: 'Maximum number of agents:',
       default: 8,
-      validate: (input) => input > 0 && input <= 100 || 'Must be between 1 and 100'
+      validate: (input) => (input > 0 && input <= 100) || 'Must be between 1 and 100',
     },
     {
       type: 'number',
       name: 'consensusThreshold',
       message: 'Consensus threshold (0.5 - 1.0):',
       default: 0.66,
-      validate: (input) => input >= 0.5 && input <= 1.0 || 'Must be between 0.5 and 1.0'
+      validate: (input) => (input >= 0.5 && input <= 1.0) || 'Must be between 0.5 and 1.0',
     },
     {
       type: 'confirm',
       name: 'autoSpawn',
       message: 'Auto-spawn initial agents?',
-      default: true
-    }
+      default: true,
+    },
   ]);
-  
+
   // Advanced options
-  const { showAdvanced } = await inquirer.prompt([{
-    type: 'confirm',
-    name: 'showAdvanced',
-    message: 'Configure advanced options?',
-    default: false
-  }]);
-  
+  const { showAdvanced } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'showAdvanced',
+      message: 'Configure advanced options?',
+      default: false,
+    },
+  ]);
+
   if (showAdvanced) {
     const advanced = await inquirer.prompt([
       {
         type: 'number',
         name: 'memoryTTL',
         message: 'Default memory TTL (seconds):',
-        default: 86400
+        default: 86400,
       },
       {
         type: 'checkbox',
@@ -214,17 +221,17 @@ async function createSwarmWizard() {
           { name: 'Performance Monitoring', value: 'monitoring', checked: true },
           { name: 'Auto-scaling', value: 'autoscale', checked: false },
           { name: 'Fault Tolerance', value: 'faultTolerance', checked: true },
-          { name: 'Predictive Task Assignment', value: 'predictive', checked: false }
-        ]
-      }
+          { name: 'Predictive Task Assignment', value: 'predictive', checked: false },
+        ],
+      },
     ]);
-    
+
     Object.assign(answers, advanced);
   }
-  
+
   // Create swarm
   const spinner = require('ora')('Creating Hive Mind swarm...').start();
-  
+
   try {
     const hiveMind = new HiveMind({
       name: answers.name,
@@ -235,19 +242,18 @@ async function createSwarmWizard() {
       consensusThreshold: answers.consensusThreshold,
       autoSpawn: answers.autoSpawn,
       enabledFeatures: answers.enabledFeatures || ['neural', 'monitoring', 'faultTolerance'],
-      createdAt: new Date()
+      createdAt: new Date(),
     });
-    
+
     const swarmId = await hiveMind.initialize();
-    
+
     spinner.succeed(formatSuccess('Hive Mind created successfully!'));
     console.log(formatInfo(`Swarm ID: ${swarmId}`));
-    
+
     if (answers.autoSpawn) {
       const agents = await hiveMind.autoSpawnAgents();
       console.log(formatSuccess(`Spawned ${agents.length} initial agents`));
     }
-    
   } catch (error) {
     spinner.fail(formatError('Failed to create swarm'));
     throw error;
@@ -256,24 +262,26 @@ async function createSwarmWizard() {
 
 async function manageAgentsWizard() {
   console.log('\n' + chalk.bold('🤖 Manage Agents'));
-  
-  const { action } = await inquirer.prompt([{
-    type: 'list',
-    name: 'action',
-    message: 'What would you like to do?',
-    choices: [
-      { name: '➕ Spawn New Agent', value: 'spawn' },
-      { name: '📊 View Agent List', value: 'list' },
-      { name: '🔧 Modify Agent', value: 'modify' },
-      { name: '🗑️ Remove Agent', value: 'remove' },
-      { name: '🔄 Rebalance Agents', value: 'rebalance' }
-    ]
-  }]);
-  
+
+  const { action } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'action',
+      message: 'What would you like to do?',
+      choices: [
+        { name: '➕ Spawn New Agent', value: 'spawn' },
+        { name: '📊 View Agent List', value: 'list' },
+        { name: '🔧 Modify Agent', value: 'modify' },
+        { name: '🗑️ Remove Agent', value: 'remove' },
+        { name: '🔄 Rebalance Agents', value: 'rebalance' },
+      ],
+    },
+  ]);
+
   const db = await DatabaseManager.getInstance();
   const swarmId = await db.getActiveSwarmId();
   const hiveMind = await HiveMind.load(swarmId!);
-  
+
   switch (action) {
     case 'spawn':
       await spawnAgentInteractive(hiveMind);
@@ -305,45 +313,44 @@ async function spawnAgentInteractive(hiveMind: HiveMind) {
     { name: '⚡ Optimizer - Performance optimization', value: 'optimizer' },
     { name: '📝 Documenter - Documentation generation', value: 'documenter' },
     { name: '📡 Monitor - System monitoring and alerts', value: 'monitor' },
-    { name: '🎨 Specialist - Custom specialized agent', value: 'specialist' }
+    { name: '🎨 Specialist - Custom specialized agent', value: 'specialist' },
   ];
-  
+
   const answers = await inquirer.prompt([
     {
       type: 'list',
       name: 'type',
       message: 'Select agent type:',
-      choices: agentTypes
+      choices: agentTypes,
     },
     {
       type: 'input',
       name: 'name',
       message: 'Agent name (optional):',
-      default: (answers: any) => `${answers.type}-${Date.now()}`
+      default: (answers: any) => `${answers.type}-${Date.now()}`,
     },
     {
       type: 'number',
       name: 'count',
       message: 'How many agents to spawn?',
       default: 1,
-      validate: (input) => input > 0 && input <= 10 || 'Must be between 1 and 10'
-    }
+      validate: (input) => (input > 0 && input <= 10) || 'Must be between 1 and 10',
+    },
   ]);
-  
+
   const spinner = require('ora')(`Spawning ${answers.count} ${answers.type} agent(s)...`).start();
-  
+
   try {
     const agents = [];
     for (let i = 0; i < answers.count; i++) {
       const agent = await hiveMind.spawnAgent({
         type: answers.type,
-        name: answers.count > 1 ? `${answers.name}-${i}` : answers.name
+        name: answers.count > 1 ? `${answers.name}-${i}` : answers.name,
       });
       agents.push(agent);
     }
-    
+
     spinner.succeed(formatSuccess(`Spawned ${agents.length} agent(s) successfully!`));
-    
   } catch (error) {
     spinner.fail(formatError('Failed to spawn agents'));
     throw error;
@@ -352,37 +359,39 @@ async function spawnAgentInteractive(hiveMind: HiveMind) {
 
 async function submitTaskWizard() {
   console.log('\n' + chalk.bold('📋 Submit Task to Hive Mind'));
-  
+
   const db = await DatabaseManager.getInstance();
   const swarmId = await db.getActiveSwarmId();
   const hiveMind = await HiveMind.load(swarmId!);
-  
+
   const templates = [
     { name: '🔍 Research Task', value: 'research' },
     { name: '💻 Development Task', value: 'development' },
     { name: '📊 Analysis Task', value: 'analysis' },
     { name: '🧪 Testing Task', value: 'testing' },
     { name: '📝 Documentation Task', value: 'documentation' },
-    { name: '✏️ Custom Task', value: 'custom' }
+    { name: '✏️ Custom Task', value: 'custom' },
   ];
-  
-  const { template } = await inquirer.prompt([{
-    type: 'list',
-    name: 'template',
-    message: 'Select task template:',
-    choices: templates
-  }]);
-  
+
+  const { template } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'template',
+      message: 'Select task template:',
+      choices: templates,
+    },
+  ]);
+
   let taskDescription = '';
   let taskConfig: any = {};
-  
+
   if (template === 'custom') {
     const answers = await inquirer.prompt([
       {
         type: 'editor',
         name: 'description',
-        message: 'Enter task description:'
-      }
+        message: 'Enter task description:',
+      },
     ]);
     taskDescription = answers.description;
   } else {
@@ -390,36 +399,38 @@ async function submitTaskWizard() {
     const templates = {
       research: {
         prompt: 'What would you like to research?',
-        prefix: 'Research and analyze: '
+        prefix: 'Research and analyze: ',
       },
       development: {
         prompt: 'What would you like to develop?',
-        prefix: 'Develop and implement: '
+        prefix: 'Develop and implement: ',
       },
       analysis: {
         prompt: 'What would you like to analyze?',
-        prefix: 'Analyze and provide insights on: '
+        prefix: 'Analyze and provide insights on: ',
       },
       testing: {
         prompt: 'What would you like to test?',
-        prefix: 'Test and validate: '
+        prefix: 'Test and validate: ',
       },
       documentation: {
         prompt: 'What would you like to document?',
-        prefix: 'Create documentation for: '
-      }
+        prefix: 'Create documentation for: ',
+      },
     };
-    
+
     const tmpl = templates[template as keyof typeof templates];
-    const { detail } = await inquirer.prompt([{
-      type: 'input',
-      name: 'detail',
-      message: tmpl.prompt
-    }]);
-    
+    const { detail } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'detail',
+        message: tmpl.prompt,
+      },
+    ]);
+
     taskDescription = tmpl.prefix + detail;
   }
-  
+
   // Task configuration
   const config = await inquirer.prompt([
     {
@@ -430,9 +441,9 @@ async function submitTaskWizard() {
         { name: '🟢 Low', value: 'low' },
         { name: '🟡 Medium', value: 'medium' },
         { name: '🟠 High', value: 'high' },
-        { name: '🔴 Critical', value: 'critical' }
+        { name: '🔴 Critical', value: 'critical' },
       ],
-      default: 'medium'
+      default: 'medium',
     },
     {
       type: 'list',
@@ -442,35 +453,34 @@ async function submitTaskWizard() {
         { name: '🤖 Adaptive (AI-optimized)', value: 'adaptive' },
         { name: '⚡ Parallel (Multiple agents)', value: 'parallel' },
         { name: '📍 Sequential (Step-by-step)', value: 'sequential' },
-        { name: '🤝 Consensus (Requires agreement)', value: 'consensus' }
+        { name: '🤝 Consensus (Requires agreement)', value: 'consensus' },
       ],
-      default: 'adaptive'
+      default: 'adaptive',
     },
     {
       type: 'confirm',
       name: 'monitor',
       message: 'Monitor task progress?',
-      default: true
-    }
+      default: true,
+    },
   ]);
-  
+
   const spinner = require('ora')('Submitting task...').start();
-  
+
   try {
     const task = await hiveMind.submitTask({
       description: taskDescription,
       priority: config.priority,
-      strategy: config.strategy
+      strategy: config.strategy,
     });
-    
+
     spinner.succeed(formatSuccess('Task submitted successfully!'));
     console.log(formatInfo(`Task ID: ${task.id}`));
-    
+
     if (config.monitor) {
       console.log('\n' + chalk.bold('Monitoring task progress...'));
       // TODO: Implement real-time monitoring
     }
-    
   } catch (error) {
     spinner.fail(formatError('Failed to submit task'));
     throw error;
@@ -478,24 +488,26 @@ async function submitTaskWizard() {
 }
 
 async function viewStatusWizard() {
-  const { view } = await inquirer.prompt([{
-    type: 'list',
-    name: 'view',
-    message: 'What would you like to view?',
-    choices: [
-      { name: '📊 Overall Status', value: 'overall' },
-      { name: '🤖 Agent Details', value: 'agents' },
-      { name: '📋 Task Queue', value: 'tasks' },
-      { name: '💾 Memory Usage', value: 'memory' },
-      { name: '📈 Performance Metrics', value: 'performance' },
-      { name: '📡 Communications', value: 'communications' }
-    ]
-  }]);
-  
+  const { view } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'view',
+      message: 'What would you like to view?',
+      choices: [
+        { name: '📊 Overall Status', value: 'overall' },
+        { name: '🤖 Agent Details', value: 'agents' },
+        { name: '📋 Task Queue', value: 'tasks' },
+        { name: '💾 Memory Usage', value: 'memory' },
+        { name: '📈 Performance Metrics', value: 'performance' },
+        { name: '📡 Communications', value: 'communications' },
+      ],
+    },
+  ]);
+
   // Execute the status command with appropriate flags
   const statusCmd = require('./status').statusCommand;
   const args = ['status'];
-  
+
   switch (view) {
     case 'agents':
       args.push('--detailed');
@@ -510,16 +522,16 @@ async function viewStatusWizard() {
       args.push('--performance');
       break;
   }
-  
+
   await statusCmd.parseAsync(args);
 }
 
 // Helper functions for other wizard actions
 async function listAgentsInteractive(hiveMind: HiveMind) {
   const agents = await hiveMind.getAgents();
-  
+
   console.log('\n' + chalk.bold('🤖 Agent List:'));
-  agents.forEach(agent => {
+  agents.forEach((agent) => {
     const statusEmoji = agent.status === 'busy' ? '🔴' : '🟢';
     console.log(`${statusEmoji} ${agent.name} (${agent.type}) - ${agent.status}`);
   });
@@ -537,7 +549,7 @@ async function removeAgentInteractive(hiveMind: HiveMind) {
 
 async function rebalanceAgentsInteractive(hiveMind: HiveMind) {
   const spinner = require('ora')('Rebalancing agents...').start();
-  
+
   try {
     await hiveMind.rebalanceAgents();
     spinner.succeed(formatSuccess('Agents rebalanced successfully!'));
@@ -562,22 +574,24 @@ async function exportDataWizard() {
 async function switchSwarmWizard() {
   const db = await DatabaseManager.getInstance();
   const swarms = await db.getAllSwarms();
-  
+
   if (swarms.length === 0) {
     console.log(formatWarning('No swarms found. Create one first!'));
     return;
   }
-  
-  const { swarmId } = await inquirer.prompt([{
-    type: 'list',
-    name: 'swarmId',
-    message: 'Select swarm:',
-    choices: swarms.map(s => ({
-      name: `${s.name} (${s.topology}) - ${s.agentCount} agents`,
-      value: s.id
-    }))
-  }]);
-  
+
+  const { swarmId } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'swarmId',
+      message: 'Select swarm:',
+      choices: swarms.map((s) => ({
+        name: `${s.name} (${s.topology}) - ${s.agentCount} agents`,
+        value: s.id,
+      })),
+    },
+  ]);
+
   await db.setActiveSwarm(swarmId);
   console.log(formatSuccess('Switched to swarm: ' + swarmId));
-}
+}