Merge commit 'd803bfe2b1fe7f5e219e50ac20d6801a0a58ac75' as 'vendor/ruvector'

vendor/ruvector/npm/packages/ruvllm/src/native.ts

@@ -0,0 +1,188 @@
+/**
+ * Native bindings loader for RuvLLM
+ *
+ * Automatically loads the correct native binary for the current platform.
+ */
+
+import { join } from 'path';
+
+// Try to load the native module
+let nativeModule: NativeRuvLLM | null = null;
+
+interface NativeRuvLLM {
+  // Native exports RuvLlmEngine (camelCase), we normalize to RuvLLMEngine
+  RuvLLMEngine: new (config?: NativeConfig) => NativeEngine;
+  SimdOperations: new () => NativeSimdOps;
+  version: () => string;
+  hasSimdSupport: () => boolean;
+}
+
+// Raw native module interface (actual export names)
+interface RawNativeModule {
+  RuvLlmEngine?: new (config?: NativeConfig) => NativeEngine;
+  RuvLLMEngine?: new (config?: NativeConfig) => NativeEngine;
+  SimdOperations: new () => NativeSimdOps;
+  version: () => string;
+  hasSimdSupport: () => boolean;
+}
+
+interface NativeConfig {
+  embedding_dim?: number;
+  router_hidden_dim?: number;
+  hnsw_m?: number;
+  hnsw_ef_construction?: number;
+  hnsw_ef_search?: number;
+  learning_enabled?: boolean;
+  quality_threshold?: number;
+  ewc_lambda?: number;
+}
+
+interface NativeEngine {
+  query(text: string, config?: NativeGenConfig): NativeQueryResponse;
+  generate(prompt: string, config?: NativeGenConfig): string;
+  route(text: string): NativeRoutingDecision;
+  searchMemory(text: string, k?: number): NativeMemoryResult[];
+  addMemory(content: string, metadata?: string): number;
+  feedback(requestId: string, rating: number, correction?: string): boolean;
+  stats(): NativeStats;
+  forceLearn(): string;
+  embed(text: string): number[];
+  similarity(text1: string, text2: string): number;
+  hasSimd(): boolean;
+  simdCapabilities(): string[];
+}
+
+interface NativeGenConfig {
+  max_tokens?: number;
+  temperature?: number;
+  top_p?: number;
+  top_k?: number;
+  repetition_penalty?: number;
+}
+
+interface NativeQueryResponse {
+  text: string;
+  confidence: number;
+  model: string;
+  context_size: number;
+  latency_ms: number;
+  request_id: string;
+}
+
+interface NativeRoutingDecision {
+  model: string;
+  context_size: number;
+  temperature: number;
+  top_p: number;
+  confidence: number;
+}
+
+interface NativeMemoryResult {
+  id: number;
+  score: number;
+  content: string;
+  metadata: string;
+}
+
+interface NativeStats {
+  total_queries: number;
+  memory_nodes: number;
+  patterns_learned: number;
+  avg_latency_ms: number;
+  cache_hit_rate: number;
+  router_accuracy: number;
+}
+
+interface NativeSimdOps {
+  dotProduct(a: number[], b: number[]): number;
+  cosineSimilarity(a: number[], b: number[]): number;
+  l2Distance(a: number[], b: number[]): number;
+  matvec(matrix: number[][], vector: number[]): number[];
+  softmax(input: number[]): number[];
+}
+
+// Platform-specific package names
+const PLATFORM_PACKAGES: Record<string, string> = {
+  'darwin-x64': '@ruvector/ruvllm-darwin-x64',
+  'darwin-arm64': '@ruvector/ruvllm-darwin-arm64',
+  'linux-x64': '@ruvector/ruvllm-linux-x64-gnu',
+  'linux-arm64': '@ruvector/ruvllm-linux-arm64-gnu',
+  'win32-x64': '@ruvector/ruvllm-win32-x64-msvc',
+};
+
+function getPlatformKey(): string {
+  const platform = process.platform;
+  const arch = process.arch;
+  return `${platform}-${arch}`;
+}
+
+function loadNativeModule(): NativeRuvLLM | null {
+  if (nativeModule) {
+    return nativeModule;
+  }
+
+  const platformKey = getPlatformKey();
+  const packageName = PLATFORM_PACKAGES[platformKey];
+
+  if (!packageName) {
+    // Silently fail - JS fallback will be used
+    return null;
+  }
+
+  // Try loading from optional dependencies
+  const attempts = [
+    // Try the platform-specific package
+    () => require(packageName),
+    // Try loading from local .node file (CJS build)
+    () => require(join(__dirname, '..', '..', 'ruvllm.node')),
+    // Try loading from local .node file (root)
+    () => require(join(__dirname, '..', 'ruvllm.node')),
+  ];
+
+  for (const attempt of attempts) {
+    try {
+      const raw = attempt() as RawNativeModule;
+      // Normalize: native exports RuvLlmEngine, we expose as RuvLLMEngine
+      nativeModule = {
+        RuvLLMEngine: raw.RuvLLMEngine ?? raw.RuvLlmEngine!,
+        SimdOperations: raw.SimdOperations,
+        version: raw.version,
+        hasSimdSupport: raw.hasSimdSupport,
+      };
+      return nativeModule;
+    } catch {
+      // Continue to next attempt
+    }
+  }
+
+  // Silently fall back to JS implementation
+  return null;
+}
+
+// Export functions to get native bindings
+export function getNativeModule(): NativeRuvLLM | null {
+  return loadNativeModule();
+}
+
+export function version(): string {
+  const mod = loadNativeModule();
+  return mod?.version() ?? '0.1.0-js';
+}
+
+export function hasSimdSupport(): boolean {
+  const mod = loadNativeModule();
+  return mod?.hasSimdSupport() ?? false;
+}
+
+// Export types for internal use
+export type {
+  NativeRuvLLM,
+  NativeConfig,
+  NativeEngine,
+  NativeGenConfig,
+  NativeQueryResponse,
+  NativeRoutingDecision,
+  NativeMemoryResult,
+  NativeStats,
+  NativeSimdOps,
+};