@ruvector/edge-net 0.1.0 → 0.1.1

package/cli.js

@@ -7,21 +7,77 @@
  *
  * Usage:
  *   npx @ruvector/edge-net [command] [options]
- *
- * Commands:
- *   start       Start an edge-net node
- *   benchmark   Run performance benchmarks
- *   info        Show package information
- *   demo        Run interactive demo
  */
 
-import { readFileSync, existsSync } from 'fs';
+import { readFileSync, existsSync, statSync } from 'fs';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
+import { webcrypto } from 'crypto';
+import { performance } from 'perf_hooks';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
+// Setup Node.js polyfills for web APIs BEFORE loading WASM
+async function setupPolyfills() {
+  // Crypto API
+  if (typeof globalThis.crypto === 'undefined') {
+    globalThis.crypto = webcrypto;
+  }
+
+  // Performance API
+  if (typeof globalThis.performance === 'undefined') {
+    globalThis.performance = performance;
+  }
+
+  // In-memory storage
+  const createStorage = () => {
+    const store = new Map();
+    return {
+      getItem: (key) => store.get(key) || null,
+      setItem: (key, value) => store.set(key, String(value)),
+      removeItem: (key) => store.delete(key),
+      clear: () => store.clear(),
+      get length() { return store.size; },
+      key: (i) => [...store.keys()][i] || null,
+    };
+  };
+
+  // Get CPU count synchronously
+  let cpuCount = 4;
+  try {
+    const os = await import('os');
+    cpuCount = os.cpus().length;
+  } catch {}
+
+  // Mock window object
+  if (typeof globalThis.window === 'undefined') {
+    globalThis.window = {
+      crypto: globalThis.crypto,
+      performance: globalThis.performance,
+      localStorage: createStorage(),
+      sessionStorage: createStorage(),
+      navigator: {
+        userAgent: `Node.js/${process.version}`,
+        language: 'en-US',
+        languages: ['en-US', 'en'],
+        hardwareConcurrency: cpuCount,
+      },
+      location: { href: 'node://localhost', hostname: 'localhost' },
+      screen: { width: 1920, height: 1080, colorDepth: 24 },
+    };
+  }
+
+  // Mock document
+  if (typeof globalThis.document === 'undefined') {
+    globalThis.document = {
+      createElement: () => ({}),
+      body: {},
+      head: {},
+    };
+  }
+}
+
 // ANSI colors
 const colors = {
   reset: '\x1b[0m',
@@ -56,6 +112,7 @@ ${c('bold', 'COMMANDS:')}
   ${c('green', 'benchmark')}   Run performance benchmarks
   ${c('green', 'info')}        Show package and WASM information
   ${c('green', 'demo')}        Run interactive demonstration
+  ${c('green', 'test')}        Test WASM module loading
   ${c('green', 'help')}        Show this help message
 
 ${c('bold', 'EXAMPLES:')}
@@ -65,8 +122,8 @@ ${c('bold', 'EXAMPLES:')}
   ${c('dim', '# Run benchmarks')}
   $ npx @ruvector/edge-net benchmark
 
-  ${c('dim', '# Show info')}
-  $ npx @ruvector/edge-net info
+  ${c('dim', '# Test WASM loading')}
+  $ npx @ruvector/edge-net test
 
 ${c('bold', 'FEATURES:')}
   ${c('magenta', '⏱️  Time Crystal')}   - Distributed coordination via period-doubled oscillations
@@ -87,18 +144,17 @@ ${c('dim', 'Documentation: https://github.com/ruvnet/ruvector/tree/main/examples
 async function showInfo() {
   printBanner();
 
-  // Read package.json
   const pkgPath = join(__dirname, 'package.json');
   const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
 
-  // Check WASM file
   const wasmPath = join(__dirname, 'ruvector_edge_net_bg.wasm');
+  const nodeWasmPath = join(__dirname, 'node', 'ruvector_edge_net_bg.wasm');
   const wasmExists = existsSync(wasmPath);
-  let wasmSize = 0;
-  if (wasmExists) {
-    const stats = await import('fs').then(fs => fs.statSync(wasmPath));
-    wasmSize = stats.size;
-  }
+  const nodeWasmExists = existsSync(nodeWasmPath);
+
+  let wasmSize = 0, nodeWasmSize = 0;
+  if (wasmExists) wasmSize = statSync(wasmPath).size;
+  if (nodeWasmExists) nodeWasmSize = statSync(nodeWasmPath).size;
 
   console.log(`${c('bold', 'PACKAGE INFO:')}
   ${c('cyan', 'Name:')}        ${pkg.name}
@@ -106,15 +162,18 @@ async function showInfo() {
   ${c('cyan', 'License:')}     ${pkg.license}
   ${c('cyan', 'Type:')}        ${pkg.type}
 
-${c('bold', 'WASM MODULE:')}
-  ${c('cyan', 'File:')}        ruvector_edge_net_bg.wasm
-  ${c('cyan', 'Exists:')}      ${wasmExists ? c('green', '✓ Yes') : c('red', '✗ No')}
-  ${c('cyan', 'Size:')}        ${(wasmSize / 1024 / 1024).toFixed(2)} MB
+${c('bold', 'WASM MODULES:')}
+  ${c('cyan', 'Web Target:')}   ${wasmExists ? c('green', '✓') : c('red', '✗')} ${(wasmSize / 1024 / 1024).toFixed(2)} MB
+  ${c('cyan', 'Node Target:')} ${nodeWasmExists ? c('green', '✓') : c('red', '✗')} ${(nodeWasmSize / 1024 / 1024).toFixed(2)} MB
 
-${c('bold', 'EXPORTS:')}
-  ${c('cyan', 'Main:')}        ${pkg.main}
-  ${c('cyan', 'Types:')}       ${pkg.types}
-  ${c('cyan', 'CLI:')}         edge-net, ruvector-edge
+${c('bold', 'ENVIRONMENT:')}
+  ${c('cyan', 'Runtime:')}     Node.js ${process.version}
+  ${c('cyan', 'Platform:')}    ${process.platform} ${process.arch}
+  ${c('cyan', 'Crypto:')}      ${typeof globalThis.crypto !== 'undefined' ? c('green', '✓ Available') : c('yellow', '⚠ Polyfilled')}
+
+${c('bold', 'CLI COMMANDS:')}
+  ${c('cyan', 'edge-net')}     Main CLI binary
+  ${c('cyan', 'ruvector-edge')} Alias
 
 ${c('bold', 'CAPABILITIES:')}
   ${c('green', '✓')} Ed25519 digital signatures
@@ -129,51 +188,118 @@ ${c('bold', 'CAPABILITIES:')}
 `);
 }
 
+async function testWasm() {
+  printBanner();
+  console.log(`${c('bold', 'Testing WASM Module Loading...')}\n`);
+
+  // Setup polyfills
+  await setupPolyfills();
+  console.log(`${c('green', '✓')} Polyfills configured\n`);
+
+  try {
+    // Load Node.js WASM module
+    const { createRequire } = await import('module');
+    const require = createRequire(import.meta.url);
+
+    console.log(`${c('cyan', '1. Loading Node.js WASM module...')}`);
+    const wasm = require('./node/ruvector_edge_net.cjs');
+    console.log(`   ${c('green', '✓')} Module loaded\n`);
+
+    console.log(`${c('cyan', '2. Available exports:')}`);
+    const exports = Object.keys(wasm).filter(k => !k.startsWith('__')).slice(0, 15);
+    exports.forEach(e => console.log(`   ${c('dim', '•')} ${e}`));
+    console.log(`   ${c('dim', '...')} and ${Object.keys(wasm).length - 15} more\n`);
+
+    console.log(`${c('cyan', '3. Testing components:')}`);
+
+    // Test ByzantineDetector
+    try {
+      const detector = new wasm.ByzantineDetector(0.5);
+      console.log(`   ${c('green', '✓')} ByzantineDetector - created`);
+    } catch (e) {
+      console.log(`   ${c('red', '✗')} ByzantineDetector - ${e.message}`);
+    }
+
+    // Test FederatedModel
+    try {
+      const model = new wasm.FederatedModel(100, 0.01, 0.9);
+      console.log(`   ${c('green', '✓')} FederatedModel - created`);
+    } catch (e) {
+      console.log(`   ${c('red', '✗')} FederatedModel - ${e.message}`);
+    }
+
+    // Test DifferentialPrivacy
+    try {
+      const dp = new wasm.DifferentialPrivacy(1.0, 0.001);
+      console.log(`   ${c('green', '✓')} DifferentialPrivacy - created`);
+    } catch (e) {
+      console.log(`   ${c('red', '✗')} DifferentialPrivacy - ${e.message}`);
+    }
+
+    // Test EdgeNetNode (may need web APIs)
+    try {
+      const node = new wasm.EdgeNetNode();
+      console.log(`   ${c('green', '✓')} EdgeNetNode - created`);
+      console.log(`      ${c('dim', 'Node ID:')} ${node.nodeId().substring(0, 32)}...`);
+    } catch (e) {
+      console.log(`   ${c('yellow', '⚠')} EdgeNetNode - ${e.message.substring(0, 50)}...`);
+      console.log(`      ${c('dim', 'Note: Some features require browser environment')}`);
+    }
+
+    console.log(`\n${c('green', '✓ WASM module test complete!')}`);
+
+  } catch (err) {
+    console.error(`${c('red', '✗ Failed to load WASM:')}\n`, err.message);
+  }
+}
+
 async function runBenchmark() {
   printBanner();
   console.log(`${c('bold', 'Running Performance Benchmarks...')}\n`);
 
-  // Dynamic import for Node.js WASM support
+  await setupPolyfills();
+
   try {
-    const wasm = await import('./ruvector_edge_net.js');
-    await wasm.default();
-
-    console.log(`${c('green', '✓')} WASM module loaded successfully\n`);
-
-    // Benchmark: Node creation
-    console.log(`${c('cyan', '1. Node Identity Creation')}`);
-    const startNode = performance.now();
-    const node = new wasm.EdgeNetNode();
-    const nodeTime = performance.now() - startNode;
-    console.log(`   ${c('dim', 'Time:')} ${nodeTime.toFixed(2)}ms`);
-    console.log(`   ${c('dim', 'Node ID:')} ${node.nodeId().substring(0, 16)}...`);
-
-    // Benchmark: Credit operations
-    console.log(`\n${c('cyan', '2. Credit Operations')}`);
-    const creditStart = performance.now();
-    for (let i = 0; i < 1000; i++) {
-      node.credit(100);
+    const { createRequire } = await import('module');
+    const require = createRequire(import.meta.url);
+    const wasm = require('./node/ruvector_edge_net.cjs');
+
+    console.log(`${c('green', '✓')} WASM module loaded\n`);
+
+    // Benchmark: ByzantineDetector
+    console.log(`${c('cyan', '1. Byzantine Detector')}`);
+    const bzStart = performance.now();
+    for (let i = 0; i < 10000; i++) {
+      const detector = new wasm.ByzantineDetector(0.5);
+      detector.getMaxMagnitude();
+      detector.free();
     }
-    const creditTime = performance.now() - creditStart;
-    console.log(`   ${c('dim', '1000 credits:')} ${creditTime.toFixed(2)}ms`);
-    console.log(`   ${c('dim', 'Balance:')} ${node.balance()} tokens`);
+    console.log(`   ${c('dim', '10k create/query/free:')} ${(performance.now() - bzStart).toFixed(2)}ms`);
 
-    // Benchmark: Statistics
-    console.log(`\n${c('cyan', '3. Node Statistics')}`);
-    const statsStart = performance.now();
-    const stats = node.stats();
-    const statsTime = performance.now() - statsStart;
-    console.log(`   ${c('dim', 'Stats generation:')} ${statsTime.toFixed(2)}ms`);
+    // Benchmark: FederatedModel
+    console.log(`\n${c('cyan', '2. Federated Model')}`);
+    const fmStart = performance.now();
+    for (let i = 0; i < 1000; i++) {
+      const model = new wasm.FederatedModel(100, 0.01, 0.9);
+      model.free();
+    }
+    console.log(`   ${c('dim', '1k model create/free:')} ${(performance.now() - fmStart).toFixed(2)}ms`);
 
-    const parsedStats = JSON.parse(stats);
-    console.log(`   ${c('dim', 'Total credits:')} ${parsedStats.credits_earned || 0}`);
+    // Benchmark: DifferentialPrivacy
+    console.log(`\n${c('cyan', '3. Differential Privacy')}`);
+    const dpStart = performance.now();
+    for (let i = 0; i < 1000; i++) {
+      const dp = new wasm.DifferentialPrivacy(1.0, 0.001);
+      dp.getEpsilon();
+      dp.isEnabled();
+      dp.free();
+    }
+    console.log(`   ${c('dim', '1k DP operations:')} ${(performance.now() - dpStart).toFixed(2)}ms`);
 
-    console.log(`\n${c('green', '✓ All benchmarks completed successfully!')}\n`);
+    console.log(`\n${c('green', '✓ Benchmarks complete!')}`);
 
   } catch (err) {
     console.error(`${c('red', '✗ Benchmark failed:')}\n`, err.message);
-    console.log(`\n${c('yellow', 'Note:')} Node.js WASM support requires specific setup.`);
-    console.log(`${c('dim', 'For full functionality, use in a browser environment.')}`);
   }
 }
 
@@ -181,35 +307,48 @@ async function startNode() {
   printBanner();
   console.log(`${c('bold', 'Starting Edge-Net Node...')}\n`);
 
-  try {
-    const wasm = await import('./ruvector_edge_net.js');
-    await wasm.default();
-
-    const node = new wasm.EdgeNetNode();
+  await setupPolyfills();
 
-    console.log(`${c('green', '✓')} Node started successfully!`);
-    console.log(`\n${c('bold', 'NODE INFO:')}`);
-    console.log(`  ${c('cyan', 'ID:')}      ${node.nodeId()}`);
-    console.log(`  ${c('cyan', 'Balance:')} ${node.balance()} tokens`);
-    console.log(`  ${c('cyan', 'Status:')}  ${c('green', 'Active')}`);
+  try {
+    const { createRequire } = await import('module');
+    const require = createRequire(import.meta.url);
+    const wasm = require('./node/ruvector_edge_net.cjs');
+
+    // Try to create EdgeNetNode
+    let node;
+    try {
+      node = new wasm.EdgeNetNode();
+      console.log(`${c('green', '✓')} Full node started`);
+      console.log(`\n${c('bold', 'NODE INFO:')}`);
+      console.log(`  ${c('cyan', 'ID:')}      ${node.nodeId()}`);
+      console.log(`  ${c('cyan', 'Balance:')} ${node.balance()} tokens`);
+    } catch (e) {
+      // Fall back to lightweight mode
+      console.log(`${c('yellow', '⚠')} Full node unavailable in CLI (needs browser)`);
+      console.log(`${c('green', '✓')} Starting in lightweight mode\n`);
+
+      const detector = new wasm.ByzantineDetector(0.5);
+      const dp = new wasm.DifferentialPrivacy(1.0, 0.001);
+
+      console.log(`${c('bold', 'LIGHTWEIGHT NODE:')}`);
+      console.log(`  ${c('cyan', 'Byzantine Detector:')} Active`);
+      console.log(`  ${c('cyan', 'Differential Privacy:')} ε=1.0, δ=0.001`);
+      console.log(`  ${c('cyan', 'Mode:')} AI Components Only`);
+    }
 
-    console.log(`\n${c('dim', 'Press Ctrl+C to stop the node.')}`);
+    console.log(`  ${c('cyan', 'Status:')}  ${c('green', 'Running')}`);
+    console.log(`\n${c('dim', 'Press Ctrl+C to stop.')}`);
 
-    // Keep the process running
+    // Keep running
     process.on('SIGINT', () => {
-      console.log(`\n${c('yellow', 'Shutting down node...')}`);
+      console.log(`\n${c('yellow', 'Node stopped.')}`);
       process.exit(0);
     });
 
-    // Heartbeat
-    setInterval(() => {
-      node.credit(1); // Simulate earning
-    }, 5000);
+    setInterval(() => {}, 1000);
 
   } catch (err) {
-    console.error(`${c('red', '✗ Failed to start node:')}\n`, err.message);
-    console.log(`\n${c('yellow', 'Note:')} Node.js WASM requires web environment features.`);
-    console.log(`${c('dim', 'Consider using: node --experimental-wasm-modules')}`);
+    console.error(`${c('red', '✗ Failed to start:')}\n`, err.message);
   }
 }
 
@@ -217,39 +356,59 @@ async function runDemo() {
   printBanner();
   console.log(`${c('bold', 'Running Interactive Demo...')}\n`);
 
-  console.log(`${c('cyan', 'Step 1:')} Creating edge-net node identity...`);
-  console.log(`  ${c('dim', '→ Generating Ed25519 keypair')}`);
-  console.log(`  ${c('dim', '→ Deriving X25519 DH key')}`);
-  console.log(`  ${c('green', '✓')} Identity created\n`);
-
-  console.log(`${c('cyan', 'Step 2:')} Initializing AI capabilities...`);
-  console.log(`  ${c('dim', '→ Time Crystal coordinator (8 oscillators)')}`);
-  console.log(`  ${c('dim', '→ DAG attention engine')}`);
-  console.log(`  ${c('dim', '→ HNSW vector index (128-dim)')}`);
-  console.log(`  ${c('green', '✓')} AI layer initialized\n`);
-
-  console.log(`${c('cyan', 'Step 3:')} Connecting to P2P network...`);
-  console.log(`  ${c('dim', '→ Gossipsub pubsub')}`);
-  console.log(`  ${c('dim', '→ Semantic routing')}`);
-  console.log(`  ${c('dim', '→ Swarm discovery')}`);
-  console.log(`  ${c('green', '✓')} Network ready\n`);
-
-  console.log(`${c('cyan', 'Step 4:')} Joining compute marketplace...`);
-  console.log(`  ${c('dim', '→ Registering compute capabilities')}`);
-  console.log(`  ${c('dim', '→ Setting credit rate')}`);
-  console.log(`  ${c('dim', '→ Listening for tasks')}`);
-  console.log(`  ${c('green', '✓')} Marketplace joined\n`);
-
-  console.log(`${c('bold', '─────────────────────────────────────────────────')}`);
-  console.log(`${c('green', '✓ Demo complete!')} Node is ready to contribute compute.\n`);
-  console.log(`${c('dim', 'In production, the node would now:')}`);
-  console.log(`  • Accept compute tasks from the network`);
-  console.log(`  • Execute WASM workloads in isolated sandboxes`);
-  console.log(`  • Earn credits for contributed compute`);
-  console.log(`  • Participate in swarm coordination`);
+  await setupPolyfills();
+
+  const delay = (ms) => new Promise(r => setTimeout(r, ms));
+
+  console.log(`${c('cyan', 'Step 1:')} Loading WASM module...`);
+  await delay(200);
+  console.log(`  ${c('green', '✓')} Module loaded (1.13 MB)\n`);
+
+  console.log(`${c('cyan', 'Step 2:')} Initializing AI components...`);
+  await delay(150);
+  console.log(`  ${c('dim', '→')} Byzantine fault detector`);
+  console.log(`  ${c('dim', '→')} Differential privacy engine`);
+  console.log(`  ${c('dim', '→')} Federated learning model`);
+  console.log(`  ${c('green', '✓')} AI layer ready\n`);
+
+  console.log(`${c('cyan', 'Step 3:')} Testing components...`);
+  await delay(100);
+
+  try {
+    const { createRequire } = await import('module');
+    const require = createRequire(import.meta.url);
+    const wasm = require('./node/ruvector_edge_net.cjs');
+
+    const detector = new wasm.ByzantineDetector(0.5);
+    const dp = new wasm.DifferentialPrivacy(1.0, 0.001);
+    const model = new wasm.FederatedModel(100, 0.01, 0.9);
+
+    console.log(`  ${c('green', '✓')} ByzantineDetector: threshold=0.5`);
+    console.log(`  ${c('green', '✓')} DifferentialPrivacy: ε=1.0, δ=0.001`);
+    console.log(`  ${c('green', '✓')} FederatedModel: dim=100, lr=0.01\n`);
+
+    console.log(`${c('cyan', 'Step 4:')} Running simulation...`);
+    await delay(200);
+
+    // Simulate some operations using available methods
+    for (let i = 0; i < 5; i++) {
+      const maxMag = detector.getMaxMagnitude();
+      const epsilon = dp.getEpsilon();
+      const enabled = dp.isEnabled();
+      console.log(`  ${c('dim', `Round ${i + 1}:`)} maxMag=${maxMag.toFixed(2)}, ε=${epsilon.toFixed(2)}, enabled=${enabled}`);
+      await delay(100);
+    }
+
+  } catch (e) {
+    console.log(`  ${c('yellow', '⚠')} Some components unavailable: ${e.message}`);
+  }
+
+  console.log(`\n${c('bold', '─────────────────────────────────────────────────')}`);
+  console.log(`${c('green', '✓ Demo complete!')} WASM module is functional.\n`);
+  console.log(`${c('dim', 'For full P2P features, run in a browser environment.')}`);
 }
 
-// Main CLI handler
+// Main
 const command = process.argv[2] || 'help';
 
 switch (command) {
@@ -266,6 +425,9 @@ switch (command) {
   case 'demo':
     runDemo();
     break;
+  case 'test':
+    testWasm();
+    break;
   case 'help':
   case '--help':
   case '-h':

package/index.js

@@ -0,0 +1,104 @@
+/**
+ * @ruvector/edge-net - Universal Entry Point
+ *
+ * Auto-detects environment (Browser vs Node.js) and loads appropriate module
+ */
+
+// Environment detection
+const isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';
+const isNode = typeof process !== 'undefined' && process.versions && process.versions.node;
+
+let wasmModule = null;
+let initPromise = null;
+
+/**
+ * Initialize the WASM module
+ * @returns {Promise<Object>} The initialized WASM module
+ */
+export async function init() {
+  if (wasmModule) return wasmModule;
+
+  if (initPromise) return initPromise;
+
+  initPromise = (async () => {
+    if (isBrowser) {
+      // Browser: use web target
+      const wasm = await import('./ruvector_edge_net.js');
+      await wasm.default();
+      wasmModule = wasm;
+    } else if (isNode) {
+      // Node.js: Setup polyfills first
+      await setupNodePolyfills();
+
+      // Dynamic import for ESM compatibility
+      const { createRequire } = await import('module');
+      const require = createRequire(import.meta.url);
+
+      // Try nodejs target first, fall back to web target with polyfills
+      try {
+        wasmModule = require('./node/ruvector_edge_net.js');
+      } catch (e) {
+        // Fallback to web version with polyfills
+        const wasm = await import('./ruvector_edge_net.js');
+        await wasm.default();
+        wasmModule = wasm;
+      }
+    } else {
+      throw new Error('Unsupported environment');
+    }
+
+    return wasmModule;
+  })();
+
+  return initPromise;
+}
+
+/**
+ * Setup Node.js polyfills for web APIs
+ */
+async function setupNodePolyfills() {
+  if (typeof globalThis.crypto === 'undefined') {
+    const { webcrypto } = await import('crypto');
+    globalThis.crypto = webcrypto;
+  }
+
+  if (typeof globalThis.performance === 'undefined') {
+    const { performance } = await import('perf_hooks');
+    globalThis.performance = performance;
+  }
+
+  // Mock minimal web APIs
+  if (typeof globalThis.window === 'undefined') {
+    globalThis.window = {
+      crypto: globalThis.crypto,
+      performance: globalThis.performance,
+      localStorage: createMemoryStorage(),
+      navigator: { userAgent: 'node' },
+    };
+  }
+
+  if (typeof globalThis.document === 'undefined') {
+    globalThis.document = {};
+  }
+}
+
+/**
+ * Create in-memory storage for Node.js
+ */
+function createMemoryStorage() {
+  const store = new Map();
+  return {
+    getItem: (key) => store.get(key) || null,
+    setItem: (key, value) => store.set(key, String(value)),
+    removeItem: (key) => store.delete(key),
+    clear: () => store.clear(),
+    get length() { return store.size; },
+    key: (i) => [...store.keys()][i] || null,
+  };
+}
+
+// Re-export everything from the web module for type compatibility
+export * from './ruvector_edge_net.js';
+
+// Default export is the init function
+export default init;