recallnest 1.4.1 → 2.2.1

package/src/__tests__/ingest.test.ts

@@ -1,360 +0,0 @@
-import { describe, expect, it } from "bun:test";
-
-import { dedupCheck } from "../ingest.js";
-
-function buildSearchResult(text: string, score: number) {
-  return {
-    score,
-    entry: {
-      id: `memory-${score}`,
-      text,
-      vector: [score],
-      category: "events",
-      scope: "cc:test-session",
-      importance: 0.6,
-      timestamp: 1_700_000_000_000,
-      metadata: "{}",
-    },
-  };
-}
-
-describe("dedupCheck", () => {
-  it("stores a new same-brand item preference instead of treating it as a duplicate topic", async () => {
-    let llmCalls = 0;
-    const store = {
-      async vectorSearch() {
-        return [
-          buildSearchResult("喜欢吃麦当劳的麦旋风", 0.92),
-          buildSearchResult("喜欢吃麦当劳的板烧鸡腿堡", 0.89),
-        ];
-      },
-    };
-    const llm = {
-      async dedupDecision() {
-        llmCalls += 1;
-        return { action: "SKIP" as const, reason: "same topic" };
-      },
-    };
-
-    const result = await dedupCheck(
-      store as any,
-      [1, 0, 0],
-      "我喜欢吃麦当劳的麦辣鸡翅",
-      llm as any,
-    );
-
-    expect(result.action).toBe("store");
-    expect(result.reason).toBe("unique");
-    expect(result.existingText).toBe("喜欢吃麦当劳的板烧鸡腿堡");
-    expect(llmCalls).toBe(0);
-  });
-
-  it("stores a new atomic preference even when the closest match is an aggregate summary", async () => {
-    const store = {
-      async vectorSearch() {
-        return [
-          buildSearchResult("喜欢吃麦当劳的麦旋风、板烧鸡腿堡和藤椒鸡派", 0.94),
-        ];
-      },
-    };
-
-    const result = await dedupCheck(
-      store as any,
-      [1, 0, 0],
-      "我喜欢吃麦当劳的麦辣鸡翅",
-    );
-
-    expect(result.action).toBe("store");
-    expect(result.reason).toBe("unique");
-    expect(result.existingText).toContain("麦旋风");
-  });
-
-  it("still skips when an exact atomic preference already exists among the candidates", async () => {
-    const store = {
-      async vectorSearch() {
-        return [
-          buildSearchResult("喜欢吃麦当劳的麦旋风、板烧鸡腿堡和藤椒鸡派", 0.94),
-          buildSearchResult("我喜欢吃麦当劳的麦辣鸡翅", 0.82),
-        ];
-      },
-    };
-
-    const result = await dedupCheck(
-      store as any,
-      [1, 0, 0],
-      "我喜欢吃麦当劳的麦辣鸡翅",
-    );
-
-    expect(result.action).toBe("skip");
-    expect(result.reason).toBe("exact");
-    expect(result.existingText).toBe("我喜欢吃麦当劳的麦辣鸡翅");
-  });
-
-  it("does not force-create when the same brand-item preference is only rephrased", async () => {
-    let llmCalls = 0;
-    const store = {
-      async vectorSearch() {
-        return [
-          buildSearchResult("我喜欢吃麦当劳的麦辣鸡翅", 0.75),
-        ];
-      },
-    };
-    const llm = {
-      async dedupDecision() {
-        llmCalls += 1;
-        return { action: "SKIP" as const, reason: "same item, rephrased" };
-      },
-    };
-
-    const result = await dedupCheck(
-      store as any,
-      [1, 0, 0],
-      "用户喜欢麦当劳的麦辣鸡翅",
-      llm as any,
-    );
-
-    expect(result.action).toBe("skip");
-    expect(result.reason).toBe("llm-skip");
-    expect(result.existingText).toBe("我喜欢吃麦当劳的麦辣鸡翅");
-    expect(llmCalls).toBe(1);
-  });
-
-  it("does not trigger the brand-item guard for non-preference text that mentions the same brand and item", async () => {
-    let llmCalls = 0;
-    const store = {
-      async vectorSearch() {
-        return [
-          buildSearchResult("我喜欢喝星巴克的抹茶拿铁", 0.75),
-        ];
-      },
-    };
-    const llm = {
-      async dedupDecision() {
-        llmCalls += 1;
-        return { action: "SKIP" as const, reason: "same context, not a new preference" };
-      },
-    };
-
-    const result = await dedupCheck(
-      store as any,
-      [1, 0, 0],
-      "我们刚讨论过星巴克的抹茶拿铁做法",
-      llm as any,
-    );
-
-    expect(result.action).toBe("skip");
-    expect(result.reason).toBe("llm-skip");
-    expect(result.existingText).toBe("我喜欢喝星巴克的抹茶拿铁");
-    expect(llmCalls).toBe(1);
-  });
-
-  it("stores a new reply-style preference instead of collapsing different style traits into one topic", async () => {
-    let llmCalls = 0;
-    const store = {
-      async vectorSearch() {
-        return [
-          buildSearchResult("User prefers concise, direct replies.", 0.91),
-        ];
-      },
-    };
-    const llm = {
-      async dedupDecision() {
-        llmCalls += 1;
-        return { action: "SKIP" as const, reason: "same topic" };
-      },
-    };
-
-    const result = await dedupCheck(
-      store as any,
-      [1, 0, 0],
-      "User prefers colloquial, grounded replies.",
-      llm as any,
-    );
-
-    expect(result.action).toBe("store");
-    expect(result.reason).toBe("unique");
-    expect(result.existingText).toBe("User prefers concise, direct replies.");
-    expect(llmCalls).toBe(0);
-  });
-
-  it("does not trigger the reply-style guard for descriptive text about a draft", async () => {
-    let llmCalls = 0;
-    const store = {
-      async vectorSearch() {
-        return [
-          buildSearchResult("User prefers colloquial, grounded replies.", 0.75),
-        ];
-      },
-    };
-    const llm = {
-      async dedupDecision() {
-        llmCalls += 1;
-        return { action: "SKIP" as const, reason: "draft note, not a user preference" };
-      },
-    };
-
-    const result = await dedupCheck(
-      store as any,
-      [1, 0, 0],
-      "这段文案简洁直接，先别改。",
-      llm as any,
-    );
-
-    expect(result.action).toBe("skip");
-    expect(result.reason).toBe("llm-skip");
-    expect(result.existingText).toBe("User prefers colloquial, grounded replies.");
-    expect(llmCalls).toBe(1);
-  });
-
-  it("stores a new tool-choice preference instead of collapsing different tool choices into one topic", async () => {
-    let llmCalls = 0;
-    const store = {
-      async vectorSearch() {
-        return [
-          buildSearchResult("Uses Bun over Node.", 0.91),
-        ];
-      },
-    };
-    const llm = {
-      async dedupDecision() {
-        llmCalls += 1;
-        return { action: "SKIP" as const, reason: "same topic" };
-      },
-    };
-
-    const result = await dedupCheck(
-      store as any,
-      [1, 0, 0],
-      "Prefers rg over grep.",
-      llm as any,
-    );
-
-    expect(result.action).toBe("store");
-    expect(result.reason).toBe("unique");
-    expect(result.existingText).toBe("Uses Bun over Node.");
-    expect(llmCalls).toBe(0);
-  });
-
-  it("does not trigger the tool-choice guard for narrative migration text", async () => {
-    let llmCalls = 0;
-    const store = {
-      async vectorSearch() {
-        return [
-          buildSearchResult("Prefers rg over grep.", 0.75),
-        ];
-      },
-    };
-    const llm = {
-      async dedupDecision() {
-        llmCalls += 1;
-        return { action: "SKIP" as const, reason: "migration note, not a tool preference" };
-      },
-    };
-
-    const result = await dedupCheck(
-      store as any,
-      [1, 0, 0],
-      "文档里写了 uses Bun over Node 的迁移说明。",
-      llm as any,
-    );
-
-    expect(result.action).toBe("skip");
-    expect(result.reason).toBe("llm-skip");
-    expect(result.existingText).toBe("Prefers rg over grep.");
-    expect(llmCalls).toBe(1);
-  });
-
-  it("stores a borderline chunk when LLM says it should CREATE", async () => {
-    let llmCalls = 0;
-    const store = {
-      async vectorSearch() {
-        return [
-          buildSearchResult(
-            "A2A gateway 之前是先本地 smoke，再补 Claude SDK 配置。",
-            0.74,
-          ),
-        ];
-      },
-    };
-    const llm = {
-      async dedupDecision() {
-        llmCalls += 1;
-        return { action: "CREATE" as const, reason: "new implementation branch" };
-      },
-    };
-
-    const result = await dedupCheck(
-      store as any,
-      [1, 0, 0],
-      "A2A gateway 升级后要补 MCP transport 配置和 LaunchAgent 环境变量，不是原来的 smoke 流程。",
-      llm as any,
-    );
-
-    expect(result.action).toBe("store");
-    expect(result.reason).toBe("unique");
-    expect(llmCalls).toBe(1);
-  });
-
-  it("stores a borderline chunk when LLM says it adds new information and should MERGE", async () => {
-    let llmCalls = 0;
-    const store = {
-      async vectorSearch() {
-        return [
-          buildSearchResult(
-            "A2A 调 Claude SDK 时，可以先看 `adapters/claude.js` 里的权限相关配置。",
-            0.77,
-          ),
-        ];
-      },
-    };
-    const llm = {
-      async dedupDecision() {
-        llmCalls += 1;
-        return { action: "MERGE" as const, reason: "same topic but new implementation detail" };
-      },
-    };
-
-    const result = await dedupCheck(
-      store as any,
-      [1, 0, 0],
-      "给 A2A 调用传 permissionMode: \"dontAsk\" + allowedTools，避免 Claude SDK 在后台 HTTP handler 里卡死等权限确认。",
-      llm as any,
-    );
-
-    expect(result.action).toBe("store");
-    expect(result.reason).toBe("llm-merge");
-    expect(result.existingText).toContain("权限相关配置");
-    expect(llmCalls).toBe(1);
-  });
-
-  it("skips a hard-threshold duplicate without calling the LLM", async () => {
-    let llmCalls = 0;
-    const store = {
-      async vectorSearch() {
-        return [
-          buildSearchResult(
-            "OpenClaw provider 配置里已经写过 `ANTHROPIC_BASE_URL` 和 `ANTHROPIC_AUTH_TOKEN` 的设置方法。",
-            0.95,
-          ),
-        ];
-      },
-    };
-    const llm = {
-      async dedupDecision() {
-        llmCalls += 1;
-        return { action: "MERGE" as const, reason: "should never be called" };
-      },
-    };
-
-    const result = await dedupCheck(
-      store as any,
-      [1, 0, 0],
-      "OpenClaw provider 配置里已经写过 `ANTHROPIC_BASE_URL` 和 `ANTHROPIC_AUTH_TOKEN` 的设置方法，但这里重复了一遍。",
-      llm as any,
-    );
-
-    expect(result.action).toBe("skip");
-    expect(result.reason).toBe("hard");
-    expect(llmCalls).toBe(0);
-  });
-});

package/src/__tests__/kg-extractor.test.ts

@@ -1,184 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { normalizeEntity, normalizePredicate, KGExtractor, isKGModeEnabled } from "../kg-extractor.js";
-
-function createMockLlm(response: unknown) {
-  return {
-    lastSystem: null as string | null,
-    lastUser: null as string | null,
-    async chatJson(_system: string, _user: string) {
-      this.lastSystem = _system;
-      this.lastUser = _user;
-      return response;
-    },
-    // Stub remaining LLMClient methods
-    async generateL0() { return null; },
-    async generateL1() { return null; },
-    async smartExtract() { return null; },
-    async smartExtractBatch() { return []; },
-    async dedupDecision() { return null; },
-    async dedupBatch() { return []; },
-    async mergeTexts() { return null; },
-    async preferenceMatch() { return null; },
-    async ping() { return false; },
-  } as any;
-}
-
-function createMockKGStore() {
-  return {
-    storedTriples: [] as any[],
-    async createTriples(triples: any[]) {
-      const result = triples.map((t: any, i: number) => ({
-        ...t,
-        id: `mock-${i}`,
-        timestamp: Date.now(),
-      }));
-      this.storedTriples.push(...result);
-      return result;
-    },
-  } as any;
-}
-
-describe("normalizeEntity", () => {
-  it("trims and collapses whitespace", () => {
-    expect(normalizeEntity("  Hello   World  ")).toBe("Hello World");
-  });
-  it("converts to title case", () => {
-    expect(normalizeEntity("alice")).toBe("Alice");
-    expect(normalizeEntity("PYTHON")).toBe("Python");
-  });
-  it("preserves CJK text", () => {
-    expect(normalizeEntity("张三")).toBe("张三");
-  });
-  it("strips quotes", () => {
-    expect(normalizeEntity('"Alice"')).toBe("Alice");
-  });
-  it("returns empty for empty input", () => {
-    expect(normalizeEntity("")).toBe("");
-  });
-});
-
-describe("normalizePredicate", () => {
-  it("converts to snake_case", () => {
-    expect(normalizePredicate("works with")).toBe("works_with");
-    expect(normalizePredicate("Created By")).toBe("created_by");
-  });
-  it("preserves CJK predicates", () => {
-    expect(normalizePredicate("属于")).toBe("属于");
-  });
-});
-
-describe("isKGModeEnabled", () => {
-  it("reads env var", () => {
-    const orig = process.env.RECALLNEST_KG_MODE;
-    try {
-      process.env.RECALLNEST_KG_MODE = "true";
-      expect(isKGModeEnabled()).toBe(true);
-      delete process.env.RECALLNEST_KG_MODE;
-      expect(isKGModeEnabled()).toBe(false);
-    } finally {
-      if (orig !== undefined) process.env.RECALLNEST_KG_MODE = orig;
-      else delete process.env.RECALLNEST_KG_MODE;
-    }
-  });
-});
-
-describe("KGExtractor.extract", () => {
-  it("extracts valid triples", async () => {
-    const llm = createMockLlm({
-      triples: [
-        { subject: "Alice", predicate: "uses", object: "Python", confidence: 0.9 },
-        { subject: "Alice", predicate: "works_at", object: "Google", confidence: 0.85 },
-      ],
-    });
-    const ext = new KGExtractor({ llmClient: llm, kgStore: createMockKGStore() });
-    const triples = await ext.extract("Alice uses Python at Google");
-    expect(triples.length).toBe(2);
-    expect(triples[0].subject).toBe("Alice");
-  });
-
-  it("filters low confidence", async () => {
-    const llm = createMockLlm({
-      triples: [
-        { subject: "Alice", predicate: "uses", object: "Python", confidence: 0.9 },
-        { subject: "Alice", predicate: "maybe", object: "Bob", confidence: 0.3 },
-      ],
-    });
-    const ext = new KGExtractor({ llmClient: llm, kgStore: createMockKGStore() });
-    const triples = await ext.extract("Alice uses Python and maybe Bob");
-    expect(triples.length).toBe(1);
-  });
-
-  it("normalizes entities", async () => {
-    const llm = createMockLlm({
-      triples: [{ subject: "  alice  ", predicate: "WORKS WITH", object: "bob", confidence: 0.9 }],
-    });
-    const ext = new KGExtractor({ llmClient: llm, kgStore: createMockKGStore() });
-    const triples = await ext.extract("alice works with bob");
-    expect(triples[0].subject).toBe("Alice");
-    expect(triples[0].predicate).toBe("works_with");
-    expect(triples[0].object).toBe("Bob");
-  });
-
-  it("skips self-referencing triples", async () => {
-    const llm = createMockLlm({
-      triples: [
-        { subject: "Alice", predicate: "is", object: "Alice", confidence: 0.9 },
-        { subject: "Bob", predicate: "uses", object: "Go", confidence: 0.9 },
-      ],
-    });
-    const ext = new KGExtractor({ llmClient: llm, kgStore: createMockKGStore() });
-    const triples = await ext.extract("Alice is Alice, Bob uses Go");
-    expect(triples.length).toBe(1);
-    expect(triples[0].subject).toBe("Bob");
-  });
-
-  it("deduplicates within batch", async () => {
-    const llm = createMockLlm({
-      triples: [
-        { subject: "Alice", predicate: "uses", object: "Python", confidence: 0.9 },
-        { subject: "Alice", predicate: "uses", object: "Python", confidence: 0.85 },
-      ],
-    });
-    const ext = new KGExtractor({ llmClient: llm, kgStore: createMockKGStore() });
-    expect((await ext.extract("Alice uses Python a lot")).length).toBe(1);
-  });
-
-  it("handles null LLM response", async () => {
-    const llm = createMockLlm(null);
-    const ext = new KGExtractor({ llmClient: llm, kgStore: createMockKGStore() });
-    expect((await ext.extract("Some text here")).length).toBe(0);
-  });
-
-  it("skips short text", async () => {
-    const llm = createMockLlm({ triples: [] });
-    const ext = new KGExtractor({ llmClient: llm, kgStore: createMockKGStore() });
-    expect((await ext.extract("hi")).length).toBe(0);
-    expect(llm.lastUser).toBeNull(); // LLM not called
-  });
-});
-
-describe("KGExtractor.extractAndStore", () => {
-  it("persists triples to KG store", async () => {
-    const llm = createMockLlm({
-      triples: [
-        { subject: "Alice", predicate: "uses", object: "Python", confidence: 0.9 },
-      ],
-    });
-    const kgStore = createMockKGStore();
-    const ext = new KGExtractor({ llmClient: llm, kgStore });
-    const count = await ext.extractAndStore("Alice uses Python", "mem-001", "global");
-    expect(count).toBe(1);
-    expect(kgStore.storedTriples[0].scope).toBe("global");
-    expect(kgStore.storedTriples[0].source_memory_id).toBe("mem-001");
-  });
-
-  it("caps source_text at 500 chars", async () => {
-    const llm = createMockLlm({
-      triples: [{ subject: "A", predicate: "uses", object: "B", confidence: 0.9 }],
-    });
-    const kgStore = createMockKGStore();
-    const ext = new KGExtractor({ llmClient: llm, kgStore });
-    await ext.extractAndStore("x".repeat(1000), "mem-001", "global");
-    expect(kgStore.storedTriples[0].source_text.length).toBe(500);
-  });
-});