@sparkleideas/ruv-swarm 1.0.18-patch.1

package/src/index-enhanced.js

@@ -0,0 +1,734 @@
+/**
+ * Enhanced RuvSwarm Main Class
+ * Provides full WASM capabilities with progressive loading,
+ * neural networks, forecasting, and swarm orchestration
+ */
+
+import { WasmModuleLoader } from './wasm-loader.js';
+import { SwarmPersistencePooled } from './persistence-pooled.js';
+import { getContainer } from './singleton-container.js';
+// import { NeuralAgentFactory } from './neural-agent.js';
+// import path from 'path';
+// import fs from 'fs';
+
+class RuvSwarm {
+  constructor() {
+    this.wasmLoader = new WasmModuleLoader();
+    this.persistence = null;
+    this.activeSwarms = new Map();
+    this.globalAgents = new Map();
+    this.isInitialized = false;
+    this.metrics = {
+      totalSwarms: 0,
+      totalAgents: 0,
+      totalTasks: 0,
+      memoryUsage: 0,
+      performance: {},
+    };
+    this.features = {
+      neural_networks: false,
+      forecasting: false,
+      cognitive_diversity: false,
+      simd_support: false,
+    };
+  }
+
+  /**
+   * Cleanup method for proper resource disposal
+   */
+  destroy() {
+    console.log('🧹 Cleaning up RuvSwarm instance...');
+
+    // Terminate all active swarms
+    for (const swarm of this.activeSwarms.values()) {
+      if (typeof swarm.terminate === 'function') {
+        swarm.terminate();
+      }
+    }
+
+    this.activeSwarms.clear();
+    this.globalAgents.clear();
+
+    // Cleanup persistence
+    if (this.persistence && typeof this.persistence.close === 'function') {
+      this.persistence.close();
+    }
+
+    // Cleanup WASM loader
+    if (this.wasmLoader && typeof this.wasmLoader.cleanup === 'function') {
+      this.wasmLoader.cleanup();
+    }
+
+    this.isInitialized = false;
+  }
+
+  static async initialize(options = {}) {
+    const container = getContainer();
+
+    // Register RuvSwarm factory if not already registered
+    if (!container.has('RuvSwarm')) {
+      container.register('RuvSwarm', () => new RuvSwarm(), {
+        singleton: true,
+        lazy: false,
+      });
+    }
+
+    // Get or create singleton instance through container
+    const instance = container.get('RuvSwarm');
+
+    const {
+      // wasmPath = './wasm',
+      loadingStrategy = 'progressive',
+      enablePersistence = true,
+      enableNeuralNetworks = true,
+      enableForecasting = false,
+      useSIMD = true,
+      debug = false,
+    } = options;
+
+    // Check if already initialized through container
+    if (instance.isInitialized) {
+      if (debug) {
+        console.log('[DEBUG] RuvSwarm already initialized through container');
+      }
+      return instance;
+    }
+
+    console.log('🧠 Initializing @sparkleideas/ruv-swarm with WASM capabilities...');
+
+    try {
+      // Initialize WASM modules
+      await instance.wasmLoader.initialize(loadingStrategy);
+
+      // Detect and enable features
+      await instance.detectFeatures(useSIMD);
+
+      // Initialize pooled persistence if enabled
+      if (enablePersistence) {
+        try {
+          // Configure pool settings based on environment or defaults
+          const poolOptions = {
+            maxReaders: parseInt(process.env.POOL_MAX_READERS) || 6,
+            maxWorkers: parseInt(process.env.POOL_MAX_WORKERS) || 3,
+            mmapSize: parseInt(process.env.POOL_MMAP_SIZE) || 268435456, // 256MB
+            cacheSize: parseInt(process.env.POOL_CACHE_SIZE) || -64000, // 64MB
+            enableBackup: process.env.POOL_ENABLE_BACKUP === 'true',
+            healthCheckInterval: 60000, // 1 minute
+          };
+          
+          instance.persistence = new SwarmPersistencePooled(undefined, poolOptions);
+          await instance.persistence.initialize();
+          console.log('💾 High-availability pooled persistence layer initialized');
+          console.log(`📊 Pool configuration: ${poolOptions.maxReaders} readers, ${poolOptions.maxWorkers} workers`);
+        } catch (error) {
+          console.warn('⚠️ Pooled persistence not available:', error.message);
+          instance.persistence = null;
+        }
+      }
+
+      // Pre-load neural networks if enabled
+      if (enableNeuralNetworks) {
+        try {
+          await instance.wasmLoader.loadModule('neural');
+          instance.features.neural_networks = true;
+          console.log('🧠 Neural network capabilities loaded');
+        } catch (error) {
+          console.warn('⚠️ Neural network module not available:', error.message);
+          instance.features.neural_networks = false;
+        }
+      }
+
+      // Pre-load forecasting if enabled
+      if (enableForecasting && enableNeuralNetworks) {
+        try {
+          await instance.wasmLoader.loadModule('forecasting');
+          instance.features.forecasting = true;
+          console.log('📈 Forecasting capabilities loaded');
+        } catch (error) {
+          console.warn('⚠️ Forecasting module not available:', error.message);
+          instance.features.forecasting = false;
+        }
+      }
+
+      console.log('✅ @sparkleideas/ruv-swarm initialized successfully');
+      console.log('📊 Features:', instance.features);
+
+      // Mark as initialized
+      instance.isInitialized = true;
+
+      return instance;
+    } catch (error) {
+      console.error('❌ Failed to initialize @sparkleideas/ruv-swarm:', error);
+      throw error;
+    }
+  }
+
+  async detectFeatures(useSIMD = true) {
+    try {
+      // Load core module to detect basic features
+      const coreModule = await this.wasmLoader.loadModule('core');
+
+      // Detect SIMD support
+      if (useSIMD) {
+        this.features.simd_support = RuvSwarm.detectSIMDSupport();
+      }
+
+      // Check if core module has the expected exports
+      if (coreModule.exports) {
+        // Check for neural network support
+        this.features.neural_networks = true; // Will be validated when module loads
+
+        // Check for cognitive diversity support
+        this.features.cognitive_diversity = true; // Default enabled
+      }
+
+      console.log('🔍 Feature detection complete');
+    } catch (error) {
+      console.warn('⚠️ Feature detection failed:', error.message);
+    }
+  }
+
+  async createSwarm(config) {
+    const {
+      id = null, // Allow existing ID for persistence loading
+      name = 'default-swarm',
+      topology = 'mesh',
+      strategy = 'balanced',
+      maxAgents = 10,
+      enableCognitiveDiversity = true,
+      // enableNeuralAgents = true,
+    } = config;
+
+    // Ensure core module is loaded
+    const coreModule = await this.wasmLoader.loadModule('core');
+
+    // Create swarm configuration
+    const swarmConfig = {
+      name,
+      topology_type: topology,
+      max_agents: maxAgents,
+      enable_cognitive_diversity: enableCognitiveDiversity && this.features.cognitive_diversity,
+    };
+
+    // Use the core module exports to create swarm
+    let wasmSwarm;
+    if (coreModule.exports && coreModule.exports.RuvSwarm) {
+      try {
+        wasmSwarm = new coreModule.exports.RuvSwarm();
+        // Store swarm config - use existing ID if provided
+        wasmSwarm.id = id || `swarm-${Date.now()}`;
+        wasmSwarm.name = name;
+        wasmSwarm.config = swarmConfig;
+      } catch (error) {
+        console.warn('Failed to create WASM swarm:', error.message);
+        // Fallback to JavaScript implementation
+        wasmSwarm = {
+          id: id || `swarm-${Date.now()}`,
+          name,
+          config: swarmConfig,
+          agents: new Map(),
+          tasks: new Map(),
+        };
+      }
+    } else {
+      // Fallback for placeholder or different module structure
+      wasmSwarm = {
+        id: id || `swarm-${Date.now()}`,
+        name,
+        config: swarmConfig,
+        agents: new Map(),
+        tasks: new Map(),
+      };
+    }
+
+    // Create JavaScript wrapper
+    const swarm = new Swarm(wasmSwarm.id || wasmSwarm.name, wasmSwarm, this);
+
+    // Persist swarm if persistence is enabled and this is a new swarm
+    if (this.persistence && !id) {
+      try {
+        this.persistence.createSwarm({
+          id: swarm.id,
+          name,
+          topology,
+          strategy,
+          maxAgents,
+          created: new Date().toISOString(),
+        });
+      } catch (error) {
+        if (!error.message.includes('UNIQUE constraint failed')) {
+          console.warn('Failed to persist swarm:', error.message);
+        }
+      }
+    }
+
+    this.activeSwarms.set(swarm.id, swarm);
+    this.metrics.totalSwarms++;
+
+    console.log(`🐝 Created swarm: ${name} (${swarm.id})`);
+    return swarm;
+  }
+
+  async getSwarmStatus(swarmId, detailed = false) {
+    const swarm = this.activeSwarms.get(swarmId);
+    if (!swarm) {
+      throw new Error(`Swarm not found: ${swarmId}`);
+    }
+
+    return swarm.getStatus(detailed);
+  }
+
+  async getAllSwarms() {
+    const swarms = [];
+    for (const [id, swarm] of this.activeSwarms) {
+      swarms.push({
+        id,
+        status: await swarm.getStatus(false),
+      });
+    }
+    return swarms;
+  }
+
+  async getGlobalMetrics() {
+    this.metrics.memoryUsage = this.wasmLoader.getTotalMemoryUsage();
+
+    // Aggregate metrics from all swarms
+    let totalAgents = 0;
+    let totalTasks = 0;
+
+    for (const swarm of this.activeSwarms.values()) {
+      const status = await swarm.getStatus(false);
+      totalAgents += status.agents?.total || 0;
+      totalTasks += status.tasks?.total || 0;
+    }
+
+    this.metrics.totalAgents = totalAgents;
+    this.metrics.totalTasks = totalTasks;
+    this.metrics.totalSwarms = this.activeSwarms.size;
+
+    return {
+      ...this.metrics,
+      features: this.features,
+      wasm_modules: this.wasmLoader.getModuleStatus(),
+      timestamp: new Date().toISOString(),
+    };
+  }
+
+  // Feature detection helpers
+  static detectSIMDSupport() {
+    try {
+      // Check for WebAssembly SIMD support using v128 type validation
+      // This is more compatible across Node.js versions
+      const simdTestModule = new Uint8Array([
+        0x00, 0x61, 0x73, 0x6d, // WASM magic
+        0x01, 0x00, 0x00, 0x00, // Version 1
+        0x01, 0x05, 0x01, // Type section: 1 type
+        0x60, 0x00, 0x01, 0x7b, // Function type: () -> v128 (SIMD type)
+      ]);
+
+      // If v128 type is supported, SIMD is available
+      return WebAssembly.validate(simdTestModule);
+    } catch {
+      return false;
+    }
+  }
+
+  static getVersion() {
+    return '0.2.0'; // Enhanced version with full WASM capabilities
+  }
+
+  static getMemoryUsage() {
+    if (typeof performance !== 'undefined' && performance.memory) {
+      return {
+        used: performance.memory.usedJSHeapSize,
+        total: performance.memory.totalJSHeapSize,
+        limit: performance.memory.jsHeapSizeLimit,
+      };
+    }
+    return null;
+  }
+
+  static getRuntimeFeatures() {
+    return {
+      webassembly: typeof WebAssembly !== 'undefined',
+      simd: RuvSwarm.detectSIMDSupport(),
+      workers: typeof Worker !== 'undefined',
+      shared_array_buffer: typeof SharedArrayBuffer !== 'undefined',
+      bigint: typeof BigInt !== 'undefined',
+    };
+  }
+
+  // Instance method that delegates to static method for API convenience
+  detectSIMDSupport() {
+    return RuvSwarm.detectSIMDSupport();
+  }
+}
+
+// Enhanced Swarm wrapper class
+class Swarm {
+  constructor(id, wasmInstance, ruvSwarmInstance) {
+    this.id = id;
+    this.wasmSwarm = wasmInstance;
+    this.ruvSwarm = ruvSwarmInstance;
+    this.agents = new Map();
+    this.tasks = new Map();
+  }
+
+  async spawn(config) {
+    const {
+      id = null, // Allow existing ID for persistence loading
+      type = 'researcher',
+      name = null,
+      capabilities = null,
+      enableNeuralNetwork = true,
+    } = config;
+
+    // Ensure neural networks are loaded if requested
+    if (enableNeuralNetwork && this.ruvSwarm.features.neural_networks) {
+      await this.ruvSwarm.wasmLoader.loadModule('neural');
+    }
+
+    const agentConfig = {
+      agent_type: type,
+      name: name || `${type}-${Date.now()}`,
+      capabilities: capabilities || [],
+      max_agents: 100, // Default limit
+    };
+
+    let result;
+    if (this.wasmSwarm.spawn) {
+      result = this.wasmSwarm.spawn(agentConfig);
+    } else {
+      // Fallback for placeholder - use existing ID if provided
+      result = {
+        agent_id: id || `agent-${Date.now()}`,
+        name: agentConfig.name,
+        type: agentConfig.agent_type,
+        capabilities: agentConfig.capabilities,
+        cognitive_pattern: 'adaptive',
+        neural_network_id: enableNeuralNetwork ? `nn-${Date.now()}` : null,
+      };
+    }
+
+    const agentId = id || result.agent_id || result.id;
+
+    // Create JavaScript wrapper
+    const agent = new Agent(agentId, result, this);
+    this.agents.set(agentId, agent);
+
+    // Persist agent if persistence is enabled and this is a new agent
+    if (this.ruvSwarm.persistence && !id) {
+      try {
+        this.ruvSwarm.persistence.createAgent({
+          id: agentId,
+          swarmId: this.id,
+          name: result.name,
+          type,
+          capabilities: result.capabilities,
+          cognitive_pattern: result.cognitive_pattern,
+          created: new Date().toISOString(),
+        });
+      } catch (error) {
+        if (!error.message.includes('UNIQUE constraint failed')) {
+          console.warn('Failed to persist agent:', error.message);
+        }
+      }
+    }
+
+    console.log(`🤖 Spawned agent: ${result.name} (${type})`);
+    return agent;
+  }
+
+  async orchestrate(taskConfig) {
+    const {
+      description,
+      priority = 'medium',
+      dependencies = [],
+      maxAgents = null,
+      estimatedDuration = null,
+      requiredCapabilities = [],
+    } = taskConfig;
+
+    const config = {
+      description,
+      priority,
+      dependencies,
+      max_agents: maxAgents,
+      estimated_duration_ms: estimatedDuration,
+    };
+
+    let result;
+    if (this.wasmSwarm.orchestrate) {
+      result = this.wasmSwarm.orchestrate(config);
+    } else {
+      // Enhanced fallback with proper agent assignment
+      const availableAgents = this.selectAvailableAgents(requiredCapabilities, maxAgents);
+
+      if (availableAgents.length === 0) {
+        throw new Error('No agents available for task orchestration. Please spawn agents first.');
+      }
+
+      // Assign task to selected agents
+      const assignedAgentIds = availableAgents.map(agent => agent.id);
+
+      // Update agent status to busy
+      for (const agent of availableAgents) {
+        await agent.updateStatus('busy');
+      }
+
+      result = {
+        task_id: `task-${Date.now()}`,
+        task_description: description,
+        description,
+        status: 'orchestrated',
+        assigned_agents: assignedAgentIds,
+        priority,
+        estimated_duration_ms: estimatedDuration,
+        agent_selection_strategy: 'capability_and_load_based',
+      };
+    }
+
+    const taskId = result.task_id || result.id;
+
+    // Create JavaScript wrapper
+    const task = new Task(taskId, result, this);
+    this.tasks.set(taskId, task);
+
+    // Persist task if persistence is enabled
+    if (this.ruvSwarm.persistence) {
+      await this.ruvSwarm.persistence.createTask({
+        id: taskId,
+        swarmId: this.id,
+        description,
+        priority,
+        assigned_agents: result.assigned_agents,
+        created: new Date().toISOString(),
+      });
+    }
+
+    console.log(`📋 Orchestrated task: ${description} (${taskId}) - Assigned to ${result.assigned_agents.length} agents`);
+    return task;
+  }
+
+  // Helper method to select available agents for task assignment
+  selectAvailableAgents(requiredCapabilities = [], maxAgents = null) {
+    const availableAgents = Array.from(this.agents.values()).filter(agent => {
+      // Agent must be idle or active (not busy)
+      if (agent.status === 'busy') {
+        return false;
+      }
+
+      // Check if agent has required capabilities
+      if (requiredCapabilities.length > 0) {
+        const hasCapabilities = requiredCapabilities.some(capability =>
+          agent.capabilities.includes(capability),
+        );
+        if (!hasCapabilities) {
+          return false;
+        }
+      }
+
+      return true;
+    });
+
+    // Apply maxAgents limit if specified
+    if (maxAgents && maxAgents > 0) {
+      return availableAgents.slice(0, maxAgents);
+    }
+
+    return availableAgents;
+  }
+
+  async getStatus(detailed = false) {
+    if (this.wasmSwarm.get_status) {
+      return this.wasmSwarm.get_status(detailed);
+    }
+
+    // Fallback status
+    return {
+      id: this.id,
+      agents: {
+        total: this.agents.size,
+        active: Array.from(this.agents.values()).filter(a => a.status === 'active').length,
+        idle: Array.from(this.agents.values()).filter(a => a.status === 'idle').length,
+      },
+      tasks: {
+        total: this.tasks.size,
+        pending: Array.from(this.tasks.values()).filter(t => t.status === 'pending').length,
+        in_progress: Array.from(this.tasks.values()).filter(t => t.status === 'in_progress').length,
+        completed: Array.from(this.tasks.values()).filter(t => t.status === 'completed').length,
+      },
+    };
+  }
+
+  async monitor(duration = 10000, interval = 1000) {
+    if (this.wasmSwarm.monitor) {
+      return this.wasmSwarm.monitor(duration, interval);
+    }
+
+    // Fallback monitoring
+    console.log(`📊 Monitoring swarm ${this.id} for ${duration}ms...`);
+    return {
+      duration,
+      interval,
+      snapshots: [],
+    };
+  }
+
+  async terminate() {
+    console.log(`🛑 Terminating swarm: ${this.id}`);
+    this.ruvSwarm.activeSwarms.delete(this.id);
+  }
+}
+
+// Enhanced Agent wrapper class
+class Agent {
+  constructor(id, wasmResult, swarm) {
+    this.id = id;
+    this.name = wasmResult.name;
+    this.type = wasmResult.type || wasmResult.agent_type;
+    this.cognitivePattern = wasmResult.cognitive_pattern || 'adaptive';
+    this.capabilities = wasmResult.capabilities || [];
+    this.neuralNetworkId = wasmResult.neural_network_id;
+    this.status = 'idle';
+    this.swarm = swarm;
+  }
+
+  async execute(_task) {
+    console.log(`🏃 Agent ${this.name} executing task`);
+    this.status = 'busy';
+
+    // Simulate task execution
+    const result = {
+      status: 'completed',
+      result: 'Task execution placeholder',
+      executionTime: 500,
+    };
+
+    this.status = 'idle';
+    return result;
+  }
+
+  async getMetrics() {
+    return {
+      tasksCompleted: 0,
+      averageExecutionTime: 0,
+      successRate: 1.0,
+      memoryUsage: 5.0,
+    };
+  }
+
+  async updateStatus(status) {
+    this.status = status;
+    console.log(`📊 Agent ${this.name} status: ${status}`);
+  }
+}
+
+// Enhanced Task wrapper class
+class Task {
+  constructor(id, wasmResult, swarm) {
+    this.id = id;
+    this.description = wasmResult.task_description || wasmResult.description;
+    this.status = wasmResult.status || 'pending';
+    this.assignedAgents = wasmResult.assigned_agents || [];
+    this.result = null;
+    this.swarm = swarm;
+    this.startTime = null;
+    this.endTime = null;
+    this.progress = 0;
+
+    // Start task execution if agents are assigned
+    if (this.assignedAgents.length > 0 && this.status === 'orchestrated') {
+      this.executeTask();
+    }
+  }
+
+  async executeTask() {
+    this.status = 'in_progress';
+    this.startTime = Date.now();
+    this.progress = 0.1;
+
+    console.log(`🏃 Executing task: ${this.description} with ${this.assignedAgents.length} agents`);
+
+    try {
+      // Execute task with all assigned agents
+      const agentResults = [];
+
+      for (const agentId of this.assignedAgents) {
+        const agent = this.swarm.agents.get(agentId);
+        if (agent) {
+          const agentResult = await agent.execute(this);
+          agentResults.push({
+            agentId,
+            agentType: agent.type,
+            result: agentResult,
+          });
+        }
+        this.progress = Math.min(0.9, this.progress + (0.8 / this.assignedAgents.length));
+      }
+
+      // Aggregate results
+      this.result = {
+        task_id: this.id,
+        description: this.description,
+        agent_results: agentResults,
+        execution_summary: {
+          total_agents: this.assignedAgents.length,
+          successful_executions: agentResults.filter(r => r.result.status === 'completed').length,
+          execution_time_ms: Date.now() - this.startTime,
+          average_agent_time_ms: agentResults.reduce((sum, r) => sum + (r.result.executionTime || 0), 0) / agentResults.length,
+        },
+      };
+
+      this.status = 'completed';
+      this.progress = 1.0;
+      this.endTime = Date.now();
+
+      // Mark agents as idle again
+      for (const agentId of this.assignedAgents) {
+        const agent = this.swarm.agents.get(agentId);
+        if (agent) {
+          await agent.updateStatus('idle');
+        }
+      }
+
+      console.log(`✅ Task completed: ${this.description} (${this.endTime - this.startTime}ms)`);
+
+    } catch (error) {
+      this.status = 'failed';
+      this.result = {
+        error: error.message,
+        execution_time_ms: Date.now() - this.startTime,
+      };
+
+      // Mark agents as idle on failure too
+      for (const agentId of this.assignedAgents) {
+        const agent = this.swarm.agents.get(agentId);
+        if (agent) {
+          await agent.updateStatus('idle');
+        }
+      }
+
+      console.error(`❌ Task failed: ${this.description} - ${error.message}`);
+    }
+  }
+
+  async getStatus() {
+    return {
+      id: this.id,
+      status: this.status,
+      assignedAgents: this.assignedAgents,
+      progress: this.progress,
+      execution_time_ms: this.startTime ? (this.endTime || Date.now()) - this.startTime : 0,
+    };
+  }
+
+  async getResults() {
+    return this.result;
+  }
+}
+
+// Import DAA service for comprehensive agent management
+import { DAAService, daaService } from './daa-service.js';
+
+export { RuvSwarm, Swarm, Agent, Task, DAAService, daaService };