@ruvector/rvf-node 0.1.3 → 0.1.4

package/README.md

@@ -255,6 +255,31 @@ const segments = db.segments();
 db.dimension(); // 384
 ```
 
+## Self-Booting RVF
+
+An `.rvf` file can embed a Linux kernel, eBPF programs, and SSH keys alongside vector data — producing a single file that boots as a microservice.
+
+The Claude Code Appliance example builds a complete AI dev environment:
+
+```bash
+cd examples/rvf
+cargo run --example claude_code_appliance
+```
+
+```
+claude_code_appliance.rvf
+  ├── KERNEL_SEG    Linux 6.8.12 bzImage (5.2 MB, x86_64)
+  ├── EBPF_SEG      Socket filter — ports 2222, 8080 only
+  ├── VEC_SEG       20 package embeddings (128-dim)
+  ├── INDEX_SEG     HNSW graph for package search
+  ├── WITNESS_SEG   6-entry tamper-evident audit trail
+  └── CRYPTO_SEG    3 Ed25519 SSH user keys
+```
+
+Final file: **5.1 MB single `.rvf`** — boots Linux, serves queries, runs Claude Code.
+
+See the [full RVF documentation](https://github.com/ruvnet/ruvector/tree/main/crates/rvf) for details.
+
 ## Build from Source
 
 ```bash

package/index.d.ts

@@ -0,0 +1,95 @@
+/* auto-generated: TypeScript declarations for @ruvector/rvf-node */
+
+export interface RvfOptions {
+  dimension: number;
+  metric?: string;
+  profile?: number;
+  signing?: boolean;
+  m?: number;
+  efConstruction?: number;
+}
+
+export interface RvfQueryOptions {
+  efSearch?: number;
+  filter?: string;
+  timeoutMs?: number;
+}
+
+export interface RvfSearchResult {
+  id: number;
+  distance: number;
+}
+
+export interface RvfIngestResult {
+  accepted: number;
+  rejected: number;
+  epoch: number;
+}
+
+export interface RvfDeleteResult {
+  deleted: number;
+  epoch: number;
+}
+
+export interface RvfCompactionResult {
+  segmentsCompacted: number;
+  bytesReclaimed: number;
+  epoch: number;
+}
+
+export interface RvfStatus {
+  totalVectors: number;
+  totalSegments: number;
+  fileSize: number;
+  currentEpoch: number;
+  profileId: number;
+  compactionState: string;
+  deadSpaceRatio: number;
+  readOnly: boolean;
+}
+
+export interface RvfMetadataEntry {
+  fieldId: number;
+  valueType: string;
+  value: string;
+}
+
+export interface RvfKernelData {
+  header: Buffer;
+  image: Buffer;
+}
+
+export interface RvfEbpfData {
+  header: Buffer;
+  payload: Buffer;
+}
+
+export interface RvfSegmentInfo {
+  id: number;
+  offset: number;
+  payloadLength: number;
+  segType: string;
+}
+
+export class RvfDatabase {
+  static create(path: string, options: RvfOptions): RvfDatabase;
+  static open(path: string): RvfDatabase;
+  static openReadonly(path: string): RvfDatabase;
+  ingestBatch(vectors: Float32Array, ids: number[], metadata?: RvfMetadataEntry[]): RvfIngestResult;
+  query(vector: Float32Array, k: number, options?: RvfQueryOptions): RvfSearchResult[];
+  delete(ids: number[]): RvfDeleteResult;
+  deleteByFilter(filterJson: string): RvfDeleteResult;
+  compact(): RvfCompactionResult;
+  status(): RvfStatus;
+  close(): void;
+  fileId(): string;
+  parentId(): string;
+  lineageDepth(): number;
+  derive(childPath: string, options?: RvfOptions): RvfDatabase;
+  embedKernel(arch: number, kernelType: number, flags: number, image: Buffer, apiPort: number, cmdline?: string): number;
+  extractKernel(): RvfKernelData | null;
+  embedEbpf(programType: number, attachType: number, maxDimension: number, bytecode: Buffer, btf?: Buffer): number;
+  extractEbpf(): RvfEbpfData | null;
+  segments(): RvfSegmentInfo[];
+  dimension(): number;
+}

package/index.js

@@ -0,0 +1,150 @@
+/* eslint-disable */
+/* auto-generated: NAPI-RS platform loader for @ruvector/rvf-node */
+
+const { existsSync, readFileSync } = require('fs');
+const { join } = require('path');
+
+const { platform, arch } = process;
+
+let nativeBinding = null;
+let localFileExisted = false;
+let loadError = null;
+
+function isMusl() {
+  // For Node 12+, check report.header.glibcVersionRuntime
+  if (!process.report || typeof process.report.getReport !== 'function') {
+    try {
+      const lddPath = require('child_process')
+        .execSync('which ldd')
+        .toString()
+        .trim();
+      return readFileSync(lddPath, 'utf8').includes('musl');
+    } catch {
+      return true;
+    }
+  } else {
+    const report = process.report.getReport();
+    const rep = typeof report === 'string' ? JSON.parse(report) : report;
+    return !rep.header.glibcVersionRuntime;
+  }
+}
+
+switch (platform) {
+  case 'darwin':
+    switch (arch) {
+      case 'x64':
+        localFileExisted = existsSync(join(__dirname, 'rvf-node.darwin-x64.node'));
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./rvf-node.darwin-x64.node');
+          } else {
+            nativeBinding = require('@ruvector/rvf-node-darwin-x64');
+          }
+        } catch (e) {
+          loadError = e;
+        }
+        break;
+      case 'arm64':
+        localFileExisted = existsSync(join(__dirname, 'rvf-node.darwin-arm64.node'));
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./rvf-node.darwin-arm64.node');
+          } else {
+            nativeBinding = require('@ruvector/rvf-node-darwin-arm64');
+          }
+        } catch (e) {
+          loadError = e;
+        }
+        break;
+      default:
+        throw new Error(`Unsupported architecture on macOS: ${arch}`);
+    }
+    break;
+  case 'win32':
+    switch (arch) {
+      case 'x64':
+        localFileExisted = existsSync(join(__dirname, 'rvf-node.win32-x64-msvc.node'));
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./rvf-node.win32-x64-msvc.node');
+          } else {
+            nativeBinding = require('@ruvector/rvf-node-win32-x64-msvc');
+          }
+        } catch (e) {
+          loadError = e;
+        }
+        break;
+      default:
+        throw new Error(`Unsupported architecture on Windows: ${arch}`);
+    }
+    break;
+  case 'linux':
+    switch (arch) {
+      case 'x64':
+        if (isMusl()) {
+          localFileExisted = existsSync(join(__dirname, 'rvf-node.linux-x64-musl.node'));
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./rvf-node.linux-x64-musl.node');
+            } else {
+              nativeBinding = require('@ruvector/rvf-node-linux-x64-musl');
+            }
+          } catch (e) {
+            loadError = e;
+          }
+        } else {
+          localFileExisted = existsSync(join(__dirname, 'rvf-node.linux-x64-gnu.node'));
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./rvf-node.linux-x64-gnu.node');
+            } else {
+              nativeBinding = require('@ruvector/rvf-node-linux-x64-gnu');
+            }
+          } catch (e) {
+            loadError = e;
+          }
+        }
+        break;
+      case 'arm64':
+        if (isMusl()) {
+          localFileExisted = existsSync(join(__dirname, 'rvf-node.linux-arm64-musl.node'));
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./rvf-node.linux-arm64-musl.node');
+            } else {
+              nativeBinding = require('@ruvector/rvf-node-linux-arm64-musl');
+            }
+          } catch (e) {
+            loadError = e;
+          }
+        } else {
+          localFileExisted = existsSync(join(__dirname, 'rvf-node.linux-arm64-gnu.node'));
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./rvf-node.linux-arm64-gnu.node');
+            } else {
+              nativeBinding = require('@ruvector/rvf-node-linux-arm64-gnu');
+            }
+          } catch (e) {
+            loadError = e;
+          }
+        }
+        break;
+      default:
+        throw new Error(`Unsupported architecture on Linux: ${arch}`);
+    }
+    break;
+  default:
+    throw new Error(`Unsupported OS: ${platform}, architecture: ${arch}`);
+}
+
+if (!nativeBinding) {
+  if (loadError) {
+    throw loadError;
+  }
+  throw new Error('Failed to load native binding');
+}
+
+const { RvfDatabase } = nativeBinding;
+
+module.exports.RvfDatabase = RvfDatabase;

package/package.json

@@ -1,25 +1,44 @@
 {
   "name": "@ruvector/rvf-node",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "RuVector Format Node.js native bindings",
   "main": "index.js",
   "types": "index.d.ts",
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "*.node"
+  ],
   "napi": {
-    "name": "rvf-node",
-    "triples": {
-      "defaults": true,
-      "additional": [
-        "aarch64-apple-darwin",
-        "aarch64-unknown-linux-gnu"
-      ]
-    }
+    "binaryName": "rvf-node",
+    "targets": [
+      "x86_64-unknown-linux-gnu",
+      "x86_64-apple-darwin",
+      "aarch64-apple-darwin",
+      "x86_64-pc-windows-msvc",
+      "aarch64-unknown-linux-gnu"
+    ]
   },
   "scripts": {
-    "build": "napi build --platform --release",
-    "test": "jest"
+    "build": "napi build --platform --release"
   },
   "license": "MIT",
-  "devDependencies": {
-    "@napi-rs/cli": "^2.18.0"
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ruvnet/ruvector"
+  },
+  "engines": {
+    "node": ">= 16"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "optionalDependencies": {
+    "@ruvector/rvf-node-linux-x64-gnu": "0.1.4",
+    "@ruvector/rvf-node-darwin-x64": "0.1.4",
+    "@ruvector/rvf-node-darwin-arm64": "0.1.4",
+    "@ruvector/rvf-node-win32-x64-msvc": "0.1.4",
+    "@ruvector/rvf-node-linux-arm64-gnu": "0.1.4"
   }
 }