recallnest 2.6.1 → 3.0.1

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

@@ -1,282 +0,0 @@
-/**
- * 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";
-import { parseEvolution } from "../memory-evolution.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; metadata?: string }> = [];
-  const archived: MemoryEntry[] = [];
-  const data = new Map<string, MemoryEntry>();
-  for (const r of searchResults) {
-    data.set(r.entry.id, { ...r.entry });
-  }
-
-  return {
-    updates,
-    archived,
-    data,
-    async vectorSearch(
-      _vector: number[],
-      _limit: number,
-      _minScore: number,
-      _scopeFilter?: string[],
-    ) {
-      return searchResults;
-    },
-    async getById(id: string) {
-      return data.get(id) ?? null;
-    },
-    // Belief-history rows land here rather than in `data` — merging must archive the
-    // version it replaces, so tests need to see what was written.
-    async upsert(entry: MemoryEntry) {
-      archived.push(entry);
-      return entry;
-    },
-    async store(entry: MemoryEntry) {
-      archived.push(entry);
-      return entry;
-    },
-    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;
-      }
-      if (upd.metadata) {
-        entry.metadata = upd.metadata;
-      }
-      updates.push({ id, text: upd.text, metadata: upd.metadata });
-      return entry;
-    },
-  };
-}
-
-const mockDeps = {
-  embedder: {
-    async embedPassage(text: string) {
-      return [text.length, 1, 0];
-    },
-  },
-};
-
-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("ignores superseded belief-history rows as match candidates", async () => {
-    // store.vectorSearch() filters by scope only, so archived versions of a preference
-    // surface here alongside live ones. Matching against one would drop the incoming
-    // preference as a duplicate of a belief that is no longer held.
-    const archivedRow = makeEntry("p-old", "I prefer dark mode");
-    archivedRow.metadata = JSON.stringify({
-      evolution: { status: "superseded", validUntil: Date.now(), supersededBy: "p-live" },
-    });
-    const store = createMockStore([{ entry: archivedRow, score: 0.99 }]);
-
-    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",
-      mockDeps,
-    );
-
-    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",
-      mockDeps,
-    );
-
-    expect(result.handled).toBe(true);
-    expect(result.entry).toBeDefined();
-    expect(store.updates.length).toBe(1);
-    expect(store.updates[0].text).toBe("merged preference text");
-
-    // Merging replaces the target's wording — the pre-merge version must survive.
-    expect(store.archived).toHaveLength(1);
-    expect(store.archived[0].text).toBe("old preference text");
-    expect(parseEvolution(store.archived[0].metadata).status).toBe("superseded");
-    expect(parseEvolution(store.updates[0].metadata).supersedes).toBe(store.archived[0].id);
-  });
-
-  it("returns not handled for create action", async () => {
-    const store = createMockStore([]);
-    const result = await applyPreferenceMatch(
-      { action: "create", reason: "new" },
-      store as any,
-      "project:test",
-      mockDeps,
-    );
-
-    expect(result.handled).toBe(false);
-  });
-});

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

@@ -1,205 +0,0 @@
-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);
-  });
-});