recallnest 1.4.1 → 2.2.1

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

@@ -1,106 +0,0 @@
-import { describe, expect, it } from "bun:test";
-
-import {
-  inferPreferenceSlot,
-  inferAtomicBrandItemPreferenceSlot,
-  parseBrandItemPreference,
-  inferReplyStylePreferenceSlot,
-  inferToolChoicePreferenceSlot,
-  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",
-    });
-  });
-});

package/src/__tests__/prospective-memory.test.ts

@@ -1,283 +0,0 @@
-/**
- * Tests for Tier 3.4: Prospective Memory (Conditional Trigger Reminders)
- *
- * Validates:
- * 1. setReminder creates a properly structured memory entry
- * 2. checkTriggers finds matching pending reminders
- * 3. checkTriggers ignores fired/expired reminders
- * 4. fireReminder marks the reminder as fired
- * 5. formatReminders produces readable output
- * 6. Trigger matching uses keyword logic
- * 7. Expiration is handled correctly
- */
-import { describe, expect, it } from "bun:test";
-import {
-  setReminder,
-  checkTriggers,
-  fireReminder,
-  formatReminders,
-} from "../prospective-memory.js";
-import type { MemoryEntry, MemorySearchResult } from "../store.js";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function createMockStore() {
-  const data = new Map<string, MemoryEntry>();
-  let idCounter = 0;
-
-  return {
-    data,
-    async store(entry: Omit<MemoryEntry, "id" | "timestamp">) {
-      const id = `reminder-${++idCounter}`;
-      const full: MemoryEntry = {
-        ...entry,
-        id,
-        timestamp: Date.now(),
-      } as MemoryEntry;
-      data.set(id, full);
-      return full;
-    },
-    async vectorSearch(
-      _vector: number[],
-      _limit: number,
-      _minScore: number,
-      _scopeFilter?: string[],
-    ): Promise<MemorySearchResult[]> {
-      return [...data.values()].map(e => ({ entry: e, score: 0.8 }));
-    },
-    async getById(id: string) {
-      return data.get(id) ?? null;
-    },
-    async update(id: string, upd: { metadata?: string; text?: string }, _scope?: string[]) {
-      const entry = data.get(id);
-      if (!entry) return null;
-      if (upd.metadata) entry.metadata = upd.metadata;
-      if (upd.text) entry.text = upd.text;
-      return entry;
-    },
-  };
-}
-
-function createMockEmbedder() {
-  return {
-    async embedPassage(_text: string) {
-      return [0.1, 0.2, 0.3];
-    },
-    async embedBatchPassage(texts: string[]) {
-      return texts.map(() => [0.1, 0.2, 0.3]);
-    },
-  };
-}
-
-// ---------------------------------------------------------------------------
-// setReminder
-// ---------------------------------------------------------------------------
-
-describe("setReminder", () => {
-  it("creates a reminder with prospective metadata", async () => {
-    const store = createMockStore();
-    const embedder = createMockEmbedder();
-
-    const entry = await setReminder(store as any, embedder as any, {
-      trigger: "deployment",
-      action: "Check the monitoring dashboard after deploy",
-      scope: "project:test",
-    });
-
-    expect(entry.id).toBeTruthy();
-    expect(entry.category).toBe("patterns");
-    expect(entry.text).toContain("Reminder");
-    expect(entry.text).toContain("deployment");
-
-    const meta = JSON.parse(entry.metadata);
-    expect(meta.prospective.trigger).toBe("deployment");
-    expect(meta.prospective.action).toBe("Check the monitoring dashboard after deploy");
-    expect(meta.prospective.status).toBe("pending");
-  });
-
-  it("creates a reminder with expiration", async () => {
-    const store = createMockStore();
-    const embedder = createMockEmbedder();
-
-    const entry = await setReminder(store as any, embedder as any, {
-      trigger: "release",
-      action: "Update changelog",
-      scope: "project:test",
-      expiresInDays: 7,
-    });
-
-    const meta = JSON.parse(entry.metadata);
-    expect(meta.prospective.expiresAt).toBeTruthy();
-    // Should expire roughly 7 days from now
-    const expiresAt = new Date(meta.prospective.expiresAt).getTime();
-    const now = Date.now();
-    const sevenDays = 7 * 86_400_000;
-    expect(expiresAt - now).toBeGreaterThan(sevenDays - 60_000);
-    expect(expiresAt - now).toBeLessThan(sevenDays + 60_000);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// checkTriggers
-// ---------------------------------------------------------------------------
-
-describe("checkTriggers", () => {
-  it("finds matching pending reminders", async () => {
-    const store = createMockStore();
-    const embedder = createMockEmbedder();
-
-    await setReminder(store as any, embedder as any, {
-      trigger: "deployment",
-      action: "Check monitoring",
-      scope: "project:test",
-    });
-
-    const reminders = await checkTriggers(
-      store as any,
-      embedder as any,
-      "We need to do a deployment today",
-    );
-
-    expect(reminders.length).toBe(1);
-    expect(reminders[0].action).toBe("Check monitoring");
-  });
-
-  it("ignores non-matching queries", async () => {
-    const store = createMockStore();
-    const embedder = createMockEmbedder();
-
-    await setReminder(store as any, embedder as any, {
-      trigger: "deployment",
-      action: "Check monitoring",
-      scope: "project:test",
-    });
-
-    const reminders = await checkTriggers(
-      store as any,
-      embedder as any,
-      "Let me review the code changes",
-    );
-
-    expect(reminders.length).toBe(0);
-  });
-
-  it("ignores fired reminders", async () => {
-    const store = createMockStore();
-    const embedder = createMockEmbedder();
-
-    const entry = await setReminder(store as any, embedder as any, {
-      trigger: "deployment",
-      action: "Check monitoring",
-      scope: "project:test",
-    });
-
-    // Fire the reminder
-    await fireReminder(store as any, entry.id);
-
-    const reminders = await checkTriggers(
-      store as any,
-      embedder as any,
-      "deployment is happening",
-    );
-
-    expect(reminders.length).toBe(0);
-  });
-
-  it("handles expired reminders", async () => {
-    const store = createMockStore();
-    const embedder = createMockEmbedder();
-
-    // Create a reminder that's already expired
-    const entry = await setReminder(store as any, embedder as any, {
-      trigger: "something",
-      action: "do something",
-      scope: "project:test",
-    });
-
-    // Manually set expiresAt to past
-    const meta = JSON.parse(entry.metadata);
-    meta.prospective.expiresAt = "2020-01-01T00:00:00Z";
-    entry.metadata = JSON.stringify(meta);
-
-    const reminders = await checkTriggers(
-      store as any,
-      embedder as any,
-      "something came up",
-    );
-
-    expect(reminders.length).toBe(0);
-    // Should be marked as expired
-    const updated = JSON.parse(entry.metadata);
-    expect(updated.prospective.status).toBe("expired");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// fireReminder
-// ---------------------------------------------------------------------------
-
-describe("fireReminder", () => {
-  it("marks reminder as fired and returns action", async () => {
-    const store = createMockStore();
-    const embedder = createMockEmbedder();
-
-    const entry = await setReminder(store as any, embedder as any, {
-      trigger: "test",
-      action: "do the thing",
-      scope: "project:test",
-    });
-
-    const action = await fireReminder(store as any, entry.id);
-
-    expect(action).toBe("do the thing");
-    const meta = JSON.parse(store.data.get(entry.id)!.metadata);
-    expect(meta.prospective.status).toBe("fired");
-    expect(meta.prospective.firedAt).toBeTruthy();
-  });
-
-  it("returns null for non-existent entry", async () => {
-    const store = createMockStore();
-    const action = await fireReminder(store as any, "nonexistent");
-    expect(action).toBeNull();
-  });
-
-  it("returns null for already-fired reminder", async () => {
-    const store = createMockStore();
-    const embedder = createMockEmbedder();
-
-    const entry = await setReminder(store as any, embedder as any, {
-      trigger: "test",
-      action: "do it",
-      scope: "project:test",
-    });
-
-    await fireReminder(store as any, entry.id);
-    const secondFire = await fireReminder(store as any, entry.id);
-
-    expect(secondFire).toBeNull();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// formatReminders
-// ---------------------------------------------------------------------------
-
-describe("formatReminders", () => {
-  it("formats reminders for context injection", () => {
-    const formatted = formatReminders([
-      { entryId: "r1", trigger: "deploy", action: "Check monitoring after deploy" },
-      { entryId: "r2", trigger: "meeting", action: "Bring up the budget issue" },
-    ]);
-
-    expect(formatted.length).toBe(2);
-    expect(formatted[0]).toContain("deploy");
-    expect(formatted[0]).toContain("Check monitoring after deploy");
-    expect(formatted[1]).toContain("meeting");
-  });
-
-  it("handles empty array", () => {
-    expect(formatReminders([])).toEqual([]);
-  });
-});

package/src/__tests__/query-entity-detector.test.ts

@@ -1,171 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { detectEntitiesSync, detectEntities } from "../query-entity-detector.js";
-
-// ============================================================================
-// Sync detection (no KG validation)
-// ============================================================================
-
-describe("detectEntitiesSync", () => {
-  describe("English entity extraction", () => {
-    it("extracts capitalized names", () => {
-      const result = detectEntitiesSync("What does Alice use?");
-      expect(result.entities).toContain("Alice");
-    });
-
-    it("extracts multi-word capitalized names", () => {
-      const result = detectEntitiesSync("Tell me about Claude Code");
-      expect(result.entities).toContain("Claude Code");
-    });
-
-    it("extracts CamelCase identifiers (normalized to title case)", () => {
-      const result = detectEntitiesSync("How does RecallNest work?");
-      // normalizeEntity applies title case: RecallNest -> Recallnest
-      expect(result.entities).toContain("Recallnest");
-    });
-
-    it("extracts quoted strings (normalized to title case)", () => {
-      const result = detectEntitiesSync('Search for "LanceDB" docs');
-      expect(result.entities).toContain("Lancedb");
-    });
-
-    it("extracts backtick-quoted strings (normalized to title case)", () => {
-      const result = detectEntitiesSync("What is `OpenAI` embedding?");
-      expect(result.entities).toContain("Openai");
-    });
-
-    it("skips stop words even when capitalized", () => {
-      const result = detectEntitiesSync("The quick brown fox");
-      // "The" should be filtered as stop word
-      expect(result.entities).not.toContain("The");
-    });
-
-    it("deduplicates entities (case-insensitive)", () => {
-      const result = detectEntitiesSync('Alice uses "alice" tool');
-      // Should have only one Alice entry
-      const aliceCount = result.entities.filter(e => e.toLowerCase() === "alice").length;
-      expect(aliceCount).toBe(1);
-    });
-
-    it("returns empty for queries without entities", () => {
-      const result = detectEntitiesSync("what happened yesterday?");
-      expect(result.entities.length).toBe(0);
-    });
-  });
-
-  describe("multi-hop detection — English", () => {
-    it("detects possessive friend pattern", () => {
-      const result = detectEntitiesSync("Alice's friends");
-      expect(result.isMultiHop).toBe(true);
-      expect(result.hopPredicate).toBe("friend_of");
-    });
-
-    it("detects 'friend of' pattern", () => {
-      const result = detectEntitiesSync("friends of Bob");
-      expect(result.isMultiHop).toBe(true);
-      expect(result.hopPredicate).toBe("friend_of");
-    });
-
-    it("detects 'what does X use' pattern", () => {
-      const result = detectEntitiesSync("what does Alice use?");
-      expect(result.isMultiHop).toBe(true);
-      expect(result.hopPredicate).toBe("uses");
-    });
-
-    it("detects 'who created' pattern", () => {
-      const result = detectEntitiesSync("who created RecallNest?");
-      expect(result.isMultiHop).toBe(true);
-      expect(result.hopPredicate).toBe("created_by");
-    });
-
-    it("detects 'who manages' pattern", () => {
-      const result = detectEntitiesSync("who manages the team?");
-      expect(result.isMultiHop).toBe(true);
-      expect(result.hopPredicate).toBe("manages");
-    });
-
-    it("detects 'X depends on' pattern", () => {
-      const result = detectEntitiesSync("what depends on LanceDB?");
-      expect(result.isMultiHop).toBe(true);
-      expect(result.hopPredicate).toBe("depends_on");
-    });
-
-    it("returns isMultiHop=false for simple queries", () => {
-      const result = detectEntitiesSync("Tell me about Python");
-      expect(result.isMultiHop).toBe(false);
-      expect(result.hopPredicate).toBeUndefined();
-    });
-  });
-
-  describe("multi-hop detection — Chinese", () => {
-    it("detects 的朋友 pattern", () => {
-      const result = detectEntitiesSync("Alice的朋友有谁？");
-      expect(result.isMultiHop).toBe(true);
-      expect(result.hopPredicate).toBe("friend_of");
-    });
-
-    it("detects 谁和X一起 pattern", () => {
-      const result = detectEntitiesSync("谁和Bob一起工作？");
-      expect(result.isMultiHop).toBe(true);
-      expect(result.hopPredicate).toBe("works_with");
-    });
-
-    it("detects 谁创建了 pattern", () => {
-      const result = detectEntitiesSync("谁创建了RecallNest？");
-      expect(result.isMultiHop).toBe(true);
-      expect(result.hopPredicate).toBe("created_by");
-    });
-
-    it("detects 依赖什么 pattern", () => {
-      const result = detectEntitiesSync("RecallNest依赖什么？");
-      expect(result.isMultiHop).toBe(true);
-      expect(result.hopPredicate).toBe("depends_on");
-    });
-  });
-});
-
-// ============================================================================
-// Async detection with KG validation
-// ============================================================================
-
-describe("detectEntities (async with mock KG)", () => {
-  function createMockKGStore(knownEntities: string[]) {
-    return {
-      async getAllEntities() {
-        return knownEntities;
-      },
-    } as any;
-  }
-
-  it("validates entities against KG", async () => {
-    const kgStore = createMockKGStore(["Alice", "Python", "LanceDB"]);
-    const result = await detectEntities("Alice uses Python and React", kgStore);
-
-    // Alice and Python are in KG, React is not
-    expect(result.entities).toContain("Alice");
-    expect(result.entities).toContain("Python");
-    expect(result.entities).not.toContain("React");
-  });
-
-  it("falls back to heuristic when KG validates nothing", async () => {
-    const kgStore = createMockKGStore([]); // empty KG
-    const result = await detectEntities("Alice uses Python", kgStore);
-
-    // Should fall back to heuristic candidates
-    expect(result.entities).toContain("Alice");
-    expect(result.entities).toContain("Python");
-  });
-
-  it("preserves KG canonical casing", async () => {
-    const kgStore = createMockKGStore(["alice"]); // lowercase in KG
-    const result = await detectEntities("Tell me about Alice", kgStore);
-
-    // Should use KG's casing
-    expect(result.entities).toContain("alice");
-  });
-
-  it("works without KG store", async () => {
-    const result = await detectEntities("Alice uses Python");
-    expect(result.entities).toContain("Alice");
-    expect(result.entities).toContain("Python");
-  });
-});

package/src/__tests__/query-expander.test.ts

@@ -1,34 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import { expandQuery } from "../query-expander.js";
-
-describe("expandQuery", () => {
-  it("expands colloquial Chinese to technical terms", () => {
-    const result = expandQuery("bot 突然挂了");
-    expect(result).toContain("崩溃");
-    expect(result).toContain("crash");
-    expect(result).toContain("挂了");
-  });
-
-  it("expands fuzzy feeling queries", () => {
-    const result = expandQuery("AI 到底有没有感受");
-    expect(result).toContain("意识");
-    expect(result).toContain("consciousness");
-    expect(result).toContain("感受");
-  });
-
-  it("preserves original query terms", () => {
-    const result = expandQuery("配图风格");
-    expect(result).toContain("配图");
-    expect(result).toContain("风格");
-  });
-
-  it("returns original for already-precise queries", () => {
-    const result = expandQuery("JINA_API_KEY");
-    expect(result).toBe("JINA_API_KEY");
-  });
-
-  it("handles empty/short queries", () => {
-    expect(expandQuery("")).toBe("");
-    expect(expandQuery("hi")).toBe("hi");
-  });
-});

package/src/__tests__/recall-mode.test.ts

@@ -1,64 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "bun:test";
-import { resolveRecallMode, type LocalMemoryConfig } from "../runtime-config.js";
-
-const baseConfig: LocalMemoryConfig = {
-  dbPath: "./data/lancedb",
-  embedding: {
-    provider: "jina",
-    apiKey: "test",
-    model: "test-model",
-  },
-  sources: {},
-};
-
-describe("resolveRecallMode", () => {
-  const originalEnv = process.env.RECALLNEST_RECALL_MODE;
-
-  beforeEach(() => {
-    delete process.env.RECALLNEST_RECALL_MODE;
-  });
-
-  afterEach(() => {
-    if (originalEnv === undefined) {
-      delete process.env.RECALLNEST_RECALL_MODE;
-    } else {
-      process.env.RECALLNEST_RECALL_MODE = originalEnv;
-    }
-  });
-
-  it("defaults to 'summary' when no config, no env, no override", () => {
-    delete process.env.RECALLNEST_RECALL_MODE;
-    expect(resolveRecallMode(baseConfig)).toBe("summary");
-  });
-
-  it("reads from config.recallMode", () => {
-    delete process.env.RECALLNEST_RECALL_MODE;
-    expect(resolveRecallMode({ ...baseConfig, recallMode: "full" })).toBe("full");
-    expect(resolveRecallMode({ ...baseConfig, recallMode: "off" })).toBe("off");
-  });
-
-  it("env var overrides config", () => {
-    process.env.RECALLNEST_RECALL_MODE = "off";
-    expect(resolveRecallMode({ ...baseConfig, recallMode: "full" })).toBe("off");
-  });
-
-  it("per-call override takes highest priority", () => {
-    process.env.RECALLNEST_RECALL_MODE = "off";
-    expect(resolveRecallMode({ ...baseConfig, recallMode: "full" }, "summary")).toBe("summary");
-  });
-
-  it("ignores invalid per-call override, falls back to env", () => {
-    process.env.RECALLNEST_RECALL_MODE = "full";
-    expect(resolveRecallMode(baseConfig, "invalid")).toBe("full");
-  });
-
-  it("ignores invalid env var, falls back to config", () => {
-    process.env.RECALLNEST_RECALL_MODE = "garbage";
-    expect(resolveRecallMode({ ...baseConfig, recallMode: "off" })).toBe("off");
-  });
-
-  it("ignores invalid env var and no config, falls back to default", () => {
-    process.env.RECALLNEST_RECALL_MODE = "garbage";
-    expect(resolveRecallMode(baseConfig)).toBe("summary");
-  });
-});