claude-flow-novice 2.0.4 → 2.0.5

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

@@ -1,127 +1,117 @@
 /**
  * Hive Mind Initialization Module for Claude Flow v2.0.0
  * Provides comprehensive hive-mind system setup for the init process
- */ import { promises as fs } from "fs";
-import { existsSync } from "fs";
-import path from "path";
-import { printSuccess, printError } from "../../utils.js";
+ */
+
+import { promises as fs } from 'fs';
+import { existsSync } from 'fs';
+import path from 'path';
+import { printSuccess, printError, printWarning } from '../../utils.js';
+
 /**
  * Default hive-mind configuration
- */ export const DEFAULT_HIVE_CONFIG = {
-    version: '2.0.0',
-    initialized: new Date().toISOString(),
-    system: {
-        enabled: true,
-        autoStart: false,
-        maxRetries: 3,
-        healthCheckInterval: 30000
-    },
-    queen: {
-        type: 'strategic',
-        name: 'Queen-Genesis',
-        capabilities: [
-            'task-decomposition',
-            'consensus-building',
-            'resource-allocation',
-            'quality-assessment',
-            'conflict-resolution'
-        ],
-        decisionThreshold: 0.75,
-        adaptiveLearning: true
+ */
+export const DEFAULT_HIVE_CONFIG = {
+  version: '2.0.0',
+  initialized: new Date().toISOString(),
+  system: {
+    enabled: true,
+    autoStart: false,
+    maxRetries: 3,
+    healthCheckInterval: 30000,
+  },
+  queen: {
+    type: 'strategic',
+    name: 'Queen-Genesis',
+    capabilities: [
+      'task-decomposition',
+      'consensus-building',
+      'resource-allocation',
+      'quality-assessment',
+      'conflict-resolution',
+    ],
+    decisionThreshold: 0.75,
+    adaptiveLearning: true,
+  },
+  workers: {
+    maxWorkers: 8,
+    defaultCapabilities: ['code-analysis', 'implementation', 'testing', 'documentation'],
+    autoScale: true,
+    scaleThreshold: 0.8,
+    specializedRoles: ['architect', 'researcher', 'implementer', 'tester', 'reviewer'],
+  },
+  consensus: {
+    algorithm: 'weighted-majority',
+    minimumParticipants: 3,
+    timeoutMs: 30000,
+    requiredConsensus: 0.67,
+    votingMethods: ['majority', 'weighted', 'unanimous', 'quorum'],
+  },
+  memory: {
+    enabled: true,
+    size: 100,
+    persistenceMode: 'database',
+    sharedMemoryNamespace: 'hive-collective',
+    retentionDays: 30,
+    compressionEnabled: true,
+    encryptionEnabled: false,
+  },
+  communication: {
+    protocol: 'secure-messaging',
+    encryption: false,
+    messageQueue: {
+      maxSize: 1000,
+      priorityLevels: 5,
+      batchProcessing: true,
     },
-    workers: {
-        maxWorkers: 8,
-        defaultCapabilities: [
-            'code-analysis',
-            'implementation',
-            'testing',
-            'documentation'
-        ],
-        autoScale: true,
-        scaleThreshold: 0.8,
-        specializedRoles: [
-            'architect',
-            'researcher',
-            'implementer',
-            'tester',
-            'reviewer'
-        ]
+    channels: [
+      'task-coordination',
+      'knowledge-sharing',
+      'consensus-voting',
+      'error-reporting',
+      'performance-metrics',
+    ],
+  },
+  integration: {
+    mcpTools: {
+      enabled: true,
+      parallel: true,
+      timeout: 60000,
+      fallbackMode: 'sequential',
     },
-    consensus: {
-        algorithm: 'weighted-majority',
-        minimumParticipants: 3,
-        timeoutMs: 30000,
-        requiredConsensus: 0.67,
-        votingMethods: [
-            'majority',
-            'weighted',
-            'unanimous',
-            'quorum'
-        ]
+    claudeCode: {
+      enabled: true,
+      autoSpawn: true,
+      coordination: true,
+      sharedContext: true,
     },
-    memory: {
-        enabled: true,
-        size: 100,
-        persistenceMode: 'database',
-        sharedMemoryNamespace: 'hive-collective',
-        retentionDays: 30,
-        compressionEnabled: true,
-        encryptionEnabled: false
+    github: {
+      enabled: false,
+      autoCommit: false,
+      branchStrategy: 'feature',
     },
-    communication: {
-        protocol: 'secure-messaging',
-        encryption: false,
-        messageQueue: {
-            maxSize: 1000,
-            priorityLevels: 5,
-            batchProcessing: true
-        },
-        channels: [
-            'task-coordination',
-            'knowledge-sharing',
-            'consensus-voting',
-            'error-reporting',
-            'performance-metrics'
-        ]
+  },
+  monitoring: {
+    enabled: true,
+    metricsCollection: true,
+    performanceTracking: true,
+    healthChecks: true,
+    alerting: {
+      enabled: false,
+      thresholds: {
+        errorRate: 0.1,
+        responseTime: 5000,
+        consensusFailures: 3,
+      },
     },
-    integration: {
-        mcpTools: {
-            enabled: true,
-            parallel: true,
-            timeout: 60000,
-            fallbackMode: 'sequential'
-        },
-        claudeCode: {
-            enabled: true,
-            autoSpawn: true,
-            coordination: true,
-            sharedContext: true
-        },
-        github: {
-            enabled: false,
-            autoCommit: false,
-            branchStrategy: 'feature'
-        }
-    },
-    monitoring: {
-        enabled: true,
-        metricsCollection: true,
-        performanceTracking: true,
-        healthChecks: true,
-        alerting: {
-            enabled: false,
-            thresholds: {
-                errorRate: 0.1,
-                responseTime: 5000,
-                consensusFailures: 3
-            }
-        }
-    }
+  },
 };
+
 /**
  * Database schema for hive-mind system
- */ export const HIVE_DB_SCHEMA = {
-    swarms: `
+ */
+export const HIVE_DB_SCHEMA = {
+  swarms: `
     CREATE TABLE IF NOT EXISTS swarms (
       id TEXT PRIMARY KEY,
       name TEXT NOT NULL,
@@ -135,7 +125,7 @@ import { printSuccess, printError } from "../../utils.js";
       metadata TEXT DEFAULT '{}'
     );
   `,
-    agents: `
+  agents: `
     CREATE TABLE IF NOT EXISTS agents (
       id TEXT PRIMARY KEY,
       swarm_id TEXT,
@@ -153,7 +143,7 @@ import { printSuccess, printError } from "../../utils.js";
       FOREIGN KEY (swarm_id) REFERENCES swarms (id)
     );
   `,
-    tasks: `
+  tasks: `
     CREATE TABLE IF NOT EXISTS tasks (
       id TEXT PRIMARY KEY,
       swarm_id TEXT,
@@ -173,7 +163,7 @@ import { printSuccess, printError } from "../../utils.js";
       FOREIGN KEY (agent_id) REFERENCES agents (id)
     );
   `,
-    messages: `
+  messages: `
     CREATE TABLE IF NOT EXISTS messages (
       id TEXT PRIMARY KEY,
       swarm_id TEXT,
@@ -192,7 +182,7 @@ import { printSuccess, printError } from "../../utils.js";
       FOREIGN KEY (recipient_id) REFERENCES agents (id)
     );
   `,
-    consensus_votes: `
+  consensus_votes: `
     CREATE TABLE IF NOT EXISTS consensus_votes (
       id TEXT PRIMARY KEY,
       swarm_id TEXT,
@@ -206,7 +196,7 @@ import { printSuccess, printError } from "../../utils.js";
       FOREIGN KEY (agent_id) REFERENCES agents (id)
     );
   `,
-    knowledge_base: `
+  knowledge_base: `
     CREATE TABLE IF NOT EXISTS knowledge_base (
       id TEXT PRIMARY KEY,
       swarm_id TEXT,
@@ -223,7 +213,7 @@ import { printSuccess, printError } from "../../utils.js";
       FOREIGN KEY (source_agent_id) REFERENCES agents (id)
     );
   `,
-    performance_metrics: `
+  performance_metrics: `
     CREATE TABLE IF NOT EXISTS performance_metrics (
       id TEXT PRIMARY KEY,
       entity_type TEXT NOT NULL,
@@ -234,7 +224,7 @@ import { printSuccess, printError } from "../../utils.js";
       metadata TEXT DEFAULT '{}'
     );
   `,
-    sessions: `
+  sessions: `
     CREATE TABLE IF NOT EXISTS sessions (
       id TEXT PRIMARY KEY,
       swarm_id TEXT NOT NULL,
@@ -252,337 +242,356 @@ import { printSuccess, printError } from "../../utils.js";
       child_pids TEXT,
       FOREIGN KEY (swarm_id) REFERENCES swarms (id)
     );
-  `
+  `,
 };
+
 /**
  * Create hive-mind directory structure
- */ export async function createHiveMindDirectories(workingDir, dryRun = false) {
-    const directories = [
-        '.hive-mind',
-        '.hive-mind/sessions',
-        '.hive-mind/memory',
-        '.hive-mind/logs',
-        '.hive-mind/backups',
-        '.hive-mind/config',
-        '.hive-mind/templates',
-        '.hive-mind/exports'
-    ];
-    console.log('  📁 Creating hive-mind directory structure...');
-    for (const dir of directories){
-        const fullPath = path.join(workingDir, dir);
-        if (!dryRun) {
-            await fs.mkdir(fullPath, {
-                recursive: true
-            });
-        } else {
-            console.log(`    [DRY RUN] Would create: ${dir}`);
-        }
-    }
+ */
+export async function createHiveMindDirectories(workingDir, dryRun = false) {
+  const directories = [
+    '.hive-mind',
+    '.hive-mind/sessions',
+    '.hive-mind/memory',
+    '.hive-mind/logs',
+    '.hive-mind/backups',
+    '.hive-mind/config',
+    '.hive-mind/templates',
+    '.hive-mind/exports',
+  ];
+
+  console.log('  📁 Creating hive-mind directory structure...');
+
+  for (const dir of directories) {
+    const fullPath = path.join(workingDir, dir);
     if (!dryRun) {
-        console.log('  ✅ Hive-mind directories created');
+      await fs.mkdir(fullPath, { recursive: true });
+    } else {
+      console.log(`    [DRY RUN] Would create: ${dir}`);
     }
+  }
+
+  if (!dryRun) {
+    console.log('  ✅ Hive-mind directories created');
+  }
 }
+
 /**
  * Initialize collective memory database
- */ export async function initializeCollectiveMemoryDatabase(workingDir, dryRun = false) {
-    console.log('  🧠 Initializing collective memory database...');
-    if (dryRun) {
-        console.log('    [DRY RUN] Would initialize hive.db with full schema');
-        console.log('    [DRY RUN] Would create indexes for performance optimization');
-        console.log('    [DRY RUN] Would insert default data and configurations');
-        return;
-    }
+ */
+export async function initializeCollectiveMemoryDatabase(workingDir, dryRun = false) {
+  console.log('  🧠 Initializing collective memory database...');
+
+  if (dryRun) {
+    console.log('    [DRY RUN] Would initialize hive.db with full schema');
+    console.log('    [DRY RUN] Would create indexes for performance optimization');
+    console.log('    [DRY RUN] Would insert default data and configurations');
+    return;
+  }
+
+  try {
+    // Dynamic import for better-sqlite3 with proper error handling
+    let Database;
     try {
-        // Dynamic import for better-sqlite3 with proper error handling
-        let Database;
-        try {
-            Database = (await import("better-sqlite3")).default;
-        } catch (err) {
-            console.log('    ⚠️  better-sqlite3 not available, using fallback memory database');
-            return await createFallbackMemoryDatabase(workingDir);
-        }
-        const hivePath = path.join(workingDir, '.hive-mind', 'hive.db');
-        const hiveDb = new Database(hivePath);
-        // Enable WAL mode for better concurrency
-        hiveDb.pragma('journal_mode = WAL');
-        hiveDb.pragma('synchronous = NORMAL');
-        hiveDb.pragma('cache_size = 1000');
-        hiveDb.pragma('temp_store = MEMORY');
-        // Create all tables
-        console.log('    📋 Creating database schema...');
-        for (const [tableName, schema] of Object.entries(HIVE_DB_SCHEMA)){
-            hiveDb.exec(schema);
-        }
-        // Create indexes for performance
-        console.log('    🔍 Creating performance indexes...');
-        const indexes = [
-            'CREATE INDEX IF NOT EXISTS idx_agents_swarm_id ON agents(swarm_id);',
-            'CREATE INDEX IF NOT EXISTS idx_agents_status ON agents(status);',
-            'CREATE INDEX IF NOT EXISTS idx_tasks_swarm_id ON tasks(swarm_id);',
-            'CREATE INDEX IF NOT EXISTS idx_tasks_agent_id ON tasks(agent_id);',
-            'CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);',
-            'CREATE INDEX IF NOT EXISTS idx_messages_swarm_id ON messages(swarm_id);',
-            'CREATE INDEX IF NOT EXISTS idx_messages_timestamp ON messages(timestamp);',
-            'CREATE INDEX IF NOT EXISTS idx_consensus_votes_swarm_id ON consensus_votes(swarm_id);',
-            'CREATE INDEX IF NOT EXISTS idx_knowledge_base_swarm_id ON knowledge_base(swarm_id);',
-            'CREATE INDEX IF NOT EXISTS idx_knowledge_base_category ON knowledge_base(category);',
-            'CREATE INDEX IF NOT EXISTS idx_performance_metrics_entity ON performance_metrics(entity_type, entity_id);',
-            'CREATE INDEX IF NOT EXISTS idx_sessions_swarm_id ON sessions(swarm_id);'
-        ];
-        for (const index of indexes){
-            hiveDb.exec(index);
-        }
-        // Insert initial metadata
-        const insertInitialData = hiveDb.prepare(`
+      Database = (await import('better-sqlite3')).default;
+    } catch (err) {
+      console.log('    ⚠️  better-sqlite3 not available, using fallback memory database');
+      return await createFallbackMemoryDatabase(workingDir);
+    }
+
+    const hivePath = path.join(workingDir, '.hive-mind', 'hive.db');
+    const hiveDb = new Database(hivePath);
+
+    // Enable WAL mode for better concurrency
+    hiveDb.pragma('journal_mode = WAL');
+    hiveDb.pragma('synchronous = NORMAL');
+    hiveDb.pragma('cache_size = 1000');
+    hiveDb.pragma('temp_store = MEMORY');
+
+    // Create all tables
+    console.log('    📋 Creating database schema...');
+    for (const [tableName, schema] of Object.entries(HIVE_DB_SCHEMA)) {
+      hiveDb.exec(schema);
+    }
+
+    // Create indexes for performance
+    console.log('    🔍 Creating performance indexes...');
+    const indexes = [
+      'CREATE INDEX IF NOT EXISTS idx_agents_swarm_id ON agents(swarm_id);',
+      'CREATE INDEX IF NOT EXISTS idx_agents_status ON agents(status);',
+      'CREATE INDEX IF NOT EXISTS idx_tasks_swarm_id ON tasks(swarm_id);',
+      'CREATE INDEX IF NOT EXISTS idx_tasks_agent_id ON tasks(agent_id);',
+      'CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);',
+      'CREATE INDEX IF NOT EXISTS idx_messages_swarm_id ON messages(swarm_id);',
+      'CREATE INDEX IF NOT EXISTS idx_messages_timestamp ON messages(timestamp);',
+      'CREATE INDEX IF NOT EXISTS idx_consensus_votes_swarm_id ON consensus_votes(swarm_id);',
+      'CREATE INDEX IF NOT EXISTS idx_knowledge_base_swarm_id ON knowledge_base(swarm_id);',
+      'CREATE INDEX IF NOT EXISTS idx_knowledge_base_category ON knowledge_base(category);',
+      'CREATE INDEX IF NOT EXISTS idx_performance_metrics_entity ON performance_metrics(entity_type, entity_id);',
+      'CREATE INDEX IF NOT EXISTS idx_sessions_swarm_id ON sessions(swarm_id);',
+    ];
+
+    for (const index of indexes) {
+      hiveDb.exec(index);
+    }
+
+    // Insert initial metadata
+    const insertInitialData = hiveDb.prepare(`
       INSERT OR IGNORE INTO knowledge_base (id, category, title, content, confidence)
       VALUES (?, ?, ?, ?, ?)
     `);
-        const initialKnowledge = [
-            [
-                'init-1',
-                'system',
-                'Hive Mind System Initialization',
-                'Hive mind system successfully initialized with full database schema and configuration.',
-                1.0
-            ],
-            [
-                'init-2',
-                'capabilities',
-                'Default Agent Capabilities',
-                JSON.stringify(DEFAULT_HIVE_CONFIG.workers.defaultCapabilities),
-                0.9
-            ],
-            [
-                'init-3',
-                'consensus',
-                'Consensus Algorithms',
-                JSON.stringify(DEFAULT_HIVE_CONFIG.consensus),
-                1.0
-            ],
-            [
-                'init-4',
-                'queen',
-                'Queen Configuration',
-                JSON.stringify(DEFAULT_HIVE_CONFIG.queen),
-                1.0
-            ]
-        ];
-        for (const knowledge of initialKnowledge){
-            insertInitialData.run(...knowledge);
-        }
-        hiveDb.close();
-        console.log('  ✅ Collective memory database initialized with full schema');
-    } catch (err) {
-        console.log(`    ⚠️  Could not initialize hive database: ${err.message}`);
-        return await createFallbackMemoryDatabase(workingDir);
+
+    const initialKnowledge = [
+      [
+        'init-1',
+        'system',
+        'Hive Mind System Initialization',
+        'Hive mind system successfully initialized with full database schema and configuration.',
+        1.0,
+      ],
+      [
+        'init-2',
+        'capabilities',
+        'Default Agent Capabilities',
+        JSON.stringify(DEFAULT_HIVE_CONFIG.workers.defaultCapabilities),
+        0.9,
+      ],
+      [
+        'init-3',
+        'consensus',
+        'Consensus Algorithms',
+        JSON.stringify(DEFAULT_HIVE_CONFIG.consensus),
+        1.0,
+      ],
+      ['init-4', 'queen', 'Queen Configuration', JSON.stringify(DEFAULT_HIVE_CONFIG.queen), 1.0],
+    ];
+
+    for (const knowledge of initialKnowledge) {
+      insertInitialData.run(...knowledge);
     }
+
+    hiveDb.close();
+    console.log('  ✅ Collective memory database initialized with full schema');
+  } catch (err) {
+    console.log(`    ⚠️  Could not initialize hive database: ${err.message}`);
+    return await createFallbackMemoryDatabase(workingDir);
+  }
 }
+
 /**
  * Create fallback memory database when SQLite is not available
- */ async function createFallbackMemoryDatabase(workingDir) {
-    console.log('    📄 Creating fallback JSON memory database...');
-    const fallbackDb = {
-        metadata: {
-            type: 'fallback',
-            initialized: new Date().toISOString(),
-            warning: 'Using JSON fallback - install better-sqlite3 for full database features'
-        },
-        swarms: [],
-        agents: [],
-        tasks: [],
-        messages: [],
-        consensus_votes: [],
-        knowledge_base: [
-            {
-                id: 'init-1',
-                category: 'system',
-                title: 'Fallback Memory System',
-                content: 'Using JSON-based fallback memory system. Install better-sqlite3 for full database features.',
-                confidence: 1.0,
-                created_at: new Date().toISOString()
-            }
-        ],
-        performance_metrics: [],
-        sessions: []
-    };
-    const fallbackPath = path.join(workingDir, '.hive-mind', 'memory.json');
-    await fs.writeFile(fallbackPath, JSON.stringify(fallbackDb, null, 2), 'utf8');
-    console.log('  ✅ Fallback memory database created');
-    return true;
+ */
+async function createFallbackMemoryDatabase(workingDir) {
+  console.log('    📄 Creating fallback JSON memory database...');
+
+  const fallbackDb = {
+    metadata: {
+      type: 'fallback',
+      initialized: new Date().toISOString(),
+      warning: 'Using JSON fallback - install better-sqlite3 for full database features',
+    },
+    swarms: [],
+    agents: [],
+    tasks: [],
+    messages: [],
+    consensus_votes: [],
+    knowledge_base: [
+      {
+        id: 'init-1',
+        category: 'system',
+        title: 'Fallback Memory System',
+        content:
+          'Using JSON-based fallback memory system. Install better-sqlite3 for full database features.',
+        confidence: 1.0,
+        created_at: new Date().toISOString(),
+      },
+    ],
+    performance_metrics: [],
+    sessions: [],
+  };
+
+  const fallbackPath = path.join(workingDir, '.hive-mind', 'memory.json');
+  await fs.writeFile(fallbackPath, JSON.stringify(fallbackDb, null, 2), 'utf8');
+
+  console.log('  ✅ Fallback memory database created');
+  return true;
 }
+
 /**
  * Create default queen and worker configurations
- */ export async function createDefaultConfigurations(workingDir, dryRun = false) {
-    console.log('  👑 Creating default queen and worker configurations...');
-    if (dryRun) {
-        console.log('    [DRY RUN] Would create queen configurations');
-        console.log('    [DRY RUN] Would create worker configurations');
-        console.log('    [DRY RUN] Would create role templates');
-        return;
-    }
-    const configDir = path.join(workingDir, '.hive-mind', 'config');
-    // Queen configurations
-    const queenConfigs = {
-        strategic: {
-            name: 'Strategic Queen',
-            description: 'Focuses on long-term planning and high-level coordination',
-            capabilities: [
-                'strategic-planning',
-                'resource-optimization',
-                'risk-assessment',
-                'quality-oversight',
-                'team-coordination'
-            ],
-            decisionStyle: 'analytical',
-            planningHorizon: 'long-term',
-            adaptability: 0.7,
-            specialties: [
-                'architecture',
-                'planning',
-                'coordination'
-            ]
-        },
-        tactical: {
-            name: 'Tactical Queen',
-            description: 'Focuses on execution efficiency and immediate problem-solving',
-            capabilities: [
-                'task-optimization',
-                'rapid-response',
-                'resource-allocation',
-                'performance-monitoring',
-                'conflict-resolution'
-            ],
-            decisionStyle: 'pragmatic',
-            planningHorizon: 'short-term',
-            adaptability: 0.9,
-            specialties: [
-                'execution',
-                'optimization',
-                'troubleshooting'
-            ]
-        },
-        adaptive: {
-            name: 'Adaptive Queen',
-            description: 'Dynamically adjusts approach based on context and feedback',
-            capabilities: [
-                'pattern-recognition',
-                'adaptive-learning',
-                'context-switching',
-                'feedback-integration',
-                'dynamic-planning'
-            ],
-            decisionStyle: 'flexible',
-            planningHorizon: 'adaptive',
-            adaptability: 1.0,
-            specialties: [
-                'learning',
-                'adaptation',
-                'context-awareness'
-            ]
-        }
-    };
-    // Worker role templates
-    const workerTemplates = {
-        architect: {
-            name: 'System Architect',
-            description: 'Designs system architecture and technical specifications',
-            capabilities: [
-                'system-design',
-                'architecture-patterns',
-                'scalability-planning',
-                'technology-selection',
-                'documentation'
-            ],
-            complexity: 0.9,
-            autonomy: 0.8,
-            collaboration: 0.7
-        },
-        researcher: {
-            name: 'Research Specialist',
-            description: 'Conducts research and gathers information for informed decisions',
-            capabilities: [
-                'information-gathering',
-                'analysis',
-                'trend-identification',
-                'competitive-research',
-                'reporting'
-            ],
-            complexity: 0.7,
-            autonomy: 0.9,
-            collaboration: 0.6
-        },
-        implementer: {
-            name: 'Implementation Specialist',
-            description: 'Translates designs into working code and solutions',
-            capabilities: [
-                'coding',
-                'debugging',
-                'integration',
-                'optimization',
-                'deployment'
-            ],
-            complexity: 0.8,
-            autonomy: 0.7,
-            collaboration: 0.8
-        },
-        tester: {
-            name: 'Quality Assurance Specialist',
-            description: 'Ensures quality through testing and validation',
-            capabilities: [
-                'testing',
-                'validation',
-                'quality-assurance',
-                'automation',
-                'reporting'
-            ],
-            complexity: 0.6,
-            autonomy: 0.8,
-            collaboration: 0.7
-        },
-        reviewer: {
-            name: 'Code Review Specialist',
-            description: 'Reviews code quality and provides improvement suggestions',
-            capabilities: [
-                'code-review',
-                'quality-assessment',
-                'best-practices',
-                'mentoring',
-                'documentation-review'
-            ],
-            complexity: 0.8,
-            autonomy: 0.8,
-            collaboration: 0.9
-        }
-    };
-    // Save configurations
-    await fs.writeFile(path.join(configDir, 'queens.json'), JSON.stringify(queenConfigs, null, 2), 'utf8');
-    await fs.writeFile(path.join(configDir, 'workers.json'), JSON.stringify(workerTemplates, null, 2), 'utf8');
-    console.log('  ✅ Default configurations created');
+ */
+export async function createDefaultConfigurations(workingDir, dryRun = false) {
+  console.log('  👑 Creating default queen and worker configurations...');
+
+  if (dryRun) {
+    console.log('    [DRY RUN] Would create queen configurations');
+    console.log('    [DRY RUN] Would create worker configurations');
+    console.log('    [DRY RUN] Would create role templates');
+    return;
+  }
+
+  const configDir = path.join(workingDir, '.hive-mind', 'config');
+
+  // Queen configurations
+  const queenConfigs = {
+    strategic: {
+      name: 'Strategic Queen',
+      description: 'Focuses on long-term planning and high-level coordination',
+      capabilities: [
+        'strategic-planning',
+        'resource-optimization',
+        'risk-assessment',
+        'quality-oversight',
+        'team-coordination',
+      ],
+      decisionStyle: 'analytical',
+      planningHorizon: 'long-term',
+      adaptability: 0.7,
+      specialties: ['architecture', 'planning', 'coordination'],
+    },
+    tactical: {
+      name: 'Tactical Queen',
+      description: 'Focuses on execution efficiency and immediate problem-solving',
+      capabilities: [
+        'task-optimization',
+        'rapid-response',
+        'resource-allocation',
+        'performance-monitoring',
+        'conflict-resolution',
+      ],
+      decisionStyle: 'pragmatic',
+      planningHorizon: 'short-term',
+      adaptability: 0.9,
+      specialties: ['execution', 'optimization', 'troubleshooting'],
+    },
+    adaptive: {
+      name: 'Adaptive Queen',
+      description: 'Dynamically adjusts approach based on context and feedback',
+      capabilities: [
+        'pattern-recognition',
+        'adaptive-learning',
+        'context-switching',
+        'feedback-integration',
+        'dynamic-planning',
+      ],
+      decisionStyle: 'flexible',
+      planningHorizon: 'adaptive',
+      adaptability: 1.0,
+      specialties: ['learning', 'adaptation', 'context-awareness'],
+    },
+  };
+
+  // Worker role templates
+  const workerTemplates = {
+    architect: {
+      name: 'System Architect',
+      description: 'Designs system architecture and technical specifications',
+      capabilities: [
+        'system-design',
+        'architecture-patterns',
+        'scalability-planning',
+        'technology-selection',
+        'documentation',
+      ],
+      complexity: 0.9,
+      autonomy: 0.8,
+      collaboration: 0.7,
+    },
+    researcher: {
+      name: 'Research Specialist',
+      description: 'Conducts research and gathers information for informed decisions',
+      capabilities: [
+        'information-gathering',
+        'analysis',
+        'trend-identification',
+        'competitive-research',
+        'reporting',
+      ],
+      complexity: 0.7,
+      autonomy: 0.9,
+      collaboration: 0.6,
+    },
+    implementer: {
+      name: 'Implementation Specialist',
+      description: 'Translates designs into working code and solutions',
+      capabilities: ['coding', 'debugging', 'integration', 'optimization', 'deployment'],
+      complexity: 0.8,
+      autonomy: 0.7,
+      collaboration: 0.8,
+    },
+    tester: {
+      name: 'Quality Assurance Specialist',
+      description: 'Ensures quality through testing and validation',
+      capabilities: ['testing', 'validation', 'quality-assurance', 'automation', 'reporting'],
+      complexity: 0.6,
+      autonomy: 0.8,
+      collaboration: 0.7,
+    },
+    reviewer: {
+      name: 'Code Review Specialist',
+      description: 'Reviews code quality and provides improvement suggestions',
+      capabilities: [
+        'code-review',
+        'quality-assessment',
+        'best-practices',
+        'mentoring',
+        'documentation-review',
+      ],
+      complexity: 0.8,
+      autonomy: 0.8,
+      collaboration: 0.9,
+    },
+  };
+
+  // Save configurations
+  await fs.writeFile(
+    path.join(configDir, 'queens.json'),
+    JSON.stringify(queenConfigs, null, 2),
+    'utf8',
+  );
+
+  await fs.writeFile(
+    path.join(configDir, 'workers.json'),
+    JSON.stringify(workerTemplates, null, 2),
+    'utf8',
+  );
+
+  console.log('  ✅ Default configurations created');
 }
+
 /**
  * Create hive-mind config file with sensible defaults
- */ export async function createHiveMindConfig(workingDir, customConfig = {}, dryRun = false) {
-    console.log('  ⚙️ Creating hive-mind configuration file...');
-    if (dryRun) {
-        console.log('    [DRY RUN] Would create config.json with merged settings');
-        return;
-    }
-    // Merge custom config with defaults
-    const config = mergeDeep(DEFAULT_HIVE_CONFIG, customConfig);
-    const configPath = path.join(workingDir, '.hive-mind', 'config.json');
-    await fs.writeFile(configPath, JSON.stringify(config, null, 2), 'utf8');
-    console.log('  ✅ Hive-mind configuration created');
-    return config;
+ */
+export async function createHiveMindConfig(workingDir, customConfig = {}, dryRun = false) {
+  console.log('  ⚙️ Creating hive-mind configuration file...');
+
+  if (dryRun) {
+    console.log('    [DRY RUN] Would create config.json with merged settings');
+    return;
+  }
+
+  // Merge custom config with defaults
+  const config = mergeDeep(DEFAULT_HIVE_CONFIG, customConfig);
+
+  const configPath = path.join(workingDir, '.hive-mind', 'config.json');
+  await fs.writeFile(configPath, JSON.stringify(config, null, 2), 'utf8');
+
+  console.log('  ✅ Hive-mind configuration created');
+  return config;
 }
+
 /**
  * Create initial README and documentation files
- */ export async function createHiveMindDocumentation(workingDir, dryRun = false) {
-    console.log('  📚 Creating hive-mind documentation...');
-    if (dryRun) {
-        console.log('    [DRY RUN] Would create README.md and documentation files');
-        return;
-    }
-    const readmeContent = `# Hive Mind System
+ */
+export async function createHiveMindDocumentation(workingDir, dryRun = false) {
+  console.log('  📚 Creating hive-mind documentation...');
+
+  if (dryRun) {
+    console.log('    [DRY RUN] Would create README.md and documentation files');
+    return;
+  }
+
+  const readmeContent = `# Hive Mind System
 
 This directory contains the Claude Flow Hive Mind system configuration and data.
 
@@ -626,105 +635,115 @@ Edit \`.hive-mind/config.json\` to customize:
 
 For more information, see the [Hive Mind Documentation](https://github.com/ruvnet/claude-flow/docs/hive-mind.md).
 `;
-    await fs.writeFile(path.join(workingDir, '.hive-mind', 'README.md'), readmeContent, 'utf8');
-    console.log('  ✅ Hive-mind documentation created');
+
+  await fs.writeFile(path.join(workingDir, '.hive-mind', 'README.md'), readmeContent, 'utf8');
+
+  console.log('  ✅ Hive-mind documentation created');
 }
+
 /**
  * Complete hive-mind initialization
- */ export async function initializeHiveMind(workingDir, options = {}, dryRun = false) {
-    console.log('🧠 Initializing Hive Mind System...');
-    try {
-        // Create directory structure
-        await createHiveMindDirectories(workingDir, dryRun);
-        // Initialize collective memory database
-        await initializeCollectiveMemoryDatabase(workingDir, dryRun);
-        // Create default configurations
-        await createDefaultConfigurations(workingDir, dryRun);
-        // Create main config file
-        await createHiveMindConfig(workingDir, options.config || {}, dryRun);
-        // Create documentation
-        await createHiveMindDocumentation(workingDir, dryRun);
-        if (!dryRun) {
-            printSuccess('🧠 Hive Mind System initialized successfully');
-        } else {
-            console.log('[DRY RUN] Hive Mind System would be fully initialized');
-        }
-        return {
-            success: true,
-            features: [
-                'Collective memory database',
-                'Queen and worker configurations',
-                'Consensus mechanisms',
-                'Performance monitoring',
-                'Session management',
-                'Knowledge base'
-            ]
-        };
-    } catch (error) {
-        printError(`Failed to initialize Hive Mind System: ${error.message}`);
-        return {
-            success: false,
-            error: error.message,
-            rollbackRequired: true
-        };
+ */
+export async function initializeHiveMind(workingDir, options = {}, dryRun = false) {
+  console.log('🧠 Initializing Hive Mind System...');
+
+  try {
+    // Create directory structure
+    await createHiveMindDirectories(workingDir, dryRun);
+
+    // Initialize collective memory database
+    await initializeCollectiveMemoryDatabase(workingDir, dryRun);
+
+    // Create default configurations
+    await createDefaultConfigurations(workingDir, dryRun);
+
+    // Create main config file
+    await createHiveMindConfig(workingDir, options.config || {}, dryRun);
+
+    // Create documentation
+    await createHiveMindDocumentation(workingDir, dryRun);
+
+    if (!dryRun) {
+      printSuccess('🧠 Hive Mind System initialized successfully');
+    } else {
+      console.log('[DRY RUN] Hive Mind System would be fully initialized');
     }
+
+    return {
+      success: true,
+      features: [
+        'Collective memory database',
+        'Queen and worker configurations',
+        'Consensus mechanisms',
+        'Performance monitoring',
+        'Session management',
+        'Knowledge base',
+      ],
+    };
+  } catch (error) {
+    printError(`Failed to initialize Hive Mind System: ${error.message}`);
+    return {
+      success: false,
+      error: error.message,
+      rollbackRequired: true,
+    };
+  }
 }
+
 /**
  * Get hive-mind initialization status for init summary
- */ export function getHiveMindStatus(workingDir) {
-    const configPath = path.join(workingDir, '.hive-mind', 'config.json');
-    const dbPath = path.join(workingDir, '.hive-mind', 'hive.db');
-    const fallbackPath = path.join(workingDir, '.hive-mind', 'memory.json');
-    const status = {
-        configured: existsSync(configPath),
-        database: existsSync(dbPath) ? 'sqlite' : existsSync(fallbackPath) ? 'fallback' : 'none',
-        directories: existsSync(path.join(workingDir, '.hive-mind'))
-    };
-    return status;
+ */
+export function getHiveMindStatus(workingDir) {
+  const configPath = path.join(workingDir, '.hive-mind', 'config.json');
+  const dbPath = path.join(workingDir, '.hive-mind', 'hive.db');
+  const fallbackPath = path.join(workingDir, '.hive-mind', 'memory.json');
+
+  const status = {
+    configured: existsSync(configPath),
+    database: existsSync(dbPath) ? 'sqlite' : existsSync(fallbackPath) ? 'fallback' : 'none',
+    directories: existsSync(path.join(workingDir, '.hive-mind')),
+  };
+
+  return status;
 }
+
 /**
  * Rollback hive-mind initialization (cleanup on failure)
- */ export async function rollbackHiveMindInit(workingDir) {
-    console.log('🔄 Rolling back hive-mind initialization...');
-    try {
-        const hiveMindDir = path.join(workingDir, '.hive-mind');
-        if (existsSync(hiveMindDir)) {
-            await fs.rmdir(hiveMindDir, {
-                recursive: true
-            });
-            console.log('  ✅ Hive-mind directory removed');
-        }
-        return {
-            success: true
-        };
-    } catch (error) {
-        printError(`Failed to rollback hive-mind initialization: ${error.message}`);
-        return {
-            success: false,
-            error: error.message
-        };
+ */
+export async function rollbackHiveMindInit(workingDir) {
+  console.log('🔄 Rolling back hive-mind initialization...');
+
+  try {
+    const hiveMindDir = path.join(workingDir, '.hive-mind');
+    if (existsSync(hiveMindDir)) {
+      await fs.rmdir(hiveMindDir, { recursive: true });
+      console.log('  ✅ Hive-mind directory removed');
     }
+    return { success: true };
+  } catch (error) {
+    printError(`Failed to rollback hive-mind initialization: ${error.message}`);
+    return { success: false, error: error.message };
+  }
 }
+
 /**
  * Deep merge utility for configuration objects
- */ function mergeDeep(target, source) {
-    const output = Object.assign({}, target);
-    if (isObject(target) && isObject(source)) {
-        Object.keys(source).forEach((key)=>{
-            if (isObject(source[key])) {
-                if (!(key in target)) Object.assign(output, {
-                    [key]: source[key]
-                });
-                else output[key] = mergeDeep(target[key], source[key]);
-            } else {
-                Object.assign(output, {
-                    [key]: source[key]
-                });
-            }
-        });
-    }
-    return output;
+ */
+function mergeDeep(target, source) {
+  const output = Object.assign({}, target);
+  if (isObject(target) && isObject(source)) {
+    Object.keys(source).forEach((key) => {
+      if (isObject(source[key])) {
+        if (!(key in target)) Object.assign(output, { [key]: source[key] });
+        else output[key] = mergeDeep(target[key], source[key]);
+      } else {
+        Object.assign(output, { [key]: source[key] });
+      }
+    });
+  }
+  return output;
 }
+
 function isObject(item) {
-    return item && typeof item === 'object' && !Array.isArray(item);
+  return item && typeof item === 'object' && !Array.isArray(item);
 }