claude-flow-novice 2.0.3 → 2.0.4

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

@@ -1,117 +1,127 @@
 /**
  * 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, printWarning } from '../../utils.js';
-
+ */ import { promises as fs } from "fs";
+import { existsSync } from "fs";
+import path from "path";
+import { printSuccess, printError } 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,
-  },
-  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,
+ */ 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
     },
-    channels: [
-      'task-coordination',
-      'knowledge-sharing',
-      'consensus-voting',
-      'error-reporting',
-      'performance-metrics',
-    ],
-  },
-  integration: {
-    mcpTools: {
-      enabled: true,
-      parallel: true,
-      timeout: 60000,
-      fallbackMode: 'sequential',
+    workers: {
+        maxWorkers: 8,
+        defaultCapabilities: [
+            'code-analysis',
+            'implementation',
+            'testing',
+            'documentation'
+        ],
+        autoScale: true,
+        scaleThreshold: 0.8,
+        specializedRoles: [
+            'architect',
+            'researcher',
+            'implementer',
+            'tester',
+            'reviewer'
+        ]
     },
-    claudeCode: {
-      enabled: true,
-      autoSpawn: true,
-      coordination: true,
-      sharedContext: true,
+    consensus: {
+        algorithm: 'weighted-majority',
+        minimumParticipants: 3,
+        timeoutMs: 30000,
+        requiredConsensus: 0.67,
+        votingMethods: [
+            'majority',
+            'weighted',
+            'unanimous',
+            'quorum'
+        ]
     },
-    github: {
-      enabled: false,
-      autoCommit: false,
-      branchStrategy: 'feature',
+    memory: {
+        enabled: true,
+        size: 100,
+        persistenceMode: 'database',
+        sharedMemoryNamespace: 'hive-collective',
+        retentionDays: 30,
+        compressionEnabled: true,
+        encryptionEnabled: false
     },
-  },
-  monitoring: {
-    enabled: true,
-    metricsCollection: true,
-    performanceTracking: true,
-    healthChecks: true,
-    alerting: {
-      enabled: false,
-      thresholds: {
-        errorRate: 0.1,
-        responseTime: 5000,
-        consensusFailures: 3,
-      },
+    communication: {
+        protocol: 'secure-messaging',
+        encryption: false,
+        messageQueue: {
+            maxSize: 1000,
+            priorityLevels: 5,
+            batchProcessing: true
+        },
+        channels: [
+            'task-coordination',
+            'knowledge-sharing',
+            'consensus-voting',
+            'error-reporting',
+            'performance-metrics'
+        ]
     },
-  },
+    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,
@@ -125,7 +135,7 @@ export const HIVE_DB_SCHEMA = {
       metadata TEXT DEFAULT '{}'
     );
   `,
-  agents: `
+    agents: `
     CREATE TABLE IF NOT EXISTS agents (
       id TEXT PRIMARY KEY,
       swarm_id TEXT,
@@ -143,7 +153,7 @@ export const HIVE_DB_SCHEMA = {
       FOREIGN KEY (swarm_id) REFERENCES swarms (id)
     );
   `,
-  tasks: `
+    tasks: `
     CREATE TABLE IF NOT EXISTS tasks (
       id TEXT PRIMARY KEY,
       swarm_id TEXT,
@@ -163,7 +173,7 @@ export const HIVE_DB_SCHEMA = {
       FOREIGN KEY (agent_id) REFERENCES agents (id)
     );
   `,
-  messages: `
+    messages: `
     CREATE TABLE IF NOT EXISTS messages (
       id TEXT PRIMARY KEY,
       swarm_id TEXT,
@@ -182,7 +192,7 @@ export const HIVE_DB_SCHEMA = {
       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,
@@ -196,7 +206,7 @@ export const HIVE_DB_SCHEMA = {
       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,
@@ -213,7 +223,7 @@ export const HIVE_DB_SCHEMA = {
       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,
@@ -224,7 +234,7 @@ export const HIVE_DB_SCHEMA = {
       metadata TEXT DEFAULT '{}'
     );
   `,
-  sessions: `
+    sessions: `
     CREATE TABLE IF NOT EXISTS sessions (
       id TEXT PRIMARY KEY,
       swarm_id TEXT NOT NULL,
@@ -242,356 +252,337 @@ export const HIVE_DB_SCHEMA = {
       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);
+ */ 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}`);
+        }
+    }
     if (!dryRun) {
-      await fs.mkdir(fullPath, { recursive: true });
-    } else {
-      console.log(`    [DRY RUN] Would create: ${dir}`);
+        console.log('  ✅ Hive-mind directories created');
     }
-  }
-
-  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;
-  }
-
-  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);
+ */ 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;
     }
-
-    // Insert initial metadata
-    const insertInitialData = hiveDb.prepare(`
+    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(`
       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);
+        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);
     }
-
-    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.
 
@@ -635,115 +626,105 @@ 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');
+ */ 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
+        };
     }
-
-    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');
+ */ 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
+        };
     }
-    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);
 }