claude-flow 2.7.0 → 2.7.2

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

@@ -1,699 +0,0 @@
-/**
- * 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';
-/**
- * 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,
-        },
-        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: `
-    CREATE TABLE IF NOT EXISTS swarms (
-      id TEXT PRIMARY KEY,
-      name TEXT NOT NULL,
-      objective TEXT,
-      status TEXT DEFAULT 'active',
-      queen_type TEXT DEFAULT 'strategic',
-      topology TEXT DEFAULT 'hierarchical',
-      max_agents INTEGER DEFAULT 8,
-      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-      updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-      metadata TEXT DEFAULT '{}'
-    );
-  `,
-    agents: `
-    CREATE TABLE IF NOT EXISTS agents (
-      id TEXT PRIMARY KEY,
-      swarm_id TEXT,
-      name TEXT NOT NULL,
-      type TEXT NOT NULL,
-      role TEXT,
-      capabilities TEXT DEFAULT '[]',
-      status TEXT DEFAULT 'active',
-      performance_score REAL DEFAULT 0.5,
-      task_count INTEGER DEFAULT 0,
-      success_rate REAL DEFAULT 1.0,
-      last_active DATETIME DEFAULT CURRENT_TIMESTAMP,
-      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-      metadata TEXT DEFAULT '{}',
-      FOREIGN KEY (swarm_id) REFERENCES swarms (id)
-    );
-  `,
-    tasks: `
-    CREATE TABLE IF NOT EXISTS tasks (
-      id TEXT PRIMARY KEY,
-      swarm_id TEXT,
-      agent_id TEXT,
-      name TEXT NOT NULL,
-      description TEXT,
-      status TEXT DEFAULT 'pending',
-      priority INTEGER DEFAULT 3,
-      complexity REAL DEFAULT 0.5,
-      estimated_time INTEGER,
-      actual_time INTEGER,
-      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-      started_at DATETIME,
-      completed_at DATETIME,
-      metadata TEXT DEFAULT '{}',
-      FOREIGN KEY (swarm_id) REFERENCES swarms (id),
-      FOREIGN KEY (agent_id) REFERENCES agents (id)
-    );
-  `,
-    messages: `
-    CREATE TABLE IF NOT EXISTS messages (
-      id TEXT PRIMARY KEY,
-      swarm_id TEXT,
-      sender_id TEXT,
-      recipient_id TEXT,
-      channel TEXT DEFAULT 'general',
-      type TEXT DEFAULT 'info',
-      content TEXT NOT NULL,
-      priority INTEGER DEFAULT 3,
-      consensus_vote REAL,
-      timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
-      processed BOOLEAN DEFAULT 0,
-      metadata TEXT DEFAULT '{}',
-      FOREIGN KEY (swarm_id) REFERENCES swarms (id),
-      FOREIGN KEY (sender_id) REFERENCES agents (id),
-      FOREIGN KEY (recipient_id) REFERENCES agents (id)
-    );
-  `,
-    consensus_votes: `
-    CREATE TABLE IF NOT EXISTS consensus_votes (
-      id TEXT PRIMARY KEY,
-      swarm_id TEXT,
-      proposal_id TEXT NOT NULL,
-      agent_id TEXT,
-      vote REAL NOT NULL,
-      weight REAL DEFAULT 1.0,
-      justification TEXT,
-      timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
-      FOREIGN KEY (swarm_id) REFERENCES swarms (id),
-      FOREIGN KEY (agent_id) REFERENCES agents (id)
-    );
-  `,
-    knowledge_base: `
-    CREATE TABLE IF NOT EXISTS knowledge_base (
-      id TEXT PRIMARY KEY,
-      swarm_id TEXT,
-      category TEXT DEFAULT 'general',
-      title TEXT NOT NULL,
-      content TEXT NOT NULL,
-      tags TEXT DEFAULT '[]',
-      confidence REAL DEFAULT 0.5,
-      source_agent_id TEXT,
-      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-      updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-      access_count INTEGER DEFAULT 0,
-      FOREIGN KEY (swarm_id) REFERENCES swarms (id),
-      FOREIGN KEY (source_agent_id) REFERENCES agents (id)
-    );
-  `,
-    performance_metrics: `
-    CREATE TABLE IF NOT EXISTS performance_metrics (
-      id TEXT PRIMARY KEY,
-      entity_type TEXT NOT NULL,
-      entity_id TEXT NOT NULL,
-      metric_name TEXT NOT NULL,
-      metric_value REAL NOT NULL,
-      timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
-      metadata TEXT DEFAULT '{}'
-    );
-  `,
-    sessions: `
-    CREATE TABLE IF NOT EXISTS sessions (
-      id TEXT PRIMARY KEY,
-      swarm_id TEXT NOT NULL,
-      swarm_name TEXT NOT NULL,
-      objective TEXT,
-      status TEXT DEFAULT 'active',
-      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-      updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-      paused_at DATETIME,
-      resumed_at DATETIME,
-      completion_percentage REAL DEFAULT 0,
-      checkpoint_data TEXT,
-      metadata TEXT,
-      parent_pid INTEGER,
-      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}`);
-        }
-    }
-    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);
-        }
-        // 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);
-    }
-}
-/**
- * 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;
-}
-/**
- * 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');
-}
-/**
- * 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;
-}
-/**
- * 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
-
-This directory contains the Claude Flow Hive Mind system configuration and data.
-
-## Directory Structure
-
-- **config/**: Configuration files for queens, workers, and system settings
-- **sessions/**: Active and historical session data
-- **memory/**: Collective memory and knowledge base
-- **logs/**: System and debug logs
-- **backups/**: Automated backups of system state
-- **templates/**: Templates for agents and workflows
-- **exports/**: Exported data and reports
-
-## Database Files
-
-- **hive.db**: Main SQLite database (or memory.json as fallback)
-- **config.json**: Primary system configuration
-
-## Getting Started
-
-1. Initialize: \`npx claude-flow@alpha hive-mind init\`
-2. Spawn swarm: \`npx claude-flow@alpha hive-mind spawn "your objective"\`
-3. Check status: \`npx claude-flow@alpha hive-mind status\`
-
-## Features
-
-- **Collective Intelligence**: Multiple AI agents working together
-- **Consensus Building**: Democratic decision-making process
-- **Adaptive Learning**: System improves over time
-- **Fault Tolerance**: Self-healing and recovery capabilities
-- **Performance Monitoring**: Real-time metrics and optimization
-
-## Configuration
-
-Edit \`.hive-mind/config.json\` to customize:
-- Queen type and capabilities
-- Worker specializations
-- Consensus algorithms
-- Memory settings
-- Integration options
-
-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');
-}
-/**
- * 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
-        };
-    }
-}
-/**
- * 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;
-}
-/**
- * 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 };
-    }
-}
-/**
- * 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 isObject(item) {
-    return (item && typeof item === 'object' && !Array.isArray(item));
-}
-//# sourceMappingURL=hive-mind-init.js.map