@plures/pluresdb 1.5.3 → 2.9.6

package/legacy/vscode/extension.ts

@@ -1,387 +0,0 @@
-import * as path from "node:path";
-import { PluresNode, SQLiteCompatibleAPI } from "../node-index";
-import type { PluresDBConfig } from "../types/node-types";
-
-type DisposableLike = { dispose(): void };
-
-type InputBoxOptions = {
-  prompt: string;
-  placeHolder?: string;
-};
-
-type TextDocumentInit = {
-  content: string;
-  language: string;
-};
-
-type UriLike = { toString(): string } | string;
-
-export type VSCodeWindow = {
-  showInformationMessage(message: string): void | Promise<unknown>;
-  showErrorMessage(message: string): void | Promise<unknown>;
-  showInputBox(options: InputBoxOptions): Promise<string | undefined>;
-  showTextDocument(document: unknown): Promise<unknown>;
-};
-
-export type VSCodeCommands = {
-  registerCommand(
-    command: string,
-    callback: (...args: unknown[]) => unknown,
-  ): DisposableLike;
-};
-
-export type VSCodeWorkspace = {
-  openTextDocument(init: TextDocumentInit): Promise<unknown>;
-};
-
-export type VSCodeEnv = {
-  openExternal(target: UriLike): Promise<unknown> | unknown;
-};
-
-export type VSCodeUri = {
-  parse(target: string): UriLike;
-};
-
-export type VSCodeAPI = {
-  window: VSCodeWindow;
-  commands: VSCodeCommands;
-  workspace: VSCodeWorkspace;
-  env: VSCodeEnv;
-  Uri: VSCodeUri;
-};
-
-export type ExtensionContextLike = {
-  subscriptions: DisposableLike[];
-  globalStorageUri: { fsPath: string };
-};
-
-export type ExtensionOptions = {
-  config?: PluresDBConfig;
-  commandPrefix?: string;
-  pluresInstance?: PluresNode;
-  sqliteInstance?: SQLiteCompatibleAPI;
-};
-
-type CommandFactory = () => Promise<void> | void;
-
-const DEFAULT_CONFIG: PluresDBConfig = {
-  port: 34567,
-  host: "localhost",
-  webPort: 34568,
-  logLevel: "info",
-};
-
-export class PluresVSCodeExtension {
-  private readonly vscode: VSCodeAPI;
-  private readonly context: ExtensionContextLike;
-  private readonly plures: PluresNode;
-  private readonly sqlite: SQLiteCompatibleAPI;
-  private readonly commandPrefix: string;
-  private readonly disposables: DisposableLike[] = [];
-  private activated = false;
-
-  constructor(
-    vscodeApi: VSCodeAPI,
-    context: ExtensionContextLike,
-    options: ExtensionOptions = {},
-  ) {
-    this.vscode = vscodeApi;
-    this.context = context;
-    this.commandPrefix = options.commandPrefix ?? "pluresdb";
-
-    const mergedConfig: PluresDBConfig = {
-      ...DEFAULT_CONFIG,
-      dataDir: path.join(context.globalStorageUri.fsPath, "pluresdb"),
-      ...options.config,
-    };
-
-    this.plures = options.pluresInstance ??
-      new PluresNode({ config: mergedConfig, autoStart: false });
-    this.sqlite = options.sqliteInstance ??
-      new SQLiteCompatibleAPI({ config: mergedConfig, autoStart: false });
-
-    this.setupEventHandlers();
-  }
-
-  async activate(): Promise<void> {
-    if (this.activated) {
-      return;
-    }
-
-    try {
-      await this.plures.start();
-      await this.sqlite.start();
-      this.registerCommands();
-      await this.setupDatabase();
-      this.activated = true;
-      await this.safeInfo("PluresDB extension activated");
-    } catch (error) {
-      await this.safeError(
-        `Failed to activate PluresDB: ${this.errorMessage(error)}`,
-      );
-      throw error;
-    }
-  }
-
-  async deactivate(): Promise<void> {
-    if (!this.activated) {
-      return;
-    }
-
-    try {
-      await this.sqlite.stop();
-      await this.plures.stop();
-    } finally {
-      this.disposeAll();
-      this.activated = false;
-    }
-  }
-
-  getWebUrl(): string {
-    return this.plures.getWebUrl();
-  }
-
-  async storeSetting(key: string, value: unknown) {
-    return this.sqlite.put(`settings:${key}`, value);
-  }
-
-  async getSetting(key: string) {
-    return this.sqlite.getValue(`settings:${key}`);
-  }
-
-  async storeDocument(
-    id: string,
-    content: string,
-    language: string,
-    filePath: string,
-  ) {
-    return this.sqlite.put(`documents:${id}`, {
-      content,
-      language,
-      filePath,
-      updatedAt: new Date().toISOString(),
-    });
-  }
-
-  async searchDocuments(query: string, limit = 20) {
-    return this.sqlite.vectorSearch(query, limit);
-  }
-
-  async executeSQL(sql: string, params: unknown[] = []) {
-    return this.sqlite.all(sql, params);
-  }
-
-  private setupEventHandlers() {
-    this.plures.on("started", () => {
-      this.safeInfo("PluresDB database started");
-    });
-
-    this.plures.on("stopped", () => {
-      this.safeInfo("PluresDB database stopped");
-    });
-
-    this.plures.on("error", (error: unknown) => {
-      this.safeError(`PluresDB error: ${this.errorMessage(error)}`);
-    });
-
-    this.plures.on("stderr", (output: string) => {
-      const trimmed = output.trim();
-      if (trimmed.length > 0) {
-        this.safeError(trimmed);
-      }
-    });
-
-    this.plures.on("stdout", (output: string) => {
-      const trimmed = output.trim();
-      if (trimmed.length > 0) {
-        this.safeInfo(trimmed);
-      }
-    });
-  }
-
-  private registerCommands() {
-    const register = (name: string, factory: CommandFactory) => {
-      const disposable = this.vscode.commands.registerCommand(
-        `${this.commandPrefix}.${name}`,
-        () => factory(),
-      );
-      this.context.subscriptions.push(disposable);
-      this.disposables.push(disposable);
-    };
-
-    register("openWebUI", async () => {
-      const webUrl = this.getWebUrl();
-      await this.vscode.env.openExternal(this.vscode.Uri.parse(webUrl));
-    });
-
-    register("executeQuery", async () => {
-      const sql = await this.vscode.window.showInputBox({
-        prompt: "Enter SQL query",
-        placeHolder: "SELECT * FROM users",
-      });
-
-      if (!sql) return;
-
-      try {
-        const result = await this.sqlite.all(sql);
-        const doc = await this.vscode.workspace.openTextDocument({
-          content: JSON.stringify(result, null, 2),
-          language: "json",
-        });
-        await this.vscode.window.showTextDocument(doc);
-      } catch (error) {
-        await this.safeError(`Query failed: ${this.errorMessage(error)}`);
-      }
-    });
-
-    register("vectorSearch", async () => {
-      const query = await this.vscode.window.showInputBox({
-        prompt: "Enter search query",
-        placeHolder: "machine learning",
-      });
-
-      if (!query) return;
-
-      try {
-        const results = await this.sqlite.vectorSearch(query, 10);
-        const doc = await this.vscode.workspace.openTextDocument({
-          content: JSON.stringify(results, null, 2),
-          language: "json",
-        });
-        await this.vscode.window.showTextDocument(doc);
-      } catch (error) {
-        await this.safeError(
-          `Vector search failed: ${this.errorMessage(error)}`,
-        );
-      }
-    });
-
-    register("storeData", async () => {
-      const key = await this.vscode.window.showInputBox({
-        prompt: "Enter key",
-        placeHolder: "user:123",
-      });
-
-      if (!key) return;
-
-      const json = await this.vscode.window.showInputBox({
-        prompt: "Enter value (JSON)",
-        placeHolder: '{"name": "Ada", "email": "ada@example.com"}',
-      });
-
-      if (!json) return;
-
-      try {
-        const value = JSON.parse(json);
-        await this.sqlite.put(key, value);
-        await this.safeInfo(`Stored data for key: ${key}`);
-      } catch (error) {
-        await this.safeError(
-          `Failed to store data: ${this.errorMessage(error)}`,
-        );
-      }
-    });
-
-    register("retrieveData", async () => {
-      const key = await this.vscode.window.showInputBox({
-        prompt: "Enter key to retrieve",
-        placeHolder: "user:123",
-      });
-
-      if (!key) return;
-
-      try {
-        const value = await this.sqlite.getValue(key);
-        if (value) {
-          const doc = await this.vscode.workspace.openTextDocument({
-            content: JSON.stringify(value, null, 2),
-            language: "json",
-          });
-          await this.vscode.window.showTextDocument(doc);
-        } else {
-          await this.safeInfo("Key not found");
-        }
-      } catch (error) {
-        await this.safeError(
-          `Failed to retrieve data: ${this.errorMessage(error)}`,
-        );
-      }
-    });
-  }
-
-  private async setupDatabase() {
-    const statements = [
-      `CREATE TABLE IF NOT EXISTS settings (
-        key TEXT PRIMARY KEY,
-        value TEXT,
-        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-        updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
-      )`,
-      `CREATE TABLE IF NOT EXISTS documents (
-        id TEXT PRIMARY KEY,
-        content TEXT,
-        language TEXT,
-        file_path TEXT,
-        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-        updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
-      )`,
-      `CREATE TABLE IF NOT EXISTS search_history (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        query TEXT,
-        results_count INTEGER,
-        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
-      )`,
-    ];
-
-    for (const sql of statements) {
-      try {
-        await this.sqlite.exec(sql);
-      } catch (error) {
-        await this.safeError(
-          `Failed to initialize database: ${this.errorMessage(error)}`,
-        );
-      }
-    }
-  }
-
-  private disposeAll() {
-    for (const disposable of this.disposables.splice(0)) {
-      try {
-        disposable.dispose();
-      } catch (_error) {
-        // ignore
-      }
-    }
-  }
-
-  private async safeInfo(message: string) {
-    try {
-      await this.vscode.window.showInformationMessage(message);
-    } catch (_error) {
-      // ignore message failures in headless tests
-    }
-  }
-
-  private async safeError(message: string) {
-    try {
-      await this.vscode.window.showErrorMessage(message);
-    } catch (_error) {
-      // ignore message failures in headless tests
-    }
-  }
-
-  private errorMessage(error: unknown): string {
-    if (error instanceof Error) {
-      return error.message;
-    }
-    return String(error);
-  }
-}
-
-export function createPluresExtension(
-  vscodeApi: VSCodeAPI,
-  context: ExtensionContextLike,
-  options: ExtensionOptions = {},
-) {
-  return new PluresVSCodeExtension(vscodeApi, context, options);
-}

package/scripts/compiled-crud-verify.ts

@@ -1,30 +0,0 @@
-import { GunDB } from "../src/core/database.ts";
-
-const serverUrl = Deno.env.get("SERVER_URL") ?? "ws://localhost:34567";
-
-const clientA = new GunDB();
-const clientB = new GunDB();
-
-const kvA = await Deno.makeTempFile({ prefix: "kv_", suffix: ".sqlite" });
-const kvB = await Deno.makeTempFile({ prefix: "kv_", suffix: ".sqlite" });
-
-await clientA.ready(kvA);
-await clientB.ready(kvB);
-
-clientA.connect(serverUrl);
-clientB.connect(serverUrl);
-
-const id = `bin:crud:${crypto.randomUUID()}`;
-
-const receivedOnB = new Promise<void>((resolve) =>
-  clientB.on(id, (n) => n && resolve())
-);
-
-await clientA.put(id, { text: "compiled works" } as Record<string, unknown>);
-
-await receivedOnB;
-
-await clientA.close();
-await clientB.close();
-
-console.log("COMPILED-CRUD-OK", id);

package/scripts/dogfood.ts

@@ -1,297 +0,0 @@
-#!/usr/bin/env -S deno run -A --unstable-kv
-
-import { GunDB } from "../legacy/core/database.ts";
-import { startApiServer } from "../legacy/http/api-server.ts";
-
-declare const Deno: any;
-
-interface StepResult {
-  name: string;
-  ok: boolean;
-  details?: string;
-}
-
-async function main() {
-  const results: StepResult[] = [];
-  const kvDir = await Deno.makeTempDir({ prefix: "pluresdb-dogfood-" });
-  const kvPath = `${kvDir}/kv`;
-  const wsPort = 4600 + Math.floor(Math.random() * 5000);
-  const apiPort = wsPort + 1;
-  const apiUrl = `http://localhost:${apiPort}`;
-
-  const db = new GunDB();
-  await db.ready(kvPath);
-  db.serve({ port: wsPort });
-  const api = startApiServer({ port: apiPort, db });
-
-  const cleanupTasks: Array<() => Promise<void> | void> = [
-    async () => {
-      try {
-        api.close();
-      } catch (_) {
-        /* ignore */
-      }
-    },
-    async () => {
-      try {
-        await db.close();
-      } catch (_) {
-        /* ignore */
-      }
-    },
-    async () => {
-      try {
-        await Deno.remove(kvDir, { recursive: true });
-      } catch (_) {
-        /* ignore */
-      }
-    },
-  ];
-
-  const finalize = async () => {
-    for (const task of cleanupTasks) {
-      await Promise.resolve(task());
-    }
-  };
-
-  const assert = (cond: boolean, message: string) => {
-    if (!cond) {
-      throw new Error(message);
-    }
-  };
-
-  const record = (name: string, ok: boolean, details?: string) => {
-    const entry: StepResult = { name, ok, details };
-    results.push(entry);
-    const icon = ok ? "✅" : "❌";
-    console.log(`${icon} ${name}${details ? ` — ${details}` : ""}`);
-  };
-
-  try {
-    console.log("🚀 Starting PluresDB dogfooding run");
-    console.log(`🗂️  KV path: ${kvPath}`);
-    console.log(`🔌 Mesh port: ${wsPort}`);
-    console.log(`🌐 API port: ${apiPort}`);
-
-    await waitFor(
-      async () => {
-        try {
-          const res = await fetch(`${apiUrl}/api/list`);
-          return res.ok;
-        } catch (_) {
-          return false;
-        }
-      },
-      { timeoutMs: 10_000, intervalMs: 250 },
-    );
-    record("Server readiness", true);
-
-    const nodeId = "dogfood:api";
-    const initialPayload = {
-      type: "DogfoodTest",
-      text: "Hello from the dogfooding script",
-      vector: Array.from({ length: 4 }, (_, i) => i + 1),
-    };
-    const putRes = await fetch(`${apiUrl}/api/put`, {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify({ id: nodeId, data: initialPayload }),
-    });
-    assert(putRes.ok, `API put failed (${putRes.status})`);
-    record("API put", true);
-
-    const getRes = await fetch(
-      `${apiUrl}/api/get?id=${encodeURIComponent(nodeId)}`,
-    );
-    assert(getRes.ok, "API get failed");
-    const getJson = await getRes.json();
-    assert(getJson.text === initialPayload.text, "Unexpected API get payload");
-    record("API get", true);
-
-    const listRes = await fetch(`${apiUrl}/api/list`);
-    assert(listRes.ok, "API list failed");
-    const listJson = await listRes.json();
-    assert(
-      Array.isArray(listJson) && listJson.some((n: any) => n.id === nodeId),
-      "Node missing from API list",
-    );
-    record("API list", true);
-
-    const searchRes = await fetch(
-      `${apiUrl}/api/search?q=${encodeURIComponent("dogfood script test")}&k=5`,
-    );
-    assert(searchRes.ok, "API search failed");
-    const searchJson = await searchRes.json();
-    assert(
-      Array.isArray(searchJson) && searchJson.length > 0,
-      "Vector search returned no results",
-    );
-    record("API vector search", true);
-
-    const updatePayload = {
-      type: "DogfoodTest",
-      text: "Hello from the updated dogfooding script",
-    };
-    const putUpdate = await fetch(`${apiUrl}/api/put`, {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify({ id: nodeId, data: updatePayload }),
-    });
-    assert(putUpdate.ok, "API put update failed");
-    record("API update", true);
-
-    const historyRes = await fetch(
-      `${apiUrl}/api/history?id=${encodeURIComponent(nodeId)}`,
-    );
-    assert(historyRes.ok, "API history failed");
-    const historyJson = await historyRes.json();
-    assert(
-      Array.isArray(historyJson) && historyJson.length >= 2,
-      "API history missing versions",
-    );
-    record("API history", true, `${historyJson.length} versions`);
-
-    const restoreTimestamp = historyJson.at(-1)?.timestamp ??
-      historyJson[historyJson.length - 1]?.timestamp;
-    assert(
-      typeof restoreTimestamp === "number",
-      "Failed to locate restore timestamp",
-    );
-    const restoreRes = await fetch(
-      `${apiUrl}/api/restore?id=${
-        encodeURIComponent(nodeId)
-      }&timestamp=${restoreTimestamp}`,
-    );
-    assert(restoreRes.ok, "API restore failed");
-    record("API restore", true);
-
-    const restored = await (
-      await fetch(`${apiUrl}/api/get?id=${encodeURIComponent(nodeId)}`)
-    ).json();
-    assert(
-      restored.text === initialPayload.text,
-      "Restore did not revert payload",
-    );
-    record("API post-restore verification", true);
-
-    const instancesRes = await fetch(
-      `${apiUrl}/api/instances?type=${encodeURIComponent("DogfoodTest")}`,
-    );
-    assert(instancesRes.ok, "API instances failed");
-    const instancesJson = await instancesRes.json();
-    assert(
-      Array.isArray(instancesJson) &&
-        instancesJson.some((n: any) => n.id === nodeId),
-      "Instances endpoint missing node",
-    );
-    record("API type instances", true);
-
-    const webRes = await fetch(`${apiUrl}/`);
-    assert(webRes.ok, "Web UI endpoint failed");
-    const webHtml = await webRes.text();
-    record("Web UI fetch", true, `${webHtml.length} chars`);
-
-    const cliId = "dogfood:cli";
-    const cliPut = await runCli([
-      "put",
-      cliId,
-      JSON.stringify({ type: "DogfoodTest", text: "CLI write" }),
-      "--kv",
-      kvPath,
-    ]);
-    assert(cliPut.code === 0, `CLI put failed: ${cliPut.stderr}`);
-    record("CLI put", true);
-
-    const cliGet = await runCli(["get", cliId, "--kv", kvPath]);
-    assert(cliGet.code === 0, `CLI get failed: ${cliGet.stderr}`);
-    const cliGetJson = JSON.parse(cliGet.stdout.trim() || "null");
-    assert(cliGetJson?.text === "CLI write", "CLI get returned wrong payload");
-    record("CLI get", true);
-
-    const cliList = await runCli(["list", "--kv", kvPath]);
-    assert(cliList.code === 0, `CLI list failed: ${cliList.stderr}`);
-    const cliListJson = JSON.parse(cliList.stdout.trim() || "[]");
-    assert(
-      Array.isArray(cliListJson) && cliListJson.length >= 2,
-      "CLI list missing entries",
-    );
-    record("CLI list", true);
-
-    const cliSearch = await runCli([
-      "vsearch",
-      "dogfooding",
-      "5",
-      "--kv",
-      kvPath,
-    ]);
-    assert(cliSearch.code === 0, `CLI vsearch failed: ${cliSearch.stderr}`);
-    const cliSearchJson = JSON.parse(cliSearch.stdout.trim() || "[]");
-    assert(
-      Array.isArray(cliSearchJson) && cliSearchJson.length > 0,
-      "CLI vsearch returned no results",
-    );
-    record("CLI vector search", true);
-
-    console.log("\n🎉 Dogfooding run succeeded!");
-  } catch (error) {
-    record(
-      "Dogfooding run",
-      false,
-      error instanceof Error ? error.message : String(error),
-    );
-    await finalize();
-    console.log("\n❌ Dogfooding run failed");
-    console.log(error);
-    Deno.exit(1);
-  }
-
-  await finalize();
-}
-
-async function runCli(args: string[]) {
-  const command = new Deno.Command("deno", {
-    args: [
-      "run",
-      "-A",
-      "--unstable-kv",
-      "--no-lock",
-      "legacy/main.ts",
-      ...args,
-    ],
-    stdout: "piped",
-    stderr: "piped",
-  });
-  const { code, stdout, stderr } = await command.output();
-  return {
-    code,
-    stdout: new TextDecoder().decode(stdout),
-    stderr: new TextDecoder().decode(stderr),
-  };
-}
-
-async function waitFor(
-  fn: () => Promise<boolean>,
-  opts: { timeoutMs: number; intervalMs: number },
-) {
-  const deadline = Date.now() + opts.timeoutMs;
-  while (Date.now() < deadline) {
-    if (await fn()) return;
-    await sleep(opts.intervalMs);
-  }
-  throw new Error("Timed out waiting for condition");
-}
-
-function sleep(ms: number): Promise<void>;
-function sleep<T>(ms: number, value: T): Promise<T>;
-function sleep(ms: number, value?: unknown) {
-  return new Promise((resolve) => {
-    const timer = setTimeout(() => {
-      clearTimeout(timer);
-      resolve(value);
-    }, ms);
-  });
-}
-
-if ((import.meta as any).main) {
-  await main();
-}