feat: vendor midstream and sublinear-time-solver libraries

Add ruvnet/midstream (AIMDS real-time inference) and ruvnet/sublinear-time-solver (sublinear optimization algorithms) as vendored dependencies under vendor/. Co-Authored-By: claude-flow <ruv@ruv.net>
2026-08-10 20:31:42 +00:00 · 2026-03-02 23:32:45 -05:00
parent 14902e6b4e
commit e91bb8a1d5
1600 changed files with 1852646 additions and 0 deletions
@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+
+/**
+ * Final WASM Integration Test
+ *
+ * This verifies that the MCP tools are using WASM with O(log n) algorithms
+ * as explicitly requested by the user.
+ */
+
+import { WasmSublinearSolverTools } from '../dist/mcp/tools/wasm-sublinear-solver.js';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+async function testWasmIntegration() {
+  console.log('🧪 Testing WASM Integration with O(log n) Algorithms');
+  console.log('=' .repeat(60));
+
+  try {
+    // Create WASM solver instance
+    const wasmSolver = new WasmSublinearSolverTools();
+
+    // Test 1: Create a diagonally dominant test matrix for O(log n) algorithm
+    const size = 10;
+    const matrix = [];
+    const b = [];
+
+    console.log(`\n📊 Creating ${size}x${size} diagonally dominant test matrix...`);
+
+    for (let i = 0; i < size; i++) {
+      matrix[i] = [];
+      for (let j = 0; j < size; j++) {
+        if (i === j) {
+          // Diagonal dominance: diagonal elements larger than sum of off-diagonal
+          matrix[i][j] = 10 + Math.random() * 5;
+        } else {
+          matrix[i][j] = Math.random() * 0.5;
+        }
+      }
+      b[i] = Math.random() * 10;
+    }
+
+    console.log('\n🚀 Testing WASM O(log n) solver...');
+    console.log('Expected: Node.js Compatible WASM should load successfully');
+
+    // Test 2: Solve using WASM
+    const startTime = Date.now();
+    const result = await wasmSolver.solveSublinear(matrix, b);
+    const totalTime = Date.now() - startTime;
+
+    console.log('\n✅ WASM Integration Results:');
+    console.log(`   Algorithm: ${result.algorithm}`);
+    console.log(`   WASM Accelerated: ${result.wasm_accelerated}`);
+    console.log(`   Complexity Bound: ${result.complexity_bound}`);
+    console.log(`   JL Dimension Reduction: ${result.jl_dimension_reduction}`);
+    console.log(`   Compression Ratio: ${result.compression_ratio?.toFixed(4) || 'N/A'}`);
+    console.log(`   Solve Time: ${result.solve_time_ms || totalTime}ms`);
+    console.log(`   Mathematical Guarantee: ${result.mathematical_guarantee}`);
+
+    // Test 3: Verify WASM capabilities
+    console.log('\n🔧 WASM Capabilities:');
+    const capabilities = wasmSolver.getCapabilities();
+    console.log(`   Enhanced WASM Available: ${capabilities.enhanced_wasm}`);
+    console.log(`   Algorithms:`, Object.keys(capabilities.algorithms));
+    console.log(`   Features: ${capabilities.features.length} available`);
+
+    // Test 4: Verify solution quality
+    console.log('\n🧮 Solution Verification:');
+    if (result.solution && result.solution.length > 0) {
+      console.log(`   Solution vector length: ${result.solution.length}`);
+      console.log(`   First 3 solution values: [${result.solution.slice(0, 3).map(x => x?.toFixed(4)).join(', ')}]`);
+
+      // Compute residual to verify accuracy
+      let maxResidual = 0;
+      for (let i = 0; i < size; i++) {
+        let sum = 0;
+        for (let j = 0; j < size; j++) {
+          sum += matrix[i][j] * (result.solution[j] || 0);
+        }
+        const residual = Math.abs(b[i] - sum);
+        maxResidual = Math.max(maxResidual, residual);
+      }
+
+      console.log(`   Maximum residual: ${maxResidual.toExponential(3)}`);
+      console.log(`   Solution accuracy: ${maxResidual < 1e-2 ? '✅ Good' : '⚠️  Needs improvement'}`);
+    } else {
+      console.log('   ❌ No solution returned');
+    }
+
+    // Test 5: Verify WASM is actually being used
+    console.log('\n🎯 WASM Usage Verification:');
+    const isWasmUsed = wasmSolver.isEnhancedWasmAvailable();
+    console.log(`   WASM Available: ${isWasmUsed}`);
+    console.log(`   User Request Satisfied: ${isWasmUsed ? '✅ YES - WASM is being used!' : '❌ NO - Fallback only'}`);
+
+    // Summary
+    console.log('\n' + '='.repeat(60));
+    console.log('🎉 WASM Integration Test Complete!');
+
+    if (isWasmUsed && result.wasm_accelerated) {
+      console.log('✅ SUCCESS: WASM with O(log n) algorithms is working!');
+      console.log('✅ User request fulfilled: "i want to make sure we\'re using the wasm"');
+    } else {
+      console.log('⚠️  WARNING: WASM not fully integrated, using fallback');
+    }
+
+    return true;
+
+  } catch (error) {
+    console.error('\n❌ WASM Integration Test Failed:');
+    console.error('Error:', error.message);
+    console.error('\nStack trace:');
+    console.error(error.stack);
+    return false;
+  }
+}
+
+// Run the test
+testWasmIntegration()
+  .then(success => {
+    process.exit(success ? 0 : 1);
+  })
+  .catch(error => {
+    console.error('Test execution failed:', error);
+    process.exit(1);
+  });