recallnest 3.0.0 → 3.0.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__/interference-detector.test.ts

@@ -1,203 +0,0 @@
-/**
- * F2: Interference Detection + Active Forgetting Gate — tests for
- * cluster detection, density measurement, RIF enhancement, and checkup.
- */
-
-import { describe, expect, test } from "bun:test";
-import {
-  detectInterference,
-  measureInterferenceDensity,
-  type InterferenceResult,
-} from "../interference-detector.js";
-import { filterInterference } from "../rif.js";
-import type { MemoryEntry } from "../store.js";
-import type { RetrievalResult } from "../retriever.js";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-/** Create a memory entry with a specific vector for clustering. */
-function makeMemory(id: string, vector: number[], importance = 0.7): MemoryEntry {
-  return {
-    id,
-    text: `memory ${id}`,
-    vector,
-    category: "events",
-    scope: "test",
-    importance,
-    timestamp: Date.now(),
-    metadata: JSON.stringify({ confidence: 0.7 }),
-  };
-}
-
-/** Create a unit vector in the given direction (for predictable cosine sim). */
-function unitVec(direction: number[], dims = 4): number[] {
-  const v = Array(dims).fill(0);
-  for (let i = 0; i < direction.length && i < dims; i++) v[i] = direction[i];
-  const norm = Math.sqrt(v.reduce((s, x) => s + x * x, 0));
-  return norm > 0 ? v.map(x => x / norm) : v;
-}
-
-function makeRetrievalResult(id: string, vector: number[], score: number): RetrievalResult {
-  return {
-    entry: makeMemory(id, vector),
-    score,
-    sources: {},
-  };
-}
-
-// ---------------------------------------------------------------------------
-// detectInterference
-// ---------------------------------------------------------------------------
-
-describe("F2: detectInterference", () => {
-  test("empty input returns empty array", () => {
-    expect(detectInterference([])).toEqual([]);
-  });
-
-  test("singleton memories have low risk", () => {
-    const m1 = makeMemory("a", unitVec([1, 0, 0, 0]));
-    const m2 = makeMemory("b", unitVec([0, 1, 0, 0])); // orthogonal — different cluster
-    const results = detectInterference([m1, m2]);
-    expect(results.length).toBe(2);
-    expect(results.every(r => r.interferenceRisk === "low")).toBe(true);
-  });
-
-  test("similar vectors form a cluster", () => {
-    const base = [1, 0.1, 0, 0];
-    const similar = [1, 0.15, 0, 0]; // very similar to base
-    const m1 = makeMemory("a", unitVec(base));
-    const m2 = makeMemory("b", unitVec(similar));
-    const m3 = makeMemory("c", unitVec([0, 0, 1, 0])); // different cluster
-    const results = detectInterference([m1, m2, m3]);
-    // m1 and m2 should be in same cluster, m3 alone
-    const clusterIds = new Set(results.map(r => r.clusterId));
-    expect(clusterIds.size).toBe(2); // 2 clusters
-  });
-
-  test("cluster rank 0 has low risk, rank 3+ has high risk", () => {
-    const v = unitVec([1, 0, 0, 0]);
-    const memories = [
-      makeMemory("a", v, 0.9),
-      makeMemory("b", v, 0.8),
-      makeMemory("c", v, 0.7),
-      makeMemory("d", v, 0.3), // weakest — should be high risk
-    ];
-    const results = detectInterference(memories);
-    // All in one cluster
-    const clusterIds = new Set(results.map(r => r.clusterId));
-    expect(clusterIds.size).toBe(1);
-    // Rank 0 is low risk
-    const topRanked = results.find(r => r.clusterRank === 0);
-    expect(topRanked?.interferenceRisk).toBe("low");
-    // Rank 3 is high risk
-    const bottomRanked = results.find(r => r.clusterRank === 3);
-    expect(bottomRanked?.interferenceRisk).toBe("high");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// measureInterferenceDensity
-// ---------------------------------------------------------------------------
-
-describe("F2: measureInterferenceDensity", () => {
-  test("no clusters → zero density", () => {
-    const memories = [
-      makeMemory("a", unitVec([1, 0, 0, 0])),
-      makeMemory("b", unitVec([0, 1, 0, 0])),
-      makeMemory("c", unitVec([0, 0, 1, 0])),
-    ];
-    const density = measureInterferenceDensity(memories);
-    expect(density.clusterCount).toBe(0);
-    expect(density.highRiskCount).toBe(0);
-    expect(density.avgClusterSize).toBe(0);
-  });
-
-  test("one cluster → density reflects cluster size", () => {
-    const v = unitVec([1, 0, 0, 0]);
-    const memories = [
-      makeMemory("a", v, 0.9),
-      makeMemory("b", v, 0.7),
-      makeMemory("c", v, 0.5),
-      makeMemory("d", v, 0.3),
-    ];
-    const density = measureInterferenceDensity(memories);
-    expect(density.clusterCount).toBe(1);
-    expect(density.avgClusterSize).toBe(4);
-    expect(density.highRiskCount).toBe(1); // rank 3 = high
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Enhanced RIF (cluster top-K)
-// ---------------------------------------------------------------------------
-
-describe("F2: Enhanced RIF with cluster top-K", () => {
-  test("cluster within top-K not demoted", () => {
-    const v = unitVec([1, 0, 0, 0]);
-    const results = [
-      makeRetrievalResult("a", v, 0.9),
-      makeRetrievalResult("b", v, 0.85),
-      makeRetrievalResult("c", v, 0.80),
-    ];
-    const filtered = filterInterference(results, 0.85, 0.80, 3);
-    // All 3 should be kept (within top-K=3)
-    expect(filtered.length).toBe(3);
-    expect(filtered[0].entry.id).toBe("a");
-  });
-
-  test("4th cluster member gets 50% score demotion", () => {
-    const v = unitVec([1, 0, 0, 0]);
-    const results = [
-      makeRetrievalResult("a", v, 0.9),
-      makeRetrievalResult("b", v, 0.85),
-      makeRetrievalResult("c", v, 0.80),
-      makeRetrievalResult("d", v, 0.75), // 4th member
-    ];
-    const filtered = filterInterference(results, 0.85, 0.80, 3);
-    // d should be at the end with 50% score
-    const d = filtered.find(r => r.entry.id === "d");
-    expect(d).toBeDefined();
-    expect(d!.score).toBeCloseTo(0.375, 2); // 0.75 * 0.5
-  });
-
-  test("diverse results unaffected by cluster top-K", () => {
-    const results = [
-      makeRetrievalResult("a", unitVec([1, 0, 0, 0]), 0.9),
-      makeRetrievalResult("b", unitVec([0, 1, 0, 0]), 0.85),
-      makeRetrievalResult("c", unitVec([0, 0, 1, 0]), 0.80),
-      makeRetrievalResult("d", unitVec([0, 0, 0, 1]), 0.75),
-    ];
-    const filtered = filterInterference(results, 0.85, 0.80, 3);
-    // All diverse — no demotion
-    expect(filtered.length).toBe(4);
-    expect(filtered.map(r => r.entry.id)).toEqual(["a", "b", "c", "d"]);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// data-checkup integration
-// ---------------------------------------------------------------------------
-
-describe("F2: data-checkup interference check", () => {
-  // We test the check function indirectly through measureInterferenceDensity
-  test("healthy density has low high-risk ratio", () => {
-    const memories = [
-      makeMemory("a", unitVec([1, 0, 0, 0])),
-      makeMemory("b", unitVec([0, 1, 0, 0])),
-      makeMemory("c", unitVec([0, 0, 1, 0])),
-    ];
-    const density = measureInterferenceDensity(memories);
-    // high-risk should be < 20% of total
-    expect(density.highRiskCount / density.totalMemories).toBeLessThan(0.2);
-  });
-
-  test("unhealthy density detected in identical vectors", () => {
-    const v = unitVec([1, 0, 0, 0]);
-    const memories = Array.from({ length: 10 }, (_, i) => makeMemory(`m${i}`, v, 0.5 - i * 0.01));
-    const density = measureInterferenceDensity(memories);
-    expect(density.clusterCount).toBe(1);
-    expect(density.highRiskCount).toBeGreaterThan(0);
-  });
-});