claude-flow-novice 2.0.3 → 2.0.4

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

@@ -2,24 +2,16 @@
  * 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:')}
@@ -64,298 +56,250 @@ ${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;
+ */ 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('');
     }
-  } 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,
-        },
+    // 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([
         {
-          name: 'Clean old memory entries',
-          value: 'cleanMemory',
-          checked: true,
+            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: 'Archive completed tasks',
-          value: 'archiveTasks',
-          checked: true,
+            type: 'number',
+            name: 'memoryDays',
+            message: 'Memory retention days:',
+            default: 30,
+            when: (answers)=>answers.operations.includes('cleanMemory')
         },
         {
-          name: 'Vacuum database (requires exclusive access)',
-          value: 'vacuum',
-          checked: false,
+            type: 'number',
+            name: 'taskDays',
+            message: 'Task retention days:',
+            default: 7,
+            when: (answers)=>answers.operations.includes('archiveTasks')
         },
         {
-          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);
+            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'));
-  }
-
-  // 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'));
+ */ 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`);
     }
-    if (largeTaskTable) {
-      console.log(chalk.yellow('  • Consider archiving completed tasks'));
+    // 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'));
+        }
+        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;