ruvector 0.1.20 → 0.1.21

package/dist/index.mjs

@@ -0,0 +1,306 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+// ../node_modules/@ruvector/core/dist/index.cjs
+var require_dist = __commonJS({
+  "../node_modules/@ruvector/core/dist/index.cjs"(exports, module) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.DistanceMetric = void 0;
+    var node_os_1 = __require("os");
+    var DistanceMetric;
+    (function(DistanceMetric2) {
+      DistanceMetric2["Euclidean"] = "euclidean";
+      DistanceMetric2["Cosine"] = "cosine";
+      DistanceMetric2["DotProduct"] = "dot";
+    })(DistanceMetric || (exports.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();
+    module.exports = nativeBinding;
+    module.exports.default = nativeBinding;
+    module.exports.DistanceMetric = DistanceMetric;
+  }
+});
+
+// package.json
+var require_package = __commonJS({
+  "package.json"(exports, module) {
+    module.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 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}`
+      );
+    }
+  }
+}
+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
+  };
+}
+function isNativeAvailable() {
+  try {
+    __require.resolve("@ruvector/core");
+    return true;
+  } catch {
+    return false;
+  }
+}
+var index_default = VectorIndex;
+export {
+  Utils,
+  VectorIndex,
+  index_default as default,
+  getBackendInfo,
+  isNativeAvailable
+};

package/package.json

@@ -1,58 +1,77 @@
 {
   "name": "ruvector",
-  "version": "0.1.20",
-  "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.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/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": "npm run build"
   },
   "keywords": [
     "vector",
     "database",
-    "vector-database",
-    "vector-search",
-    "similarity-search",
-    "semantic-search",
     "embeddings",
-    "hnsw",
-    "ann",
-    "ai",
+    "similarity-search",
     "machine-learning",
-    "rag",
+    "ai",
     "rust",
+    "napi",
     "wasm",
-    "native",
-    "ruv",
-    "ruvector"
+    "graph",
+    "cypher",
+    "neo4j",
+    "gnn",
+    "neural-network",
+    "compression",
+    "hnsw",
+    "rag"
   ],
-  "author": "ruv.io Team <info@ruv.io> (https://ruv.io)",
-  "homepage": "https://ruv.io",
-  "bugs": {
-    "url": "https://github.com/ruvnet/ruvector/issues"
-  },
+  "author": "rUv",
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "https://github.com/ruvnet/ruvector.git",
-    "directory": "npm/packages/ruvector"
+    "directory": "npm/ruvector"
   },
   "dependencies": {
-    "@ruvector/core": "^0.1.14",
     "commander": "^11.1.0",
     "chalk": "^4.1.2",
-    "ora": "^5.4.1"
+    "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": 1764098223504,
-  "sessionId": "session-1764098223504",
-  "lastActivity": 1764098223504,
-  "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-1764098223654",
-    "type": "hooks",
-    "success": true,
-    "duration": 9.898746000000017,
-    "timestamp": 1764098223664,
-    "metadata": {}
-  }
-]