claude-flow/src/cli/commands/hive-mind/wizard.ts

Enterprise-grade AI agent orchestration with ruv-swarm integration (Alpha Release)

#!/usr/bin/env node
/**
 * Hive Mind Interactive Wizard
 * 
 * Interactive setup and management wizard for Hive Mind swarms
 * with guided workflows and visual feedback.
 */

import { Command } from 'commander';
import chalk from 'chalk';
import inquirer from 'inquirer';
import figlet from 'figlet';
import gradient from 'gradient-string';
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 = 
  | 'create_swarm'
  | 'manage_agents'
  | 'submit_task'
  | 'view_status'
  | 'configure_memory'
  | 'run_simulation'
  | 'export_data'
  | 'switch_swarm'
  | 'exit';

export const wizardCommand = new Command('wizard')
  .description('Interactive Hive Mind setup and management wizard')
  .option('--skip-intro', 'Skip the intro animation', false)
  .action(async (options) => {
    try {
      // Show intro
      if (!options.skipIntro) {
        await showIntro();
      }
      
      // Main wizard loop
      let exit = false;
      while (!exit) {
        const action = await selectAction();
        
        switch (action) {
          case 'create_swarm':
            await createSwarmWizard();
            break;
          case 'manage_agents':
            await manageAgentsWizard();
            break;
          case 'submit_task':
            await submitTaskWizard();
            break;
          case 'view_status':
            await viewStatusWizard();
            break;
          case 'configure_memory':
            await configureMemoryWizard();
            break;
          case 'run_simulation':
            await runSimulationWizard();
            break;
          case 'export_data':
            await exportDataWizard();
            break;
          case 'switch_swarm':
            await switchSwarmWizard();
            break;
          case 'exit':
            exit = true;
            break;
        }
        
        if (!exit) {
          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);
    }
  });

async function showIntro() {
  console.clear();
  const title = figlet.textSync('Hive Mind', {
    font: 'Big',
    horizontalLayout: '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));
}

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' }
    ]
  }]);
  
  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'
    },
    {
      type: 'list',
      name: 'topology',
      message: 'Select swarm topology:',
      choices: [
        { 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' }
      ]
    },
    {
      type: 'list',
      name: 'queenMode',
      message: 'Queen coordination mode:',
      choices: [
        { name: '👑 Centralized - Single Queen controls all decisions', value: 'centralized' },
        { 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'
    },
    {
      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'
    },
    {
      type: 'confirm',
      name: 'autoSpawn',
      message: 'Auto-spawn initial agents?',
      default: true
    }
  ]);
  
  // Advanced options
  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
      },
      {
        type: 'checkbox',
        name: 'enabledFeatures',
        message: 'Enable features:',
        choices: [
          { name: 'Neural Learning', value: 'neural', checked: true },
          { 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 }
        ]
      }
    ]);
    
    Object.assign(answers, advanced);
  }
  
  // Create swarm
  const spinner = require('ora')('Creating Hive Mind swarm...').start();
  
  try {
    const hiveMind = new HiveMind({
      name: answers.name,
      topology: answers.topology,
      maxAgents: answers.maxAgents,
      queenMode: answers.queenMode,
      memoryTTL: answers.memoryTTL || 86400,
      consensusThreshold: answers.consensusThreshold,
      autoSpawn: answers.autoSpawn,
      enabledFeatures: answers.enabledFeatures || ['neural', 'monitoring', 'faultTolerance'],
      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;
  }
}

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 db = await DatabaseManager.getInstance();
  const swarmId = await db.getActiveSwarmId();
  const hiveMind = await HiveMind.load(swarmId!);
  
  switch (action) {
    case 'spawn':
      await spawnAgentInteractive(hiveMind);
      break;
    case 'list':
      await listAgentsInteractive(hiveMind);
      break;
    case 'modify':
      await modifyAgentInteractive(hiveMind);
      break;
    case 'remove':
      await removeAgentInteractive(hiveMind);
      break;
    case 'rebalance':
      await rebalanceAgentsInteractive(hiveMind);
      break;
  }
}

async function spawnAgentInteractive(hiveMind: HiveMind) {
  const agentTypes = [
    { name: '🎯 Coordinator - Task management and delegation', value: 'coordinator' },
    { name: '🔬 Researcher - Information gathering and analysis', value: 'researcher' },
    { name: '💻 Coder - Code generation and implementation', value: 'coder' },
    { name: '📊 Analyst - Data analysis and insights', value: 'analyst' },
    { name: '🏗️ Architect - System design and planning', value: 'architect' },
    { name: '🧪 Tester - Quality assurance and testing', value: 'tester' },
    { name: '👁️ Reviewer - Code and design review', value: 'reviewer' },
    { 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' }
  ];
  
  const answers = await inquirer.prompt([
    {
      type: 'list',
      name: 'type',
      message: 'Select agent type:',
      choices: agentTypes
    },
    {
      type: 'input',
      name: 'name',
      message: 'Agent name (optional):',
      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'
    }
  ]);
  
  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
      });
      agents.push(agent);
    }
    
    spinner.succeed(formatSuccess(`Spawned ${agents.length} agent(s) successfully!`));
    
  } catch (error) {
    spinner.fail(formatError('Failed to spawn agents'));
    throw error;
  }
}

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' }
  ];
  
  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:'
      }
    ]);
    taskDescription = answers.description;
  } else {
    // Use predefined templates
    const templates = {
      research: {
        prompt: 'What would you like to research?',
        prefix: 'Research and analyze: '
      },
      development: {
        prompt: 'What would you like to develop?',
        prefix: 'Develop and implement: '
      },
      analysis: {
        prompt: 'What would you like to analyze?',
        prefix: 'Analyze and provide insights on: '
      },
      testing: {
        prompt: 'What would you like to test?',
        prefix: 'Test and validate: '
      },
      documentation: {
        prompt: 'What would you like to document?',
        prefix: 'Create documentation for: '
      }
    };
    
    const tmpl = templates[template as keyof typeof templates];
    const { detail } = await inquirer.prompt([{
      type: 'input',
      name: 'detail',
      message: tmpl.prompt
    }]);
    
    taskDescription = tmpl.prefix + detail;
  }
  
  // Task configuration
  const config = await inquirer.prompt([
    {
      type: 'list',
      name: 'priority',
      message: 'Task priority:',
      choices: [
        { name: '🟢 Low', value: 'low' },
        { name: '🟡 Medium', value: 'medium' },
        { name: '🟠 High', value: 'high' },
        { name: '🔴 Critical', value: 'critical' }
      ],
      default: 'medium'
    },
    {
      type: 'list',
      name: 'strategy',
      message: 'Execution strategy:',
      choices: [
        { 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' }
      ],
      default: 'adaptive'
    },
    {
      type: 'confirm',
      name: 'monitor',
      message: 'Monitor task progress?',
      default: true
    }
  ]);
  
  const spinner = require('ora')('Submitting task...').start();
  
  try {
    const task = await hiveMind.submitTask({
      description: taskDescription,
      priority: config.priority,
      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;
  }
}

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' }
    ]
  }]);
  
  // Execute the status command with appropriate flags
  const statusCmd = require('./status').statusCommand;
  const args = ['status'];
  
  switch (view) {
    case 'agents':
      args.push('--detailed');
      break;
    case 'tasks':
      args.push('--tasks');
      break;
    case 'memory':
      args.push('--memory');
      break;
    case 'performance':
      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 => {
    const statusEmoji = agent.status === 'busy' ? '🔴' : '🟢';
    console.log(`${statusEmoji} ${agent.name} (${agent.type}) - ${agent.status}`);
  });
}

async function modifyAgentInteractive(hiveMind: HiveMind) {
  // Implementation for modifying agents
  console.log(formatInfo('Agent modification coming soon...'));
}

async function removeAgentInteractive(hiveMind: HiveMind) {
  // Implementation for removing agents
  console.log(formatInfo('Agent removal coming soon...'));
}

async function rebalanceAgentsInteractive(hiveMind: HiveMind) {
  const spinner = require('ora')('Rebalancing agents...').start();
  
  try {
    await hiveMind.rebalanceAgents();
    spinner.succeed(formatSuccess('Agents rebalanced successfully!'));
  } catch (error) {
    spinner.fail(formatError('Failed to rebalance agents'));
    throw error;
  }
}

async function configureMemoryWizard() {
  console.log(formatInfo('Memory configuration coming soon...'));
}

async function runSimulationWizard() {
  console.log(formatInfo('Simulation mode coming soon...'));
}

async function exportDataWizard() {
  console.log(formatInfo('Data export coming soon...'));
}

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
    }))
  }]);
  
  await db.setActiveSwarm(swarmId);
  console.log(formatSuccess('Switched to swarm: ' + swarmId));
}