@cue-dev/retrieval-core 0.1.3

package/test/local-sqlite.integration.test.ts

@@ -0,0 +1,258 @@
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { SqliteIndexRepository, SqliteQueryCache } from "@cue-dev/data-plane";
+import { RetrievalCore } from "../src/index.js";
+
+describe("retrieval-core local sqlite integration", () => {
+  const dirs: string[] = [];
+
+  afterEach(async () => {
+    while (dirs.length > 0) {
+      const dir = dirs.pop();
+      if (dir) {
+        await rm(dir, { recursive: true, force: true });
+      }
+    }
+  });
+
+  it("persists indexing lifecycle and serves search from durable local store", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "cue-local-core-"));
+    dirs.push(dir);
+    const sqlitePath = join(dir, "data-plane.sqlite");
+
+    const repo1 = new SqliteIndexRepository(sqlitePath);
+    await repo1.migrate();
+    await repo1.upsertWorkspace({
+      workspace_id: "ws-local",
+      tenant_id: "tenant-local",
+      name: "local-workspace",
+      project_root_path: "/workspace/local"
+    });
+    const cache1 = new SqliteQueryCache(sqlitePath);
+    const core1 = new RetrievalCore(repo1, cache1);
+
+    await core1.indexArtifact({
+      tenant_id: "tenant-local",
+      workspace_id: "ws-local",
+      index_version: "idx-v1",
+      files: [
+        {
+          path: "src/math.ts",
+          language: "typescript",
+          content: "export function add(a: number, b: number) { return a + b; }"
+        },
+        {
+          path: "src/old.ts",
+          language: "typescript",
+          content: "export const OLD = true;"
+        }
+      ]
+    });
+
+    const reportV2 = await core1.indexArtifact({
+      tenant_id: "tenant-local",
+      workspace_id: "ws-local",
+      index_version: "idx-v2",
+      files: [
+        {
+          path: "src/math.ts",
+          language: "typescript",
+          content: "export function add(a: number, b: number) { return a + b + 1; }"
+        },
+        {
+          path: "src/new.ts",
+          language: "typescript",
+          content: "export function multiply(a: number, b: number) { return a * b; }"
+        }
+      ]
+    });
+
+    expect(reportV2.counts.modified).toBe(1);
+    expect(reportV2.counts.added).toBe(1);
+    expect(reportV2.counts.deleted).toBe(1);
+
+    repo1.close();
+    cache1.close();
+
+    const repo2 = new SqliteIndexRepository(sqlitePath);
+    await repo2.migrate();
+    const cache2 = new SqliteQueryCache(sqlitePath);
+    const core2 = new RetrievalCore(repo2, cache2);
+
+    const result = await core2.searchContext({
+      trace_id: "trc-local",
+      tenant_id: "tenant-local",
+      workspace_id: "ws-local",
+      request: {
+        project_root_path: "/workspace/local",
+        query: "multiply function",
+        top_k: 8
+      }
+    });
+
+    expect(result.search_metadata.index_version).toBe("idx-v2");
+    expect(result.results.some((row) => row.path === "src/new.ts")).toBe(true);
+
+    const latest = await repo2.getLatestReadyIndex({
+      tenant_id: "tenant-local",
+      workspace_id: "ws-local"
+    });
+    expect(latest).toBeDefined();
+    const metadata = await repo2.getIndexMetadata?.({
+      tenant_id: "tenant-local",
+      index_id: latest!.index_id
+    });
+    expect(metadata?.chunking_strategy).toBe("language_aware");
+    expect(metadata?.embedding_provider).toBe("deterministic");
+    expect(metadata?.embedding_model).toBe("pseudo-sha256");
+    expect(metadata?.embedding_dimensions).toBe(24);
+
+    repo2.close();
+    cache2.close();
+  });
+
+  it("applies delta indexing against a base index and preserves unchanged files", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "cue-local-core-delta-"));
+    dirs.push(dir);
+    const sqlitePath = join(dir, "data-plane.sqlite");
+
+    const repo = new SqliteIndexRepository(sqlitePath);
+    await repo.migrate();
+    await repo.upsertWorkspace({
+      workspace_id: "ws-delta",
+      tenant_id: "tenant-local",
+      name: "delta-workspace",
+      project_root_path: "/workspace/local"
+    });
+    const cache = new SqliteQueryCache(sqlitePath);
+    const core = new RetrievalCore(repo, cache);
+
+    await core.indexArtifact({
+      tenant_id: "tenant-local",
+      workspace_id: "ws-delta",
+      index_version: "idx-v1",
+      files: [
+        {
+          path: "src/base.ts",
+          language: "typescript",
+          content: "export const BASE = true;"
+        },
+        {
+          path: "src/math.ts",
+          language: "typescript",
+          content: "export function add(a: number, b: number) { return a + b; }"
+        },
+        {
+          path: "src/legacy.ts",
+          language: "typescript",
+          content: "export const LEGACY_FLAG = true;"
+        }
+      ]
+    });
+
+    const report = await core.indexArtifactDelta({
+      tenant_id: "tenant-local",
+      workspace_id: "ws-delta",
+      index_version: "idx-v2",
+      base_index_version: "idx-v1",
+      upsert_files: [
+        {
+          path: "src/math.ts",
+          language: "typescript",
+          content: "export function add(a: number, b: number) { return a + b + 1; }"
+        },
+        {
+          path: "src/new.ts",
+          language: "typescript",
+          content: "export function multiply(a: number, b: number) { return a * b; }"
+        }
+      ],
+      deleted_paths: ["src/legacy.ts"]
+    });
+
+    expect(report.counts.added).toBe(1);
+    expect(report.counts.modified).toBe(1);
+    expect(report.counts.deleted).toBe(1);
+    expect(report.counts.unchanged).toBe(1);
+
+    const search = await core.searchContext({
+      trace_id: "trc-delta",
+      tenant_id: "tenant-local",
+      workspace_id: "ws-delta",
+      request: {
+        project_root_path: "/workspace/local",
+        query: "multiply function",
+        top_k: 8
+      }
+    });
+    expect(search.search_metadata.index_version).toBe("idx-v2");
+    expect(search.results.some((row) => row.path === "src/new.ts")).toBe(true);
+
+    const oldSearch = await core.searchContext({
+      trace_id: "trc-delta-legacy",
+      tenant_id: "tenant-local",
+      workspace_id: "ws-delta",
+      request: {
+        project_root_path: "/workspace/local",
+        query: "LEGACY_FLAG",
+        top_k: 8
+      }
+    });
+    expect(oldSearch.results.some((row) => row.path === "src/legacy.ts")).toBe(false);
+
+    repo.close();
+    cache.close();
+  });
+
+  it("rejects delta indexing when base index version is missing or not ready", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "cue-local-core-delta-invalid-base-"));
+    dirs.push(dir);
+    const sqlitePath = join(dir, "data-plane.sqlite");
+
+    const repo = new SqliteIndexRepository(sqlitePath);
+    await repo.migrate();
+    await repo.upsertWorkspace({
+      workspace_id: "ws-delta-invalid",
+      tenant_id: "tenant-local",
+      name: "delta-invalid-workspace",
+      project_root_path: "/workspace/local"
+    });
+    const cache = new SqliteQueryCache(sqlitePath);
+    const core = new RetrievalCore(repo, cache);
+
+    await core.indexArtifact({
+      tenant_id: "tenant-local",
+      workspace_id: "ws-delta-invalid",
+      index_version: "idx-v1",
+      files: [
+        {
+          path: "src/a.ts",
+          language: "typescript",
+          content: "export const A = 1;"
+        }
+      ]
+    });
+
+    await expect(
+      core.indexArtifactDelta({
+        tenant_id: "tenant-local",
+        workspace_id: "ws-delta-invalid",
+        index_version: "idx-v2",
+        base_index_version: "idx-does-not-exist",
+        upsert_files: [
+          {
+            path: "src/a.ts",
+            language: "typescript",
+            content: "export const A = 2;"
+          }
+        ],
+        deleted_paths: []
+      })
+    ).rejects.toThrow(/base index version/i);
+
+    repo.close();
+    cache.close();
+  });
+});