pluresdb 1.0.1

package/src/tests/unit/vector-search.test.ts

@@ -0,0 +1,173 @@
+// @ts-nocheck
+import { assertEquals, assertExists } from "jsr:@std/assert@1.0.14";
+import { GunDB } from "../../core/database.ts";
+
+Deno.test("Vector Search - Basic Functionality", async () => {
+  const db = new GunDB();
+  try {
+    const kvPath = await Deno.makeTempFile({
+      prefix: "kv_",
+      suffix: ".sqlite",
+    });
+    await db.ready(kvPath);
+
+    // Add documents with different content
+    await db.put("doc:1", {
+      text: "Machine learning and artificial intelligence algorithms",
+      content: "Deep learning neural networks for pattern recognition",
+    });
+    await db.put("doc:2", {
+      text: "Cooking recipes and food preparation techniques",
+      content: "Italian pasta recipes and cooking methods",
+    });
+    await db.put("doc:3", {
+      text: "Web development and JavaScript programming",
+      content: "React and TypeScript for modern web applications",
+    });
+
+    // Test search with text field
+    const results1 = await db.vectorSearch("machine learning", 2);
+    assertExists(results1);
+    assertEquals(results1.length, 2);
+
+    // Test search with content field
+    const results2 = await db.vectorSearch("neural networks", 1);
+    assertExists(results2);
+    assertEquals(results2.length, 1);
+    assertEquals(results2[0].id, "doc:1");
+
+    // Test search with different query
+    const results3 = await db.vectorSearch("cooking food", 1);
+    assertExists(results3);
+    assertEquals(results3.length, 1);
+    assertEquals(results3[0].id, "doc:2");
+  } finally {
+    await db.close();
+  }
+});
+
+Deno.test("Vector Search - Similarity Scoring", async () => {
+  const db = new GunDB();
+  try {
+    const kvPath = await Deno.makeTempFile({
+      prefix: "kv_",
+      suffix: ".sqlite",
+    });
+    await db.ready(kvPath);
+
+    await db.put("doc:1", { text: "Machine learning algorithms" });
+    await db.put("doc:2", { text: "Machine learning and AI" });
+    await db.put("doc:3", { text: "Cooking recipes" });
+
+    const results = await db.vectorSearch("machine learning", 3);
+    assertExists(results);
+    assertEquals(results.length, 3);
+
+    // Results should be ordered by similarity (highest first)
+    assertExists(results[0].similarity);
+    assertExists(results[1].similarity);
+    assertExists(results[2].similarity);
+
+    // First result should have highest similarity
+    assertEquals(results[0].similarity >= results[1].similarity, true);
+    assertEquals(results[1].similarity >= results[2].similarity, true);
+  } finally {
+    await db.close();
+  }
+});
+
+Deno.test("Vector Search - Limit Parameter", async () => {
+  const db = new GunDB();
+  try {
+    const kvPath = await Deno.makeTempFile({
+      prefix: "kv_",
+      suffix: ".sqlite",
+    });
+    await db.ready(kvPath);
+
+    // Add multiple documents
+    for (let i = 1; i <= 10; i++) {
+      await db.put(`doc:${i}`, {
+        text: `Document ${i} about machine learning and AI`,
+      });
+    }
+
+    // Test different limits
+    const results1 = await db.vectorSearch("machine learning", 3);
+    assertEquals(results1.length, 3);
+
+    const results2 = await db.vectorSearch("machine learning", 5);
+    assertEquals(results2.length, 5);
+
+    const results3 = await db.vectorSearch("machine learning", 1);
+    assertEquals(results3.length, 1);
+  } finally {
+    await db.close();
+  }
+});
+
+Deno.test("Vector Search - Empty Results", async () => {
+  const db = new GunDB();
+  try {
+    const kvPath = await Deno.makeTempFile({
+      prefix: "kv_",
+      suffix: ".sqlite",
+    });
+    await db.ready(kvPath);
+
+    // Search in empty database
+    const results = await db.vectorSearch("anything", 5);
+    assertEquals(results.length, 0);
+  } finally {
+    await db.close();
+  }
+});
+
+Deno.test("Vector Search - Custom Vector Input", async () => {
+  const db = new GunDB();
+  try {
+    const kvPath = await Deno.makeTempFile({
+      prefix: "kv_",
+      suffix: ".sqlite",
+    });
+    await db.ready(kvPath);
+
+    // Add document with custom vector
+    const customVector = [0.1, 0.2, 0.3, 0.4, 0.5];
+    await db.put("doc:custom", {
+      text: "Custom vector document",
+      vector: customVector,
+    });
+
+    // Search with custom vector
+    const results = await db.vectorSearch(customVector, 1);
+    assertExists(results);
+    assertEquals(results.length, 1);
+    assertEquals(results[0].id, "doc:custom");
+  } finally {
+    await db.close();
+  }
+});
+
+Deno.test("Vector Search - No Text Content", async () => {
+  const db = new GunDB();
+  try {
+    const kvPath = await Deno.makeTempFile({
+      prefix: "kv_",
+      suffix: ".sqlite",
+    });
+    await db.ready(kvPath);
+
+    // Add document without text or content
+    await db.put("doc:no-text", {
+      name: "Document without text",
+      value: 123,
+    });
+
+    // Search should return empty results
+    const results = await db.vectorSearch("anything", 5);
+    assertEquals(results.length, 0);
+  } finally {
+    await db.close();
+  }
+});

package/src/tests/vscode_extension_test.ts

@@ -0,0 +1,253 @@
+// @ts-nocheck
+import { assert, assertEquals, assertMatch } from "jsr:@std/assert@1.0.14";
+import {
+  createPluresExtension,
+  ExtensionContextLike,
+  PluresVSCodeExtension,
+  VSCodeAPI,
+} from "../vscode/extension.ts";
+
+interface RecordedDocument {
+  content: string;
+  language: string;
+}
+
+interface RecordedMessage {
+  type: "info" | "error";
+  text: string;
+}
+
+type CommandHandler = (...args: unknown[]) => unknown;
+
+type TestHarness = {
+  vscode: VSCodeAPI;
+  context: ExtensionContextLike;
+  commands: Map<string, CommandHandler>;
+  docs: RecordedDocument[];
+  messages: RecordedMessage[];
+  shownTargets: string[];
+  queueInputs: (...values: (string | undefined)[]) => void;
+};
+
+function createHarness(storageDir: string): TestHarness {
+  const commands = new Map<string, CommandHandler>();
+  const docs: RecordedDocument[] = [];
+  const messages: RecordedMessage[] = [];
+  const shownTargets: string[] = [];
+  const inputQueue: Array<string | undefined> = [];
+
+  const vscode: VSCodeAPI = {
+    commands: {
+      registerCommand(command, handler) {
+        commands.set(command, handler);
+        return {
+          dispose() {
+            commands.delete(command);
+          },
+        };
+      },
+    },
+    window: {
+      async showInformationMessage(message: string) {
+        messages.push({ type: "info", text: message });
+      },
+      async showErrorMessage(message: string) {
+        messages.push({ type: "error", text: message });
+      },
+      async showInputBox() {
+        return inputQueue.shift();
+      },
+      async showTextDocument(doc: unknown) {
+        if (typeof doc === "object" && doc && "content" in doc && "language" in doc) {
+          const record = doc as RecordedDocument;
+          docs.push({ content: record.content, language: record.language });
+        }
+      },
+    },
+    workspace: {
+      async openTextDocument(init) {
+        docs.push(init as RecordedDocument);
+        return init;
+      },
+    },
+    env: {
+      async openExternal(target) {
+        shownTargets.push(typeof target === "string" ? target : target.toString());
+      },
+    },
+    Uri: {
+      parse(target: string) {
+        return target;
+      },
+    },
+  };
+
+  const context: ExtensionContextLike = {
+    subscriptions: [],
+    globalStorageUri: { fsPath: storageDir },
+  };
+
+  return {
+    vscode,
+    context,
+    commands,
+    docs,
+    messages,
+    shownTargets,
+    queueInputs: (...values: (string | undefined)[]) => {
+      inputQueue.push(...values);
+    },
+  };
+}
+
+async function getFreePort(): Promise<number> {
+  const listener = Deno.listen({ hostname: "127.0.0.1", port: 0 });
+  const { port } = listener.addr as Deno.NetAddr;
+  listener.close();
+  return port;
+}
+
+async function waitFor(predicate: () => Promise<boolean>, timeout = 10_000, interval = 200) {
+  const deadline = Date.now() + timeout;
+  while (Date.now() < deadline) {
+    if (await predicate()) return;
+    await new Promise((resolve) => setTimeout(resolve, interval));
+  }
+  throw new Error("Timed out waiting for condition");
+}
+
+async function removeDirWithRetry(target: string) {
+  const delays = [0, 200, 400, 800, 1600, 3200];
+  for (let i = 0; i < delays.length; i++) {
+    if (delays[i] > 0) {
+      await new Promise((resolve) => setTimeout(resolve, delays[i]));
+    }
+    try {
+      await Deno.remove(target, { recursive: true });
+      return;
+    } catch (error) {
+      const retryable = error instanceof Error && /used by another process/i.test(error.message);
+      if (!retryable || i === delays.length - 1) {
+        throw error;
+      }
+    }
+  }
+}
+
+Deno.test("VSCode integration dogfood workflow", async () => {
+  const storageDir = await Deno.makeTempDir({ prefix: "plures-vscode-" });
+  const apiPort = await getFreePort();
+  const webPort = await getFreePort();
+  const apiUrl = `http://127.0.0.1:${apiPort}`;
+
+  const harness = createHarness(storageDir);
+  const extension = createPluresExtension(harness.vscode, harness.context, {
+    config: {
+      host: "127.0.0.1",
+      port: apiPort,
+      webPort,
+    },
+  });
+
+  try {
+    try {
+      await extension.activate();
+    } catch (error) {
+      console.error("Activation failed", harness.messages);
+      throw error;
+    }
+
+    await waitFor(async () => {
+      try {
+        const res = await fetch(`${apiUrl}/api/list`);
+        return res.ok;
+      } catch {
+        return false;
+      }
+    });
+
+    const seed = await fetch(`${apiUrl}/api/put`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({
+        id: "extension:vector-doc",
+        data: {
+          type: "VSCodeDocument",
+          title: "Integration Test",
+          tags: ["extension", "sqlite"],
+          vector: [0.12, 0.24, 0.48, 0.96],
+        },
+      }),
+    });
+    assert(seed.ok, "Failed to seed vector test data");
+
+    const openWebUICmd = harness.commands.get("pluresdb.openWebUI");
+    if (!openWebUICmd) {
+      throw new Error("openWebUI command should be registered");
+    }
+    await openWebUICmd();
+    assertEquals(harness.shownTargets.at(-1), `http://127.0.0.1:${webPort}`);
+
+    harness.queueInputs("SELECT name FROM pragma_table_info('settings')");
+    const execQuery = harness.commands.get("pluresdb.executeQuery");
+    if (!execQuery) {
+      throw new Error("executeQuery command should be registered");
+    }
+    await execQuery();
+    const schemaDoc = harness.docs.at(-1);
+    if (!schemaDoc) {
+      throw new Error("Expected schema document to open");
+    }
+    const schemaRows = JSON.parse(schemaDoc.content) as Array<Record<string, unknown>>;
+    const columnNames = schemaRows.map((row) => String(row.name));
+    assert(columnNames.includes("key"), "Settings table should expose key column");
+
+    harness.queueInputs("user:alpha", '{"name":"Ada","vector":[0.2,0.1,0.3,0.4],"role":"builder"}');
+    const storeCommand = harness.commands.get("pluresdb.storeData");
+    if (!storeCommand) {
+      throw new Error("storeData command should be registered");
+    }
+    await storeCommand();
+    assertMatch(harness.messages.at(-1)?.text ?? "", /Stored data for key: user:alpha/);
+
+    harness.queueInputs("user:alpha");
+    const retrieveCommand = harness.commands.get("pluresdb.retrieveData");
+    if (!retrieveCommand) {
+      throw new Error("retrieveData command should be registered");
+    }
+    await retrieveCommand();
+    const retrievedDoc = harness.docs.at(-1);
+    if (!retrievedDoc) {
+      throw new Error("Expected retrieved document to open");
+    }
+    const retrieved = JSON.parse(retrievedDoc.content);
+    assertEquals(retrieved.name, "Ada");
+
+    harness.queueInputs("sqlite builder search");
+    const vectorCommand = harness.commands.get("pluresdb.vectorSearch");
+    if (!vectorCommand) {
+      throw new Error("vectorSearch command should be registered");
+    }
+    await vectorCommand();
+    const vectorDoc = harness.docs.at(-1);
+    if (!vectorDoc) {
+      throw new Error("Expected vector search document to open");
+    }
+    const vectorResults = JSON.parse(vectorDoc.content) as Array<Record<string, unknown>>;
+    assert(vectorResults.length > 0, "Vector search should return at least one result");
+
+    const settingsRows = await extension.executeSQL(
+      "SELECT name FROM pragma_table_info('documents')",
+    );
+    assert(Array.isArray(settingsRows));
+  } finally {
+    await extension.deactivate();
+    try {
+      await removeDirWithRetry(storageDir);
+    } catch (error) {
+      console.warn(
+        `⚠️  Failed to remove temp dir: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+});

package/src/types/index.ts

@@ -0,0 +1,32 @@
+export interface VectorClock {
+  [peerId: string]: number;
+}
+
+export interface NodeRecord {
+  id: string;
+  data: Record<string, unknown>;
+  vector?: number[];
+  type?: string;
+  timestamp: number;
+  state?: Record<string, number>;
+  vectorClock: VectorClock;
+}
+
+export interface PutMessage {
+  type: "put";
+  originId?: string;
+  node: NodeRecord;
+}
+
+export interface DeleteMessage {
+  type: "delete";
+  originId?: string;
+  id: string;
+}
+
+export interface SyncRequestMessage {
+  type: "sync_request";
+  originId?: string;
+}
+
+export type MeshMessage = PutMessage | DeleteMessage | SyncRequestMessage;

package/src/types/node-types.ts

@@ -0,0 +1,66 @@
+/**
+ * Node.js-specific types for PluresDB
+ */
+
+export interface PluresDBConfig {
+  port?: number;
+  host?: string;
+  dataDir?: string;
+  webPort?: number;
+  logLevel?: "debug" | "info" | "warn" | "error";
+}
+
+export interface PluresDBOptions {
+  config?: PluresDBConfig;
+  autoStart?: boolean;
+  denoPath?: string;
+}
+
+export interface QueryResult {
+  rows: any[];
+  columns: string[];
+  changes: number;
+  lastInsertRowId: number;
+}
+
+export interface VectorSearchResult {
+  id: string;
+  content: string;
+  score: number;
+  metadata?: any;
+}
+
+export interface Peer {
+  id: string;
+  name: string;
+  email: string;
+  publicKey: string;
+  lastSeen: Date;
+  status: "online" | "offline" | "connecting";
+}
+
+export interface SharedNode {
+  id: string;
+  nodeId: string;
+  peerId: string;
+  accessLevel: "read-only" | "read-write" | "admin";
+  encrypted: boolean;
+  createdAt: Date;
+  expiresAt?: Date;
+}
+
+export interface Device {
+  id: string;
+  name: string;
+  type: "laptop" | "phone" | "server" | "desktop";
+  lastSync: Date;
+  status: "online" | "offline" | "syncing";
+}
+
+export interface SyncStatus {
+  isOnline: boolean;
+  lastSync: Date | null;
+  pendingChanges: number;
+  connectedPeers: number;
+  syncProgress: number;
+}

package/src/util/debug.ts

@@ -0,0 +1,14 @@
+export const DEBUG_ENABLED: boolean = (() => {
+  try {
+    const v = Deno.env.get("PLURESDB_DEBUG") ?? "";
+    return v === "1" || v.toLowerCase() === "true";
+  } catch {
+    return false;
+  }
+})();
+
+export function debugLog(...args: unknown[]): void {
+  if (!DEBUG_ENABLED) return;
+  // deno-lint-ignore no-console
+  console.log("[pluresdb]", ...args);
+}

package/src/vector/index.ts

@@ -0,0 +1,59 @@
+export interface VectorIndexResult {
+  id: string;
+  score: number;
+}
+
+export interface VectorIndex {
+  upsert(id: string, vector: number[]): void;
+  remove(id: string): void;
+  search(vector: number[], k: number): VectorIndexResult[];
+  clear(): void;
+}
+
+export class BruteForceVectorIndex implements VectorIndex {
+  private readonly idToVector = new Map<string, Float32Array>();
+
+  upsert(id: string, vector: number[]): void {
+    const normed = normalizeVector(vector);
+    this.idToVector.set(id, normed);
+  }
+
+  remove(id: string): void {
+    this.idToVector.delete(id);
+  }
+
+  clear(): void {
+    this.idToVector.clear();
+  }
+
+  search(vector: number[], k: number): VectorIndexResult[] {
+    const q = normalizeVector(vector);
+    const results: VectorIndexResult[] = [];
+    for (const [id, v] of this.idToVector) {
+      const score = cosine(q, v);
+      if (Number.isFinite(score)) results.push({ id, score });
+    }
+    results.sort((a, b) => b.score - a.score);
+    return results.slice(0, k);
+  }
+}
+
+function normalizeVector(vector: number[]): Float32Array {
+  const arr = new Float32Array(vector.length);
+  let n = 0;
+  for (let i = 0; i < vector.length; i++) {
+    const v = vector[i] ?? 0;
+    arr[i] = v;
+    n += v * v;
+  }
+  const norm = Math.sqrt(n) || 1;
+  for (let i = 0; i < arr.length; i++) arr[i] /= norm;
+  return arr;
+}
+
+function cosine(a: Float32Array, b: Float32Array): number {
+  const len = Math.min(a.length, b.length);
+  let dot = 0;
+  for (let i = 0; i < len; i++) dot += a[i] * b[i];
+  return dot;
+}