nlm-memory 0.5.0 → 0.5.2

package/tests/integration/fact-supersedence.test.ts

@@ -1,313 +0,0 @@
-/**
- * Phase B.4 — deterministic supersedence on (subject, predicate) collision.
- *
- * Drives SqliteSessionStore.insertSession with factSink wired and verifies
- * that prior non-superseded facts get marked superseded_by = newFactId
- * atomically with the session ingest. Tests live at the integration layer
- * because the behavior is inside a SQL transaction.
- */
-
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join, resolve } from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { SqliteFactStore } from "../../src/core/storage/sqlite-fact-store.js";
-import {
-  type IngestRecord,
-  SqliteSessionStore,
-} from "../../src/core/storage/sqlite-session-store.js";
-import type { Fact } from "../../src/shared/types.js";
-import { makeFact } from "../fixtures/facts.js";
-
-const MIGRATIONS_DIR = resolve(__dirname, "../../migrations");
-
-function makeRecord(overrides: Partial<IngestRecord> = {}): IngestRecord {
-  return {
-    id: "sess_test",
-    runtime: "claude-code",
-    runtimeSessionId: "test-1",
-    startedAt: "2026-05-19T10:00:00Z",
-    endedAt: "2026-05-19T10:30:00Z",
-    durationMin: 30,
-    label: "L",
-    summary: "S",
-    body: "",
-    status: "closed",
-    transcriptKind: "claude-code-jsonl",
-    transcriptPath: null,
-    transcriptOffset: null,
-    transcriptLength: null,
-    entities: [],
-    decisions: [],
-    openQuestions: [],
-    ...overrides,
-  };
-}
-
-function fact(overrides: Partial<Fact>): Fact {
-  return makeFact({
-    id: `fact_${Math.random().toString(36).slice(2, 10)}`,
-    confidence: 0.9,
-    ...overrides,
-  });
-}
-
-describe("Phase B.4 — supersedence-on-ingest", () => {
-  let tmp: string;
-  let store: SqliteSessionStore;
-  let factStore: SqliteFactStore;
-
-  beforeEach(() => {
-    tmp = mkdtempSync(join(tmpdir(), "nlm-b4-"));
-    store = new SqliteSessionStore({
-      dbPath: join(tmp, "canonical.sqlite"),
-      migrationsDir: MIGRATIONS_DIR,
-    });
-    factStore = new SqliteFactStore(store.rawDb());
-  });
-
-  afterEach(() => {
-    store.close();
-    rmSync(tmp, { recursive: true, force: true });
-  });
-
-  it("cross-session collision: new fact supersedes prior current fact for the same (s, p)", async () => {
-    // Session A asserts framework=Fastify
-    const factA = fact({
-      id: "f_A",
-      subject: "nlm-memory-ts",
-      predicate: "framework",
-      value: "Fastify",
-      sourceSessionId: "sess_A",
-      createdAt: "2026-05-18T10:00:00Z",
-    });
-    await store.insertSession(
-      makeRecord({ id: "sess_A", startedAt: "2026-05-18T10:00:00Z" }),
-      null,
-      null,
-      { factStore, facts: [factA] },
-    );
-
-    // Session B asserts framework=Hono
-    const factB = fact({
-      id: "f_B",
-      subject: "nlm-memory-ts",
-      predicate: "framework",
-      value: "Hono",
-      sourceSessionId: "sess_B",
-      createdAt: "2026-05-19T10:00:00Z",
-    });
-    await store.insertSession(
-      makeRecord({ id: "sess_B" }),
-      null,
-      null,
-      { factStore, facts: [factB] },
-    );
-
-    const fetchedA = await factStore.getById("f_A");
-    const fetchedB = await factStore.getById("f_B");
-    expect(fetchedA?.supersededBy).toBe("f_B");
-    expect(fetchedB?.supersededBy).toBeNull();
-
-    const current = await factStore.findCurrent("nlm-memory-ts", "framework");
-    expect(current?.id).toBe("f_B");
-    expect(current?.value).toBe("Hono");
-  });
-
-  it("no collision when subject differs", async () => {
-    await store.insertSession(
-      makeRecord({ id: "sess_A" }),
-      null, null,
-      {
-        factStore,
-        facts: [fact({ id: "fA", subject: "alpha", predicate: "framework", value: "v", sourceSessionId: "sess_A" })],
-      },
-    );
-    await store.insertSession(
-      makeRecord({ id: "sess_B" }),
-      null, null,
-      {
-        factStore,
-        facts: [fact({ id: "fB", subject: "beta", predicate: "framework", value: "v", sourceSessionId: "sess_B" })],
-      },
-    );
-    expect((await factStore.getById("fA"))?.supersededBy).toBeNull();
-    expect((await factStore.getById("fB"))?.supersededBy).toBeNull();
-  });
-
-  it("no collision when predicate differs", async () => {
-    await store.insertSession(
-      makeRecord({ id: "sess_A" }),
-      null, null,
-      {
-        factStore,
-        facts: [fact({ id: "fA", subject: "x", predicate: "framework", value: "v", sourceSessionId: "sess_A" })],
-      },
-    );
-    await store.insertSession(
-      makeRecord({ id: "sess_B" }),
-      null, null,
-      {
-        factStore,
-        facts: [fact({ id: "fB", subject: "x", predicate: "endpoint", value: "v", sourceSessionId: "sess_B" })],
-      },
-    );
-    expect((await factStore.getById("fA"))?.supersededBy).toBeNull();
-    expect((await factStore.getById("fB"))?.supersededBy).toBeNull();
-  });
-
-  it("always-supersede policy: same value from a new session still supersedes (provenance changes)", async () => {
-    const factA = fact({
-      id: "f_A", subject: "x", predicate: "framework", value: "Hono",
-      sourceSessionId: "sess_A", createdAt: "2026-05-18T10:00:00Z",
-    });
-    await store.insertSession(makeRecord({ id: "sess_A", startedAt: "2026-05-18T10:00:00Z" }), null, null,
-      { factStore, facts: [factA] });
-
-    const factB = fact({
-      id: "f_B", subject: "x", predicate: "framework", value: "Hono",
-      sourceSessionId: "sess_B", createdAt: "2026-05-19T10:00:00Z",
-    });
-    await store.insertSession(makeRecord({ id: "sess_B" }), null, null,
-      { factStore, facts: [factB] });
-
-    expect((await factStore.getById("f_A"))?.supersededBy).toBe("f_B");
-    expect((await factStore.getById("f_B"))?.supersededBy).toBeNull();
-  });
-
-  it("three-deep chain: A → B → C, only the immediate predecessor gets re-linked per ingest", async () => {
-    const factA = fact({ id: "f_A", subject: "x", predicate: "framework", value: "Fastify", sourceSessionId: "sess_A", createdAt: "2026-05-17T10:00:00Z" });
-    const factB = fact({ id: "f_B", subject: "x", predicate: "framework", value: "Hono", sourceSessionId: "sess_B", createdAt: "2026-05-18T10:00:00Z" });
-    const factC = fact({ id: "f_C", subject: "x", predicate: "framework", value: "Elysia", sourceSessionId: "sess_C", createdAt: "2026-05-19T10:00:00Z" });
-
-    await store.insertSession(makeRecord({ id: "sess_A", startedAt: "2026-05-17T10:00:00Z" }), null, null, { factStore, facts: [factA] });
-    await store.insertSession(makeRecord({ id: "sess_B", startedAt: "2026-05-18T10:00:00Z" }), null, null, { factStore, facts: [factB] });
-    await store.insertSession(makeRecord({ id: "sess_C", startedAt: "2026-05-19T10:00:00Z" }), null, null, { factStore, facts: [factC] });
-
-    expect((await factStore.getById("f_A"))?.supersededBy).toBe("f_B");
-    expect((await factStore.getById("f_B"))?.supersededBy).toBe("f_C");
-    expect((await factStore.getById("f_C"))?.supersededBy).toBeNull();
-
-    // History walks newest → oldest
-    const chains = await factStore.getHistory("x", "framework");
-    expect(chains[0]?.history.map((f) => f.id)).toEqual(["f_C", "f_B", "f_A"]);
-  });
-
-  it("re-ingest of same session re-establishes the chain (CASCADE-SET-NULL on the old self-fact)", async () => {
-    // First, an old session asserts framework=v1
-    const oldFact = fact({
-      id: "f_old", subject: "x", predicate: "framework", value: "v1",
-      sourceSessionId: "sess_old", createdAt: "2026-05-17T10:00:00Z",
-    });
-    await store.insertSession(
-      makeRecord({ id: "sess_old", startedAt: "2026-05-17T10:00:00Z" }),
-      null, null, { factStore, facts: [oldFact] },
-    );
-
-    // Self session asserts framework=v2 — supersedes f_old
-    const selfFactV1 = fact({
-      id: "f_self_v1", subject: "x", predicate: "framework", value: "v2",
-      sourceSessionId: "sess_self", createdAt: "2026-05-18T10:00:00Z",
-    });
-    await store.insertSession(
-      makeRecord({ id: "sess_self", startedAt: "2026-05-18T10:00:00Z" }),
-      null, null, { factStore, facts: [selfFactV1] },
-    );
-    expect((await factStore.getById("f_old"))?.supersededBy).toBe("f_self_v1");
-
-    // Re-ingest sess_self with a refreshed fact (e.g. classifier produced a
-    // new id on a re-classification). The old self fact is wiped via DELETE;
-    // ON DELETE SET NULL releases f_old; then the new self fact picks up
-    // the collision and re-supersedes f_old.
-    const selfFactV2 = fact({
-      id: "f_self_v2", subject: "x", predicate: "framework", value: "v2",
-      sourceSessionId: "sess_self", createdAt: "2026-05-18T11:00:00Z",
-    });
-    await store.insertSession(
-      makeRecord({ id: "sess_self", startedAt: "2026-05-18T10:00:00Z" }),
-      null, null, { factStore, facts: [selfFactV2] },
-    );
-
-    expect(await factStore.getById("f_self_v1")).toBeNull(); // deleted
-    expect((await factStore.getById("f_old"))?.supersededBy).toBe("f_self_v2");
-    expect((await factStore.getById("f_self_v2"))?.supersededBy).toBeNull();
-
-    const current = await factStore.findCurrent("x", "framework");
-    expect(current?.id).toBe("f_self_v2");
-  });
-
-  it("does not supersede when factSink is omitted", async () => {
-    // Pre-seed a fact via the direct factStore API (no session txn route)
-    store.insertSessionForTest({
-      id: "sess_seed",
-      runtime: "claude-code",
-      runtimeSessionId: "seed",
-      startedAt: "2026-05-18T00:00:00Z",
-      endedAt: null,
-      durationMin: null,
-      label: "seed",
-      summary: "",
-      status: "closed",
-      transcriptKind: "claude-code-jsonl",
-      transcriptPath: null,
-      body: "",
-      entities: [],
-      decisions: [],
-      open: [],
-    });
-    await factStore.insert(
-      fact({ id: "f_seed", subject: "x", predicate: "framework", value: "v1", sourceSessionId: "sess_seed" }),
-    );
-
-    // Insert a session with NO factSink. The seed fact stays current.
-    await store.insertSession(makeRecord({ id: "sess_nofacts" }));
-    expect((await factStore.getById("f_seed"))?.supersededBy).toBeNull();
-  });
-
-  it("multi-fact ingest: each new fact supersedes its own (s, p) predecessor independently", async () => {
-    // Two prior facts, different (s, p) pairs
-    const sessFirst = "sess_first";
-    await store.insertSession(
-      makeRecord({ id: sessFirst, startedAt: "2026-05-18T10:00:00Z" }),
-      null, null,
-      {
-        factStore,
-        facts: [
-          fact({ id: "p1", subject: "a", predicate: "framework", value: "Fastify", sourceSessionId: sessFirst, createdAt: "2026-05-18T10:00:00Z" }),
-          fact({ id: "p2", subject: "b", predicate: "endpoint", value: ":8080", sourceSessionId: sessFirst, createdAt: "2026-05-18T10:00:00Z" }),
-        ],
-      },
-    );
-
-    // One ingest delivering supersedents to both
-    await store.insertSession(
-      makeRecord({ id: "sess_multi", startedAt: "2026-05-19T10:00:00Z" }),
-      null, null,
-      {
-        factStore,
-        facts: [
-          fact({ id: "n1", subject: "a", predicate: "framework", value: "Hono", sourceSessionId: "sess_multi", createdAt: "2026-05-19T10:00:00Z" }),
-          fact({ id: "n2", subject: "b", predicate: "endpoint", value: ":3940", sourceSessionId: "sess_multi", createdAt: "2026-05-19T10:00:00Z" }),
-        ],
-      },
-    );
-
-    expect((await factStore.getById("p1"))?.supersededBy).toBe("n1");
-    expect((await factStore.getById("p2"))?.supersededBy).toBe("n2");
-    expect((await factStore.getById("n1"))?.supersededBy).toBeNull();
-    expect((await factStore.getById("n2"))?.supersededBy).toBeNull();
-  });
-
-  it("FactRecallService default minConfidence respects supersedence — only current shows", async () => {
-    const factA = fact({ id: "f_old", subject: "x", predicate: "framework", value: "Fastify", sourceSessionId: "sess_A", createdAt: "2026-05-17T10:00:00Z" });
-    const factB = fact({ id: "f_new", subject: "x", predicate: "framework", value: "Hono", sourceSessionId: "sess_B", createdAt: "2026-05-19T10:00:00Z" });
-    await store.insertSession(makeRecord({ id: "sess_A", startedAt: "2026-05-17T10:00:00Z" }), null, null, { factStore, facts: [factA] });
-    await store.insertSession(makeRecord({ id: "sess_B", startedAt: "2026-05-19T10:00:00Z" }), null, null, { factStore, facts: [factB] });
-
-    const current = await factStore.list({ subject: "x", predicate: "framework" });
-    expect(current.map((f) => f.id)).toEqual(["f_new"]);
-
-    const all = await factStore.list({ subject: "x", predicate: "framework", includeSuperseded: true });
-    expect(all.map((f) => f.id).sort()).toEqual(["f_new", "f_old"]);
-  });
-});

package/tests/integration/fts-index.test.ts

@@ -1,60 +0,0 @@
-/**
- * Verifies the sessions_fts FTS5 index is present and kept in sync with the
- * sessions table after migrations run and rows are inserted.
- */
-
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join, resolve } from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { SqliteSessionStore } from "../../src/core/storage/sqlite-session-store.js";
-import { makeSession } from "../fixtures/sessions.js";
-
-const MIGRATIONS_DIR = resolve(__dirname, "../../migrations");
-
-describe("sessions_fts index", () => {
-  let tmp: string;
-  let store: SqliteSessionStore;
-
-  beforeEach(() => {
-    tmp = mkdtempSync(join(tmpdir(), "nlm-fts-"));
-    store = new SqliteSessionStore({
-      dbPath: join(tmp, "canonical.sqlite"),
-      migrationsDir: MIGRATIONS_DIR,
-    });
-  });
-
-  afterEach(() => {
-    store.close();
-    rmSync(tmp, { recursive: true, force: true });
-  });
-
-  it("populates sessions_fts via triggers on insert", () => {
-    store.insertSessionForTest(makeSession({ id: "s1", label: "alpha", body: "beta" }));
-    store.insertSessionForTest(makeSession({ id: "s2", label: "gamma", body: "delta" }));
-    const db = store.rawDb();
-    const fts = db.prepare<[], { n: number }>("SELECT count(*) AS n FROM sessions_fts").get();
-    const rows = db.prepare<[], { n: number }>("SELECT count(*) AS n FROM sessions").get();
-    expect(fts?.n).toBe(rows?.n);
-    expect(fts?.n).toBe(2);
-  });
-
-  it("records the 008 fts_rebuild migration as applied", () => {
-    const db = store.rawDb();
-    const row = db
-      .prepare<[number], { name: string }>("SELECT name FROM schema_migrations WHERE version = ?")
-      .get(8);
-    expect(row?.name).toBe("fts_rebuild");
-  });
-
-  it("answers a raw FTS5 MATCH query", () => {
-    store.insertSessionForTest(makeSession({ id: "s1", label: "pgvector plan", body: "" }));
-    const db = store.rawDb();
-    const hit = db
-      .prepare<[string], { id: string }>(
-        "SELECT s.id FROM sessions_fts JOIN sessions s ON s.rowid = sessions_fts.rowid WHERE sessions_fts MATCH ?",
-      )
-      .get('"pgvector"');
-    expect(hit?.id).toBe("s1");
-  });
-});

package/tests/integration/getbyids-sqlite.test.ts

@@ -1,100 +0,0 @@
-/**
- * SqliteSessionStore.getByIds — batched, body-free session fetch used by
- * the recall path so it never loads the full corpus.
- */
-
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join, resolve } from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { SqliteSessionStore } from "../../src/core/storage/sqlite-session-store.js";
-import { makeSession } from "../fixtures/sessions.js";
-
-const MIGRATIONS_DIR = resolve(__dirname, "../../migrations");
-
-describe("SqliteSessionStore.getByIds", () => {
-  let tmp: string;
-  let store: SqliteSessionStore;
-
-  beforeEach(() => {
-    tmp = mkdtempSync(join(tmpdir(), "nlm-getbyids-"));
-    store = new SqliteSessionStore({
-      dbPath: join(tmp, "canonical.sqlite"),
-      migrationsDir: MIGRATIONS_DIR,
-    });
-    store.insertSessionForTest(
-      makeSession({ id: "s1", label: "alpha", body: "BODY ONE", entities: ["NLM"], decisions: ["d1"] }),
-    );
-    store.insertSessionForTest(
-      makeSession({ id: "s2", label: "beta", body: "BODY TWO", open: ["q1"] }),
-    );
-    store.insertSessionForTest(makeSession({ id: "s3", label: "gamma" }));
-  });
-
-  afterEach(() => {
-    store.close();
-    rmSync(tmp, { recursive: true, force: true });
-  });
-
-  it("returns only the requested sessions", async () => {
-    const got = await store.getByIds(["s1", "s3"]);
-    expect(got.map((s) => s.id).sort()).toEqual(["s1", "s3"]);
-  });
-
-  it("returns an empty array for an empty id list", async () => {
-    expect(await store.getByIds([])).toEqual([]);
-  });
-
-  it("ignores ids that do not exist", async () => {
-    const got = await store.getByIds(["s2", "missing"]);
-    expect(got.map((s) => s.id)).toEqual(["s2"]);
-  });
-
-  it("populates entities and markers but omits body (body is empty)", async () => {
-    const got = await store.getByIds(["s1"]);
-    const s1 = got[0];
-    expect(s1?.entities).toEqual(["NLM"]);
-    expect(s1?.decisions).toEqual(["d1"]);
-    expect(s1?.body).toBe("");
-  });
-});
-
-describe("SqliteSessionStore.getById — supersedence edges", () => {
-  let tmp: string;
-  let store: SqliteSessionStore;
-
-  beforeEach(() => {
-    tmp = mkdtempSync(join(tmpdir(), "nlm-getbyid-edges-"));
-    store = new SqliteSessionStore({
-      dbPath: join(tmp, "canonical.sqlite"),
-      migrationsDir: MIGRATIONS_DIR,
-    });
-    store.insertSessionForTest(makeSession({ id: "old", label: "old session" }));
-    store.insertSessionForTest(makeSession({ id: "new", label: "new session" }));
-    store.insertEdgeForTest("new", "old", "supersedes");
-  });
-
-  afterEach(() => {
-    store.close();
-    rmSync(tmp, { recursive: true, force: true });
-  });
-
-  it("superseding session reports what it supersedes", async () => {
-    const s = await store.getById("new");
-    expect(s?.supersedes).toEqual(["old"]);
-    expect(s?.supersededBy).toBeNull();
-  });
-
-  it("superseded session reports what superseded it", async () => {
-    const s = await store.getById("old");
-    expect(s?.supersededBy).toBe("new");
-    expect(s?.supersedes).toEqual([]);
-  });
-
-  it("session with no edges has null supersededBy and empty supersedes", async () => {
-    store.insertSessionForTest(makeSession({ id: "unrelated", label: "standalone" }));
-    const s = await store.getById("unrelated");
-    expect(s?.supersededBy).toBeNull();
-    expect(s?.supersedes).toEqual([]);
-  });
-});