claude-flow-novice 2.0.3 → 2.0.4

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

@@ -3,425 +3,282 @@
  *
  * Safe, backward-compatible database optimization for existing deployments
  * Adds indexes, performance improvements, and new features without breaking changes
- */
-
-import Database from 'better-sqlite3';
-import { existsSync, mkdirSync } from 'fs';
-import { writeFile, readFile } from 'fs/promises';
-import path from 'path';
-import chalk from 'chalk';
-import ora from 'ora';
-
+ */ import Database from "better-sqlite3";
+import chalk from "chalk";
+import ora from "ora";
 /**
  * Optimize existing hive mind database with backward compatibility
- */
-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,
-    });
-
-    // 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) => {
-        console.log('  - ' + opt);
-      });
-    } else {
-      console.log('\n' + chalk.yellow('ℹ') + ' Database already optimized');
+ */ 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
+        });
+        // 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)=>{
+                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);
+        return {
+            success: false,
+            error: error.message
+        };
     }
-
-    return { success: true, optimizations: optimizationsApplied };
-  } catch (error) {
-    spinner.fail('Database optimization failed');
-    console.error(chalk.red('Error:'), error.message);
-    return { success: false, error: error.message };
-  }
 }
-
 /**
  * Get current schema version
- */
-function getSchemaVersion(db) {
-  try {
-    // Check if schema_version table exists
-    const tableExists = db
-      .prepare(
-        `
+ */ function getSchemaVersion(db) {
+    try {
+        // Check if schema_version table exists
+        const tableExists = db.prepare(`
       SELECT name FROM sqlite_master 
       WHERE type='table' AND name='schema_version'
-    `,
-      )
-      .get();
-
-    if (!tableExists) {
-      // Create schema version table
-      db.exec(`
+    `).get();
+        if (!tableExists) {
+            // Create schema version table
+            db.exec(`
         CREATE TABLE schema_version (
           version REAL PRIMARY KEY,
           applied_at DATETIME DEFAULT CURRENT_TIMESTAMP,
           description TEXT
         )
       `);
-
-      // Insert initial version
-      db.prepare(
-        `
+            // Insert initial version
+            db.prepare(`
         INSERT INTO schema_version (version, description) 
         VALUES (1.0, 'Initial schema')
-      `,
-      ).run();
-
-      return 1.0;
-    }
-
-    // Get latest version
-    const result = db
-      .prepare(
-        `
+      `).run();
+            return 1.0;
+        }
+        // Get latest version
+        const result = db.prepare(`
       SELECT version FROM schema_version 
       ORDER BY version DESC LIMIT 1
-    `,
-      )
-      .get();
-
-    return result ? result.version : 1.0;
-  } catch (error) {
-    // If any error, assume version 1.0
-    return 1.0;
-  }
+    `).get();
+        return result ? result.version : 1.0;
+    } catch (error) {
+        // If any error, assume version 1.0
+        return 1.0;
+    }
 }
-
 /**
  * Update schema version
- */
-function updateSchemaVersion(db, version, description = '') {
-  db.prepare(
-    `
+ */ function updateSchemaVersion(db, version, description = '') {
+    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}`);
 }
-
 /**
  * Apply basic performance indexes
- */
-function applyBasicIndexes(db) {
-  // First ensure all required columns exist
-  ensureRequiredColumns(db);
-
-  // Check which tables exist before creating indexes
-  const tables = db
-    .prepare(
-      `
+ */ function applyBasicIndexes(db) {
+    // First ensure all required columns exist
+    ensureRequiredColumns(db);
+    // Check which tables exist before creating indexes
+    const tables = db.prepare(`
     SELECT name FROM sqlite_master 
     WHERE type='table' AND name NOT LIKE 'sqlite_%'
-  `,
-    )
-    .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)',
-    );
-  }
-
-  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)',
-    );
-  }
-
-  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)',
-    );
-  }
-
-  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)',
-    );
-  }
-
-  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)',
-    );
-  }
-
-  indexes.forEach((sql) => {
-    try {
-      db.exec(sql);
-    } catch (error) {
-      console.warn(`Warning: Could not create index: ${error.message}`);
+  `).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)');
+    }
+    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)');
+    }
+    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)');
     }
-  });
+    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)');
+    }
+    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)');
+    }
+    indexes.forEach((sql)=>{
+        try {
+            db.exec(sql);
+        } catch (error) {
+            console.warn(`Warning: Could not create index: ${error.message}`);
+        }
+    });
 }
-
 /**
  * Ensure all required columns exist
- */
-function ensureRequiredColumns(db) {
-  // First check which tables exist
-  const tables = db
-    .prepare(
-      `
+ */ function ensureRequiredColumns(db) {
+    // First check which tables exist
+    const tables = db.prepare(`
     SELECT name FROM sqlite_master 
     WHERE type='table' AND name NOT LIKE 'sqlite_%'
-  `,
-    )
-    .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(
-        `
+  `).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(`
       SELECT COUNT(*) as count FROM pragma_table_info('tasks') 
       WHERE name = 'priority'
-    `,
-      )
-      .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')
-        ) {
-          throw error;
+    `).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')) {
+                    throw error;
+                }
+            }
         }
-      }
-    }
-
-    // Check and add completed_at column to tasks table
-    const hasCompletedAt = db
-      .prepare(
-        `
+        // Check and add completed_at column to tasks table
+        const hasCompletedAt = db.prepare(`
       SELECT COUNT(*) as count FROM pragma_table_info('tasks') 
       WHERE name = 'completed_at'
-    `,
-      )
-      .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')
-        ) {
-          throw error;
+    `).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')) {
+                    throw error;
+                }
+            }
         }
-      }
-    }
-
-    // Check and add result column to tasks table
-    const hasResult = db
-      .prepare(
-        `
+        // Check and add result column to tasks table
+        const hasResult = db.prepare(`
       SELECT COUNT(*) as count FROM pragma_table_info('tasks') 
       WHERE name = 'result'
-    `,
-      )
-      .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')
-        ) {
-          throw error;
+    `).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')) {
+                    throw error;
+                }
+            }
         }
-      }
     }
-  }
-
-  if (tableSet.has('swarms')) {
-    // Check and add updated_at column to swarms table
-    const hasUpdatedAt = db
-      .prepare(
-        `
+    if (tableSet.has('swarms')) {
+        // Check and add updated_at column to swarms table
+        const hasUpdatedAt = db.prepare(`
       SELECT COUNT(*) as count FROM pragma_table_info('swarms') 
       WHERE name = 'updated_at'
-    `,
-      )
-      .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')
-        ) {
-          throw error;
+    `).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')) {
+                    throw error;
+                }
+            }
         }
-      }
     }
-  }
 }
-
 /**
  * Apply advanced performance indexes
- */
-function applyAdvancedIndexes(db) {
-  // Check which tables exist
-  const tables = db
-    .prepare(
-      `
+ */ function applyAdvancedIndexes(db) {
+    // Check which tables exist
+    const tables = db.prepare(`
     SELECT name FROM sqlite_master 
     WHERE type='table' AND name NOT LIKE 'sqlite_%'
-  `,
-    )
-    .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'",
-    );
-  }
-
-  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)',
-    );
-  }
-
-  if (tableSet.has('collective_memory')) {
-    indexes.push(
-      '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'",
-    );
-  }
-
-  indexes.forEach((sql) => {
-    try {
-      db.exec(sql);
-    } catch (error) {
-      console.warn(`Warning: Could not create index: ${error.message}`);
+  `).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'");
+    }
+    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)');
+    }
+    if (tableSet.has('collective_memory')) {
+        indexes.push('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'");
+    }
+    indexes.forEach((sql)=>{
+        try {
+            db.exec(sql);
+        } catch (error) {
+            console.warn(`Warning: Could not create index: ${error.message}`);
+        }
+    });
 }
-
 /**
  * Add performance tracking tables
- */
-function addPerformanceTracking(db) {
-  // Agent performance metrics
-  db.exec(`
+ */ function addPerformanceTracking(db) {
+    // Agent performance metrics
+    db.exec(`
     CREATE TABLE IF NOT EXISTS agent_performance (
       agent_id TEXT PRIMARY KEY,
       tasks_completed INTEGER DEFAULT 0,
@@ -432,9 +289,8 @@ function addPerformanceTracking(db) {
       FOREIGN KEY (agent_id) REFERENCES agents(id)
     )
   `);
-
-  // Swarm performance metrics
-  db.exec(`
+    // Swarm performance metrics
+    db.exec(`
     CREATE TABLE IF NOT EXISTS swarm_performance (
       swarm_id TEXT PRIMARY KEY,
       total_tasks INTEGER DEFAULT 0,
@@ -445,9 +301,8 @@ function addPerformanceTracking(db) {
       FOREIGN KEY (swarm_id) REFERENCES swarms(id)
     )
   `);
-
-  // Create triggers to update performance metrics
-  db.exec(`
+    // Create triggers to update performance metrics
+    db.exec(`
     CREATE TRIGGER IF NOT EXISTS update_agent_performance
     AFTER UPDATE OF status ON tasks
     WHEN NEW.status = 'completed' OR NEW.status = 'failed'
@@ -463,121 +318,89 @@ function addPerformanceTracking(db) {
     END
   `);
 }
-
 /**
  * Add memory optimization features
- */
-function addMemoryOptimization(db) {
-  // Check if collective_memory table exists
-  const tables = db
-    .prepare(
-      `
+ */ function addMemoryOptimization(db) {
+    // Check if collective_memory table exists
+    const tables = db.prepare(`
     SELECT name FROM sqlite_master 
     WHERE type='table' AND name = 'collective_memory'
-  `,
-    )
-    .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(
-      `
+  `).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(`
     SELECT COUNT(*) as count FROM pragma_table_info('collective_memory') 
     WHERE name = 'access_count'
-  `,
-    )
-    .get();
-
-  if (!hasAccessCount || hasAccessCount.count === 0) {
-    try {
-      db.exec(`
+  `).get();
+    if (!hasAccessCount || hasAccessCount.count === 0) {
+        try {
+            db.exec(`
         ALTER TABLE collective_memory 
         ADD COLUMN access_count INTEGER DEFAULT 0
       `);
-      console.log('Added access_count column to collective_memory table');
-    } catch (error) {
-      if (!error.message.includes('duplicate column') && !error.message.includes('no such table')) {
-        throw error;
-      }
+            console.log('Added access_count column to collective_memory table');
+        } catch (error) {
+            if (!error.message.includes('duplicate column') && !error.message.includes('no such table')) {
+                throw error;
+            }
+        }
     }
-  }
-
-  // Check and add accessed_at column (not last_accessed)
-  const hasAccessedAt = db
-    .prepare(
-      `
+    // Check and add accessed_at column (not last_accessed)
+    const hasAccessedAt = db.prepare(`
     SELECT COUNT(*) as count FROM pragma_table_info('collective_memory') 
     WHERE name = 'accessed_at'
-  `,
-    )
-    .get();
-
-  if (!hasAccessedAt || hasAccessedAt.count === 0) {
-    try {
-      db.exec(`
+  `).get();
+    if (!hasAccessedAt || hasAccessedAt.count === 0) {
+        try {
+            db.exec(`
         ALTER TABLE collective_memory 
         ADD COLUMN accessed_at DATETIME
       `);
-      console.log('Added accessed_at column to collective_memory table');
-    } catch (error) {
-      if (!error.message.includes('duplicate column') && !error.message.includes('no such table')) {
-        throw error;
-      }
+            console.log('Added accessed_at column to collective_memory table');
+        } catch (error) {
+            if (!error.message.includes('duplicate column') && !error.message.includes('no such table')) {
+                throw error;
+            }
+        }
     }
-  }
-
-  // Add compressed and size columns if missing
-  const hasCompressed = db
-    .prepare(
-      `
+    // Add compressed and size columns if missing
+    const hasCompressed = db.prepare(`
     SELECT COUNT(*) as count FROM pragma_table_info('collective_memory') 
     WHERE name = 'compressed'
-  `,
-    )
-    .get();
-
-  if (!hasCompressed || hasCompressed.count === 0) {
-    try {
-      db.exec(`
+  `).get();
+    if (!hasCompressed || hasCompressed.count === 0) {
+        try {
+            db.exec(`
         ALTER TABLE collective_memory 
         ADD COLUMN compressed INTEGER DEFAULT 0
       `);
-    } catch (error) {
-      if (!error.message.includes('duplicate column') && !error.message.includes('no such table')) {
-        throw error;
-      }
+        } catch (error) {
+            if (!error.message.includes('duplicate column') && !error.message.includes('no such table')) {
+                throw error;
+            }
+        }
     }
-  }
-
-  const hasSize = db
-    .prepare(
-      `
+    const hasSize = db.prepare(`
     SELECT COUNT(*) as count FROM pragma_table_info('collective_memory') 
     WHERE name = 'size'
-  `,
-    )
-    .get();
-
-  if (!hasSize || hasSize.count === 0) {
-    try {
-      db.exec(`
+  `).get();
+    if (!hasSize || hasSize.count === 0) {
+        try {
+            db.exec(`
         ALTER TABLE collective_memory 
         ADD COLUMN size INTEGER DEFAULT 0
       `);
-    } catch (error) {
-      if (!error.message.includes('duplicate column') && !error.message.includes('no such table')) {
-        throw error;
-      }
+        } catch (error) {
+            if (!error.message.includes('duplicate column') && !error.message.includes('no such table')) {
+                throw error;
+            }
+        }
     }
-  }
-
-  // Create memory usage summary view
-  db.exec(`
+    // Create memory usage summary view
+    db.exec(`
     CREATE VIEW IF NOT EXISTS memory_usage_summary AS
     SELECT 
       swarm_id,
@@ -588,9 +411,8 @@ function addMemoryOptimization(db) {
     FROM collective_memory
     GROUP BY swarm_id
   `);
-
-  // Add memory cleanup tracking
-  db.exec(`
+    // Add memory cleanup tracking
+    db.exec(`
     CREATE TABLE IF NOT EXISTS memory_cleanup_log (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
       swarm_id TEXT,
@@ -601,13 +423,11 @@ function addMemoryOptimization(db) {
     )
   `);
 }
-
 /**
  * Add behavioral tracking features
- */
-function addBehavioralTracking(db) {
-  // Agent interaction patterns
-  db.exec(`
+ */ function addBehavioralTracking(db) {
+    // Agent interaction patterns
+    db.exec(`
     CREATE TABLE IF NOT EXISTS agent_interactions (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
       from_agent_id TEXT,
@@ -620,9 +440,8 @@ function addBehavioralTracking(db) {
       FOREIGN KEY (swarm_id) REFERENCES swarms(id)
     )
   `);
-
-  // Behavioral patterns
-  db.exec(`
+    // Behavioral patterns
+    db.exec(`
     CREATE TABLE IF NOT EXISTS behavioral_patterns (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
       swarm_id TEXT,
@@ -635,238 +454,170 @@ function addBehavioralTracking(db) {
       FOREIGN KEY (swarm_id) REFERENCES swarms(id)
     )
   `);
-
-  // Create indexes for behavioral analysis
-  db.exec(`
+    // Create indexes for behavioral analysis
+    db.exec(`
     CREATE INDEX IF NOT EXISTS idx_interactions_swarm ON agent_interactions(swarm_id);
     CREATE INDEX IF NOT EXISTS idx_interactions_agents ON agent_interactions(from_agent_id, to_agent_id);
     CREATE INDEX IF NOT EXISTS idx_patterns_swarm_type ON behavioral_patterns(swarm_id, pattern_type);
   `);
 }
-
 /**
  * Database maintenance utilities
- */
-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(
-          `
+ */ 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(`
         SELECT name FROM sqlite_master 
         WHERE type='table' AND name='collective_memory'
-      `,
-        )
-        .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(
-              `
+      `).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(`
             DELETE FROM collective_memory 
             WHERE accessed_at < ? AND access_count < 5
-          `,
-            )
-            .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}`));
+          `).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}`));
+                }
+            } else {
+                console.log(chalk.yellow('⚠ collective_memory table not found, skipping memory cleanup'));
+            }
         }
-      } else {
-        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(`
+        // 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(
-          `
+            // Check if completed_at column exists
+            const hasCompletedAt = db.prepare(`
         SELECT COUNT(*) as count FROM pragma_table_info('tasks') 
         WHERE name = 'completed_at'
-      `,
-        )
-        .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(`
+      `).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());
-      } else {
-        // Use created_at as fallback
-        const archiveCutoff = new Date();
-        archiveCutoff.setDate(archiveCutoff.getDate() - (options.taskRetentionDays || 7));
-
-        db.exec(`
+        `).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());
-      }
-
-      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...';
-      const integrityCheck = db.prepare('PRAGMA integrity_check').get();
-      if (integrityCheck.integrity_check === 'ok') {
-        console.log(chalk.green('✓ Database integrity check passed'));
-      } else {
-        console.log(chalk.yellow('⚠ Database integrity issues detected'));
-      }
+        `).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...';
+            const integrityCheck = db.prepare('PRAGMA integrity_check').get();
+            if (integrityCheck.integrity_check === 'ok') {
+                console.log(chalk.green('✓ Database integrity check passed'));
+            } else {
+                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);
     }
-
-    db.close();
-    spinner.succeed('Database maintenance complete!');
-  } catch (error) {
-    spinner.fail('Database maintenance failed');
-    console.error(chalk.red('Error:'), error.message);
-  }
 }
-
 /**
  * Generate optimization report
- */
-export async function generateOptimizationReport(dbPath) {
-  try {
-    const db = new Database(dbPath, { readonly: true });
-
-    const report = {
-      schemaVersion: getSchemaVersion(db),
-      tables: {},
-      indexes: [],
-      performance: {},
-    };
-
-    // Get table statistics
-    const tables = db
-      .prepare(
-        `
+ */ export async function generateOptimizationReport(dbPath) {
+    try {
+        const db = new Database(dbPath, {
+            readonly: true
+        });
+        const report = {
+            schemaVersion: getSchemaVersion(db),
+            tables: {},
+            indexes: [],
+            performance: {}
+        };
+        // Get table statistics
+        const tables = db.prepare(`
       SELECT name FROM sqlite_master WHERE type='table'
-    `,
-      )
-      .all();
-
-    for (const table of tables) {
-      const count = db.prepare(`SELECT COUNT(*) as count FROM ${table.name}`).get();
-      const size = db
-        .prepare(
-          `
+    `).all();
+        for (const table of tables){
+            const count = db.prepare(`SELECT COUNT(*) as count FROM ${table.name}`).get();
+            const size = db.prepare(`
         SELECT SUM(pgsize) as size FROM dbstat WHERE name=?
-      `,
-        )
-        .get(table.name);
-
-      report.tables[table.name] = {
-        rowCount: count.count,
-        sizeBytes: size?.size || 0,
-      };
-    }
-
-    // Get index information
-    report.indexes = db
-      .prepare(
-        `
+      `).get(table.name);
+            report.tables[table.name] = {
+                rowCount: count.count,
+                sizeBytes: size?.size || 0
+            };
+        }
+        // Get index information
+        report.indexes = db.prepare(`
       SELECT name, tbl_name FROM sqlite_master WHERE type='index'
-    `,
-      )
-      .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(
-          `
+    `).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(`
         SELECT COUNT(*) as count FROM pragma_table_info('tasks') 
         WHERE name = 'completed_at'
-      `,
-        )
-        .get();
-
-      if (hasCompletedAt && hasCompletedAt.count > 0) {
-        avgTaskTime = db
-          .prepare(
-            `
+      `).get();
+            if (hasCompletedAt && hasCompletedAt.count > 0) {
+                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) {
-      // If error, just use default value
-      console.warn('Could not calculate average task time:', error.message);
+        console.error('Error generating report:', error);
+        return null;
     }
-
-    report.performance.avgTaskCompletionMinutes = avgTaskTime?.avg_minutes || 0;
-
-    db.close();
-
-    return report;
-  } catch (error) {
-    console.error('Error generating report:', error);
-    return null;
-  }
 }
-
 // Export for use in CLI
 export default {
-  optimizeHiveMindDatabase,
-  performMaintenance,
-  generateOptimizationReport,
+    optimizeHiveMindDatabase,
+    performMaintenance,
+    generateOptimizationReport
 };