@sparkleideas/ruv-swarm 1.0.18-patch.1

package/src/sqlite-worker.js

@@ -0,0 +1,141 @@
+/**
+ * SQLite Worker Thread for CPU-intensive database operations
+ * 
+ * This worker handles long-running queries and CPU-intensive operations
+ * to prevent blocking the main thread during heavy database workloads.
+ */
+
+import { parentPort, workerData } from 'worker_threads';
+import Database from 'better-sqlite3';
+
+class SQLiteWorker {
+  constructor(dbPath, options = {}) {
+    this.dbPath = dbPath;
+    this.options = options;
+    this.db = null;
+    this.preparedStatements = new Map();
+    
+    this.initialize();
+  }
+  
+  initialize() {
+    try {
+      this.db = new Database(this.dbPath, { readonly: true });
+      this.configureConnection();
+      
+      // Test connection
+      this.db.prepare('SELECT 1').get();
+      
+      // Setup message handling
+      if (parentPort) {
+        parentPort.on('message', (message) => {
+          this.handleMessage(message);
+        });
+      }
+      
+    } catch (error) {
+      if (parentPort) {
+        parentPort.postMessage({
+          error: `Worker initialization failed: ${error.message}`
+        });
+      }
+    }
+  }
+  
+  configureConnection() {
+    // Configure for optimal read performance
+    this.db.pragma('journal_mode = WAL');
+    this.db.pragma('synchronous = NORMAL');
+    this.db.pragma('temp_store = MEMORY');
+    this.db.pragma('mmap_size = ' + (this.options.mmapSize || 268435456));
+    this.db.pragma('cache_size = ' + (this.options.cacheSize || -64000));
+    this.db.pragma('busy_timeout = 5000');
+    
+    // Optimize for queries
+    this.db.pragma('optimize');
+  }
+  
+  handleMessage(message) {
+    try {
+      if (message.health) {
+        // Health check
+        this.db.prepare('SELECT 1').get();
+        parentPort.postMessage({ health: 'ok' });
+        return;
+      }
+      
+      if (message.sql && message.params !== undefined) {
+        // Execute query
+        const result = this.executeQuery(message.sql, message.params);
+        parentPort.postMessage({
+          data: result,
+          error: null
+        });
+      } else {
+        parentPort.postMessage({
+          error: 'Invalid message format'
+        });
+      }
+      
+    } catch (error) {
+      parentPort.postMessage({
+        error: error.message,
+        data: null
+      });
+    }
+  }
+  
+  executeQuery(sql, params) {
+    const stmt = this.getPreparedStatement(sql);
+    
+    // Determine operation type
+    const operation = sql.trim().toUpperCase().split(' ')[0];
+    
+    switch (operation) {
+      case 'SELECT':
+        return stmt.all(params);
+      case 'INSERT':
+      case 'UPDATE':
+      case 'DELETE':
+        return stmt.run(params);
+      default:
+        // For other operations, try to execute and return result
+        try {
+          return stmt.all(params);
+        } catch {
+          return stmt.run(params);
+        }
+    }
+  }
+  
+  getPreparedStatement(sql) {
+    if (!this.preparedStatements.has(sql)) {
+      this.preparedStatements.set(sql, this.db.prepare(sql));
+    }
+    return this.preparedStatements.get(sql);
+  }
+  
+  cleanup() {
+    if (this.db) {
+      this.db.close();
+    }
+  }
+}
+
+// Initialize worker
+const worker = new SQLiteWorker(workerData.dbPath, workerData.options);
+
+// Cleanup on exit
+process.on('exit', () => {
+  worker.cleanup();
+});
+
+process.on('SIGINT', () => {
+  worker.cleanup();
+  process.exit(0);
+});
+
+process.on('SIGTERM', () => {
+  worker.cleanup();
+  process.exit(0);
+});

package/src/types.ts

@@ -0,0 +1,164 @@
+/**
+ * Core types and interfaces for RuvSwarm
+ */
+
+export interface SwarmOptions {
+  topology?: SwarmTopology;
+  maxAgents?: number;
+  connectionDensity?: number;
+  syncInterval?: number;
+  wasmPath?: string;
+}
+
+export type SwarmTopology = 'mesh' | 'hierarchical' | 'distributed' | 'centralized' | 'hybrid';
+
+export interface AgentConfig {
+  id: string;
+  type: AgentType;
+  cognitiveProfile?: CognitiveProfile;
+  capabilities?: string[];
+  memory?: AgentMemory;
+}
+
+export type AgentType = 
+  | 'researcher'
+  | 'coder'
+  | 'analyst'
+  | 'architect'
+  | 'reviewer'
+  | 'debugger'
+  | 'tester'
+  | 'documenter'
+  | 'optimizer'
+  | 'custom';
+
+export interface CognitiveProfile {
+  analytical: number;
+  creative: number;
+  systematic: number;
+  intuitive: number;
+  collaborative: number;
+  independent: number;
+}
+
+export interface AgentMemory {
+  shortTerm: Map<string, any>;
+  longTerm: Map<string, any>;
+  episodic: EpisodicMemory[];
+}
+
+export interface EpisodicMemory {
+  timestamp: number;
+  context: string;
+  data: any;
+  importance: number;
+}
+
+export interface Task {
+  id: string;
+  description: string;
+  priority: TaskPriority;
+  dependencies?: string[];
+  assignedAgents?: string[];
+  status: TaskStatus;
+  result?: any;
+  error?: Error;
+}
+
+export type TaskPriority = 'low' | 'medium' | 'high' | 'critical';
+export type TaskStatus = 'pending' | 'assigned' | 'in_progress' | 'completed' | 'failed';
+
+export interface SwarmState {
+  agents: Map<string, Agent>;
+  tasks: Map<string, Task>;
+  topology: SwarmTopology;
+  connections: Connection[];
+  metrics: SwarmMetrics;
+}
+
+export interface Connection {
+  from: string;
+  to: string;
+  weight: number;
+  type: ConnectionType;
+}
+
+export type ConnectionType = 'data' | 'control' | 'feedback' | 'coordination';
+
+export interface SwarmMetrics {
+  totalTasks: number;
+  completedTasks: number;
+  failedTasks: number;
+  averageCompletionTime: number;
+  agentUtilization: Map<string, number>;
+  throughput: number;
+}
+
+export interface Agent {
+  id: string;
+  config: AgentConfig;
+  state: AgentState;
+  connections: string[];
+  execute(task: Task): Promise<any>;
+  communicate(message: Message): Promise<void>;
+  update(state: Partial<AgentState>): void;
+}
+
+export interface AgentState {
+  status: AgentStatus;
+  currentTask?: string;
+  load: number;
+  performance: AgentPerformance;
+}
+
+export type AgentStatus = 'idle' | 'busy' | 'error' | 'offline';
+
+export interface AgentPerformance {
+  tasksCompleted: number;
+  tasksFailed: number;
+  averageExecutionTime: number;
+  successRate: number;
+}
+
+export interface Message {
+  id: string;
+  from: string;
+  to: string | string[];
+  type: MessageType;
+  payload: any;
+  timestamp: number;
+}
+
+export type MessageType = 
+  | 'task_assignment'
+  | 'task_result'
+  | 'status_update'
+  | 'coordination'
+  | 'knowledge_share'
+  | 'error';
+
+export interface SwarmEventEmitter {
+  on(event: SwarmEvent, handler: (data: any) => void): void;
+  off(event: SwarmEvent, handler: (data: any) => void): void;
+  emit(event: SwarmEvent, data: any): void;
+}
+
+export type SwarmEvent =
+  | 'agent:added'
+  | 'agent:removed'
+  | 'agent:status_changed'
+  | 'task:created'
+  | 'task:assigned'
+  | 'task:completed'
+  | 'task:failed'
+  | 'swarm:topology_changed'
+  | 'swarm:error';
+
+export interface WasmModule {
+  init(): Promise<void>;
+  createSwarm(options: SwarmOptions): number;
+  addAgent(swarmId: number, config: AgentConfig): number;
+  assignTask(swarmId: number, task: Task): void;
+  getState(swarmId: number): SwarmState;
+  destroy(swarmId: number): void;
+}

package/src/utils.ts

@@ -0,0 +1,286 @@
+/**
+ * Utility functions for RuvSwarm
+ */
+
+import { CognitiveProfile, SwarmTopology, AgentType, TaskPriority } from './types';
+
+/**
+ * Generate a unique ID for agents, tasks, and messages
+ */
+export function generateId(prefix: string = ''): string {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 9);
+  return prefix ? `${prefix}_${timestamp}_${random}` : `${timestamp}_${random}`;
+}
+
+/**
+ * Create a default cognitive profile based on agent type
+ */
+export function getDefaultCognitiveProfile(type: AgentType): CognitiveProfile {
+  const profiles: Record<AgentType, CognitiveProfile> = {
+    researcher: {
+      analytical: 0.9,
+      creative: 0.6,
+      systematic: 0.8,
+      intuitive: 0.5,
+      collaborative: 0.7,
+      independent: 0.8,
+    },
+    coder: {
+      analytical: 0.8,
+      creative: 0.7,
+      systematic: 0.9,
+      intuitive: 0.4,
+      collaborative: 0.6,
+      independent: 0.7,
+    },
+    analyst: {
+      analytical: 0.95,
+      creative: 0.4,
+      systematic: 0.9,
+      intuitive: 0.3,
+      collaborative: 0.6,
+      independent: 0.8,
+    },
+    architect: {
+      analytical: 0.8,
+      creative: 0.8,
+      systematic: 0.85,
+      intuitive: 0.7,
+      collaborative: 0.8,
+      independent: 0.6,
+    },
+    reviewer: {
+      analytical: 0.85,
+      creative: 0.5,
+      systematic: 0.9,
+      intuitive: 0.4,
+      collaborative: 0.7,
+      independent: 0.7,
+    },
+    debugger: {
+      analytical: 0.9,
+      creative: 0.6,
+      systematic: 0.85,
+      intuitive: 0.6,
+      collaborative: 0.5,
+      independent: 0.8,
+    },
+    tester: {
+      analytical: 0.8,
+      creative: 0.6,
+      systematic: 0.95,
+      intuitive: 0.3,
+      collaborative: 0.6,
+      independent: 0.7,
+    },
+    documenter: {
+      analytical: 0.7,
+      creative: 0.7,
+      systematic: 0.85,
+      intuitive: 0.4,
+      collaborative: 0.8,
+      independent: 0.6,
+    },
+    optimizer: {
+      analytical: 0.9,
+      creative: 0.6,
+      systematic: 0.8,
+      intuitive: 0.5,
+      collaborative: 0.5,
+      independent: 0.8,
+    },
+    custom: {
+      analytical: 0.5,
+      creative: 0.5,
+      systematic: 0.5,
+      intuitive: 0.5,
+      collaborative: 0.5,
+      independent: 0.5,
+    },
+  };
+
+  return profiles[type];
+}
+
+/**
+ * Calculate cognitive diversity score between two profiles
+ */
+export function calculateCognitiveDiversity(
+  profile1: CognitiveProfile,
+  profile2: CognitiveProfile,
+): number {
+  const dimensions = Object.keys(profile1) as (keyof CognitiveProfile)[];
+  let totalDifference = 0;
+
+  for (const dimension of dimensions) {
+    const diff = Math.abs(profile1[dimension] - profile2[dimension]);
+    totalDifference += diff;
+  }
+
+  return totalDifference / dimensions.length;
+}
+
+/**
+ * Determine optimal topology based on swarm characteristics
+ */
+export function recommendTopology(
+  agentCount: number,
+  taskComplexity: 'low' | 'medium' | 'high',
+  coordinationNeeds: 'minimal' | 'moderate' | 'extensive',
+): SwarmTopology {
+  if (agentCount <= 5) {
+    return 'mesh';
+  }
+
+  if (coordinationNeeds === 'extensive') {
+    return 'hierarchical';
+  }
+
+  if (taskComplexity === 'high' && agentCount > 10) {
+    return 'hybrid';
+  }
+
+  if (coordinationNeeds === 'minimal') {
+    return 'distributed';
+  }
+
+  return 'centralized';
+}
+
+/**
+ * Convert task priority to numeric value for sorting
+ */
+export function priorityToNumber(priority: TaskPriority): number {
+  const priorityMap: Record<TaskPriority, number> = {
+    low: 1,
+    medium: 2,
+    high: 3,
+    critical: 4,
+  };
+  return priorityMap[priority];
+}
+
+/**
+ * Format swarm metrics for display
+ */
+export function formatMetrics(metrics: {
+  totalTasks: number;
+  completedTasks: number;
+  failedTasks: number;
+  averageCompletionTime: number;
+  throughput: number;
+}): string {
+  const successRate = metrics.totalTasks > 0 
+    ? ((metrics.completedTasks / metrics.totalTasks) * 100).toFixed(1)
+    : '0.0';
+
+  return `
+Swarm Metrics:
+- Total Tasks: ${metrics.totalTasks}
+- Completed: ${metrics.completedTasks}
+- Failed: ${metrics.failedTasks}
+- Success Rate: ${successRate}%
+- Avg Completion Time: ${metrics.averageCompletionTime.toFixed(2)}ms
+- Throughput: ${metrics.throughput.toFixed(2)} tasks/sec
+  `.trim();
+}
+
+/**
+ * Validate swarm options
+ */
+export function validateSwarmOptions(options: any): string[] {
+  const errors: string[] = [];
+
+  if (options.maxAgents !== undefined) {
+    if (typeof options.maxAgents !== 'number' || options.maxAgents < 1) {
+      errors.push('maxAgents must be a positive number');
+    }
+  }
+
+  if (options.connectionDensity !== undefined) {
+    if (
+      typeof options.connectionDensity !== 'number' ||
+      options.connectionDensity < 0 ||
+      options.connectionDensity > 1
+    ) {
+      errors.push('connectionDensity must be a number between 0 and 1');
+    }
+  }
+
+  if (options.topology !== undefined) {
+    const validTopologies = ['mesh', 'hierarchical', 'distributed', 'centralized', 'hybrid'];
+    if (!validTopologies.includes(options.topology)) {
+      errors.push(`topology must be one of: ${validTopologies.join(', ')}`);
+    }
+  }
+
+  return errors;
+}
+
+/**
+ * Deep clone an object
+ */
+export function deepClone<T>(obj: T): T {
+  if (obj === null || typeof obj !== 'object') {
+    return obj;
+  }
+
+  if (obj instanceof Date) {
+    return new Date(obj.getTime()) as any;
+  }
+
+  if (obj instanceof Array) {
+    return obj.map(item => deepClone(item)) as any;
+  }
+
+  if (obj instanceof Map) {
+    const cloned = new Map();
+    obj.forEach((value, key) => {
+      cloned.set(key, deepClone(value));
+    });
+    return cloned as any;
+  }
+
+  if (obj instanceof Set) {
+    const cloned = new Set();
+    obj.forEach(value => {
+      cloned.add(deepClone(value));
+    });
+    return cloned as any;
+  }
+
+  const cloned = {} as T;
+  for (const key in obj) {
+    if (obj.hasOwnProperty(key)) {
+      cloned[key] = deepClone(obj[key]);
+    }
+  }
+
+  return cloned;
+}
+
+/**
+ * Retry a function with exponential backoff
+ */
+export async function retryWithBackoff<T>(
+  fn: () => Promise<T>,
+  maxRetries: number = 3,
+  initialDelay: number = 100,
+): Promise<T> {
+  let lastError: Error;
+  
+  for (let i = 0; i < maxRetries; i++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error as Error;
+      if (i < maxRetries - 1) {
+        const delay = initialDelay * Math.pow(2, i);
+        await new Promise(resolve => setTimeout(resolve, delay));
+      }
+    }
+  }
+
+  throw lastError!;
+}