@sparkleideas/ruv-swarm 1.0.18-patch.1

package/package.json

@@ -0,0 +1,221 @@
+{
+  "name": "@sparkleideas/ruv-swarm",
+  "version": "1.0.18-patch.1",
+  "description": "High-performance neural network swarm orchestration in WebAssembly",
+  "main": "src/index.js",
+  "module": "src/index.js",
+  "types": "src/index.d.ts",
+  "type": "module",
+  "bin": {
+    "ruv-swarm-legacy": "bin/ruv-swarm-clean.js",
+    "@sparkleideas/ruv-swarm": "bin/ruv-swarm-secure.js"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "wasm/",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "node test/test.js",
+    "test:all": "node test/run-all-tests.js",
+    "test:jest": "NODE_OPTIONS='--experimental-vm-modules --experimental-wasm-modules' jest --config jest.config.cjs",
+    "test:jest:watch": "NODE_OPTIONS='--experimental-vm-modules --experimental-wasm-modules' jest --watch --config jest.config.cjs",
+    "test:jest:coverage": "NODE_OPTIONS='--experimental-vm-modules --experimental-wasm-modules' jest --coverage --config jest.config.cjs",
+    "test:mcp": "node test/mcp-integration.test.js",
+    "test:persistence": "node test/persistence.test.js",
+    "test:neural": "node test/neural-integration.test.js",
+    "test:coverage": "nyc --reporter=text --reporter=lcov --reporter=html npm test",
+    "test:coverage:full": "nyc --reporter=text --reporter=lcov --reporter=html node test/test-coverage-all.js",
+    "test:coverage:integration": "nyc --reporter=text node test/coverage-integration.test.js",
+    "test:coverage:execute": "nyc --reporter=text --reporter=lcov node test/execute-coverage.test.js",
+    "test:watch": "nodemon --watch test --exec 'npm run test:all'",
+    "test:performance": "node test/comprehensive-performance-validation.test.js",
+    "test:load": "node test/load-testing-suite.test.js",
+    "test:security": "node test/security-audit.test.js",
+    "test:regression": "node test/regression-testing-pipeline.test.js",
+    "test:comprehensive": "node test/run-comprehensive-validation.js",
+    "test:orchestrator": "node test/comprehensive-test-orchestrator.js",
+    "test:mcp-tools": "node test/mcp-tools-comprehensive.test.js",
+    "test:daa-functionality": "node test/daa-functionality-comprehensive.test.js",
+    "test:error-handling": "node test/error-handling-comprehensive.test.js",
+    "test:mcp-protocol": "node test/mcp-protocol-integration.test.js",
+    "test:master-coverage": "node test/master-test-coverage-runner.test.js",
+    "test:docker:comprehensive": "bash scripts/docker-test-suite.sh",
+    "test:docker:cross-platform": "node test/docker-cross-platform.test.js",
+    "test:docker:wasm": "node test/validate-wasm-loading.js",
+    "test:docker:performance": "node test/docker-performance-suite.js",
+    "test:docker:mcp": "node test/docker-mcp-validation.js",
+    "test:docker:npx": "bash scripts/test-npx-commands.sh",
+    "test:docker:all": "docker-compose -f docker-compose.test.yml up --abort-on-container-exit",
+    "test:docker:build": "docker-compose -f docker-compose.test.yml build",
+    "test:docker:clean": "docker-compose -f docker-compose.test.yml down -v",
+    "lint": "eslint src/ test/ --ext .js,.ts,.mjs,.cjs",
+    "lint:fix": "eslint src/ test/ --ext .js,.ts,.mjs,.cjs --fix",
+    "lint:check": "eslint src/ test/ --ext .js,.ts,.mjs,.cjs --max-warnings 0",
+    "lint:report": "eslint src/ test/ --ext .js,.ts,.mjs,.cjs --format json --output-file eslint-report.json",
+    "quality:check": "npm run lint:check && npm run test:all",
+    "quality:fix": "npm run lint:fix && npm run test:all",
+    "mcp:server": "cd ../crates/ruv-swarm-mcp && cargo run",
+    "mcp:server:dev": "cd ../crates/ruv-swarm-mcp && cargo watch -x run",
+    "examples": "node examples/mcp-workflows.js",
+    "examples:webapp": "node examples/mcp-workflows.js webapp",
+    "examples:research": "node examples/mcp-workflows.js research",
+    "examples:cicd": "node examples/mcp-workflows.js cicd",
+    "examples:data": "node examples/mcp-workflows.js data",
+    "examples:swarm": "node examples/mcp-workflows.js swarm",
+    "examples:daa": "node ../examples/daa-service-demo.js",
+    "test:daa": "node test/daa-service.test.js",
+    "benchmark:wasm": "node test/benchmarks/benchmark-neural-models.js",
+    "build": "node scripts/build.js",
+    "build:wasm": "cd ../crates/ruv-swarm-wasm && wasm-pack build --target web --out-dir ../../npm/wasm -- --no-default-features",
+    "build:wasm-simd": "cd ../crates/ruv-swarm-wasm && RUSTFLAGS=\"-C target-feature=+simd128\" wasm-pack build --target web --out-dir ../../npm/wasm-simd -- --no-default-features",
+    "build:wasm-opt": "cd ../crates/ruv-swarm-wasm && wasm-pack build --target web --out-dir ../../npm/wasm-opt -- --features minimal && wasm-opt -Oz -o ../../npm/wasm-opt/ruv_swarm_wasm_bg.wasm ../../npm/wasm-opt/ruv_swarm_wasm_bg.wasm",
+    "build:all": "npm run build:wasm && npm run build:wasm-simd && npm run build",
+    "build:docs": "node scripts/generate-docs.js",
+    "deploy:prepare": "npm run quality:check && npm run build:all && npm run build:docs",
+    "deploy:npm": "npm publish --access public",
+    "deploy:check": "npm pack --dry-run",
+    "version:patch": "npm version patch && git push && git push --tags",
+    "version:minor": "npm version minor && git push && git push --tags",
+    "version:major": "npm version major && git push && git push --tags",
+    "pretest-disabled": "npm run lint:check",
+    "prepublishOnly-disabled": "npm run deploy:prepare"
+  },
+  "engines": {
+    "node": ">=18.20.8"
+  },
+  "overrides": {
+    "@types/node": "^18.19.115",
+    "vite": "^6.0.0",
+    "vitest": "^2.0.0",
+    "@vitest/ui": "^2.1.9"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ruvnet/ruv-FANN.git",
+    "directory": "ruv-swarm/npm"
+  },
+  "keywords": [
+    "neural-network",
+    "wasm",
+    "webassembly",
+    "machine-learning",
+    "swarm",
+    "ai",
+    "orchestration",
+    "multi-agent",
+    "distributed-computing",
+    "daa",
+    "autonomous-agents",
+    "workflow-coordination",
+    "state-persistence"
+  ],
+  "author": "rUv Contributors",
+  "license": "MIT OR Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/ruvnet/ruv-FANN/issues"
+  },
+  "homepage": "https://github.com/ruvnet/ruv-FANN#readme",
+  "dependencies": {
+    "better-sqlite3": "^11.6.0",
+    "uuid": "^9.0.1",
+    "ws": "^8.14.0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.28.0",
+    "@babel/plugin-proposal-class-properties": "^7.18.6",
+    "@babel/plugin-proposal-export-default-from": "^7.22.17",
+    "@babel/plugin-proposal-export-namespace-from": "^7.18.9",
+    "@babel/plugin-proposal-logical-assignment-operators": "^7.20.7",
+    "@babel/plugin-proposal-nullish-coalescing-operator": "^7.18.6",
+    "@babel/plugin-proposal-object-rest-spread": "^7.20.7",
+    "@babel/plugin-proposal-optional-chaining": "^7.21.0",
+    "@babel/plugin-proposal-private-methods": "^7.18.6",
+    "@babel/plugin-syntax-dynamic-import": "^7.8.3",
+    "@babel/plugin-transform-async-to-generator": "^7.22.5",
+    "@babel/plugin-transform-class-properties": "^7.27.1",
+    "@babel/plugin-transform-export-namespace-from": "^7.27.1",
+    "@babel/plugin-transform-logical-assignment-operators": "^7.27.1",
+    "@babel/plugin-transform-nullish-coalescing-operator": "^7.27.1",
+    "@babel/plugin-transform-object-rest-spread": "^7.28.0",
+    "@babel/plugin-transform-optional-chaining": "^7.27.1",
+    "@babel/plugin-transform-private-methods": "^7.27.1",
+    "@babel/preset-env": "^7.28.0",
+    "@eslint/js": "^9.30.1",
+    "@rollup/plugin-commonjs": "^25.0.0",
+    "@rollup/plugin-node-resolve": "^15.2.0",
+    "@rollup/plugin-wasm": "^6.2.0",
+    "@types/node": "^18.19.115",
+    "@types/uuid": "^9.0.0",
+    "@types/ws": "^8.5.0",
+    "@typescript-eslint/eslint-plugin": "^8.35.1",
+    "@typescript-eslint/parser": "^8.35.1",
+    "@vitest/ui": "^2.1.9",
+    "babel-jest": "^29.7.0",
+    "core-js": "^3.43.0",
+    "eslint": "^9.30.1",
+    "eslint-import-resolver-typescript": "^4.4.4",
+    "eslint-plugin-import": "^2.32.0",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-security": "^3.0.1",
+    "jest": "^29.7.0",
+    "jest-html-reporters": "^3.1.7",
+    "nodemon": "^3.0.0",
+    "nyc": "^17.1.0",
+    "rollup": "^3.29.0",
+    "sqlite3": "^5.1.6",
+    "typescript": "^5.2.0",
+    "vitest": "^2.0.0",
+    "wasm-opt": "^1.3.0",
+    "wasm-pack": "^0.12.0",
+    "webpack": "^5.88.0",
+    "webpack-cli": "^5.1.4"
+  },
+  "optionalDependencies": {
+    "worker_threads": "*"
+  },
+  "nyc": {
+    "all": true,
+    "include": [
+      "src/**/*.js",
+      "src/**/*.mjs"
+    ],
+    "exclude": [
+      "test/**/*",
+      "examples/**/*",
+      "scripts/**/*",
+      "bin/**/*",
+      "wasm/**/*",
+      "src/**/*.test.js",
+      "src/**/*.spec.js"
+    ],
+    "reporter": [
+      "text",
+      "lcov",
+      "html"
+    ],
+    "watermarks": {
+      "lines": [
+        80,
+        95
+      ],
+      "functions": [
+        80,
+        95
+      ],
+      "branches": [
+        80,
+        95
+      ],
+      "statements": [
+        80,
+        95
+      ]
+    }
+  }
+}

package/src/agent.ts

@@ -0,0 +1,342 @@
+/**
+ * Agent implementation and wrappers
+ */
+
+import {
+  Agent,
+  AgentConfig,
+  AgentState,
+  AgentStatus,
+  Task,
+  Message,
+  MessageType,
+} from './types';
+import { generateId, getDefaultCognitiveProfile } from './utils';
+
+export class BaseAgent implements Agent {
+  id: string;
+  config: AgentConfig;
+  state: AgentState;
+  connections: string[] = [];
+  
+  private messageHandlers: Map<MessageType, (message: Message) => Promise<void>> = new Map();
+  private wasmAgentId?: number;
+
+  constructor(config: AgentConfig) {
+    this.id = config.id || generateId('agent');
+    this.config = {
+      ...config,
+      id: this.id,
+      cognitiveProfile: config.cognitiveProfile || getDefaultCognitiveProfile(config.type),
+    };
+    
+    this.state = {
+      status: 'idle',
+      load: 0,
+      performance: {
+        tasksCompleted: 0,
+        tasksFailed: 0,
+        averageExecutionTime: 0,
+        successRate: 0,
+      },
+    };
+
+    this.setupMessageHandlers();
+  }
+
+  private setupMessageHandlers(): void {
+    this.messageHandlers.set('task_assignment', this.handleTaskAssignment.bind(this));
+    this.messageHandlers.set('coordination', this.handleCoordination.bind(this));
+    this.messageHandlers.set('knowledge_share', this.handleKnowledgeShare.bind(this));
+    this.messageHandlers.set('status_update', this.handleStatusUpdate.bind(this));
+  }
+
+  async execute(task: Task): Promise<any> {
+    const startTime = Date.now();
+    
+    try {
+      this.update({ status: 'busy', currentTask: task.id });
+      
+      // Execute task based on agent type
+      const result = await this.executeTaskByType(task);
+      
+      // Update performance metrics
+      const executionTime = Date.now() - startTime;
+      this.updatePerformanceMetrics(true, executionTime);
+      
+      this.update({ status: 'idle', currentTask: undefined });
+      
+      return result;
+    } catch (error) {
+      this.updatePerformanceMetrics(false, Date.now() - startTime);
+      this.update({ status: 'error', currentTask: undefined });
+      throw error;
+    }
+  }
+
+  protected async executeTaskByType(task: Task): Promise<any> {
+    // Base implementation - override in specialized agents
+    console.log(`Agent ${this.id} executing task ${task.id}: ${task.description}`);
+    
+    // Simulate work
+    await new Promise(resolve => setTimeout(resolve, 100 + Math.random() * 400));
+    
+    return {
+      taskId: task.id,
+      agentId: this.id,
+      result: `Task completed by ${this.config.type} agent`,
+      timestamp: Date.now(),
+    };
+  }
+
+  async communicate(message: Message): Promise<void> {
+    const handler = this.messageHandlers.get(message.type);
+    if (handler) {
+      await handler(message);
+    } else {
+      console.warn(`No handler for message type: ${message.type}`);
+    }
+  }
+
+  update(state: Partial<AgentState>): void {
+    this.state = { ...this.state, ...state };
+  }
+
+  private updatePerformanceMetrics(success: boolean, executionTime: number): void {
+    const performance = this.state.performance;
+    
+    if (success) {
+      performance.tasksCompleted++;
+    } else {
+      performance.tasksFailed++;
+    }
+    
+    const totalTasks = performance.tasksCompleted + performance.tasksFailed;
+    performance.successRate = totalTasks > 0 ? performance.tasksCompleted / totalTasks : 0;
+    
+    // Update average execution time
+    const totalTime = performance.averageExecutionTime * (totalTasks - 1) + executionTime;
+    performance.averageExecutionTime = totalTime / totalTasks;
+  }
+
+  private async handleTaskAssignment(message: Message): Promise<void> {
+    const task = message.payload as Task;
+    console.log(`Agent ${this.id} received task assignment: ${task.id}`);
+    // Task execution is handled by the swarm coordinator
+  }
+
+  private async handleCoordination(message: Message): Promise<void> {
+    console.log(`Agent ${this.id} received coordination message from ${message.from}`);
+    // Handle coordination logic
+  }
+
+  private async handleKnowledgeShare(message: Message): Promise<void> {
+    console.log(`Agent ${this.id} received knowledge share from ${message.from}`);
+    // Store shared knowledge in memory
+    if (this.config.memory) {
+      this.config.memory.shortTerm.set(`knowledge_${message.id}`, message.payload);
+    }
+  }
+
+  private async handleStatusUpdate(message: Message): Promise<void> {
+    console.log(`Agent ${this.id} received status update from ${message.from}`);
+    // Process status update
+  }
+
+  setWasmAgentId(id: number): void {
+    this.wasmAgentId = id;
+  }
+
+  getWasmAgentId(): number | undefined {
+    return this.wasmAgentId;
+  }
+}
+
+/**
+ * Specialized agent for research tasks
+ */
+export class ResearcherAgent extends BaseAgent {
+  constructor(config: Omit<AgentConfig, 'type'>) {
+    super({ ...config, type: 'researcher' });
+  }
+
+  protected async executeTaskByType(task: Task): Promise<any> {
+    console.log(`Researcher ${this.id} analyzing: ${task.description}`);
+    
+    // Simulate research activities
+    const phases = ['collecting_data', 'analyzing', 'synthesizing', 'reporting'];
+    const results: any[] = [];
+    
+    for (const phase of phases) {
+      await new Promise(resolve => setTimeout(resolve, 200));
+      results.push({
+        phase,
+        timestamp: Date.now(),
+        findings: `${phase} completed for ${task.description}`,
+      });
+    }
+    
+    return {
+      taskId: task.id,
+      agentId: this.id,
+      type: 'research_report',
+      phases: results,
+      summary: `Research completed on: ${task.description}`,
+      recommendations: ['Further investigation needed', 'Consider alternative approaches'],
+    };
+  }
+}
+
+/**
+ * Specialized agent for coding tasks
+ */
+export class CoderAgent extends BaseAgent {
+  constructor(config: Omit<AgentConfig, 'type'>) {
+    super({ ...config, type: 'coder' });
+  }
+
+  protected async executeTaskByType(task: Task): Promise<any> {
+    console.log(`Coder ${this.id} implementing: ${task.description}`);
+    
+    // Simulate coding activities
+    const steps = ['design', 'implement', 'test', 'refactor'];
+    const codeArtifacts: any[] = [];
+    
+    for (const step of steps) {
+      await new Promise(resolve => setTimeout(resolve, 300));
+      codeArtifacts.push({
+        step,
+        timestamp: Date.now(),
+        artifact: `${step}_${task.id}.ts`,
+      });
+    }
+    
+    return {
+      taskId: task.id,
+      agentId: this.id,
+      type: 'code_implementation',
+      artifacts: codeArtifacts,
+      summary: `Implementation completed for: ${task.description}`,
+      metrics: {
+        linesOfCode: Math.floor(Math.random() * 500) + 100,
+        complexity: Math.floor(Math.random() * 10) + 1,
+      },
+    };
+  }
+}
+
+/**
+ * Specialized agent for analysis tasks
+ */
+export class AnalystAgent extends BaseAgent {
+  constructor(config: Omit<AgentConfig, 'type'>) {
+    super({ ...config, type: 'analyst' });
+  }
+
+  protected async executeTaskByType(task: Task): Promise<any> {
+    console.log(`Analyst ${this.id} analyzing: ${task.description}`);
+    
+    // Simulate analysis activities
+    await new Promise(resolve => setTimeout(resolve, 400));
+    
+    return {
+      taskId: task.id,
+      agentId: this.id,
+      type: 'analysis_report',
+      metrics: {
+        dataPoints: Math.floor(Math.random() * 1000) + 100,
+        confidence: Math.random() * 0.3 + 0.7,
+      },
+      insights: [
+        'Pattern detected in data',
+        'Anomaly found at timestamp X',
+        'Recommendation for optimization',
+      ],
+      visualizations: ['chart_1.png', 'graph_2.svg'],
+    };
+  }
+}
+
+/**
+ * Factory function to create specialized agents
+ */
+export function createAgent(config: AgentConfig): Agent {
+  switch (config.type) {
+  case 'researcher':
+    return new ResearcherAgent(config);
+  case 'coder':
+    return new CoderAgent(config);
+  case 'analyst':
+    return new AnalystAgent(config);
+  default:
+    return new BaseAgent(config);
+  }
+}
+
+/**
+ * Agent pool for managing multiple agents
+ */
+export class AgentPool {
+  private agents: Map<string, Agent> = new Map();
+  private availableAgents: Set<string> = new Set();
+
+  addAgent(agent: Agent): void {
+    this.agents.set(agent.id, agent);
+    if (agent.state.status === 'idle') {
+      this.availableAgents.add(agent.id);
+    }
+  }
+
+  removeAgent(agentId: string): void {
+    this.agents.delete(agentId);
+    this.availableAgents.delete(agentId);
+  }
+
+  getAgent(agentId: string): Agent | undefined {
+    return this.agents.get(agentId);
+  }
+
+  getAvailableAgent(preferredType?: string): Agent | undefined {
+    let selectedAgent: Agent | undefined;
+
+    for (const agentId of this.availableAgents) {
+      const agent = this.agents.get(agentId);
+      if (!agent) continue;
+
+      if (!preferredType || agent.config.type === preferredType) {
+        selectedAgent = agent;
+        break;
+      }
+    }
+
+    if (!selectedAgent && this.availableAgents.size > 0) {
+      const firstAvailable = Array.from(this.availableAgents)[0];
+      selectedAgent = this.agents.get(firstAvailable);
+    }
+
+    if (selectedAgent) {
+      this.availableAgents.delete(selectedAgent.id);
+    }
+
+    return selectedAgent;
+  }
+
+  releaseAgent(agentId: string): void {
+    const agent = this.agents.get(agentId);
+    if (agent && agent.state.status === 'idle') {
+      this.availableAgents.add(agentId);
+    }
+  }
+
+  getAllAgents(): Agent[] {
+    return Array.from(this.agents.values());
+  }
+
+  getAgentsByType(type: string): Agent[] {
+    return this.getAllAgents().filter(agent => agent.config.type === type);
+  }
+
+  getAgentsByStatus(status: AgentStatus): Agent[] {
+    return this.getAllAgents().filter(agent => agent.state.status === status);
+  }
+}