ruvector 0.1.34 → 0.1.36

package/dist/index.d.mts

@@ -0,0 +1,95 @@
+/**
+ * Vector database types compatible with both NAPI and WASM backends
+ */
+
+interface Vector {
+  id: string;
+  values: number[];
+  metadata?: Record<string, any>;
+}
+
+interface SearchResult {
+  id: string;
+  score: number;
+  metadata?: Record<string, any>;
+}
+
+interface IndexStats {
+  vectorCount: number;
+  dimension: number;
+  indexType: string;
+  memoryUsage?: number;
+}
+
+interface CreateIndexOptions {
+  dimension: number;
+  metric?: 'cosine' | 'euclidean' | 'dot';
+  indexType?: 'flat' | 'hnsw';
+  hnswConfig?: {
+    m?: number;
+    efConstruction?: number;
+  };
+}
+
+interface SearchOptions {
+  k?: number;
+  ef?: number;
+  filter?: Record<string, any>;
+}
+
+interface BatchInsertOptions {
+  batchSize?: number;
+  progressCallback?: (progress: number) => void;
+}
+
+/**
+ * Backend information
+ */
+interface BackendInfo {
+  type: 'native' | 'wasm';
+  version: string;
+  features: string[];
+}
+
+/**
+ * rUvector - High-performance vector database
+ *
+ * Smart loader that tries native bindings first, falls back to WASM
+ */
+
+/**
+ * VectorIndex class that wraps the backend
+ */
+declare class VectorIndex {
+    private index;
+    constructor(options: CreateIndexOptions);
+    insert(vector: Vector): Promise<void>;
+    insertBatch(vectors: Vector[], options?: BatchInsertOptions): Promise<void>;
+    search(query: number[], options?: SearchOptions): Promise<SearchResult[]>;
+    get(id: string): Promise<Vector | null>;
+    delete(id: string): Promise<boolean>;
+    stats(): Promise<IndexStats>;
+    save(path: string): Promise<void>;
+    static load(path: string): Promise<VectorIndex>;
+    clear(): Promise<void>;
+    optimize(): Promise<void>;
+}
+/**
+ * Utility functions
+ */
+declare const Utils: {
+    cosineSimilarity(a: number[], b: number[]): number;
+    euclideanDistance(a: number[], b: number[]): number;
+    normalize(vector: number[]): number[];
+    randomVector(dimension: number): number[];
+};
+/**
+ * Get backend information
+ */
+declare function getBackendInfo(): BackendInfo;
+/**
+ * Check if native bindings are available
+ */
+declare function isNativeAvailable(): boolean;
+
+export { type BackendInfo, type BatchInsertOptions, type CreateIndexOptions, type IndexStats, type SearchOptions, type SearchResult, Utils, type Vector, VectorIndex, VectorIndex as default, getBackendInfo, isNativeAvailable };

package/dist/index.d.ts

@@ -1,37 +1,95 @@
 /**
- * ruvector - High-performance vector database for Node.js
- *
- * This package automatically detects and uses the best available implementation:
- * 1. Native (Rust-based, fastest) - if available for your platform
- * 2. WASM (WebAssembly, universal fallback) - works everywhere
- *
- * Also provides safe wrappers for GNN and Attention modules that handle
- * array type conversions automatically.
+ * Vector database types compatible with both NAPI and WASM backends
  */
-export * from './types';
-export * from './core';
-export * from './services';
-declare let implementation: any;
+
+interface Vector {
+  id: string;
+  values: number[];
+  metadata?: Record<string, any>;
+}
+
+interface SearchResult {
+  id: string;
+  score: number;
+  metadata?: Record<string, any>;
+}
+
+interface IndexStats {
+  vectorCount: number;
+  dimension: number;
+  indexType: string;
+  memoryUsage?: number;
+}
+
+interface CreateIndexOptions {
+  dimension: number;
+  metric?: 'cosine' | 'euclidean' | 'dot';
+  indexType?: 'flat' | 'hnsw';
+  hnswConfig?: {
+    m?: number;
+    efConstruction?: number;
+  };
+}
+
+interface SearchOptions {
+  k?: number;
+  ef?: number;
+  filter?: Record<string, any>;
+}
+
+interface BatchInsertOptions {
+  batchSize?: number;
+  progressCallback?: (progress: number) => void;
+}
+
 /**
- * Get the current implementation type
+ * Backend information
  */
-export declare function getImplementationType(): 'native' | 'wasm';
+interface BackendInfo {
+  type: 'native' | 'wasm';
+  version: string;
+  features: string[];
+}
+
 /**
- * Check if native implementation is being used
+ * rUvector - High-performance vector database
+ *
+ * Smart loader that tries native bindings first, falls back to WASM
  */
-export declare function isNative(): boolean;
+
 /**
- * Check if WASM implementation is being used
+ * VectorIndex class that wraps the backend
  */
-export declare function isWasm(): boolean;
+declare class VectorIndex {
+    private index;
+    constructor(options: CreateIndexOptions);
+    insert(vector: Vector): Promise<void>;
+    insertBatch(vectors: Vector[], options?: BatchInsertOptions): Promise<void>;
+    search(query: number[], options?: SearchOptions): Promise<SearchResult[]>;
+    get(id: string): Promise<Vector | null>;
+    delete(id: string): Promise<boolean>;
+    stats(): Promise<IndexStats>;
+    save(path: string): Promise<void>;
+    static load(path: string): Promise<VectorIndex>;
+    clear(): Promise<void>;
+    optimize(): Promise<void>;
+}
 /**
- * Get version information
+ * Utility functions
  */
-export declare function getVersion(): {
-    version: string;
-    implementation: string;
+declare const Utils: {
+    cosineSimilarity(a: number[], b: number[]): number;
+    euclideanDistance(a: number[], b: number[]): number;
+    normalize(vector: number[]): number[];
+    randomVector(dimension: number): number[];
 };
-export declare const VectorDb: any;
-export declare const VectorDB: any;
-export default implementation;
-//# sourceMappingURL=index.d.ts.map
+/**
+ * Get backend information
+ */
+declare function getBackendInfo(): BackendInfo;
+/**
+ * Check if native bindings are available
+ */
+declare function isNativeAvailable(): boolean;
+
+export { type BackendInfo, type BatchInsertOptions, type CreateIndexOptions, type IndexStats, type SearchOptions, type SearchResult, Utils, type Vector, VectorIndex, VectorIndex as default, getBackendInfo, isNativeAvailable };

package/dist/index.js

@@ -1,90 +1,98 @@
 "use strict";
 /**
- * ruvector - High-performance vector database for Node.js
- *
- * This package automatically detects and uses the best available implementation:
- * 1. Native (Rust-based, fastest) - if available for your platform
- * 2. WASM (WebAssembly, universal fallback) - works everywhere
- *
- * Also provides safe wrappers for GNN and Attention modules that handle
- * array type conversions automatically.
+ * rUvector - High-performance vector database
+ * Smart loader that tries native bindings first, falls back to WASM
  */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VectorDB = exports.VectorDb = void 0;
-exports.getImplementationType = getImplementationType;
-exports.isNative = isNative;
-exports.isWasm = isWasm;
-exports.getVersion = getVersion;
-__exportStar(require("./types"), exports);
-// Export core wrappers (safe interfaces with automatic type conversion)
-__exportStar(require("./core"), exports);
-__exportStar(require("./services"), exports);
-let implementation;
-let implementationType = 'wasm';
-try {
-    // Try to load native module first
-    implementation = require('@ruvector/core');
-    implementationType = 'native';
-    // Verify it's actually working (native exports VectorDb, not VectorDB)
-    if (typeof implementation.VectorDb !== 'function') {
-        throw new Error('Native module loaded but VectorDb not found');
+exports.VectorIndex = exports.Utils = void 0;
+exports.getBackendInfo = getBackendInfo;
+exports.isNativeAvailable = isNativeAvailable;
+
+let backend;
+let backendType = 'wasm';
+
+function loadBackend() {
+  if (backend) return backend;
+  try {
+    backend = require('@ruvector/core');
+    backendType = 'native';
+    return backend;
+  } catch (e) {
+    try {
+      backend = require('@ruvector/wasm');
+      backendType = 'wasm';
+      return backend;
+    } catch (wasmError) {
+      throw new Error('Failed to load rUvector backend. Please install @ruvector/core or @ruvector/wasm.');
     }
+  }
 }
-catch (e) {
-    // No WASM fallback available yet
-    throw new Error(`Failed to load ruvector native module.\n` +
-        `Error: ${e.message}\n` +
-        `\nSupported platforms:\n` +
-        `- Linux x64/ARM64\n` +
-        `- macOS Intel/Apple Silicon\n` +
-        `- Windows x64\n` +
-        `\nIf you're on a supported platform, try:\n` +
-        `  npm install --force @ruvector/core`);
-}
-/**
- * Get the current implementation type
- */
-function getImplementationType() {
-    return implementationType;
-}
-/**
- * Check if native implementation is being used
- */
-function isNative() {
-    return implementationType === 'native';
+
+class VectorIndex {
+  constructor(options) {
+    const backend = loadBackend();
+    this.index = new backend.VectorIndex(options);
+  }
+  async insert(vector) { return this.index.insert(vector); }
+  async insertBatch(vectors, options) {
+    if (this.index.insertBatch) return this.index.insertBatch(vectors, options);
+    const batchSize = options?.batchSize || 1000;
+    for (let i = 0; i < vectors.length; i += batchSize) {
+      const batch = vectors.slice(i, Math.min(i + batchSize, vectors.length));
+      await Promise.all(batch.map(v => this.insert(v)));
+      if (options?.progressCallback) options.progressCallback(Math.min(i + batchSize, vectors.length) / vectors.length);
+    }
+  }
+  async search(query, options) { return this.index.search(query, options); }
+  async get(id) { return this.index.get(id); }
+  async delete(id) { return this.index.delete(id); }
+  async stats() { return this.index.stats(); }
+  async save(path) { return this.index.save(path); }
+  static async load(path) {
+    const backend = loadBackend();
+    const index = await backend.VectorIndex.load(path);
+    const wrapper = Object.create(VectorIndex.prototype);
+    wrapper.index = index;
+    return wrapper;
+  }
+  async clear() { return this.index.clear(); }
+  async optimize() { if (this.index.optimize) return this.index.optimize(); }
 }
-/**
- * Check if WASM implementation is being used
- */
-function isWasm() {
-    return implementationType === 'wasm';
+exports.VectorIndex = VectorIndex;
+
+const Utils = {
+  cosineSimilarity(a, b) {
+    if (a.length !== b.length) throw new Error('Vectors must have the same dimension');
+    let dotProduct = 0, normA = 0, normB = 0;
+    for (let i = 0; i < a.length; i++) { dotProduct += a[i] * b[i]; normA += a[i] * a[i]; normB += b[i] * b[i]; }
+    return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+  },
+  euclideanDistance(a, b) {
+    if (a.length !== b.length) throw new Error('Vectors must have the same dimension');
+    let sum = 0;
+    for (let i = 0; i < a.length; i++) { const diff = a[i] - b[i]; sum += diff * diff; }
+    return Math.sqrt(sum);
+  },
+  normalize(vector) {
+    const norm = Math.sqrt(vector.reduce((sum, val) => sum + val * val, 0));
+    return vector.map(val => val / norm);
+  },
+  randomVector(dimension) {
+    const vector = new Array(dimension);
+    for (let i = 0; i < dimension; i++) vector[i] = Math.random() * 2 - 1;
+    return this.normalize(vector);
+  }
+};
+exports.Utils = Utils;
+
+function getBackendInfo() {
+  loadBackend();
+  const features = backendType === 'native' ? ['SIMD', 'Multi-threading', 'Memory-mapped I/O'] : ['Browser-compatible', 'No native dependencies'];
+  return { type: backendType, version: require('../package.json').version, features };
 }
-/**
- * Get version information
- */
-function getVersion() {
-    const pkg = require('../package.json');
-    return {
-        version: pkg.version,
-        implementation: implementationType
-    };
+
+function isNativeAvailable() {
+  try { require.resolve('@ruvector/core'); return true; } catch { return false; }
 }
-// Export the VectorDb class (aliased as VectorDB for backwards compatibility)
-exports.VectorDb = implementation.VectorDb;
-exports.VectorDB = implementation.VectorDb;
-// Export everything from the implementation
-exports.default = implementation;
+
+exports.default = VectorIndex;

package/dist/index.mjs

@@ -0,0 +1,5 @@
+/**
+ * rUvector - High-performance vector database (ESM)
+ */
+export { VectorIndex, Utils, getBackendInfo, isNativeAvailable } from './index.js';
+export { default } from './index.js';

package/package.json

@@ -1,70 +1,122 @@
 {
   "name": "ruvector",
-  "version": "0.1.34",
-  "description": "High-performance vector database for Node.js with automatic native/WASM fallback",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "version": "0.1.36",
+  "description": "High-performance vector database with Graph Neural Networks, Cypher queries, and AI agent routing. Build RAG apps, semantic search, recommendations, and agentic AI systems. Pinecone + Neo4j + PyTorch alternative.",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "bin": {
-    "ruvector": "./bin/cli.js"
+    "ruvector": "./bin/ruvector.js"
   },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "files": [
+    "dist",
+    "bin",
+    "README.md"
+  ],
   "scripts": {
-    "build": "tsc",
-    "prepublishOnly": "npm run build",
-    "test": "node test/integration.js"
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "echo 'Ready to publish'"
   },
   "keywords": [
-    "vector",
-    "database",
     "vector-database",
     "vector-search",
+    "embeddings",
     "similarity-search",
     "semantic-search",
-    "embeddings",
-    "hnsw",
-    "ann",
+    "rag",
+    "retrieval-augmented-generation",
+    "llm",
+    "langchain",
+    "openai",
+    "gpt",
+    "claude",
+    "anthropic",
     "ai",
+    "artificial-intelligence",
     "machine-learning",
-    "rag",
+    "deep-learning",
+    "neural-network",
+    "gnn",
+    "graph-neural-network",
+    "knowledge-graph",
+    "graph-database",
+    "cypher",
+    "neo4j",
+    "hnsw",
+    "ann",
+    "approximate-nearest-neighbor",
+    "knn",
+    "cosine-similarity",
+    "recommendation-system",
+    "chatbot",
+    "conversational-ai",
+    "agentic-ai",
+    "ai-agents",
+    "multi-agent",
+    "agent-routing",
+    "model-router",
+    "llm-router",
     "rust",
+    "napi",
+    "napi-rs",
     "wasm",
-    "native",
-    "ruv",
-    "ruvector",
-    "attention",
-    "transformer",
-    "flash-attention",
-    "hyperbolic",
-    "sona",
-    "lora",
-    "ewc",
-    "adaptive-learning",
-    "continual-learning"
+    "webassembly",
+    "compression",
+    "quantization",
+    "product-quantization",
+    "pinecone-alternative",
+    "chromadb-alternative",
+    "milvus-alternative",
+    "qdrant-alternative",
+    "weaviate-alternative"
   ],
-  "author": "ruv.io Team <info@ruv.io> (https://ruv.io)",
-  "homepage": "https://ruv.io",
-  "bugs": {
-    "url": "https://github.com/ruvnet/ruvector/issues"
+  "author": {
+    "name": "rUv",
+    "url": "https://ruv.io"
   },
   "license": "MIT",
+  "homepage": "https://github.com/ruvnet/ruvector#readme",
   "repository": {
     "type": "git",
-    "url": "https://github.com/ruvnet/ruvector.git",
-    "directory": "npm/packages/ruvector"
+    "url": "git+https://github.com/ruvnet/ruvector.git",
+    "directory": "npm/ruvector"
+  },
+  "bugs": {
+    "url": "https://github.com/ruvnet/ruvector/issues"
+  },
+  "funding": {
+    "type": "github",
+    "url": "https://github.com/sponsors/ruvnet"
   },
   "dependencies": {
-    "@ruvector/core": "^0.1.25",
-    "@ruvector/attention": "^0.1.3",
-    "@ruvector/gnn": "^0.1.22",
-    "@ruvector/sona": "^0.1.4",
-    "chalk": "^4.1.2",
     "commander": "^11.1.0",
-    "ora": "^5.4.1"
+    "chalk": "^4.1.2",
+    "ora": "^5.4.1",
+    "cli-table3": "^0.6.3",
+    "inquirer": "^8.2.6"
+  },
+  "optionalDependencies": {
+    "@ruvector/core": "^0.1.1",
+    "@ruvector/graph-node": "^0.1.0",
+    "@ruvector/graph-wasm": "^0.1.0",
+    "@ruvector/gnn-node": "^0.1.0",
+    "@ruvector/gnn-wasm": "^0.1.0"
   },
   "devDependencies": {
-    "@types/node": "^20.10.5",
-    "typescript": "^5.3.3"
+    "@types/node": "^20.10.0",
+    "@types/inquirer": "^8.2.10",
+    "typescript": "^5.3.3",
+    "tsup": "^8.0.0"
   },
   "engines": {
-    "node": ">=14.0.0"
+    "node": ">=16.0.0"
   }
 }

package/.claude-flow/metrics/agent-metrics.json

@@ -1 +0,0 @@
-{}

package/.claude-flow/metrics/performance.json

@@ -1,87 +0,0 @@
-{
-  "startTime": 1765249648027,
-  "sessionId": "session-1765249648027",
-  "lastActivity": 1765249648027,
-  "sessionDuration": 0,
-  "totalTasks": 1,
-  "successfulTasks": 1,
-  "failedTasks": 0,
-  "totalAgents": 0,
-  "activeAgents": 0,
-  "neuralEvents": 0,
-  "memoryMode": {
-    "reasoningbankOperations": 0,
-    "basicOperations": 0,
-    "autoModeSelections": 0,
-    "modeOverrides": 0,
-    "currentMode": "auto"
-  },
-  "operations": {
-    "store": {
-      "count": 0,
-      "totalDuration": 0,
-      "errors": 0
-    },
-    "retrieve": {
-      "count": 0,
-      "totalDuration": 0,
-      "errors": 0
-    },
-    "query": {
-      "count": 0,
-      "totalDuration": 0,
-      "errors": 0
-    },
-    "list": {
-      "count": 0,
-      "totalDuration": 0,
-      "errors": 0
-    },
-    "delete": {
-      "count": 0,
-      "totalDuration": 0,
-      "errors": 0
-    },
-    "search": {
-      "count": 0,
-      "totalDuration": 0,
-      "errors": 0
-    },
-    "init": {
-      "count": 0,
-      "totalDuration": 0,
-      "errors": 0
-    }
-  },
-  "performance": {
-    "avgOperationDuration": 0,
-    "minOperationDuration": null,
-    "maxOperationDuration": null,
-    "slowOperations": 0,
-    "fastOperations": 0,
-    "totalOperationTime": 0
-  },
-  "storage": {
-    "totalEntries": 0,
-    "reasoningbankEntries": 0,
-    "basicEntries": 0,
-    "databaseSize": 0,
-    "lastBackup": null,
-    "growthRate": 0
-  },
-  "errors": {
-    "total": 0,
-    "byType": {},
-    "byOperation": {},
-    "recent": []
-  },
-  "reasoningbank": {
-    "semanticSearches": 0,
-    "sqlFallbacks": 0,
-    "embeddingGenerated": 0,
-    "consolidations": 0,
-    "avgQueryTime": 0,
-    "cacheHits": 0,
-    "cacheMisses": 0
-  }
-}

package/.claude-flow/metrics/task-metrics.json

@@ -1,10 +0,0 @@
-[
-  {
-    "id": "cmd-hooks-1765249648131",
-    "type": "hooks",
-    "success": true,
-    "duration": 7.553539000000001,
-    "timestamp": 1765249648139,
-    "metadata": {}
-  }
-]