recallnest 2.2.1 → 2.5.4

package/src/__tests__/store-upsert.test.ts

@@ -0,0 +1,184 @@
+import { afterEach, describe, expect, it } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { MemoryStore, deterministicId, type MemoryEntry } from "../store.js";
+import { getWriteCount } from "../activity-counter.js";
+
+/**
+ * P0-2 回归：store()/storeBatch() 改走 upsert（delete+add 入全局 store-write 锁）后，
+ * 相同 deterministicId 的写入是幂等的 —— 同 (scope,text) 写两次只留一行，不再堆 dup-id。
+ */
+
+const tmpDirs: string[] = [];
+
+function makeStore(): MemoryStore {
+  const dir = mkdtempSync(join(tmpdir(), "recallnest-upsert-"));
+  tmpDirs.push(dir);
+  return new MemoryStore({ dbPath: dir, vectorDim: 3 });
+}
+
+afterEach(() => {
+  while (tmpDirs.length > 0) {
+    try {
+      rmSync(tmpDirs.pop()!, { recursive: true, force: true });
+    } catch {
+      /* ignore */
+    }
+  }
+});
+
+describe("store P0-2 idempotency (upsert-backed store/storeBatch)", () => {
+  it("store() of the same (scope,text) twice yields one row, latest wins", async () => {
+    const store = makeStore();
+    const scope = "project:upsert-test";
+    await store.store({ text: "同一条内容", vector: [1, 0, 0], category: "entities", scope, importance: 0.7, metadata: "{}" });
+    await store.store({ text: "同一条内容", vector: [1, 0, 0], category: "entities", scope, importance: 0.9, metadata: "{}" });
+
+    const rows = await store.list([scope]);
+    const target = rows.filter((r) => r.text === "同一条内容");
+    expect(target.length).toBe(1);
+    expect(target[0].importance).toBeCloseTo(0.9, 5); // upsert overwrote the 0.7 row
+  });
+
+  it("upsert() with the same id twice overwrites (single row, latest content)", async () => {
+    const store = makeStore();
+    const scope = "project:upsert-test";
+    const id = deterministicId(scope, "anchor");
+    const base: MemoryEntry = {
+      id,
+      text: "v1",
+      vector: [0, 1, 0],
+      category: "entities",
+      scope,
+      importance: 0.5,
+      timestamp: Date.now(),
+      metadata: "{}",
+      language: "en",
+      fts_text: "v1",
+    };
+    await store.upsert(base);
+    await store.upsert({ ...base, text: "v2", fts_text: "v2", importance: 0.8 });
+
+    const rows = await store.list([scope]);
+    const byId = rows.filter((r) => r.id === id);
+    expect(byId.length).toBe(1);
+    expect(byId[0].text).toBe("v2");
+  });
+
+  it("upsert failure leaves the prior row intact (mergeInsert is atomic — no delete+add loss)", async () => {
+    const store = makeStore(); // vectorDim 3
+    const scope = "project:upsert-test";
+    const id = deterministicId(scope, "atomic-anchor");
+    const good: MemoryEntry = {
+      id, text: "original", vector: [1, 0, 0], category: "entities", scope, importance: 0.5,
+      timestamp: Date.now(), metadata: "{}", language: "en", fts_text: "original",
+    };
+    await store.upsert(good);
+
+    // Inject a write failure. With the old delete-then-add path the delete would already
+    // have removed the row before add threw (row lost); the atomic mergeInsert touches
+    // nothing on failure, so the prior row must survive.
+    const table = (store as unknown as { table: { mergeInsert: unknown } }).table;
+    const orig = table.mergeInsert;
+    table.mergeInsert = () => {
+      throw new Error("simulated write failure");
+    };
+    try {
+      await expect(store.upsert({ ...good, text: "corrupt", fts_text: "corrupt" })).rejects.toThrow("simulated write failure");
+    } finally {
+      table.mergeInsert = orig;
+    }
+
+    const survivor = (await store.list([scope])).filter((r) => r.id === id);
+    expect(survivor.length).toBe(1);
+    expect(survivor[0].text).toBe("original"); // prior row preserved, not lost
+  });
+
+  it("storeBatch() honors a caller-supplied id (idempotent re-run)", async () => {
+    const store = makeStore();
+    const scope = "project:upsert-test";
+    const fixedId = deterministicId(scope, "batch-anchor");
+    const entry = {
+      id: fixedId,
+      text: "batch-a",
+      vector: [0, 0, 1] as number[],
+      category: "entities" as const,
+      scope,
+      importance: 0.6,
+      metadata: "{}",
+    };
+    await store.storeBatch([entry]);
+    await store.storeBatch([{ ...entry, text: "batch-a-updated", fts_text: "batch-a-updated" }]);
+
+    const rows = await store.list([scope]);
+    const byId = rows.filter((r) => r.id === fixedId);
+    expect(byId.length).toBe(1);
+    expect(byId[0].text).toBe("batch-a-updated");
+  });
+
+  it("storeBatch() collapses in-batch duplicate ids (latest-wins) into one row", async () => {
+    const store = makeStore();
+    const scope = "project:upsert-test";
+    const stored = await store.storeBatch([
+      { text: "dup-in-batch", vector: [1, 0, 0], category: "entities", scope, importance: 0.3, metadata: "{}" },
+      { text: "dup-in-batch", vector: [1, 0, 0], category: "entities", scope, importance: 0.8, metadata: "{}" },
+    ]);
+    expect(stored).toBe(1); // two same-(scope,text) entries collapse to one
+    const rows = await store.list([scope]);
+    const target = rows.filter((r) => r.text === "dup-in-batch");
+    expect(target.length).toBe(1);
+    expect(target[0].importance).toBeCloseTo(0.8, 5); // last occurrence wins
+  });
+
+  // A store whose activity-stats sits in its own unique dir (dirname(dbPath)), so the
+  // per-scope counter assertions are isolated from other tests' shared tmproot writes.
+  function makeIsolatedStore(): { store: MemoryStore; statsPath: string } {
+    const dir = mkdtempSync(join(tmpdir(), "recallnest-count-"));
+    tmpDirs.push(dir);
+    const dbPath = join(dir, "lancedb");
+    return { store: new MemoryStore({ dbPath, vectorDim: 3 }), statsPath: join(dir, "activity-stats.json") };
+  }
+
+  it("store() increments the per-scope write counter once each (no double-count via upsert)", async () => {
+    const { store, statsPath } = makeIsolatedStore();
+    const scope = "cc:project:count-a";
+    await store.store({ text: "m1", vector: [1, 0, 0], category: "entities", scope, importance: 0.5, metadata: "{}" });
+    await store.store({ text: "m2", vector: [0, 1, 0], category: "entities", scope, importance: 0.5, metadata: "{}" });
+    // store()→upsert() counts once per call; two stores ⇒ 2 (not 4).
+    expect(getWriteCount(scope, { statsPath })).toBe(2);
+  });
+
+  it("storeBatch() counts per scope by number of entries in that scope", async () => {
+    const { store, statsPath } = makeIsolatedStore();
+    await store.storeBatch([
+      { text: "a", vector: [1, 0, 0], category: "entities", scope: "cc:s1", importance: 0.5, metadata: "{}" },
+      { text: "b", vector: [0, 1, 0], category: "entities", scope: "cc:s1", importance: 0.5, metadata: "{}" },
+      { text: "c", vector: [0, 0, 1], category: "entities", scope: "cc:s2", importance: 0.5, metadata: "{}" },
+    ]);
+    expect(getWriteCount("cc:s1", { statsPath })).toBe(2);
+    expect(getWriteCount("cc:s2", { statsPath })).toBe(1);
+  });
+
+  it("storeBatch() with an in-batch duplicate counts the collapsed row once", async () => {
+    const { store, statsPath } = makeIsolatedStore();
+    await store.storeBatch([
+      { text: "dup", vector: [1, 0, 0], category: "entities", scope: "cc:s3", importance: 0.3, metadata: "{}" },
+      { text: "dup", vector: [1, 0, 0], category: "entities", scope: "cc:s3", importance: 0.8, metadata: "{}" },
+    ]);
+    expect(getWriteCount("cc:s3", { statsPath })).toBe(1); // deduped to one row ⇒ counted once
+  });
+
+  it("storeBatch() without ids still stores distinct entries", async () => {
+    const store = makeStore();
+    const scope = "project:upsert-test";
+    const stored = await store.storeBatch([
+      { text: "batch-x", vector: [1, 0, 0], category: "entities", scope, importance: 0.5, metadata: "{}" },
+      { text: "batch-y", vector: [0, 1, 0], category: "entities", scope, importance: 0.5, metadata: "{}" },
+    ]);
+    expect(stored).toBe(2);
+    const rows = await store.list([scope]);
+    expect(rows.filter((r) => r.text === "batch-x" || r.text === "batch-y").length).toBe(2);
+  });
+});

package/src/__tests__/supersede-chain.test.ts

@@ -0,0 +1,154 @@
+import { describe, it, expect } from "bun:test";
+import {
+  buildSupersedeMetadata,
+  buildSupersedeMetadataForNew,
+  parseEvolution,
+  traceEvolution,
+  patchEvolution,
+  defaultEvolution,
+} from "../memory-evolution.js";
+
+describe("HP-1: Superseded chain enhancement", () => {
+  describe("bidirectional linking", () => {
+    it("buildSupersedeMetadata marks old → supersededBy", () => {
+      const oldMeta = patchEvolution("{}", defaultEvolution());
+      const result = buildSupersedeMetadata(oldMeta, "new-id");
+      const evo = parseEvolution(result);
+      expect(evo.status).toBe("superseded");
+      expect(evo.supersededBy).toBe("new-id");
+      expect(evo.validUntil).toBeGreaterThan(0);
+    });
+
+    it("buildSupersedeMetadataForNew marks new → supersedes + note", () => {
+      const newMeta = patchEvolution("{}", defaultEvolution());
+      const result = buildSupersedeMetadataForNew(newMeta, "old-id", "updated preference");
+      const evo = parseEvolution(result);
+      expect(evo.status).toBe("active"); // new memory stays active
+      expect(evo.supersedes).toBe("old-id");
+      expect(evo.evolutionNote).toBe("updated preference");
+    });
+
+    it("bidirectional: old.supersededBy == new.id AND new.supersedes == old.id", () => {
+      const oldMeta = patchEvolution("{}", defaultEvolution());
+      const newMeta = patchEvolution("{}", defaultEvolution());
+
+      const updatedOld = buildSupersedeMetadata(oldMeta, "new-id");
+      const updatedNew = buildSupersedeMetadataForNew(newMeta, "old-id");
+
+      const oldEvo = parseEvolution(updatedOld);
+      const newEvo = parseEvolution(updatedNew);
+
+      expect(oldEvo.supersededBy).toBe("new-id");
+      expect(newEvo.supersedes).toBe("old-id");
+    });
+  });
+
+  describe("traceEvolution", () => {
+    it("traces a 3-node chain", async () => {
+      // v1 → v2 → v3
+      const entries: Record<string, { metadata: string; timestamp: number }> = {
+        v1: {
+          metadata: patchEvolution("{}", {
+            status: "superseded",
+            supersededBy: "v2",
+            validFrom: 1000,
+            validUntil: 2000,
+          }),
+          timestamp: 1000,
+        },
+        v2: {
+          metadata: patchEvolution("{}", {
+            status: "superseded",
+            supersedes: "v1",
+            supersededBy: "v3",
+            evolutionNote: "added detail",
+            validFrom: 2000,
+            validUntil: 3000,
+          }),
+          timestamp: 2000,
+        },
+        v3: {
+          metadata: patchEvolution("{}", {
+            status: "active",
+            supersedes: "v2",
+            evolutionNote: "corrected error",
+            validFrom: 3000,
+          }),
+          timestamp: 3000,
+        },
+      };
+
+      const getEntry = async (id: string) => entries[id] ?? null;
+
+      // Trace from v2 (middle)
+      const trace = await traceEvolution("v2", getEntry);
+      expect(trace.length).toBe(3);
+      expect(trace[0].id).toBe("v1");
+      expect(trace[0].direction).toBe("predecessor");
+      expect(trace[1].id).toBe("v2");
+      expect(trace[1].direction).toBe("self");
+      expect(trace[2].id).toBe("v3");
+      expect(trace[2].direction).toBe("successor");
+    });
+
+    it("handles single node (no chain)", async () => {
+      const getEntry = async (id: string) => {
+        if (id === "solo") return { metadata: patchEvolution("{}", defaultEvolution()), timestamp: 1000 };
+        return null;
+      };
+
+      const trace = await traceEvolution("solo", getEntry);
+      expect(trace.length).toBe(1);
+      expect(trace[0].direction).toBe("self");
+    });
+
+    it("respects maxDepth", async () => {
+      // Create a long chain: v0 → v1 → v2 → ... → v20
+      const entries: Record<string, { metadata: string; timestamp: number }> = {};
+      for (let i = 0; i <= 20; i++) {
+        entries[`v${i}`] = {
+          metadata: patchEvolution("{}", {
+            status: i < 20 ? "superseded" : "active",
+            supersedes: i > 0 ? `v${i - 1}` : null,
+            supersededBy: i < 20 ? `v${i + 1}` : null,
+            validFrom: i * 1000,
+          }),
+          timestamp: i * 1000,
+        };
+      }
+
+      const getEntry = async (id: string) => entries[id] ?? null;
+      const trace = await traceEvolution("v10", getEntry, 3);
+      // maxDepth=3: at most 3 predecessors + self + 3 successors = 7
+      expect(trace.length).toBeLessThanOrEqual(7);
+    });
+
+    it("handles missing entries gracefully", async () => {
+      const entries: Record<string, { metadata: string; timestamp: number }> = {
+        v1: {
+          metadata: patchEvolution("{}", {
+            status: "active",
+            supersedes: "missing",
+            validFrom: 1000,
+          }),
+          timestamp: 1000,
+        },
+      };
+      const getEntry = async (id: string) => entries[id] ?? null;
+      const trace = await traceEvolution("v1", getEntry);
+      expect(trace.length).toBe(1); // only self, missing predecessor stops chain
+    });
+  });
+
+  describe("backward compatibility", () => {
+    it("parseEvolution defaults new fields to null", () => {
+      // Old metadata without supersedes/evolutionNote
+      const oldMeta = JSON.stringify({
+        evolution: { status: "active", version: 1, accessCount: 0 },
+      });
+      const evo = parseEvolution(oldMeta);
+      expect(evo.supersedes).toBeNull();
+      expect(evo.evolutionNote).toBeNull();
+    });
+  });
+});

package/src/__tests__/temporal-parser.test.ts

@@ -0,0 +1,241 @@
+import { describe, expect, it } from "bun:test";
+import {
+  parseTemporalQuery,
+  matchesTemporalConstraint,
+  temporalWhereClause,
+  type TemporalConstraint,
+} from "../temporal-parser.js";
+
+// ============================================================================
+// parseTemporalQuery
+// ============================================================================
+
+describe("parseTemporalQuery", () => {
+  // --- Absolute year (ZH) ---
+  it("parses '2023年的记忆'", () => {
+    const result = parseTemporalQuery("2023年的记忆里有什么");
+    expect(result.constraint).not.toBeNull();
+    expect(result.constraint!.type).toBe("range");
+    expect(result.constraint!.startMs).toBe(new Date(2023, 0, 1).getTime());
+    expect(result.constraint!.endMs).toBe(new Date(2024, 0, 1).getTime() - 1);
+    // Time expression removed from cleaned query
+    expect(result.cleanedQuery).not.toContain("2023年");
+    expect(result.cleanedQuery).toContain("里有什么");
+  });
+
+  it("parses standalone '2024年'", () => {
+    const result = parseTemporalQuery("关于 2024年 的项目");
+    expect(result.constraint).not.toBeNull();
+    expect(result.constraint!.type).toBe("range");
+  });
+
+  // --- Absolute year+month (ZH) ---
+  it("parses '2023年3月'", () => {
+    const result = parseTemporalQuery("2023年3月我们讨论了什么");
+    expect(result.constraint).not.toBeNull();
+    expect(result.constraint!.startMs).toBe(new Date(2023, 2, 1).getTime());
+    expect(result.constraint!.endMs).toBe(new Date(2023, 3, 1).getTime() - 1);
+  });
+
+  it("parses '2023年三月'", () => {
+    const result = parseTemporalQuery("2023年三月的对话");
+    expect(result.constraint).not.toBeNull();
+    expect(result.constraint!.startMs).toBe(new Date(2023, 2, 1).getTime());
+  });
+
+  // --- Absolute year+month (EN) ---
+  it("parses 'March 2023'", () => {
+    const result = parseTemporalQuery("What did we discuss in March 2023");
+    expect(result.constraint).not.toBeNull();
+    expect(result.constraint!.startMs).toBe(new Date(2023, 2, 1).getTime());
+    expect(result.constraint!.endMs).toBe(new Date(2023, 3, 1).getTime() - 1);
+  });
+
+  // --- "in YYYY" ---
+  it("parses 'in 2022'", () => {
+    const result = parseTemporalQuery("Projects discussed in 2022");
+    expect(result.constraint).not.toBeNull();
+    expect(result.constraint!.type).toBe("range");
+    expect(result.constraint!.startMs).toBe(new Date(2022, 0, 1).getTime());
+  });
+
+  // --- Relative: 最近N天/周/月 ---
+  it("parses '最近7天'", () => {
+    const result = parseTemporalQuery("最近7天的记忆");
+    expect(result.constraint).not.toBeNull();
+    expect(result.constraint!.type).toBe("range");
+    const now = Date.now();
+    expect(result.constraint!.startMs).toBeGreaterThan(now - 8 * 86_400_000);
+    expect(result.constraint!.endMs).toBeLessThanOrEqual(now + 1000);
+  });
+
+  it("parses '最近2周'", () => {
+    const result = parseTemporalQuery("最近2周讨论过什么");
+    expect(result.constraint).not.toBeNull();
+    const now = Date.now();
+    expect(result.constraint!.startMs).toBeGreaterThan(now - 15 * 86_400_000);
+  });
+
+  it("parses '最近3个月'", () => {
+    const result = parseTemporalQuery("最近3个月的项目进展");
+    expect(result.constraint).not.toBeNull();
+    const now = Date.now();
+    expect(result.constraint!.startMs).toBeGreaterThan(now - 100 * 86_400_000);
+  });
+
+  // --- Relative: last N days/weeks/months ---
+  it("parses 'last 30 days'", () => {
+    const result = parseTemporalQuery("What happened in the last 30 days");
+    expect(result.constraint).not.toBeNull();
+    expect(result.constraint!.type).toBe("range");
+    const now = Date.now();
+    expect(result.constraint!.startMs).toBeGreaterThan(now - 31 * 86_400_000);
+  });
+
+  it("parses 'last 2 weeks'", () => {
+    const result = parseTemporalQuery("Changes in the last 2 weeks");
+    expect(result.constraint).not.toBeNull();
+  });
+
+  // --- Relative: 上周/上个月/去年 ---
+  it("parses '去年'", () => {
+    const result = parseTemporalQuery("去年我们做了什么项目");
+    expect(result.constraint).not.toBeNull();
+    const lastYear = new Date().getFullYear() - 1;
+    expect(result.constraint!.startMs).toBe(new Date(lastYear, 0, 1).getTime());
+    expect(result.constraint!.endMs).toBe(new Date(lastYear + 1, 0, 1).getTime() - 1);
+  });
+
+  it("parses 'last year'", () => {
+    const result = parseTemporalQuery("Projects from last year");
+    expect(result.constraint).not.toBeNull();
+    expect(result.constraint!.type).toBe("range");
+  });
+
+  it("parses '上个月'", () => {
+    const result = parseTemporalQuery("上个月的讨论");
+    expect(result.constraint).not.toBeNull();
+  });
+
+  it("parses '去年3月'", () => {
+    const result = parseTemporalQuery("去年3月的事情");
+    expect(result.constraint).not.toBeNull();
+    const lastYear = new Date().getFullYear() - 1;
+    expect(result.constraint!.startMs).toBe(new Date(lastYear, 2, 1).getTime());
+  });
+
+  // --- Operator syntax ---
+  it("parses 'after:2024-01'", () => {
+    const result = parseTemporalQuery("TypeScript projects after:2024-01");
+    expect(result.constraint).not.toBeNull();
+    expect(result.constraint!.type).toBe("after");
+    expect(result.constraint!.startMs).toBe(new Date(2024, 0, 1).getTime());
+    expect(result.cleanedQuery).toContain("TypeScript projects");
+  });
+
+  it("parses 'before:2025-06'", () => {
+    const result = parseTemporalQuery("memory entries before:2025-06");
+    expect(result.constraint).not.toBeNull();
+    expect(result.constraint!.type).toBe("before");
+  });
+
+  // --- No temporal expression ---
+  it("returns null for non-temporal queries", () => {
+    const result = parseTemporalQuery("How to configure TypeScript");
+    expect(result.constraint).toBeNull();
+    expect(result.cleanedQuery).toBe("How to configure TypeScript");
+  });
+
+  it("returns null for empty query", () => {
+    const result = parseTemporalQuery("");
+    expect(result.constraint).toBeNull();
+  });
+
+  // --- Cleaned query ---
+  it("removes temporal expression and preserves the rest", () => {
+    const result = parseTemporalQuery("2023年我们讨论了 Docker 配置");
+    expect(result.cleanedQuery).toContain("Docker");
+    expect(result.cleanedQuery).not.toContain("2023年");
+  });
+});
+
+// ============================================================================
+// matchesTemporalConstraint
+// ============================================================================
+
+describe("matchesTemporalConstraint", () => {
+  it("matches timestamp within range", () => {
+    const constraint: TemporalConstraint = {
+      type: "range",
+      startMs: new Date(2023, 0, 1).getTime(),
+      endMs: new Date(2024, 0, 1).getTime() - 1,
+      anchor: "2023年",
+    };
+    const mid2023 = new Date(2023, 6, 1).getTime();
+    expect(matchesTemporalConstraint(mid2023, constraint)).toBe(true);
+  });
+
+  it("rejects timestamp outside range", () => {
+    const constraint: TemporalConstraint = {
+      type: "range",
+      startMs: new Date(2023, 0, 1).getTime(),
+      endMs: new Date(2024, 0, 1).getTime() - 1,
+      anchor: "2023年",
+    };
+    const mid2022 = new Date(2022, 6, 1).getTime();
+    expect(matchesTemporalConstraint(mid2022, constraint)).toBe(false);
+  });
+
+  it("handles 'after' constraint", () => {
+    const constraint: TemporalConstraint = {
+      type: "after",
+      startMs: new Date(2024, 0, 1).getTime(),
+      anchor: "after:2024-01",
+    };
+    expect(matchesTemporalConstraint(new Date(2024, 6, 1).getTime(), constraint)).toBe(true);
+    expect(matchesTemporalConstraint(new Date(2023, 6, 1).getTime(), constraint)).toBe(false);
+  });
+
+  it("handles 'before' constraint", () => {
+    const constraint: TemporalConstraint = {
+      type: "before",
+      endMs: new Date(2024, 0, 1).getTime(),
+      anchor: "before:2024-01",
+    };
+    expect(matchesTemporalConstraint(new Date(2023, 6, 1).getTime(), constraint)).toBe(true);
+    expect(matchesTemporalConstraint(new Date(2025, 0, 1).getTime(), constraint)).toBe(false);
+  });
+});
+
+// ============================================================================
+// temporalWhereClause
+// ============================================================================
+
+describe("temporalWhereClause", () => {
+  it("generates range clause", () => {
+    const clause = temporalWhereClause({
+      type: "range",
+      startMs: 1000,
+      endMs: 2000,
+      anchor: "test",
+    });
+    expect(clause).toBe("timestamp >= 1000 AND timestamp <= 2000");
+  });
+
+  it("generates after-only clause", () => {
+    const clause = temporalWhereClause({
+      type: "after",
+      startMs: 1000,
+      anchor: "test",
+    });
+    expect(clause).toBe("timestamp >= 1000");
+  });
+
+  it("returns null for empty constraint", () => {
+    const clause = temporalWhereClause({
+      type: "range",
+      anchor: "test",
+    });
+    expect(clause).toBeNull();
+  });
+});