pluresdb 1.0.1

package/src/benchmarks/run-benchmarks.ts

@@ -0,0 +1,293 @@
+#!/usr/bin/env -S deno run -A
+
+import { GunDB } from "../core/database.ts";
+
+interface BenchmarkResult {
+  name: string;
+  operations: number;
+  totalTime: number;
+  averageTime: number;
+  operationsPerSecond: number;
+  memoryUsage?: number;
+}
+
+class BenchmarkRunner {
+  private results: BenchmarkResult[] = [];
+
+  async runBenchmark(
+    name: string,
+    operations: number,
+    operation: () => Promise<void>,
+  ): Promise<BenchmarkResult> {
+    console.log(`Running benchmark: ${name} (${operations} operations)`);
+
+    const startTime = performance.now();
+    const startMemory = (performance as any).memory?.usedJSHeapSize || 0;
+
+    for (let i = 0; i < operations; i++) {
+      await operation();
+    }
+
+    const endTime = performance.now();
+    const endMemory = (performance as any).memory?.usedJSHeapSize || 0;
+
+    const totalTime = endTime - startTime;
+    const averageTime = totalTime / operations;
+    const operationsPerSecond = (operations / totalTime) * 1000;
+    const memoryUsage = endMemory - startMemory;
+
+    const result: BenchmarkResult = {
+      name,
+      operations,
+      totalTime,
+      averageTime,
+      operationsPerSecond,
+      memoryUsage,
+    };
+
+    this.results.push(result);
+    console.log(`  ✓ ${operationsPerSecond.toFixed(2)} ops/sec (${averageTime.toFixed(2)}ms avg)`);
+
+    return result;
+  }
+
+  printSummary() {
+    console.log("\n" + "=".repeat(80));
+    console.log("BENCHMARK SUMMARY");
+    console.log("=".repeat(80));
+
+    this.results.forEach((result) => {
+      console.log(`${result.name}:`);
+      console.log(`  Operations: ${result.operations.toLocaleString()}`);
+      console.log(`  Total Time: ${result.totalTime.toFixed(2)}ms`);
+      console.log(`  Average Time: ${result.averageTime.toFixed(2)}ms`);
+      console.log(`  Operations/sec: ${result.operationsPerSecond.toFixed(2)}`);
+      if (result.memoryUsage) {
+        console.log(`  Memory Usage: ${(result.memoryUsage / 1024 / 1024).toFixed(2)}MB`);
+      }
+      console.log();
+    });
+  }
+}
+
+async function runCoreBenchmarks() {
+  const runner = new BenchmarkRunner();
+  const db = new GunDB();
+
+  try {
+    const kvPath = await Deno.makeTempFile({
+      prefix: "kv_",
+      suffix: ".sqlite",
+    });
+    await db.ready(kvPath);
+
+    console.log("Starting Core Database Benchmarks...\n");
+
+    // Benchmark 1: Basic CRUD Operations
+    await runner.runBenchmark("Basic CRUD Operations", 1000, async () => {
+      const id = `crud:${Math.random()}`;
+      await db.put(id, { value: Math.random(), timestamp: Date.now() });
+      await db.get(id);
+      await db.delete(id);
+    });
+
+    // Benchmark 2: Bulk Insert
+    await runner.runBenchmark("Bulk Insert", 5000, async () => {
+      const id = `bulk:${Math.random()}`;
+      await db.put(id, {
+        data: "x".repeat(100),
+        timestamp: Date.now(),
+        random: Math.random(),
+      });
+    });
+
+    // Benchmark 3: Bulk Read
+    // First populate with data
+    for (let i = 0; i < 1000; i++) {
+      await db.put(`read:${i}`, { value: i, data: `Data ${i}` });
+    }
+
+    let readCount = 0;
+    await runner.runBenchmark("Bulk Read", 1000, async () => {
+      await db.get(`read:${readCount % 1000}`);
+      readCount++;
+    });
+
+    // Benchmark 4: Vector Search
+    // First populate with documents
+    for (let i = 0; i < 100; i++) {
+      await db.put(`doc:${i}`, {
+        text: `Document ${i} about machine learning and artificial intelligence`,
+        content: `This is document number ${i} containing information about AI and ML algorithms`,
+      });
+    }
+
+    const searchQueries = [
+      "machine learning",
+      "artificial intelligence",
+      "neural networks",
+      "deep learning",
+      "data science",
+    ];
+
+    let queryCount = 0;
+    await runner.runBenchmark("Vector Search", 100, async () => {
+      const query = searchQueries[queryCount % searchQueries.length];
+      await db.vectorSearch(query, 10);
+      queryCount++;
+    });
+
+    // Benchmark 5: Subscription Performance
+    const subscriptions: Array<() => void> = [];
+    for (let i = 0; i < 100; i++) {
+      subscriptions.push(db.on(`sub:${i}`, () => {}));
+    }
+
+    let updateCount = 0;
+    await runner.runBenchmark("Subscription Updates", 500, async () => {
+      await db.put(`sub:${updateCount % 100}`, {
+        update: updateCount,
+        timestamp: Date.now(),
+      });
+      updateCount++;
+    });
+
+    // Clean up subscriptions
+    subscriptions.forEach((unsubscribe) => unsubscribe());
+
+    // Benchmark 6: Type System Operations
+    await runner.runBenchmark("Type System Operations", 1000, async () => {
+      const id = `type:${Math.random()}`;
+      await db.put(id, { name: `Item ${Math.random()}` });
+      await db.setType(id, "TestItem");
+      await db.instancesOf("TestItem");
+    });
+
+    runner.printSummary();
+  } finally {
+    await db.close();
+  }
+}
+
+async function runNetworkBenchmarks() {
+  const runner = new BenchmarkRunner();
+
+  console.log("Starting Network Benchmarks...\n");
+
+  // Benchmark 1: WebSocket Connection Performance
+  const db = new GunDB();
+  try {
+    const kvPath = await Deno.makeTempFile({
+      prefix: "kv_",
+      suffix: ".sqlite",
+    });
+    await db.ready(kvPath);
+
+    const port = 18000 + Math.floor(Math.random() * 10000);
+    await db.serve({ port });
+
+    const serverUrl = `ws://localhost:${port}`;
+
+    await runner.runBenchmark("WebSocket Connections", 10, async () => {
+      const clientDb = new GunDB();
+      const clientKv = await Deno.makeTempFile({
+        prefix: "kv_client_",
+        suffix: ".sqlite",
+      });
+      await clientDb.ready(clientKv);
+
+      const connectionPromise = new Promise<void>((resolve, reject) => {
+        const ws = new WebSocket(serverUrl);
+        ws.onopen = () => {
+          ws.close();
+          resolve();
+        };
+        ws.onerror = reject;
+        setTimeout(() => reject(new Error("Connection timeout")), 5000);
+      });
+
+      await connectionPromise;
+      await clientDb.close();
+    });
+  } finally {
+    await db.close();
+  }
+
+  runner.printSummary();
+}
+
+async function runMemoryBenchmarks() {
+  const runner = new BenchmarkRunner();
+  const db = new GunDB();
+
+  try {
+    const kvPath = await Deno.makeTempFile({
+      prefix: "kv_",
+      suffix: ".sqlite",
+    });
+    await db.ready(kvPath);
+
+    console.log("Starting Memory Benchmarks...\n");
+
+    // Benchmark 1: Memory Usage with Large Datasets
+    const initialMemory = (performance as any).memory?.usedJSHeapSize || 0;
+
+    await runner.runBenchmark("Large Dataset Memory Usage", 1000, async () => {
+      const id = `memory:${Math.random()}`;
+      await db.put(id, {
+        data: "x".repeat(1024), // 1KB per record
+        timestamp: Date.now(),
+        random: Math.random(),
+      });
+    });
+
+    const finalMemory = (performance as any).memory?.usedJSHeapSize || 0;
+    const memoryIncrease = finalMemory - initialMemory;
+
+    console.log(`Memory Usage: ${(memoryIncrease / 1024 / 1024).toFixed(2)}MB for 1000 records`);
+    console.log(`Memory per record: ${(memoryIncrease / 1000).toFixed(2)} bytes`);
+
+    // Benchmark 2: Subscription Memory Usage
+    const subscriptionMemory = (performance as any).memory?.usedJSHeapSize || 0;
+
+    const subscriptions: Array<() => void> = [];
+    await runner.runBenchmark("Subscription Memory Usage", 1000, async () => {
+      const id = `sub:${Math.random()}`;
+      const unsubscribe = db.on(id, () => {});
+      subscriptions.push(unsubscribe);
+    });
+
+    const afterSubscriptionMemory = (performance as any).memory?.usedJSHeapSize || 0;
+    const subscriptionMemoryIncrease = afterSubscriptionMemory - subscriptionMemory;
+
+    console.log(
+      `Subscription Memory: ${(subscriptionMemoryIncrease / 1024).toFixed(2)}KB for 1000 subscriptions`,
+    );
+    console.log(`Memory per subscription: ${(subscriptionMemoryIncrease / 1000).toFixed(2)} bytes`);
+
+    // Clean up subscriptions
+    subscriptions.forEach((unsubscribe) => unsubscribe());
+  } finally {
+    await db.close();
+  }
+}
+
+async function main() {
+  console.log("PluresDB Benchmark Suite");
+  console.log("========================\n");
+
+  try {
+    await runCoreBenchmarks();
+    await runNetworkBenchmarks();
+    await runMemoryBenchmarks();
+
+    console.log("All benchmarks completed successfully!");
+  } catch (error) {
+    console.error("Benchmark failed:", error);
+    Deno.exit(1);
+  }
+}
+
+if (import.meta.main) {
+  await main();
+}

package/src/cli.ts

@@ -0,0 +1,231 @@
+#!/usr/bin/env node
+
+/**
+ * CLI wrapper for PluresDB in Node.js environment
+ * This allows VSCode extensions to use pluresdb as a regular npm package
+ */
+
+import { PluresNode } from "./node-wrapper";
+import * as path from "path";
+import * as fs from "fs";
+
+// Parse command line arguments
+const args = process.argv.slice(2);
+const command = args[0];
+
+if (!command) {
+  console.log(`
+PluresDB - P2P Graph Database with SQLite Compatibility
+
+Usage: pluresdb <command> [options]
+
+Commands:
+  serve                    Start the PluresDB server
+  put <key> <value>        Store a key-value pair
+  get <key>                Retrieve a value by key
+  delete <key>             Delete a key-value pair
+  query <sql>              Execute SQL query
+  vsearch <query>          Perform vector search
+  list [prefix]            List all keys (optionally with prefix)
+  config                   Show configuration
+  config set <key> <value> Set configuration value
+  --help                   Show this help message
+  --version                Show version
+
+Examples:
+  pluresdb serve --port 8080
+  pluresdb put "user:123" '{"name": "John"}'
+  pluresdb get "user:123"
+  pluresdb query "SELECT * FROM users"
+  pluresdb vsearch "machine learning"
+`);
+  process.exit(0);
+}
+
+if (command === "--version") {
+  const packageJson = JSON.parse(fs.readFileSync(path.join(__dirname, "../package.json"), "utf8"));
+  console.log(packageJson.version);
+  process.exit(0);
+}
+
+if (command === "--help") {
+  console.log(`
+PluresDB - P2P Graph Database with SQLite Compatibility
+
+Usage: pluresdb <command> [options]
+
+Commands:
+  serve                    Start the PluresDB server
+  put <key> <value>        Store a key-value pair
+  get <key>                Retrieve a value by key
+  delete <key>             Delete a key-value pair
+  query <sql>              Execute SQL query
+  vsearch <query>          Perform vector search
+  list [prefix]            List all keys (optionally with prefix)
+  config                   Show configuration
+  config set <key> <value> Set configuration value
+  --help                   Show this help message
+  --version                Show version
+
+Examples:
+  pluresdb serve --port 8080
+  pluresdb put "user:123" '{"name": "John"}'
+  pluresdb get "user:123"
+  pluresdb query "SELECT * FROM users"
+  pluresdb vsearch "machine learning"
+`);
+  process.exit(0);
+}
+
+// Parse options
+const options: any = {};
+let i = 1;
+while (i < args.length) {
+  const arg = args[i];
+  if (arg.startsWith("--")) {
+    const key = arg.substring(2);
+    const value = args[i + 1];
+    if (value && !value.startsWith("--")) {
+      options[key] = value;
+      i += 2;
+    } else {
+      options[key] = true;
+      i += 1;
+    }
+  } else {
+    i += 1;
+  }
+}
+
+async function main() {
+  try {
+    if (command === "serve") {
+      const config = {
+        port: options.port ? parseInt(options.port) : 34567,
+        host: options.host || "localhost",
+        dataDir: options["data-dir"] || path.join(require("os").homedir(), ".pluresdb"),
+        webPort: options["web-port"] ? parseInt(options["web-port"]) : 34568,
+        logLevel: options["log-level"] || "info",
+      };
+
+      const plures = new PluresNode({ config, autoStart: true });
+
+      console.log(`🚀 PluresDB server starting...`);
+      console.log(`📊 API: http://${config.host}:${config.port}`);
+      console.log(`🌐 Web UI: http://${config.host}:${config.webPort}`);
+      console.log(`📁 Data: ${config.dataDir}`);
+      console.log(`\nPress Ctrl+C to stop the server`);
+
+      // Handle graceful shutdown
+      process.on("SIGINT", async () => {
+        console.log("\n🛑 Shutting down PluresDB...");
+        await plures.stop();
+        process.exit(0);
+      });
+
+      // Keep the process alive
+      await new Promise(() => {});
+    } else {
+      // For other commands, we need to start the server first
+      const plures = new PluresNode({ autoStart: true });
+
+      try {
+        switch (command) {
+          case "put":
+            if (args.length < 3) {
+              console.error("Error: put command requires key and value");
+              process.exit(1);
+            }
+            const key = args[1];
+            const value = JSON.parse(args[2]);
+            await plures.put(key, value);
+            console.log(`✅ Stored: ${key}`);
+            break;
+
+          case "get":
+            if (args.length < 2) {
+              console.error("Error: get command requires key");
+              process.exit(1);
+            }
+            const getKey = args[1];
+            const result = await plures.get(getKey);
+            if (result === null) {
+              console.log("Key not found");
+            } else {
+              console.log(JSON.stringify(result, null, 2));
+            }
+            break;
+
+          case "delete":
+            if (args.length < 2) {
+              console.error("Error: delete command requires key");
+              process.exit(1);
+            }
+            const deleteKey = args[1];
+            await plures.delete(deleteKey);
+            console.log(`✅ Deleted: ${deleteKey}`);
+            break;
+
+          case "query":
+            if (args.length < 2) {
+              console.error("Error: query command requires SQL");
+              process.exit(1);
+            }
+            const sql = args[1];
+            const queryResult = await plures.query(sql);
+            console.log(JSON.stringify(queryResult, null, 2));
+            break;
+
+          case "vsearch":
+            if (args.length < 2) {
+              console.error("Error: vsearch command requires query");
+              process.exit(1);
+            }
+            const searchQuery = args[1];
+            const limit = options.limit ? parseInt(options.limit) : 10;
+            const searchResult = await plures.vectorSearch(searchQuery, limit);
+            console.log(JSON.stringify(searchResult, null, 2));
+            break;
+
+          case "list":
+            const prefix = args[1];
+            const listResult = await plures.list(prefix);
+            console.log(JSON.stringify(listResult, null, 2));
+            break;
+
+          case "config":
+            if (args[1] === "set") {
+              if (args.length < 4) {
+                console.error("Error: config set requires key and value");
+                process.exit(1);
+              }
+              const configKey = args[2];
+              const configValue = args[3];
+              await plures.setConfig({ [configKey]: configValue });
+              console.log(`✅ Set config: ${configKey} = ${configValue}`);
+            } else {
+              const config = await plures.getConfig();
+              console.log(JSON.stringify(config, null, 2));
+            }
+            break;
+
+          default:
+            console.error(`Unknown command: ${command}`);
+            console.log('Run "pluresdb --help" for usage information');
+            process.exit(1);
+        }
+      } finally {
+        await plures.stop();
+      }
+    }
+  } catch (error) {
+    console.error("Error:", error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+
+// Run the main function
+main().catch((error) => {
+  console.error("Fatal error:", error instanceof Error ? error.message : String(error));
+  process.exit(1);
+});

package/src/config.ts

@@ -0,0 +1,49 @@
+export interface AppConfig {
+  kvPath?: string;
+  port?: number;
+  peers?: string[];
+  apiPortOffset?: number; // default 1
+}
+
+export async function loadConfig(): Promise<AppConfig> {
+  const path = getConfigPath();
+  try {
+    const text = await Deno.readTextFile(path);
+    const cfg = JSON.parse(text) as AppConfig;
+    return cfg;
+  } catch {
+    return {};
+  }
+}
+
+export async function saveConfig(cfg: AppConfig): Promise<void> {
+  const path = getConfigPath();
+  await ensureDirForFile(path);
+  await Deno.writeTextFile(path, JSON.stringify(cfg, null, 2));
+}
+
+export function getConfigPath(): string {
+  const appName = "PluresDB";
+  try {
+    const os = Deno.build.os;
+    if (os === "windows") {
+      const appData = Deno.env.get("APPDATA") || Deno.env.get("LOCALAPPDATA") || ".";
+      return `${appData}\\${appName}\\config.json`;
+    }
+    const home = Deno.env.get("HOME") || ".";
+    return `${home}/.${appName.toLowerCase()}/config.json`;
+  } catch {
+    return `./config.json`;
+  }
+}
+
+async function ensureDirForFile(filePath: string): Promise<void> {
+  const sep = filePath.includes("\\") ? "\\" : "/";
+  const dir = filePath.split(sep).slice(0, -1).join(sep);
+  if (!dir) return;
+  try {
+    await Deno.mkdir(dir, { recursive: true });
+  } catch {
+    /* ignore */
+  }
+}

package/src/core/crdt.ts

@@ -0,0 +1,104 @@
+import type { NodeRecord, VectorClock } from "../types/index.ts";
+
+export function mergeVectorClocks(a: VectorClock, b: VectorClock): VectorClock {
+  const merged: VectorClock = {};
+  const keys = new Set([...Object.keys(a ?? {}), ...Object.keys(b ?? {})]);
+  for (const key of keys) {
+    merged[key] = Math.max(a?.[key] ?? 0, b?.[key] ?? 0);
+  }
+  return merged;
+}
+
+function isPlainObject(val: unknown): val is Record<string, unknown> {
+  return typeof val === "object" && val !== null && !Array.isArray(val);
+}
+
+function deepMergeWithDeletes(
+  base: Record<string, unknown>,
+  incoming: Record<string, unknown>,
+  baseState: Record<string, number> | undefined,
+  incomingState: Record<string, number> | undefined,
+  now: number,
+): { data: Record<string, unknown>; state: Record<string, number> } {
+  const out: Record<string, unknown> = { ...base };
+  const outState: Record<string, number> = { ...(baseState ?? {}) };
+  for (const [key, incVal] of Object.entries(incoming)) {
+    const baseVal = out[key];
+    const incTs = (incomingState ?? {})[key] ?? now; // default to now if missing
+    const baseTs = (baseState ?? {})[key] ?? 0;
+    if (incTs < baseTs) continue; // base wins
+
+    if (incVal === null) {
+      delete out[key];
+      outState[key] = incTs;
+      continue;
+    }
+    if (isPlainObject(baseVal) && isPlainObject(incVal)) {
+      const merged = deepMergeWithDeletes(
+        baseVal as Record<string, unknown>,
+        incVal as Record<string, unknown>,
+        baseState,
+        incomingState,
+        now,
+      );
+      out[key] = merged.data;
+      outState[key] = incTs;
+    } else {
+      out[key] = incVal as unknown;
+      outState[key] = incTs;
+    }
+  }
+  return { data: out, state: outState };
+}
+
+export function mergeNodes(local: NodeRecord | null, incoming: NodeRecord): NodeRecord {
+  if (!local) return incoming;
+  if (local.id !== incoming.id) {
+    throw new Error("mergeNodes called with mismatched ids");
+  }
+
+  if (incoming.timestamp > local.timestamp) {
+    const merged = deepMergeWithDeletes(
+      local.data,
+      incoming.data,
+      local.state,
+      incoming.state,
+      incoming.timestamp,
+    );
+    return {
+      id: local.id,
+      data: merged.data,
+      vector: incoming.vector ?? local.vector,
+      type: incoming.type ?? local.type,
+      timestamp: incoming.timestamp,
+      state: merged.state,
+      vectorClock: mergeVectorClocks(local.vectorClock, incoming.vectorClock),
+    };
+  }
+  if (incoming.timestamp < local.timestamp) {
+    return {
+      ...local,
+      vectorClock: mergeVectorClocks(local.vectorClock, incoming.vectorClock),
+    };
+  }
+
+  // Equal timestamps: deterministic field-wise merge with per-field state
+  const merged = deepMergeWithDeletes(
+    local.data,
+    incoming.data,
+    local.state,
+    incoming.state,
+    incoming.timestamp,
+  );
+  const mergedVector = incoming.vector ?? local.vector;
+  const mergedType = incoming.type ?? local.type;
+  return {
+    id: local.id,
+    data: merged.data,
+    vector: mergedVector,
+    type: mergedType,
+    timestamp: incoming.timestamp, // ties keep timestamp
+    state: merged.state,
+    vectorClock: mergeVectorClocks(local.vectorClock, incoming.vectorClock),
+  };
+}