claude-flow-novice 2.0.4 → 2.0.5

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

@@ -2,16 +2,24 @@
  * 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";
+ */
+
+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(`
+ */
+function showOptimizeHelp() {
+  console.log(`
 ${chalk.yellow('🔧 Hive Mind Database Optimization')}
 
 ${chalk.bold('USAGE:')}
@@ -56,250 +64,298 @@ ${chalk.bold('SAFETY:')}
   • 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-novice 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);
-    }
+ */
+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-novice 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`));
+ */
+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;
     }
-    // Ask for optimization options
-    const answers = await inquirer.prompt([
+  } 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: [
         {
-            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
-                }
-            ]
+          name: 'Apply performance optimizations',
+          value: 'optimize',
+          checked: needsOptimization,
+          disabled: !needsOptimization,
         },
         {
-            type: 'number',
-            name: 'memoryDays',
-            message: 'Memory retention days:',
-            default: 30,
-            when: (answers)=>answers.operations.includes('cleanMemory')
+          name: 'Clean old memory entries',
+          value: 'cleanMemory',
+          checked: true,
         },
         {
-            type: 'number',
-            name: 'taskDays',
-            message: 'Task retention days:',
-            default: 7,
-            when: (answers)=>answers.operations.includes('archiveTasks')
+          name: 'Archive completed tasks',
+          value: 'archiveTasks',
+          checked: true,
         },
         {
-            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);
+          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-novice hive-mind metrics');
-    console.log('  • Schedule regular maintenance: claude-flow-novice hive-mind-optimize --auto');
-    console.log('  • Check swarm status: claude-flow-novice hive-mind status');
+ */
+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-novice hive-mind metrics');
+  console.log('  • Schedule regular maintenance: claude-flow-novice hive-mind-optimize --auto');
+  console.log('  • Check swarm status: claude-flow-novice 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-novice hive-mind-optimize'));
+ */
+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-novice 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'));
     }
-    // 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'));
-        }
+    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);
-        }
+ */
+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;