claude-flow-novice 1.3.0 → 1.3.2

package/src/cli/simple-commands/hive-mind-optimize.js

@@ -0,0 +1,361 @@
+/**
+ * Hive Mind Database Optimization Command
+ *
+ * Safe optimization of existing hive mind databases without breaking compatibility
+ */
+
+import { cwd, exit } from '../node-compat.js';
+import path from 'path';
+import { existsSync } from 'fs';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import {
+  optimizeHiveMindDatabase,
+  performMaintenance,
+  generateOptimizationReport,
+} from './hive-mind/db-optimizer.js';
+
+/**
+ * Show help for hive-mind-optimize command
+ */
+function showOptimizeHelp() {
+  console.log(`
+${chalk.yellow('🔧 Hive Mind Database Optimization')}
+
+${chalk.bold('USAGE:')}
+  claude-flow hive-mind-optimize [options]
+
+${chalk.bold('OPTIONS:')}
+  --auto              Run optimization without prompts
+  --vacuum            Vacuum database (requires exclusive access)
+  --clean-memory      Clean old memory entries
+  --archive-tasks     Archive completed tasks
+  --check-integrity   Run integrity check
+  --report            Generate optimization report only
+  --memory-days <n>   Memory retention days (default: 30)
+  --task-days <n>     Task retention days (default: 7)
+  --verbose           Show detailed output
+
+${chalk.bold('EXAMPLES:')}
+  ${chalk.gray('# Interactive optimization')}
+  claude-flow hive-mind-optimize
+
+  ${chalk.gray('# Auto-optimize with all features')}
+  claude-flow hive-mind-optimize --auto --vacuum --clean-memory --archive-tasks
+
+  ${chalk.gray('# Generate report only')}
+  claude-flow hive-mind-optimize --report
+
+  ${chalk.gray('# Custom retention periods')}
+  claude-flow hive-mind-optimize --clean-memory --memory-days 60 --task-days 14
+
+${chalk.bold('FEATURES:')}
+  ${chalk.cyan('🚀')} Performance indexes for faster queries
+  ${chalk.cyan('📊')} Query optimization and statistics
+  ${chalk.cyan('🧹')} Memory cleanup and archiving
+  ${chalk.cyan('📈')} Performance tracking tables
+  ${chalk.cyan('🔍')} Behavioral pattern analysis
+  ${chalk.cyan('💾')} Backward-compatible upgrades
+
+${chalk.bold('SAFETY:')}
+  • All changes are backward-compatible
+  • Existing data is preserved
+  • Automatic backups before major operations
+  • Rollback capability on errors
+`);
+}
+
+/**
+ * Main optimization command handler
+ */
+export async function hiveMindOptimizeCommand(args, flags) {
+  // Show help if requested
+  if (flags.help || flags.h) {
+    showOptimizeHelp();
+    return;
+  }
+
+  // Check if hive mind is initialized
+  const hiveMindDir = path.join(cwd(), '.hive-mind');
+  const dbPath = path.join(hiveMindDir, 'hive.db');
+
+  if (!existsSync(dbPath)) {
+    console.error(chalk.red('Error: Hive Mind database not found'));
+    console.log('Run "claude-flow hive-mind init" first');
+    exit(1);
+  }
+
+  // Generate report only
+  if (flags.report) {
+    await generateReport(dbPath);
+    return;
+  }
+
+  // Auto mode or interactive
+  if (flags.auto) {
+    await runOptimization(dbPath, {
+      vacuum: flags.vacuum || false,
+      cleanMemory: flags['clean-memory'] || false,
+      archiveTasks: flags['archive-tasks'] || false,
+      checkIntegrity: flags['check-integrity'] || false,
+      memoryRetentionDays: flags['memory-days'] || 30,
+      taskRetentionDays: flags['task-days'] || 7,
+      verbose: flags.verbose || false,
+    });
+  } else {
+    await interactiveOptimization(dbPath, flags);
+  }
+}
+
+/**
+ * Interactive optimization wizard
+ */
+async function interactiveOptimization(dbPath, flags) {
+  console.log(chalk.yellow('\n🔧 Hive Mind Database Optimization Wizard\n'));
+
+  // Generate current report
+  const report = await generateOptimizationReport(dbPath);
+
+  if (report) {
+    console.log(chalk.cyan('Current Database Status:'));
+    console.log(`  Schema Version: ${report.schemaVersion}`);
+    console.log(`  Tables: ${Object.keys(report.tables).length}`);
+    console.log(`  Indexes: ${report.indexes.length}`);
+
+    let totalSize = 0;
+    let totalRows = 0;
+    Object.entries(report.tables).forEach(([name, stats]) => {
+      totalSize += stats.sizeBytes;
+      totalRows += stats.rowCount;
+    });
+
+    console.log(`  Total Size: ${(totalSize / 1024 / 1024).toFixed(2)} MB`);
+    console.log(`  Total Rows: ${totalRows.toLocaleString()}`);
+    console.log('');
+  }
+
+  // Check what optimizations are needed
+  const schemaVersion = report?.schemaVersion || 1.0;
+  const needsOptimization = schemaVersion < 1.5;
+
+  if (!needsOptimization) {
+    console.log(chalk.green('✓ Database is already fully optimized!\n'));
+
+    const { maintenance } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'maintenance',
+        message: 'Would you like to perform maintenance tasks?',
+        default: true,
+      },
+    ]);
+
+    if (!maintenance) {
+      console.log(chalk.gray('No changes made.'));
+      return;
+    }
+  } else {
+    console.log(
+      chalk.yellow(`⚠ Database can be optimized from version ${schemaVersion} to 1.5\n`),
+    );
+  }
+
+  // Ask for optimization options
+  const answers = await inquirer.prompt([
+    {
+      type: 'checkbox',
+      name: 'operations',
+      message: 'Select operations to perform:',
+      choices: [
+        {
+          name: 'Apply performance optimizations',
+          value: 'optimize',
+          checked: needsOptimization,
+          disabled: !needsOptimization,
+        },
+        {
+          name: 'Clean old memory entries',
+          value: 'cleanMemory',
+          checked: true,
+        },
+        {
+          name: 'Archive completed tasks',
+          value: 'archiveTasks',
+          checked: true,
+        },
+        {
+          name: 'Vacuum database (requires exclusive access)',
+          value: 'vacuum',
+          checked: false,
+        },
+        {
+          name: 'Check database integrity',
+          value: 'checkIntegrity',
+          checked: true,
+        },
+      ],
+    },
+    {
+      type: 'number',
+      name: 'memoryDays',
+      message: 'Memory retention days:',
+      default: 30,
+      when: (answers) => answers.operations.includes('cleanMemory'),
+    },
+    {
+      type: 'number',
+      name: 'taskDays',
+      message: 'Task retention days:',
+      default: 7,
+      when: (answers) => answers.operations.includes('archiveTasks'),
+    },
+    {
+      type: 'confirm',
+      name: 'confirm',
+      message: 'Proceed with optimization?',
+      default: true,
+    },
+  ]);
+
+  if (!answers.confirm) {
+    console.log(chalk.gray('Optimization cancelled.'));
+    return;
+  }
+
+  // Create backup if doing major operations
+  if (answers.operations.includes('optimize') || answers.operations.includes('vacuum')) {
+    console.log(chalk.blue('\n📦 Creating backup...'));
+    await createBackup(dbPath);
+  }
+
+  // Run optimization
+  const options = {
+    vacuum: answers.operations.includes('vacuum'),
+    cleanMemory: answers.operations.includes('cleanMemory'),
+    archiveTasks: answers.operations.includes('archiveTasks'),
+    checkIntegrity: answers.operations.includes('checkIntegrity'),
+    memoryRetentionDays: answers.memoryDays || 30,
+    taskRetentionDays: answers.taskDays || 7,
+    verbose: flags.verbose || false,
+  };
+
+  await runOptimization(dbPath, options);
+}
+
+/**
+ * Run database optimization
+ */
+async function runOptimization(dbPath, options) {
+  console.log(chalk.blue('\n🚀 Starting optimization...\n'));
+
+  // Run schema optimization
+  const result = await optimizeHiveMindDatabase(dbPath, options);
+
+  if (!result.success) {
+    console.error(chalk.red('\n❌ Optimization failed:', result.error));
+    exit(1);
+  }
+
+  // Run maintenance tasks
+  if (options.cleanMemory || options.archiveTasks || options.checkIntegrity) {
+    console.log(chalk.blue('\n🧹 Running maintenance tasks...\n'));
+    await performMaintenance(dbPath, options);
+  }
+
+  // Generate final report
+  console.log(chalk.blue('\n📊 Generating optimization report...\n'));
+  await generateReport(dbPath);
+
+  console.log(chalk.green('\n✅ Optimization complete!\n'));
+
+  // Show tips
+  console.log(chalk.bold('💡 Tips:'));
+  console.log('  • Monitor performance with: claude-flow hive-mind metrics');
+  console.log('  • Schedule regular maintenance: claude-flow hive-mind-optimize --auto');
+  console.log('  • Check swarm status: claude-flow hive-mind status');
+}
+
+/**
+ * Generate and display optimization report
+ */
+async function generateReport(dbPath) {
+  const report = await generateOptimizationReport(dbPath);
+
+  if (!report) {
+    console.error(chalk.red('Failed to generate report'));
+    return;
+  }
+
+  console.log(chalk.bold('\n📊 Database Optimization Report\n'));
+  console.log(chalk.cyan('Schema Version:'), report.schemaVersion);
+  console.log(chalk.cyan('Indexes:'), report.indexes.length);
+
+  console.log(chalk.cyan('\nTable Statistics:'));
+  Object.entries(report.tables).forEach(([name, stats]) => {
+    const sizeMB = (stats.sizeBytes / 1024 / 1024).toFixed(2);
+    console.log(`  ${name}: ${stats.rowCount.toLocaleString()} rows (${sizeMB} MB)`);
+  });
+
+  if (report.performance.avgTaskCompletionMinutes > 0) {
+    console.log(chalk.cyan('\nPerformance Metrics:'));
+    console.log(
+      `  Avg Task Completion: ${report.performance.avgTaskCompletionMinutes.toFixed(1)} minutes`,
+    );
+  }
+
+  // Optimization suggestions
+  console.log(chalk.cyan('\nOptimization Status:'));
+  if (report.schemaVersion >= 1.5) {
+    console.log(chalk.green('  ✓ Database is fully optimized'));
+  } else {
+    console.log(chalk.yellow(`  ⚠ Can be upgraded from v${report.schemaVersion} to v1.5`));
+    console.log(chalk.gray('    Run: claude-flow hive-mind-optimize'));
+  }
+
+  // Check for large tables
+  const largeMemoryTable = report.tables.collective_memory?.rowCount > 10000;
+  const largeTaskTable = report.tables.tasks?.rowCount > 50000;
+
+  if (largeMemoryTable || largeTaskTable) {
+    console.log(chalk.cyan('\nMaintenance Recommendations:'));
+    if (largeMemoryTable) {
+      console.log(chalk.yellow('  • Consider cleaning old memory entries'));
+    }
+    if (largeTaskTable) {
+      console.log(chalk.yellow('  • Consider archiving completed tasks'));
+    }
+  }
+}
+
+/**
+ * Create database backup
+ */
+async function createBackup(dbPath) {
+  try {
+    const { execSync } = await import('child_process');
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const backupPath = dbPath.replace('.db', `-backup-${timestamp}.db`);
+
+    execSync(`cp "${dbPath}" "${backupPath}"`);
+    console.log(chalk.green(`✓ Backup created: ${path.basename(backupPath)}`));
+
+    return backupPath;
+  } catch (error) {
+    console.error(chalk.yellow('⚠ Backup failed:', error.message));
+    const { proceed } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'proceed',
+        message: 'Continue without backup?',
+        default: false,
+      },
+    ]);
+
+    if (!proceed) {
+      exit(1);
+    }
+  }
+}
+
+// Export for CLI
+export default hiveMindOptimizeCommand;

package/src/cli/simple-commands/hive-mind-wizard.js

@@ -0,0 +1,281 @@
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs');
+const Database = require('better-sqlite3');
+
+// Interactive Wizard Implementation
+async function runInteractiveWizard() {
+  console.log(chalk.blue.bold('🐝 Welcome to the Hive Mind Setup Wizard!'));
+  console.log(chalk.gray('This wizard will help you create your first intelligent AI swarm.\n'));
+
+  try {
+    // Check if system is initialized
+    const configPath = path.join(process.cwd(), '.hive-mind', 'config.json');
+    let config = { initialized: false };
+
+    if (fs.existsSync(configPath)) {
+      config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    }
+
+    if (!config.initialized) {
+      console.log(chalk.yellow('📋 Step 1: Initializing Hive Mind System...'));
+      await initializeHiveMind();
+      console.log(chalk.green('✅ Hive Mind system initialized!\n'));
+    } else {
+      console.log(chalk.green('✅ Hive Mind system already initialized!\n'));
+    }
+
+    // Guided objective input
+    console.log(chalk.blue('📋 Step 2: Define Your Objective'));
+    console.log(chalk.gray('What would you like your Hive Mind swarm to accomplish?'));
+    console.log(chalk.gray('Examples:'));
+    console.log(chalk.gray('  • "Build a REST API for user management"'));
+    console.log(chalk.gray('  • "Research and analyze market trends"'));
+    console.log(chalk.gray('  • "Optimize database performance"'));
+    console.log(chalk.gray('  • "Create comprehensive test suite"\n'));
+
+    const objective = 'Build a modern web application'; // Placeholder for demo
+    console.log(chalk.cyan(`💡 Using example objective: "${objective}"`));
+    console.log(chalk.gray('(In full wizard, this would be interactive input)\n'));
+
+    // Configuration selection
+    console.log(chalk.blue('📋 Step 3: Choose Configuration'));
+    console.log(chalk.gray('Based on your objective, here are recommended settings:\n'));
+
+    const swarmConfig = {
+      topology: 'hierarchical',
+      coordination: 'queen',
+      agents: 5,
+      complexity: 'medium',
+    };
+
+    console.log(chalk.cyan('📊 Recommended Configuration:'));
+    console.log(chalk.gray(`  • Topology: ${swarmConfig.topology} (best for structured tasks)`));
+    console.log(
+      chalk.gray(`  • Coordination: ${swarmConfig.coordination} (fastest decision making)`),
+    );
+    console.log(
+      chalk.gray(`  • Agent Count: ${swarmConfig.agents} (optimal for medium complexity)`),
+    );
+    console.log(chalk.gray(`  • Complexity: ${swarmConfig.complexity}\n`));
+
+    // Create the swarm
+    console.log(chalk.blue('📋 Step 4: Creating Your Swarm...'));
+    console.log(chalk.gray('🔄 Spawning intelligent agents...'));
+
+    const result = await createSwarm(objective, swarmConfig);
+
+    if (result.success) {
+      console.log(chalk.green('🎉 Swarm created successfully!\n'));
+
+      console.log(chalk.blue.bold('🐝 Your Hive Mind is Ready!'));
+      console.log(chalk.gray('Your intelligent swarm has been created and is ready to work.\n'));
+
+      console.log(chalk.cyan('📱 Next Steps:'));
+      console.log(chalk.gray('  • View status: claude-flow hive-mind status'));
+      console.log(chalk.gray('  • Monitor progress: claude-flow hive-mind metrics'));
+      console.log(chalk.gray('  • Create another swarm: claude-flow hive-mind wizard'));
+      console.log(chalk.gray('  • Learn more: claude-flow help hive-mind\n'));
+
+      console.log(chalk.green.bold('🚀 Happy swarming!'));
+    } else {
+      console.log(chalk.red('❌ Failed to create swarm. Please try again.'));
+    }
+  } catch (error) {
+    console.log(chalk.red(`❌ Wizard error: ${error.message}`));
+    console.log(chalk.gray('You can try manual setup with: claude-flow hive-mind init'));
+  }
+}
+
+// Initialize Hive Mind system
+async function initializeHiveMind() {
+  const hiveMindDir = path.join(process.cwd(), '.hive-mind');
+
+  // Create directory if it doesn't exist
+  if (!fs.existsSync(hiveMindDir)) {
+    fs.mkdirSync(hiveMindDir, { recursive: true });
+  }
+
+  // Create configuration file
+  const config = {
+    version: '2.0.0',
+    initialized: new Date().toISOString(),
+    defaults: {
+      queenType: 'strategic',
+      maxWorkers: 8,
+      consensusAlgorithm: 'majority',
+      memorySize: 100,
+      autoScale: true,
+      encryption: false,
+    },
+    mcpTools: {
+      enabled: true,
+      parallel: true,
+      timeout: 60000,
+    },
+  };
+
+  const configPath = path.join(hiveMindDir, 'config.json');
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+
+  // Initialize SQLite database
+  const dbPath = path.join(hiveMindDir, 'hive.db');
+  const db = new sqlite3.Database(dbPath);
+
+  await new Promise((resolve, reject) => {
+    db.serialize(() => {
+      // Create tables
+      db.run(`
+                CREATE TABLE IF NOT EXISTS swarms (
+                    id TEXT PRIMARY KEY,
+                    name TEXT NOT NULL,
+                    objective TEXT,
+                    status TEXT DEFAULT 'active',
+                    queen_type TEXT DEFAULT 'strategic',
+                    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+                    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+                )
+            `);
+
+      db.run(`
+                CREATE TABLE IF NOT EXISTS agents (
+                    id TEXT PRIMARY KEY,
+                    swarm_id TEXT,
+                    name TEXT NOT NULL,
+                    type TEXT NOT NULL,
+                    role TEXT,
+                    status TEXT DEFAULT 'idle',
+                    capabilities TEXT,
+                    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+                    FOREIGN KEY (swarm_id) REFERENCES swarms(id)
+                )
+            `);
+
+      db.run(`
+                CREATE TABLE IF NOT EXISTS tasks (
+                    id TEXT PRIMARY KEY,
+                    swarm_id TEXT,
+                    description TEXT,
+                    status TEXT DEFAULT 'pending',
+                    result TEXT,
+                    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+                    FOREIGN KEY (swarm_id) REFERENCES swarms(id)
+                )
+            `);
+
+      db.run(`
+                CREATE TABLE IF NOT EXISTS collective_memory (
+                    id TEXT PRIMARY KEY,
+                    swarm_id TEXT,
+                    key TEXT NOT NULL,
+                    value TEXT,
+                    ttl INTEGER,
+                    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+                    FOREIGN KEY (swarm_id) REFERENCES swarms(id)
+                )
+            `);
+
+      db.close((err) => {
+        if (err) reject(err);
+        else resolve();
+      });
+    });
+  });
+}
+
+// Enhanced swarm creation with better UX
+async function createSwarm(objective, config) {
+  try {
+    // Simulate swarm creation with progress indication
+    const steps = [
+      'Initializing swarm topology...',
+      'Spawning Queen coordinator...',
+      'Creating worker agents...',
+      'Establishing communication protocols...',
+      'Setting up collective memory...',
+      'Activating swarm intelligence...',
+    ];
+
+    for (let i = 0; i < steps.length; i++) {
+      process.stdout.write(chalk.gray(`  ${steps[i]} `));
+      await new Promise((resolve) => setTimeout(resolve, 500)); // Simulate work
+      console.log(chalk.green('✓'));
+    }
+
+    const swarmId = `swarm-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    const queenId = `queen-${Date.now()}`;
+
+    // Open database
+    const dbPath = path.join(process.cwd(), '.hive-mind', 'hive.db');
+    const db = new sqlite3.Database(dbPath);
+
+    await new Promise((resolve, reject) => {
+      db.serialize(() => {
+        // Create swarm record
+        const insertSwarm = db.prepare(`
+                    INSERT INTO swarms (id, name, objective, status, queen_type, created_at, updated_at)
+                    VALUES (?, ?, ?, ?, ?, ?, ?)
+                `);
+
+        insertSwarm.run(
+          swarmId,
+          `hive-${Date.now()}`,
+          objective,
+          'active',
+          config.coordination,
+          new Date().toISOString(),
+          new Date().toISOString(),
+        );
+
+        // Create agents
+        const insertAgent = db.prepare(`
+                    INSERT INTO agents (id, swarm_id, name, type, role, status, capabilities, created_at)
+                    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+                `);
+
+        // Create Queen
+        insertAgent.run(
+          queenId,
+          swarmId,
+          'Queen Coordinator',
+          'coordinator',
+          'queen',
+          'active',
+          JSON.stringify(['orchestration', 'strategy', 'coordination']),
+          new Date().toISOString(),
+        );
+
+        // Create worker agents
+        const workerTypes = ['researcher', 'coder', 'analyst', 'tester'];
+        for (let i = 0; i < config.agents - 1; i++) {
+          const agentType = workerTypes[i % workerTypes.length];
+          insertAgent.run(
+            `agent-${Date.now()}-${i}`,
+            swarmId,
+            `${agentType.charAt(0).toUpperCase() + agentType.slice(1)} Worker ${i + 1}`,
+            agentType,
+            'worker',
+            'idle',
+            JSON.stringify([agentType, 'collaboration']),
+            new Date().toISOString(),
+          );
+        }
+
+        insertSwarm.finalize();
+        insertAgent.finalize();
+
+        db.close((err) => {
+          if (err) reject(err);
+          else resolve();
+        });
+      });
+    });
+
+    return { success: true, swarmId, queenId };
+  } catch (error) {
+    console.error('Error creating swarm:', error);
+    return { success: false, error: error.message };
+  }
+}
+
+module.exports = { runInteractiveWizard };