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

package/src/cli/simple-commands/hive-mind/db-optimizer.js

@@ -1,6 +1,6 @@
 /**
  * Hive Mind Database Optimizer
- * 
+ *
  * Safe, backward-compatible database optimization for existing deployments
  * Adds indexes, performance improvements, and new features without breaking changes
  */
@@ -17,89 +17,88 @@ import ora from 'ora';
  */
 export async function optimizeHiveMindDatabase(dbPath, options = {}) {
   const spinner = ora('Optimizing Hive Mind database...').start();
-  
+
   try {
     // Open database with write-ahead logging for better performance
-    const db = new Database(dbPath, { 
-      verbose: options.verbose ? console.log : null 
+    const db = new Database(dbPath, {
+      verbose: options.verbose ? console.log : null,
     });
-    
+
     // Enable WAL mode for better concurrency
     db.pragma('journal_mode = WAL');
     db.pragma('synchronous = NORMAL');
-    
+
     // Get current schema version
     const schemaVersion = getSchemaVersion(db);
     spinner.text = `Current schema version: ${schemaVersion}`;
-    
+
     // Apply optimizations based on version
     let optimizationsApplied = [];
-    
+
     // Version 1.0 -> 1.1: Add basic indexes
     if (schemaVersion < 1.1) {
       spinner.text = 'Applying performance indexes...';
       applyBasicIndexes(db);
       optimizationsApplied.push('Basic performance indexes');
     }
-    
+
     // Version 1.1 -> 1.2: Add advanced indexes and analyze
     if (schemaVersion < 1.2) {
       spinner.text = 'Applying advanced indexes...';
       applyAdvancedIndexes(db);
       optimizationsApplied.push('Advanced query optimization');
     }
-    
+
     // Version 1.2 -> 1.3: Add performance tracking tables
     if (schemaVersion < 1.3) {
       spinner.text = 'Adding performance tracking...';
       addPerformanceTracking(db);
       optimizationsApplied.push('Performance monitoring tables');
     }
-    
+
     // Version 1.3 -> 1.4: Add memory optimization
     if (schemaVersion < 1.4) {
       spinner.text = 'Optimizing memory management...';
       addMemoryOptimization(db);
       optimizationsApplied.push('Memory optimization features');
     }
-    
+
     // Version 1.4 -> 1.5: Add behavioral tracking
     if (schemaVersion < 1.5) {
       spinner.text = 'Adding behavioral analysis...';
       addBehavioralTracking(db);
       optimizationsApplied.push('Behavioral pattern tracking');
     }
-    
+
     // Run ANALYZE to update query planner statistics
     spinner.text = 'Updating query statistics...';
     db.exec('ANALYZE');
-    
+
     // Vacuum if requested (requires exclusive access)
     if (options.vacuum) {
       spinner.text = 'Vacuuming database...';
       db.exec('VACUUM');
       optimizationsApplied.push('Database vacuumed');
     }
-    
+
     // Update schema version
     updateSchemaVersion(db, 1.5);
-    
+
     // Close database
     db.close();
-    
+
     spinner.succeed('Database optimization complete!');
-    
+
     if (optimizationsApplied.length > 0) {
       console.log('\n' + chalk.green('✓') + ' Optimizations applied:');
-      optimizationsApplied.forEach(opt => {
+      optimizationsApplied.forEach((opt) => {
         console.log('  - ' + opt);
       });
     } else {
       console.log('\n' + chalk.yellow('ℹ') + ' Database already optimized');
     }
-    
+
     return { success: true, optimizations: optimizationsApplied };
-    
   } catch (error) {
     spinner.fail('Database optimization failed');
     console.error(chalk.red('Error:'), error.message);
@@ -113,11 +112,15 @@ export async function optimizeHiveMindDatabase(dbPath, options = {}) {
 function getSchemaVersion(db) {
   try {
     // Check if schema_version table exists
-    const tableExists = db.prepare(`
+    const tableExists = db
+      .prepare(
+        `
       SELECT name FROM sqlite_master 
       WHERE type='table' AND name='schema_version'
-    `).get();
-    
+    `,
+      )
+      .get();
+
     if (!tableExists) {
       // Create schema version table
       db.exec(`
@@ -127,24 +130,29 @@ function getSchemaVersion(db) {
           description TEXT
         )
       `);
-      
+
       // Insert initial version
-      db.prepare(`
+      db.prepare(
+        `
         INSERT INTO schema_version (version, description) 
         VALUES (1.0, 'Initial schema')
-      `).run();
-      
+      `,
+      ).run();
+
       return 1.0;
     }
-    
+
     // Get latest version
-    const result = db.prepare(`
+    const result = db
+      .prepare(
+        `
       SELECT version FROM schema_version 
       ORDER BY version DESC LIMIT 1
-    `).get();
-    
+    `,
+      )
+      .get();
+
     return result ? result.version : 1.0;
-    
   } catch (error) {
     // If any error, assume version 1.0
     return 1.0;
@@ -155,10 +163,12 @@ function getSchemaVersion(db) {
  * Update schema version
  */
 function updateSchemaVersion(db, version, description = '') {
-  db.prepare(`
+  db.prepare(
+    `
     INSERT OR REPLACE INTO schema_version (version, description) 
     VALUES (?, ?)
-  `).run(version, description || `Updated to version ${version}`);
+  `,
+  ).run(version, description || `Updated to version ${version}`);
 }
 
 /**
@@ -167,58 +177,63 @@ function updateSchemaVersion(db, version, description = '') {
 function applyBasicIndexes(db) {
   // First ensure all required columns exist
   ensureRequiredColumns(db);
-  
+
   // Check which tables exist before creating indexes
-  const tables = db.prepare(`
+  const tables = db
+    .prepare(
+      `
     SELECT name FROM sqlite_master 
     WHERE type='table' AND name NOT LIKE 'sqlite_%'
-  `).all().map(row => row.name);
-  
+  `,
+    )
+    .all()
+    .map((row) => row.name);
+
   const tableSet = new Set(tables);
-  
+
   const indexes = [];
-  
+
   // Only create indexes for tables that exist
   if (tableSet.has('swarms')) {
     indexes.push(
       'CREATE INDEX IF NOT EXISTS idx_swarms_status ON swarms(status)',
-      'CREATE INDEX IF NOT EXISTS idx_swarms_created ON swarms(created_at)'
+      'CREATE INDEX IF NOT EXISTS idx_swarms_created ON swarms(created_at)',
     );
   }
-  
+
   if (tableSet.has('agents')) {
     indexes.push(
       'CREATE INDEX IF NOT EXISTS idx_agents_swarm ON agents(swarm_id)',
       'CREATE INDEX IF NOT EXISTS idx_agents_type ON agents(type)',
-      'CREATE INDEX IF NOT EXISTS idx_agents_status ON agents(status)'
+      'CREATE INDEX IF NOT EXISTS idx_agents_status ON agents(status)',
     );
   }
-  
+
   if (tableSet.has('tasks')) {
     indexes.push(
       'CREATE INDEX IF NOT EXISTS idx_tasks_swarm ON tasks(swarm_id)',
       'CREATE INDEX IF NOT EXISTS idx_tasks_agent ON tasks(agent_id)',
       'CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status)',
-      'CREATE INDEX IF NOT EXISTS idx_tasks_priority ON tasks(priority DESC)'
+      'CREATE INDEX IF NOT EXISTS idx_tasks_priority ON tasks(priority DESC)',
     );
   }
-  
+
   if (tableSet.has('collective_memory')) {
     indexes.push(
       'CREATE INDEX IF NOT EXISTS idx_memory_swarm ON collective_memory(swarm_id)',
       'CREATE INDEX IF NOT EXISTS idx_memory_key ON collective_memory(key)',
-      'CREATE INDEX IF NOT EXISTS idx_memory_type ON collective_memory(type)'
+      'CREATE INDEX IF NOT EXISTS idx_memory_type ON collective_memory(type)',
     );
   }
-  
+
   if (tableSet.has('consensus_decisions')) {
     indexes.push(
       'CREATE INDEX IF NOT EXISTS idx_consensus_swarm ON consensus_decisions(swarm_id)',
-      'CREATE INDEX IF NOT EXISTS idx_consensus_created ON consensus_decisions(created_at)'
+      'CREATE INDEX IF NOT EXISTS idx_consensus_created ON consensus_decisions(created_at)',
     );
   }
-  
-  indexes.forEach(sql => {
+
+  indexes.forEach((sql) => {
     try {
       db.exec(sql);
     } catch (error) {
@@ -232,81 +247,113 @@ function applyBasicIndexes(db) {
  */
 function ensureRequiredColumns(db) {
   // First check which tables exist
-  const tables = db.prepare(`
+  const tables = db
+    .prepare(
+      `
     SELECT name FROM sqlite_master 
     WHERE type='table' AND name NOT LIKE 'sqlite_%'
-  `).all().map(row => row.name);
-  
+  `,
+    )
+    .all()
+    .map((row) => row.name);
+
   const tableSet = new Set(tables);
-  
+
   // Only check columns for tables that exist
   if (tableSet.has('tasks')) {
     // Check and add priority column to tasks table
-    const hasPriority = db.prepare(`
+    const hasPriority = db
+      .prepare(
+        `
       SELECT COUNT(*) as count FROM pragma_table_info('tasks') 
       WHERE name = 'priority'
-    `).get();
-    
+    `,
+      )
+      .get();
+
     if (!hasPriority || hasPriority.count === 0) {
       try {
         db.exec('ALTER TABLE tasks ADD COLUMN priority INTEGER DEFAULT 5');
         console.log('Added missing priority column to tasks table');
       } catch (error) {
-        if (!error.message.includes('duplicate column') && !error.message.includes('no such table')) {
+        if (
+          !error.message.includes('duplicate column') &&
+          !error.message.includes('no such table')
+        ) {
           throw error;
         }
       }
     }
-  
+
     // Check and add completed_at column to tasks table
-    const hasCompletedAt = db.prepare(`
+    const hasCompletedAt = db
+      .prepare(
+        `
       SELECT COUNT(*) as count FROM pragma_table_info('tasks') 
       WHERE name = 'completed_at'
-    `).get();
-    
+    `,
+      )
+      .get();
+
     if (!hasCompletedAt || hasCompletedAt.count === 0) {
       try {
         db.exec('ALTER TABLE tasks ADD COLUMN completed_at DATETIME');
         console.log('Added missing completed_at column to tasks table');
       } catch (error) {
-        if (!error.message.includes('duplicate column') && !error.message.includes('no such table')) {
+        if (
+          !error.message.includes('duplicate column') &&
+          !error.message.includes('no such table')
+        ) {
           throw error;
         }
       }
     }
-    
+
     // Check and add result column to tasks table
-    const hasResult = db.prepare(`
+    const hasResult = db
+      .prepare(
+        `
       SELECT COUNT(*) as count FROM pragma_table_info('tasks') 
       WHERE name = 'result'
-    `).get();
-    
+    `,
+      )
+      .get();
+
     if (!hasResult || hasResult.count === 0) {
       try {
         db.exec('ALTER TABLE tasks ADD COLUMN result TEXT');
         console.log('Added missing result column to tasks table');
       } catch (error) {
-        if (!error.message.includes('duplicate column') && !error.message.includes('no such table')) {
+        if (
+          !error.message.includes('duplicate column') &&
+          !error.message.includes('no such table')
+        ) {
           throw error;
         }
       }
     }
   }
-  
-  
+
   if (tableSet.has('swarms')) {
     // Check and add updated_at column to swarms table
-    const hasUpdatedAt = db.prepare(`
+    const hasUpdatedAt = db
+      .prepare(
+        `
       SELECT COUNT(*) as count FROM pragma_table_info('swarms') 
       WHERE name = 'updated_at'
-    `).get();
-    
+    `,
+      )
+      .get();
+
     if (!hasUpdatedAt || hasUpdatedAt.count === 0) {
       try {
         db.exec('ALTER TABLE swarms ADD COLUMN updated_at DATETIME');
         console.log('Added missing updated_at column to swarms table');
       } catch (error) {
-        if (!error.message.includes('duplicate column') && !error.message.includes('no such table')) {
+        if (
+          !error.message.includes('duplicate column') &&
+          !error.message.includes('no such table')
+        ) {
           throw error;
         }
       }
@@ -319,43 +366,48 @@ function ensureRequiredColumns(db) {
  */
 function applyAdvancedIndexes(db) {
   // Check which tables exist
-  const tables = db.prepare(`
+  const tables = db
+    .prepare(
+      `
     SELECT name FROM sqlite_master 
     WHERE type='table' AND name NOT LIKE 'sqlite_%'
-  `).all().map(row => row.name);
-  
+  `,
+    )
+    .all()
+    .map((row) => row.name);
+
   const tableSet = new Set(tables);
   const indexes = [];
-  
+
   // Composite indexes for common queries
   if (tableSet.has('tasks')) {
     indexes.push(
       'CREATE INDEX IF NOT EXISTS idx_tasks_swarm_status ON tasks(swarm_id, status)',
       'CREATE INDEX IF NOT EXISTS idx_tasks_full ON tasks(swarm_id, agent_id, status, priority)',
-      "CREATE INDEX IF NOT EXISTS idx_tasks_pending ON tasks(swarm_id, priority) WHERE status = 'pending'"
+      "CREATE INDEX IF NOT EXISTS idx_tasks_pending ON tasks(swarm_id, priority) WHERE status = 'pending'",
     );
   }
-  
+
   if (tableSet.has('agents')) {
     indexes.push(
       'CREATE INDEX IF NOT EXISTS idx_agents_swarm_type ON agents(swarm_id, type)',
-      'CREATE INDEX IF NOT EXISTS idx_agents_full ON agents(swarm_id, type, status, role)'
+      'CREATE INDEX IF NOT EXISTS idx_agents_full ON agents(swarm_id, type, status, role)',
     );
   }
-  
+
   if (tableSet.has('collective_memory')) {
     indexes.push(
-      'CREATE INDEX IF NOT EXISTS idx_memory_swarm_key ON collective_memory(swarm_id, key)'
+      'CREATE INDEX IF NOT EXISTS idx_memory_swarm_key ON collective_memory(swarm_id, key)',
     );
   }
-  
+
   if (tableSet.has('swarms')) {
     indexes.push(
-      "CREATE INDEX IF NOT EXISTS idx_swarms_active ON swarms(id, name) WHERE status = 'active'"
+      "CREATE INDEX IF NOT EXISTS idx_swarms_active ON swarms(id, name) WHERE status = 'active'",
     );
   }
-  
-  indexes.forEach(sql => {
+
+  indexes.forEach((sql) => {
     try {
       db.exec(sql);
     } catch (error) {
@@ -380,7 +432,7 @@ function addPerformanceTracking(db) {
       FOREIGN KEY (agent_id) REFERENCES agents(id)
     )
   `);
-  
+
   // Swarm performance metrics
   db.exec(`
     CREATE TABLE IF NOT EXISTS swarm_performance (
@@ -393,7 +445,7 @@ function addPerformanceTracking(db) {
       FOREIGN KEY (swarm_id) REFERENCES swarms(id)
     )
   `);
-  
+
   // Create triggers to update performance metrics
   db.exec(`
     CREATE TRIGGER IF NOT EXISTS update_agent_performance
@@ -417,22 +469,30 @@ function addPerformanceTracking(db) {
  */
 function addMemoryOptimization(db) {
   // Check if collective_memory table exists
-  const tables = db.prepare(`
+  const tables = db
+    .prepare(
+      `
     SELECT name FROM sqlite_master 
     WHERE type='table' AND name = 'collective_memory'
-  `).all();
-  
+  `,
+    )
+    .all();
+
   if (tables.length === 0) {
     console.log('collective_memory table does not exist, skipping memory optimization');
     return;
   }
-  
+
   // Check and add access_count column
-  const hasAccessCount = db.prepare(`
+  const hasAccessCount = db
+    .prepare(
+      `
     SELECT COUNT(*) as count FROM pragma_table_info('collective_memory') 
     WHERE name = 'access_count'
-  `).get();
-  
+  `,
+    )
+    .get();
+
   if (!hasAccessCount || hasAccessCount.count === 0) {
     try {
       db.exec(`
@@ -446,13 +506,17 @@ function addMemoryOptimization(db) {
       }
     }
   }
-  
+
   // Check and add accessed_at column (not last_accessed)
-  const hasAccessedAt = db.prepare(`
+  const hasAccessedAt = db
+    .prepare(
+      `
     SELECT COUNT(*) as count FROM pragma_table_info('collective_memory') 
     WHERE name = 'accessed_at'
-  `).get();
-  
+  `,
+    )
+    .get();
+
   if (!hasAccessedAt || hasAccessedAt.count === 0) {
     try {
       db.exec(`
@@ -466,13 +530,17 @@ function addMemoryOptimization(db) {
       }
     }
   }
-  
+
   // Add compressed and size columns if missing
-  const hasCompressed = db.prepare(`
+  const hasCompressed = db
+    .prepare(
+      `
     SELECT COUNT(*) as count FROM pragma_table_info('collective_memory') 
     WHERE name = 'compressed'
-  `).get();
-  
+  `,
+    )
+    .get();
+
   if (!hasCompressed || hasCompressed.count === 0) {
     try {
       db.exec(`
@@ -485,12 +553,16 @@ function addMemoryOptimization(db) {
       }
     }
   }
-  
-  const hasSize = db.prepare(`
+
+  const hasSize = db
+    .prepare(
+      `
     SELECT COUNT(*) as count FROM pragma_table_info('collective_memory') 
     WHERE name = 'size'
-  `).get();
-  
+  `,
+    )
+    .get();
+
   if (!hasSize || hasSize.count === 0) {
     try {
       db.exec(`
@@ -503,7 +575,7 @@ function addMemoryOptimization(db) {
       }
     }
   }
-  
+
   // Create memory usage summary view
   db.exec(`
     CREATE VIEW IF NOT EXISTS memory_usage_summary AS
@@ -516,7 +588,7 @@ function addMemoryOptimization(db) {
     FROM collective_memory
     GROUP BY swarm_id
   `);
-  
+
   // Add memory cleanup tracking
   db.exec(`
     CREATE TABLE IF NOT EXISTS memory_cleanup_log (
@@ -548,7 +620,7 @@ function addBehavioralTracking(db) {
       FOREIGN KEY (swarm_id) REFERENCES swarms(id)
     )
   `);
-  
+
   // Behavioral patterns
   db.exec(`
     CREATE TABLE IF NOT EXISTS behavioral_patterns (
@@ -563,7 +635,7 @@ function addBehavioralTracking(db) {
       FOREIGN KEY (swarm_id) REFERENCES swarms(id)
     )
   `);
-  
+
   // Create indexes for behavioral analysis
   db.exec(`
     CREATE INDEX IF NOT EXISTS idx_interactions_swarm ON agent_interactions(swarm_id);
@@ -577,29 +649,37 @@ function addBehavioralTracking(db) {
  */
 export async function performMaintenance(dbPath, options = {}) {
   const spinner = ora('Performing database maintenance...').start();
-  
+
   try {
     const db = new Database(dbPath);
-    
+
     // Clean up old memory entries
     if (options.cleanMemory) {
       // Check if collective_memory table exists
-      const hasMemoryTable = db.prepare(`
+      const hasMemoryTable = db
+        .prepare(
+          `
         SELECT name FROM sqlite_master 
         WHERE type='table' AND name='collective_memory'
-      `).get();
-      
+      `,
+        )
+        .get();
+
       if (hasMemoryTable) {
         spinner.text = 'Cleaning old memory entries...';
         const cutoffDate = new Date();
         cutoffDate.setDate(cutoffDate.getDate() - (options.memoryRetentionDays || 30));
-        
+
         try {
-          const result = db.prepare(`
+          const result = db
+            .prepare(
+              `
             DELETE FROM collective_memory 
             WHERE accessed_at < ? AND access_count < 5
-          `).run(cutoffDate.toISOString());
-          
+          `,
+            )
+            .run(cutoffDate.toISOString());
+
           console.log(chalk.green(`✓ Removed ${result.changes} old memory entries`));
         } catch (error) {
           console.warn(chalk.yellow(`⚠ Could not clean memory entries: ${error.message}`));
@@ -608,64 +688,76 @@ export async function performMaintenance(dbPath, options = {}) {
         console.log(chalk.yellow('⚠ collective_memory table not found, skipping memory cleanup'));
       }
     }
-    
+
     // Archive completed tasks
     if (options.archiveTasks) {
       spinner.text = 'Archiving completed tasks...';
-      
+
       // Create archive table if not exists
       db.exec(`
         CREATE TABLE IF NOT EXISTS tasks_archive AS 
         SELECT * FROM tasks WHERE 1=0
       `);
-      
+
       // Check if completed_at column exists
-      const hasCompletedAt = db.prepare(`
+      const hasCompletedAt = db
+        .prepare(
+          `
         SELECT COUNT(*) as count FROM pragma_table_info('tasks') 
         WHERE name = 'completed_at'
-      `).get();
-      
+      `,
+        )
+        .get();
+
       let archived = { changes: 0 };
-      
+
       if (hasCompletedAt && hasCompletedAt.count > 0) {
         // Move old completed tasks using completed_at
         const archiveCutoff = new Date();
         archiveCutoff.setDate(archiveCutoff.getDate() - (options.taskRetentionDays || 7));
-        
+
         db.exec(`
           INSERT INTO tasks_archive 
           SELECT * FROM tasks 
           WHERE status = 'completed' AND completed_at < '${archiveCutoff.toISOString()}'
         `);
-        
-        archived = db.prepare(`
+
+        archived = db
+          .prepare(
+            `
           DELETE FROM tasks 
           WHERE status = 'completed' AND completed_at < ?
-        `).run(archiveCutoff.toISOString());
+        `,
+          )
+          .run(archiveCutoff.toISOString());
       } else {
         // Use created_at as fallback
         const archiveCutoff = new Date();
         archiveCutoff.setDate(archiveCutoff.getDate() - (options.taskRetentionDays || 7));
-        
+
         db.exec(`
           INSERT INTO tasks_archive 
           SELECT * FROM tasks 
           WHERE status = 'completed' AND created_at < '${archiveCutoff.toISOString()}'
         `);
-        
-        archived = db.prepare(`
+
+        archived = db
+          .prepare(
+            `
           DELETE FROM tasks 
           WHERE status = 'completed' AND created_at < ?
-        `).run(archiveCutoff.toISOString());
+        `,
+          )
+          .run(archiveCutoff.toISOString());
       }
-      
+
       console.log(chalk.green(`✓ Archived ${archived.changes} completed tasks`));
     }
-    
+
     // Update statistics
     spinner.text = 'Updating database statistics...';
     db.exec('ANALYZE');
-    
+
     // Check integrity
     if (options.checkIntegrity) {
       spinner.text = 'Checking database integrity...';
@@ -676,10 +768,9 @@ export async function performMaintenance(dbPath, options = {}) {
         console.log(chalk.yellow('⚠ Database integrity issues detected'));
       }
     }
-    
+
     db.close();
     spinner.succeed('Database maintenance complete!');
-    
   } catch (error) {
     spinner.fail('Database maintenance failed');
     console.error(chalk.red('Error:'), error.message);
@@ -692,62 +783,81 @@ export async function performMaintenance(dbPath, options = {}) {
 export async function generateOptimizationReport(dbPath) {
   try {
     const db = new Database(dbPath, { readonly: true });
-    
+
     const report = {
       schemaVersion: getSchemaVersion(db),
       tables: {},
       indexes: [],
-      performance: {}
+      performance: {},
     };
-    
+
     // Get table statistics
-    const tables = db.prepare(`
+    const tables = db
+      .prepare(
+        `
       SELECT name FROM sqlite_master WHERE type='table'
-    `).all();
-    
+    `,
+      )
+      .all();
+
     for (const table of tables) {
       const count = db.prepare(`SELECT COUNT(*) as count FROM ${table.name}`).get();
-      const size = db.prepare(`
+      const size = db
+        .prepare(
+          `
         SELECT SUM(pgsize) as size FROM dbstat WHERE name=?
-      `).get(table.name);
-      
+      `,
+        )
+        .get(table.name);
+
       report.tables[table.name] = {
         rowCount: count.count,
-        sizeBytes: size?.size || 0
+        sizeBytes: size?.size || 0,
       };
     }
-    
+
     // Get index information
-    report.indexes = db.prepare(`
+    report.indexes = db
+      .prepare(
+        `
       SELECT name, tbl_name FROM sqlite_master WHERE type='index'
-    `).all();
-    
+    `,
+      )
+      .all();
+
     // Get performance metrics (check if completed_at column exists)
     let avgTaskTime = { avg_minutes: 0 };
     try {
       // First check if completed_at column exists
-      const hasCompletedAt = db.prepare(`
+      const hasCompletedAt = db
+        .prepare(
+          `
         SELECT COUNT(*) as count FROM pragma_table_info('tasks') 
         WHERE name = 'completed_at'
-      `).get();
-      
+      `,
+        )
+        .get();
+
       if (hasCompletedAt && hasCompletedAt.count > 0) {
-        avgTaskTime = db.prepare(`
+        avgTaskTime = db
+          .prepare(
+            `
           SELECT AVG(julianday(completed_at) - julianday(created_at)) * 24 * 60 as avg_minutes
           FROM tasks WHERE completed_at IS NOT NULL
-        `).get();
+        `,
+          )
+          .get();
       }
     } catch (error) {
       // If error, just use default value
       console.warn('Could not calculate average task time:', error.message);
     }
-    
+
     report.performance.avgTaskCompletionMinutes = avgTaskTime?.avg_minutes || 0;
-    
+
     db.close();
-    
+
     return report;
-    
   } catch (error) {
     console.error('Error generating report:', error);
     return null;
@@ -758,5 +868,5 @@ export async function generateOptimizationReport(dbPath) {
 export default {
   optimizeHiveMindDatabase,
   performMaintenance,
-  generateOptimizationReport
-};
+  generateOptimizationReport,
+};