recallnest 2.3.0 → 2.5.4

package/src/__tests__/babel-integration.test.ts

@@ -0,0 +1,144 @@
+import { describe, expect, test, beforeAll, afterAll } from "bun:test";
+import { MemoryStore } from "../store.js";
+import { rmSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+// babel-memory is an optional dependency — skip integration tests if not installed
+let babelMemory: typeof import("babel-memory") | null = null;
+try {
+  babelMemory = await import("babel-memory");
+} catch {
+  // not installed — tests will be skipped
+}
+
+const describeIfBabel = babelMemory ? describe : describe.skip;
+
+beforeAll(async () => {
+  if (babelMemory) {
+    await babelMemory.initTokenizer();
+  }
+});
+
+describeIfBabel("babel-memory integration", () => {
+  test("Chinese memory: language detected + fts_text tokenized", () => {
+    const text = "RecallNest 是一个基于 LanceDB 的 AI 记忆系统";
+    const language = babelMemory!.detectLanguage(text);
+    const fts_text = babelMemory!.tokenizeForFts(text, language);
+
+    expect(language).toBe("zh");
+    expect(fts_text).toContain("RecallNest");
+    expect(fts_text.includes(" ")).toBe(true);
+  });
+
+  test("English memory: language detected + fts_text unchanged", () => {
+    const text = "RecallNest is an AI memory system built on LanceDB";
+    const language = babelMemory!.detectLanguage(text);
+    const fts_text = babelMemory!.tokenizeForFts(text, language);
+
+    expect(language).toBe("en");
+    expect(fts_text).toBe(text);
+  });
+
+  test("BM25 query symmetry: tokenized query matches tokenized stored text", () => {
+    const storedText = "机器学习在自然语言处理中的应用";
+    const storedLang = babelMemory!.detectLanguage(storedText);
+    const storedFts = babelMemory!.tokenizeForFts(storedText, storedLang);
+
+    const query = "机器学习";
+    const queryLang = babelMemory!.detectLanguage(query);
+    const queryFts = babelMemory!.tokenizeForFts(query, queryLang);
+
+    const queryTerms = queryFts
+      .split(" ")
+      .filter((t) => t.length > 0);
+    const matchedTerms = queryTerms.filter((term) =>
+      storedFts.includes(term),
+    );
+    expect(matchedTerms.length).toBeGreaterThan(0);
+  });
+
+  test("KG prompt routes correctly for Chinese input", () => {
+    const text = "RecallNest 使用 LanceDB 存储记忆";
+    const lang = babelMemory!.detectLanguage(text);
+    const { system } = babelMemory!.getKgPrompt(lang);
+    expect(system).toContain("知识图谱");
+  });
+
+  test("Session prompt routes correctly for Chinese input", () => {
+    const text = "用户今天讨论了多语言支持方案";
+    const lang = babelMemory!.detectLanguage(text);
+    const { dimensionLabels } = babelMemory!.getSessionPrompt(lang);
+    expect(dimensionLabels.user_intent).toContain("用户意图");
+  });
+
+  test("backward compat: missing language defaults to en", () => {
+    const entry = { text: "some old text", language: undefined };
+    const lang = entry.language || "en";
+    const fts = babelMemory!.tokenizeForFts(entry.text, lang);
+    expect(lang).toBe("en");
+    expect(fts).toBe(entry.text);
+  });
+});
+
+describe("store.update() preserves language + fts_text", () => {
+  const dbPath = join(tmpdir(), `recallnest-update-lang-test-${Date.now()}`);
+  let store: MemoryStore;
+
+  beforeAll(async () => {
+    mkdirSync(dbPath, { recursive: true });
+    store = new MemoryStore({ dbPath, vectorDim: 3 });
+    await (store as any).ensureInitialized();
+  });
+
+  afterAll(() => {
+    try { rmSync(dbPath, { recursive: true, force: true }); } catch {}
+  });
+
+  test("update preserves language and fts_text when not in updates", async () => {
+    const entry = await store.store({
+      text: "这是一条中文记忆",
+      vector: [0.1, 0.2, 0.3],
+      category: "events",
+      scope: "test:lang",
+      importance: 0.7,
+      metadata: "{}",
+      language: "zh",
+      fts_text: "这是 一条 中文 记忆",
+    });
+
+    // Update only text — language and fts_text should be preserved from old row
+    const updated = await store.update(entry.id, {
+      importance: 0.9,
+    });
+
+    expect(updated).not.toBeNull();
+    expect(updated!.language).toBe("zh");
+    expect(updated!.fts_text).toBe("这是 一条 中文 记忆");
+    expect(updated!.importance).toBe(0.9);
+  });
+
+  test("update overwrites language and fts_text when provided", async () => {
+    const entry = await store.store({
+      text: "old english text",
+      vector: [0.4, 0.5, 0.6],
+      category: "events",
+      scope: "test:lang",
+      importance: 0.6,
+      metadata: "{}",
+      language: "en",
+      fts_text: "old english text",
+    });
+
+    const updated = await store.update(entry.id, {
+      text: "新的中文文本",
+      language: "zh",
+      fts_text: "新的 中文 文本",
+    });
+
+    expect(updated).not.toBeNull();
+    expect(updated!.language).toBe("zh");
+    expect(updated!.fts_text).toBe("新的 中文 文本");
+    expect(updated!.text).toBe("新的中文文本");
+  });
+});

package/src/__tests__/batch-dedup.test.ts

@@ -0,0 +1,65 @@
+import { describe, expect, it } from "bun:test";
+import { batchInternalDedup } from "../ingest.js";
+
+describe("batchInternalDedup", () => {
+  it("keeps all entries when vectors are dissimilar", () => {
+    const vectors = [
+      [1, 0, 0],
+      [0, 1, 0],
+      [0, 0, 1],
+    ];
+    const importances = [0.8, 0.7, 0.6];
+    const kept = batchInternalDedup(vectors, importances);
+    expect(kept).toEqual([0, 1, 2]);
+  });
+
+  it("drops lower-importance duplicate when vectors are near-identical", () => {
+    const vectors = [
+      [1, 0, 0],    // importance 0.6
+      [1, 0.01, 0], // importance 0.9 — nearly identical to [0]
+      [0, 1, 0],    // importance 0.7 — dissimilar
+    ];
+    const importances = [0.6, 0.9, 0.7];
+    const kept = batchInternalDedup(vectors, importances);
+    // [1] has higher importance and is near-identical to [0], so [0] gets dropped
+    expect(kept).toContain(1);
+    expect(kept).toContain(2);
+    expect(kept).not.toContain(0);
+  });
+
+  it("returns single-item batch unchanged", () => {
+    expect(batchInternalDedup([[1, 0, 0]], [0.5])).toEqual([0]);
+  });
+
+  it("returns empty for empty input", () => {
+    expect(batchInternalDedup([], [])).toEqual([]);
+  });
+
+  it("preserves original order in output", () => {
+    const vectors = [
+      [0, 1, 0],    // idx 0, imp 0.9
+      [1, 0, 0],    // idx 1, imp 0.5
+      [0, 0, 1],    // idx 2, imp 0.7
+    ];
+    const importances = [0.9, 0.5, 0.7];
+    const kept = batchInternalDedup(vectors, importances);
+    // All dissimilar, all kept, in original order
+    expect(kept).toEqual([0, 1, 2]);
+  });
+
+  it("respects custom threshold", () => {
+    const vectors = [
+      [1, 0, 0],
+      [0.95, 0.31, 0], // cosine ~0.95 with [0]
+    ];
+    const importances = [0.8, 0.7];
+
+    // Default threshold 0.85 → should dedup
+    const strictKept = batchInternalDedup(vectors, importances, 0.85);
+    expect(strictKept).toHaveLength(1);
+
+    // Loose threshold 0.99 → should keep both
+    const looseKept = batchInternalDedup(vectors, importances, 0.99);
+    expect(looseKept).toHaveLength(2);
+  });
+});

package/src/__tests__/canary-eval.test.ts

@@ -0,0 +1,114 @@
+import { describe, expect, it } from "bun:test";
+
+import { scoreCanaryCase, type CanaryEvalCase } from "../eval.js";
+
+function res(id: string, text = "", scope = "cc", metadata = "") {
+  return { entry: { id, text, scope, metadata } };
+}
+
+describe("scoreCanaryCase", () => {
+  it("A 类 top1 命中给满目标分并 pass", () => {
+    const c: CanaryEvalCase = { name: "a", query: "q", targets: ["m1"], expectTopK: 3 };
+    const r = scoreCanaryCase(c, [res("m1", "hit"), res("m2")]);
+    expect(r.top1Hit).toBe(true);
+    expect(r.top3Hit).toBe(true);
+    expect(r.targetRanks).toEqual([{ id: "m1", rank: 1 }]);
+    expect(r.score).toBeCloseTo(1, 5);
+    expect(r.passed).toBe(true);
+  });
+
+  it("A 类命中但排第 3 给 top3 分", () => {
+    const c: CanaryEvalCase = { name: "a", query: "q", targets: ["m3"], expectTopK: 3 };
+    const r = scoreCanaryCase(c, [res("a"), res("b"), res("m3")]);
+    expect(r.top1Hit).toBe(false);
+    expect(r.top3Hit).toBe(true);
+    expect(r.targetRanks).toEqual([{ id: "m3", rank: 3 }]);
+    expect(r.score).toBeCloseTo(0.7, 5);
+    expect(r.passed).toBe(true);
+  });
+
+  it("A 类 miss 给 0 并 fail", () => {
+    const c: CanaryEvalCase = { name: "a", query: "q", targets: ["zzz"] };
+    const r = scoreCanaryCase(c, [res("a"), res("b")]);
+    expect(r.targetRanks).toEqual([{ id: "zzz", rank: null }]);
+    expect(r.score).toBe(0);
+    expect(r.passed).toBe(false);
+  });
+
+  it("B 类新旧序正确 orderOk=true 并 pass", () => {
+    const c: CanaryEvalCase = { name: "b", query: "q", expectOrder: ["new", "old"] };
+    const r = scoreCanaryCase(c, [res("new"), res("old")]);
+    expect(r.orderOk).toBe(true);
+    expect(r.score).toBeCloseTo(1, 5);
+    expect(r.passed).toBe(true);
+  });
+
+  it("B 类新旧序颠倒 orderOk=false 并 fail", () => {
+    const c: CanaryEvalCase = { name: "b", query: "q", expectOrder: ["new", "old"] };
+    const r = scoreCanaryCase(c, [res("old"), res("new")]);
+    expect(r.orderOk).toBe(false);
+    expect(r.score).toBe(0);
+    expect(r.passed).toBe(false);
+  });
+
+  it("B 类 newer 未召回 orderOk=false", () => {
+    const c: CanaryEvalCase = { name: "b", query: "q", expectOrder: ["new", "old"] };
+    const r = scoreCanaryCase(c, [res("old"), res("other")]);
+    expect(r.orderOk).toBe(false);
+  });
+
+  it("C 类干扰项进 TopK 直接判 fail（即便目标命中）", () => {
+    const c: CanaryEvalCase = { name: "c", query: "q", targets: ["m1"], hardNegatives: ["bad"], limit: 8 };
+    const r = scoreCanaryCase(c, [res("m1"), res("bad")]);
+    expect(r.top1Hit).toBe(true);
+    expect(r.forbiddenIdMatches).toEqual(["bad"]);
+    expect(r.passed).toBe(false);
+  });
+
+  it("C 类干扰项在 limit 之外不算违规", () => {
+    const c: CanaryEvalCase = { name: "c", query: "q", targets: ["m1"], hardNegatives: ["bad"], limit: 1 };
+    const r = scoreCanaryCase(c, [res("m1"), res("bad")]);
+    expect(r.forbiddenIdMatches).toEqual([]);
+    expect(r.passed).toBe(true);
+  });
+
+  it("D 类内容全命中给满分", () => {
+    const c: CanaryEvalCase = { name: "d", query: "q", expectContentAny: ["口语化", "剧评腔"] };
+    const r = scoreCanaryCase(c, [res("x", "她要口语化，带点剧评腔", "cc")]);
+    expect(r.matchedContentAny).toEqual(["口语化", "剧评腔"]);
+    expect(r.score).toBeCloseTo(1, 5);
+    expect(r.passed).toBe(true);
+  });
+
+  it("D 类内容部分命中按比例", () => {
+    const c: CanaryEvalCase = { name: "d", query: "q", expectContentAny: ["口语化", "剧评腔"] };
+    const r = scoreCanaryCase(c, [res("x", "只提了口语化", "cc")]);
+    expect(r.matchedContentAny).toEqual(["口语化"]);
+    expect(r.score).toBeCloseTo(0.5, 5);
+    expect(r.passed).toBe(false);
+  });
+
+  it("文本 forbid 命中判 fail", () => {
+    const c: CanaryEvalCase = { name: "f", query: "q", targets: ["m1"], forbid: ["机密"] };
+    const r = scoreCanaryCase(c, [res("m1", "这是机密内容")]);
+    expect(r.forbiddenMatches).toEqual(["机密"]);
+    expect(r.passed).toBe(false);
+  });
+
+  it("空召回 score 0", () => {
+    const c: CanaryEvalCase = { name: "e", query: "q", targets: ["m1"] };
+    const r = scoreCanaryCase(c, []);
+    expect(r.hitCount).toBe(0);
+    expect(r.score).toBe(0);
+    expect(r.passed).toBe(false);
+  });
+
+  it("A+B 复合：目标命中且新旧序正确，综合 pass", () => {
+    const c: CanaryEvalCase = { name: "ab", query: "q", targets: ["new"], expectOrder: ["new", "old"], expectTopK: 3 };
+    const r = scoreCanaryCase(c, [res("new"), res("old")]);
+    expect(r.top1Hit).toBe(true);
+    expect(r.orderOk).toBe(true);
+    expect(r.score).toBeCloseTo(1, 5);
+    expect(r.passed).toBe(true);
+  });
+});