ruvector 0.1.20 → 0.1.21

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,31 +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
+ * Vector database types compatible with both NAPI and WASM backends
  */
-export * from './types';
-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 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,83 +1,336 @@
 "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
- */
-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);
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VectorDB = void 0;
-exports.getImplementationType = getImplementationType;
-exports.isNative = isNative;
-exports.isWasm = isWasm;
-exports.getVersion = getVersion;
-__exportStar(require("./types"), exports);
-let implementation;
-let implementationType = 'wasm';
-try {
-    // Try to load native module first
-    implementation = require('@ruvector/core');
-    implementationType = 'native';
-    // Verify it's actually working
-    if (typeof implementation.VectorDB !== 'function') {
-        throw new Error('Native module loaded but VectorDB not found');
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ../node_modules/@ruvector/core/dist/index.cjs
+var require_dist = __commonJS({
+  "../node_modules/@ruvector/core/dist/index.cjs"(exports2, module2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.DistanceMetric = void 0;
+    var node_os_1 = require("os");
+    var DistanceMetric;
+    (function(DistanceMetric2) {
+      DistanceMetric2["Euclidean"] = "euclidean";
+      DistanceMetric2["Cosine"] = "cosine";
+      DistanceMetric2["DotProduct"] = "dot";
+    })(DistanceMetric || (exports2.DistanceMetric = DistanceMetric = {}));
+    function getPlatformPackage() {
+      const plat = (0, node_os_1.platform)();
+      const architecture = (0, node_os_1.arch)();
+      const packageMap = {
+        "linux-x64": "ruvector-core-linux-x64-gnu",
+        "linux-arm64": "ruvector-core-linux-arm64-gnu",
+        "darwin-x64": "ruvector-core-darwin-x64",
+        "darwin-arm64": "ruvector-core-darwin-arm64",
+        "win32-x64": "ruvector-core-win32-x64-msvc"
+      };
+      const key = `${plat}-${architecture}`;
+      const packageName = packageMap[key];
+      if (!packageName) {
+        throw new Error(`Unsupported platform: ${plat}-${architecture}. Supported platforms: ${Object.keys(packageMap).join(", ")}`);
+      }
+      return packageName;
     }
+    function loadNativeBinding() {
+      const packageName = getPlatformPackage();
+      try {
+        return require(packageName);
+      } catch (error) {
+        try {
+          const plat = (0, node_os_1.platform)();
+          const architecture = (0, node_os_1.arch)();
+          const platformKey = `${plat}-${architecture}`;
+          const platformMap = {
+            "linux-x64": "linux-x64-gnu",
+            "linux-arm64": "linux-arm64-gnu",
+            "darwin-x64": "darwin-x64",
+            "darwin-arm64": "darwin-arm64",
+            "win32-x64": "win32-x64-msvc"
+          };
+          const localPath = `../platforms/${platformMap[platformKey]}/ruvector.node`;
+          return require(localPath);
+        } catch (fallbackError) {
+          throw new Error(`Failed to load native binding: ${error.message}
+Fallback also failed: ${fallbackError.message}
+Platform: ${(0, node_os_1.platform)()}-${(0, node_os_1.arch)()}
+Expected package: ${packageName}`);
+        }
+      }
+    }
+    var nativeBinding = loadNativeBinding();
+    module2.exports = nativeBinding;
+    module2.exports.default = nativeBinding;
+    module2.exports.DistanceMetric = DistanceMetric;
+  }
+});
+
+// package.json
+var require_package = __commonJS({
+  "package.json"(exports2, module2) {
+    module2.exports = {
+      name: "ruvector",
+      version: "0.1.21",
+      description: "All-in-one vector database: HNSW search, Cypher queries, GNN layers, compression. Pinecone + Neo4j + PyTorch in one package.",
+      main: "./dist/index.js",
+      types: "./dist/index.d.ts",
+      bin: {
+        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: "tsup src/index.ts --format cjs,esm --dts --clean",
+        dev: "tsup src/index.ts --format cjs,esm --dts --watch",
+        typecheck: "tsc --noEmit",
+        prepublishOnly: "npm run build"
+      },
+      keywords: [
+        "vector",
+        "database",
+        "embeddings",
+        "similarity-search",
+        "machine-learning",
+        "ai",
+        "rust",
+        "napi",
+        "wasm",
+        "graph",
+        "cypher",
+        "neo4j",
+        "gnn",
+        "neural-network",
+        "compression",
+        "hnsw",
+        "rag"
+      ],
+      author: "rUv",
+      license: "MIT",
+      repository: {
+        type: "git",
+        url: "https://github.com/ruvnet/ruvector.git",
+        directory: "npm/ruvector"
+      },
+      dependencies: {
+        commander: "^11.1.0",
+        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.0",
+        "@types/inquirer": "^8.2.10",
+        typescript: "^5.3.3",
+        tsup: "^8.0.0"
+      },
+      engines: {
+        node: ">=16.0.0"
+      }
+    };
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Utils: () => Utils,
+  VectorIndex: () => VectorIndex,
+  default: () => index_default,
+  getBackendInfo: () => getBackendInfo,
+  isNativeAvailable: () => isNativeAvailable
+});
+module.exports = __toCommonJS(index_exports);
+var backend;
+var backendType = "wasm";
+function loadBackend() {
+  if (backend) {
+    return backend;
+  }
+  try {
+    backend = require_dist();
+    backendType = "native";
+    console.log("\u2713 Loaded native rUvector bindings");
+    return backend;
+  } catch (e) {
+    try {
+      backend = require("@ruvector/wasm");
+      backendType = "wasm";
+      console.warn("\u26A0 Native bindings not available, using WASM fallback");
+      console.warn("  For better performance, install @ruvector/core");
+      return backend;
+    } catch (wasmError) {
+      throw new Error(
+        `Failed to load rUvector backend. Please ensure either @ruvector/core or @ruvector/wasm is installed.
+Native error: ${e}
+WASM error: ${wasmError}`
+      );
+    }
+  }
 }
-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';
-}
-/**
- * Check if WASM implementation is being used
- */
-function isWasm() {
-    return implementationType === 'wasm';
+var VectorIndex = class _VectorIndex {
+  constructor(options) {
+    const backend2 = loadBackend();
+    this.index = new backend2.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 || 1e3;
+    const total = vectors.length;
+    for (let i = 0; i < total; i += batchSize) {
+      const batch = vectors.slice(i, Math.min(i + batchSize, total));
+      await Promise.all(batch.map((v) => this.insert(v)));
+      if (options?.progressCallback) {
+        options.progressCallback(Math.min(i + batchSize, total) / total);
+      }
+    }
+  }
+  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 backend2 = loadBackend();
+    const index = await backend2.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();
+    }
+  }
+};
+var Utils = {
+  cosineSimilarity(a, b) {
+    if (a.length !== b.length) {
+      throw new Error("Vectors must have the same dimension");
+    }
+    let dotProduct = 0;
+    let normA = 0;
+    let 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);
+  }
+};
+function getBackendInfo() {
+  loadBackend();
+  const features = [];
+  if (backendType === "native") {
+    features.push("SIMD", "Multi-threading", "Memory-mapped I/O");
+  } else {
+    features.push("Browser-compatible", "No native dependencies");
+  }
+  return {
+    type: backendType,
+    version: require_package().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
-exports.VectorDB = implementation.VectorDB;
-// Export everything from the implementation
-exports.default = implementation;
+var index_default = VectorIndex;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Utils,
+  VectorIndex,
+  getBackendInfo,
+  isNativeAvailable
+});