recallnest 2.2.1 → 2.5.4

package/src/__tests__/preference-matcher.test.ts

@@ -0,0 +1,230 @@
+/**
+ * Tests for Tier 3.6: Preference Pattern Quick Matching
+ *
+ * Validates:
+ * 1. matchPreference returns "create" when no similar preferences exist
+ * 2. matchPreference returns "skip" for near-duplicate preferences (no LLM)
+ * 3. matchPreference uses LLM when available for decision
+ * 4. matchPreference returns "merge" with merged text from LLM
+ * 5. matchPreference handles LLM failure gracefully
+ * 6. applyPreferenceMatch handles merge and skip correctly
+ * 7. Non-preference categories are not filtered
+ */
+import { describe, expect, it } from "bun:test";
+import {
+  matchPreference,
+  applyPreferenceMatch,
+  DEFAULT_PREFERENCE_MATCHER_CONFIG,
+} from "../preference-matcher.js";
+import type { MemoryEntry, MemorySearchResult } from "../store.js";
+import type { LLMClient, DedupDecision } from "../llm-client.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeEntry(id: string, text: string, category = "preferences"): MemoryEntry {
+  return {
+    id,
+    text,
+    vector: [1, 0, 0],
+    category,
+    scope: "project:test",
+    importance: 0.7,
+    timestamp: Date.now(),
+    metadata: "{}",
+  };
+}
+
+function createMockStore(searchResults: MemorySearchResult[] = []) {
+  const updates: Array<{ id: string; text?: string }> = [];
+  const data = new Map<string, MemoryEntry>();
+  for (const r of searchResults) {
+    data.set(r.entry.id, { ...r.entry });
+  }
+
+  return {
+    updates,
+    data,
+    async vectorSearch(
+      _vector: number[],
+      _limit: number,
+      _minScore: number,
+      _scopeFilter?: string[],
+    ) {
+      return searchResults;
+    },
+    async update(id: string, upd: { text?: string; metadata?: string }, _scope?: string[]) {
+      const entry = data.get(id);
+      if (!entry) return null;
+      if (upd.text) {
+        entry.text = upd.text;
+        updates.push({ id, text: upd.text });
+      }
+      return entry;
+    },
+  };
+}
+
+function createMockLLM(dedupResult: DedupDecision, synthResult: string | null = "merged preference text"): LLMClient {
+  return {
+    async dedupDecision(_newText: string, _existingText: string) {
+      return dedupResult;
+    },
+    async synthesizeFragments(_fragments: string[], _query: string) {
+      return synthResult;
+    },
+  } as any;
+}
+
+// ---------------------------------------------------------------------------
+// matchPreference tests
+// ---------------------------------------------------------------------------
+
+describe("matchPreference", () => {
+  const vector = [1, 0, 0];
+  const scope = "project:test";
+
+  it("returns create when no similar preferences found", async () => {
+    const store = createMockStore([]);
+    const result = await matchPreference("I prefer dark mode", vector, scope, store as any, null);
+
+    expect(result.action).toBe("create");
+    expect(result.reason).toBe("no-similar-preferences");
+  });
+
+  it("returns create when matches are non-preference category", async () => {
+    const store = createMockStore([
+      { entry: makeEntry("e1", "some entity", "entities"), score: 0.85 },
+    ]);
+    const result = await matchPreference("I prefer dark mode", vector, scope, store as any, null);
+
+    expect(result.action).toBe("create");
+    expect(result.reason).toBe("no-similar-preferences");
+  });
+
+  it("returns skip for high similarity without LLM", async () => {
+    const store = createMockStore([
+      { entry: makeEntry("p1", "User prefers dark mode"), score: 0.95 },
+    ]);
+    const result = await matchPreference("I like dark mode", vector, scope, store as any, null);
+
+    expect(result.action).toBe("skip");
+    expect(result.reason).toContain("no-llm");
+  });
+
+  it("returns create for moderate similarity without LLM", async () => {
+    const store = createMockStore([
+      { entry: makeEntry("p1", "User prefers dark mode"), score: 0.82 },
+    ]);
+    const result = await matchPreference("I like vim keybindings", vector, scope, store as any, null);
+
+    expect(result.action).toBe("create");
+    expect(result.reason).toContain("no-llm");
+  });
+
+  it("uses LLM to decide SKIP", async () => {
+    const store = createMockStore([
+      { entry: makeEntry("p1", "User prefers dark mode"), score: 0.85 },
+    ]);
+    const llm = createMockLLM({ action: "SKIP", reason: "same preference" });
+
+    const result = await matchPreference("I like dark mode", vector, scope, store as any, llm);
+
+    expect(result.action).toBe("skip");
+    expect(result.reason).toContain("llm-skip");
+  });
+
+  it("uses LLM to decide MERGE and generates merged text", async () => {
+    const store = createMockStore([
+      { entry: makeEntry("p1", "User prefers dark mode"), score: 0.85 },
+    ]);
+    const llm = createMockLLM(
+      { action: "MERGE", reason: "compatible preferences" },
+      "User prefers dark mode and compact layout",
+    );
+
+    const result = await matchPreference("I also like compact layout", vector, scope, store as any, llm);
+
+    expect(result.action).toBe("merge");
+    expect(result.mergeTargetId).toBe("p1");
+    expect(result.mergedText).toBe("User prefers dark mode and compact layout");
+  });
+
+  it("uses LLM to decide CREATE", async () => {
+    const store = createMockStore([
+      { entry: makeEntry("p1", "User prefers dark mode"), score: 0.80 },
+    ]);
+    const llm = createMockLLM({ action: "CREATE", reason: "different preference" });
+
+    const result = await matchPreference("I prefer vim keybindings", vector, scope, store as any, llm);
+
+    expect(result.action).toBe("create");
+    expect(result.reason).toContain("llm-create");
+  });
+
+  it("falls back to create on LLM failure", async () => {
+    const store = createMockStore([
+      { entry: makeEntry("p1", "User prefers dark mode"), score: 0.85 },
+    ]);
+    const llm = {
+      async dedupDecision() { throw new Error("LLM down"); },
+      async synthesizeFragments() { return null; },
+    } as any;
+
+    const result = await matchPreference("test pref", vector, scope, store as any, llm);
+
+    expect(result.action).toBe("create");
+    expect(result.reason).toBe("llm-error");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// applyPreferenceMatch tests
+// ---------------------------------------------------------------------------
+
+describe("applyPreferenceMatch", () => {
+  it("handles skip action", async () => {
+    const store = createMockStore([]);
+    const result = await applyPreferenceMatch(
+      { action: "skip", reason: "duplicate" },
+      store as any,
+      "project:test",
+    );
+
+    expect(result.handled).toBe(true);
+    expect(result.entry).toBeUndefined();
+  });
+
+  it("handles merge action — updates existing entry text", async () => {
+    const existing = makeEntry("p1", "old preference text");
+    const store = createMockStore([{ entry: existing, score: 0.9 }]);
+
+    const result = await applyPreferenceMatch(
+      {
+        action: "merge",
+        mergeTargetId: "p1",
+        mergedText: "merged preference text",
+        reason: "llm-merge",
+      },
+      store as any,
+      "project:test",
+    );
+
+    expect(result.handled).toBe(true);
+    expect(result.entry).toBeDefined();
+    expect(store.updates.length).toBe(1);
+    expect(store.updates[0].text).toBe("merged preference text");
+  });
+
+  it("returns not handled for create action", async () => {
+    const store = createMockStore([]);
+    const result = await applyPreferenceMatch(
+      { action: "create", reason: "new" },
+      store as any,
+      "project:test",
+    );
+
+    expect(result.handled).toBe(false);
+  });
+});

package/src/__tests__/preference-slots.test.ts

@@ -0,0 +1,205 @@
+import { describe, expect, it } from "bun:test";
+
+import {
+  inferPreferenceSlot,
+  inferAtomicBrandItemPreferenceSlot,
+  parseBrandItemPreference,
+  inferReplyStylePreferenceSlot,
+  inferToolChoicePreferenceSlot,
+  inferImplicitUsageSlot,
+  samePreferenceSlot,
+} from "../preference-slots.js";
+
+describe("preference slots", () => {
+  it("parses Chinese and English brand-item preferences", () => {
+    expect(parseBrandItemPreference("我喜欢喝星巴克的抹茶拿铁")).toEqual({
+      brand: "星巴克",
+      items: ["抹茶拿铁"],
+      aggregate: false,
+    });
+
+    expect(parseBrandItemPreference("我喜欢吃麦当劳的麦旋风、板烧鸡腿堡和藤椒鸡派")).toEqual({
+      brand: "麦当劳",
+      items: ["麦旋风", "板烧鸡腿堡", "藤椒鸡派"],
+      aggregate: true,
+    });
+
+    expect(parseBrandItemPreference("I like the Big Mac from McDonald's")).toEqual({
+      brand: "mcdonald's",
+      items: ["bigmac"],
+      aggregate: false,
+    });
+
+    expect(parseBrandItemPreference("我们刚讨论过星巴克的抹茶拿铁做法")).toBeNull();
+  });
+
+  it("infers atomic brand-item slots and skips aggregate preferences", () => {
+    expect(inferAtomicBrandItemPreferenceSlot("我喜欢喝星巴克的抹茶拿铁")).toEqual({
+      type: "brand-item",
+      brand: "星巴克",
+      item: "抹茶拿铁",
+    });
+
+    expect(inferAtomicBrandItemPreferenceSlot("I like Big Mac from McDonald's")).toEqual({
+      type: "brand-item",
+      brand: "mcdonald's",
+      item: "bigmac",
+    });
+
+    expect(samePreferenceSlot(
+      inferAtomicBrandItemPreferenceSlot("I like the Big Mac from McDonald's"),
+      inferAtomicBrandItemPreferenceSlot("I like Big Mac from McDonald's"),
+    )).toBe(true);
+
+    expect(inferAtomicBrandItemPreferenceSlot("我喜欢吃麦当劳的麦旋风、板烧鸡腿堡")).toBeNull();
+  });
+
+  it("infers reply-style traits from explicit reply-style preferences", () => {
+    expect(inferReplyStylePreferenceSlot("User prefers concise, direct replies.")).toEqual({
+      type: "reply-style",
+      traits: ["concise", "direct"],
+    });
+
+    expect(inferReplyStylePreferenceSlot("用户不接受浮夸/营销腔，语气要口语化、不端着。")).toEqual({
+      type: "reply-style",
+      traits: ["colloquial", "grounded"],
+    });
+  });
+
+  it("can infer reply-style slots from compact trait phrases", () => {
+    expect(inferPreferenceSlot("用户偏好短句直说。")).toEqual({
+      type: "reply-style",
+      traits: ["concise", "direct"],
+    });
+  });
+
+  it("ignores descriptive non-preference text for reply-style and tool-choice parsing", () => {
+    expect(inferReplyStylePreferenceSlot("这段文案简洁直接，先别改。")).toBeNull();
+    expect(inferReplyStylePreferenceSlot("这段文案挺口语化，先别改。")).toBeNull();
+    expect(inferToolChoicePreferenceSlot("文档里写了 uses Bun over Node 的迁移说明。")).toBeNull();
+  });
+
+  it("compares reply-style slots by normalized trait sets", () => {
+    expect(samePreferenceSlot(
+      inferReplyStylePreferenceSlot("User prefers concise, direct replies."),
+      inferReplyStylePreferenceSlot("User prefers direct concise responses."),
+    )).toBe(true);
+
+    expect(samePreferenceSlot(
+      inferReplyStylePreferenceSlot("User prefers concise, direct replies."),
+      inferReplyStylePreferenceSlot("User prefers colloquial grounded replies."),
+    )).toBe(false);
+  });
+
+  it("infers tool-choice slots from explicit comparative preferences", () => {
+    expect(inferToolChoicePreferenceSlot("Uses Bun over Node.")).toEqual({
+      type: "tool-choice",
+      preferredTool: "bun",
+      avoidedTool: "node",
+    });
+
+    expect(inferToolChoicePreferenceSlot("更喜欢用 rg 而不是 grep")).toEqual({
+      type: "tool-choice",
+      preferredTool: "rg",
+      avoidedTool: "grep",
+    });
+  });
+
+  it("detects implicit usage preferences from 'I use X' patterns", () => {
+    expect(inferImplicitUsageSlot("I use Adobe Premiere Pro for video editing.")).toEqual({
+      type: "implicit-usage",
+      subject: "adobepremierepro",
+    });
+
+    expect(inferImplicitUsageSlot("User uses Python for data analysis.")).toEqual({
+      type: "implicit-usage",
+      subject: "python",
+    });
+
+    expect(inferImplicitUsageSlot("I have been using VS Code.")).toEqual({
+      type: "implicit-usage",
+      subject: "vscode",
+    });
+  });
+
+  it("detects implicit ownership preferences from 'I have X' patterns", () => {
+    expect(inferImplicitUsageSlot("I have a Sony A7III camera")).toEqual({
+      type: "implicit-usage",
+      subject: "sonya7iii",
+    });
+
+    expect(inferImplicitUsageSlot("User bought a Canon EOS R5 camera")).toEqual({
+      type: "implicit-usage",
+      subject: "canoneosr5",
+    });
+  });
+
+  it("detects implicit activity preferences from 'I enjoy X' patterns", () => {
+    expect(inferImplicitUsageSlot("I enjoy hiking.")).toEqual({
+      type: "implicit-usage",
+      subject: "hiking",
+    });
+
+    expect(inferImplicitUsageSlot("User loves ocean views.")).toEqual({
+      type: "implicit-usage",
+      subject: "oceanviews",
+    });
+
+    expect(inferImplicitUsageSlot("I really like photography.")).toEqual({
+      type: "implicit-usage",
+      subject: "photography",
+    });
+  });
+
+  it("detects implicit interest preferences from 'I'm learning X' patterns", () => {
+    expect(inferImplicitUsageSlot("I'm learning Spanish.")).toEqual({
+      type: "implicit-usage",
+      subject: "spanish",
+    });
+
+    expect(inferImplicitUsageSlot("User is interested in machine learning.")).toEqual({
+      type: "implicit-usage",
+      subject: "machinelearning",
+    });
+  });
+
+  it("detects Chinese implicit usage preferences", () => {
+    expect(inferImplicitUsageSlot("我在用Figma做设计。")).toEqual({
+      type: "implicit-usage",
+      subject: "figma",
+    });
+
+    expect(inferImplicitUsageSlot("我在学西班牙语。")).toEqual({
+      type: "implicit-usage",
+      subject: "西班牙语",
+    });
+  });
+
+  it("rejects short/empty implicit usage subjects", () => {
+    // "I use it" → subject "it" normalizes to 2 chars — at threshold
+    expect(inferImplicitUsageSlot("I use a.")).toBeNull();
+  });
+
+  it("explicit patterns take priority over implicit in inferPreferenceSlot", () => {
+    // "I like Big Mac from McDonald's" → brand-item, not implicit-usage
+    expect(inferPreferenceSlot("I like Big Mac from McDonald's")?.type).toBe("brand-item");
+
+    // "Uses Bun over Node." → tool-choice, not implicit-usage
+    expect(inferPreferenceSlot("Uses Bun over Node.")?.type).toBe("tool-choice");
+
+    // "I use Adobe Premiere Pro for video editing." → implicit-usage (no explicit pattern matches)
+    expect(inferPreferenceSlot("I use Adobe Premiere Pro for video editing.")?.type).toBe("implicit-usage");
+  });
+
+  it("compares implicit-usage slots by normalized subject", () => {
+    expect(samePreferenceSlot(
+      inferImplicitUsageSlot("I use Adobe Premiere Pro."),
+      inferImplicitUsageSlot("User uses Adobe Premiere Pro for editing."),
+    )).toBe(true);
+
+    expect(samePreferenceSlot(
+      inferImplicitUsageSlot("I use Premiere Pro."),
+      inferImplicitUsageSlot("I use DaVinci Resolve."),
+    )).toBe(false);
+  });
+});