recallnest 1.4.1 → 2.2.0

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

@@ -0,0 +1,416 @@
+/**
+ * Tests for HP-predictive Phase 5: Predictive Prospective Memory
+ *
+ * Validates:
+ * 1. suggestPredictedReminders() generates and stores predicted reminders
+ * 2. Deduplication via vector similarity
+ * 3. Predicted reminders stored with ephemeral privacy tier + 7-day expiry
+ * 4. acceptPredictedReminder() upgrades predicted → explicit + durable
+ * 5. demotePredictedReminder() reduces confidence, expires below threshold
+ * 6. formatSuggestedReminders() output format
+ * 7. Feature flag gating
+ * 8. setReminder() marks source as "explicit"
+ */
+import { describe, expect, it, beforeEach, afterEach } from "bun:test";
+import {
+  setReminder,
+  suggestPredictedReminders,
+  acceptPredictedReminder,
+  demotePredictedReminder,
+  formatSuggestedReminders,
+  type SuggestedReminder,
+  type ProspectiveMetadata,
+} from "../prospective-memory.js";
+import type { MemoryEntry, MemorySearchResult } from "../store.js";
+import type { PredictionContext } from "../prediction-engine.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function createMockStore() {
+  const data = new Map<string, MemoryEntry>();
+  let idCounter = 0;
+
+  return {
+    data,
+    async store(entry: Omit<MemoryEntry, "id" | "timestamp">) {
+      const id = `predicted-${++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[]> {
+      // By default, return no duplicates (empty = no existing similar reminders)
+      return [];
+    },
+    async getById(id: string) {
+      return data.get(id) ?? null;
+    },
+    async update(id: string, upd: { metadata?: string; text?: string; importance?: number }, _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;
+      if (upd.importance !== undefined) entry.importance = upd.importance;
+      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]);
+    },
+  };
+}
+
+function makePredictionContext(overrides?: Partial<PredictionContext>): PredictionContext {
+  const now = new Date("2026-04-11T12:00:00Z");
+  return {
+    checkpoints: [{
+      checkpointId: "cp-1",
+      sessionId: "test-session",
+      resolvedScope: "test",
+      scope: "test",
+      summary: "test",
+      task: "test",
+      decisions: [],
+      openLoops: ["Fix CI pipeline", "Review PR #42"],
+      nextActions: [],
+      entities: [],
+      files: [],
+      updatedAt: new Date(now.getTime() - 48 * 60 * 60 * 1000).toISOString(), // 48h ago
+    }],
+    workflowObservations: [],
+    frequentMemories: [],
+    uncoveredTopics: [],
+    now,
+    ...overrides,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Feature flag helpers
+// ---------------------------------------------------------------------------
+
+let originalEnv: string | undefined;
+
+function enablePredictiveMemory() {
+  originalEnv = process.env.RECALLNEST_PREDICTIVE_MEMORY;
+  process.env.RECALLNEST_PREDICTIVE_MEMORY = "true";
+}
+
+function disablePredictiveMemory() {
+  if (originalEnv === undefined) {
+    delete process.env.RECALLNEST_PREDICTIVE_MEMORY;
+  } else {
+    process.env.RECALLNEST_PREDICTIVE_MEMORY = originalEnv;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// suggestPredictedReminders
+// ---------------------------------------------------------------------------
+
+describe("suggestPredictedReminders", () => {
+  beforeEach(enablePredictiveMemory);
+  afterEach(disablePredictiveMemory);
+
+  it("generates predicted reminders from stale open loops", async () => {
+    const store = createMockStore();
+    const embedder = createMockEmbedder();
+    const ctx = makePredictionContext();
+
+    const suggestions = await suggestPredictedReminders(store as any, embedder as any, ctx, "test");
+
+    expect(suggestions.length).toBeGreaterThan(0);
+    const fixCi = suggestions.find(s => s.trigger === "Fix CI pipeline");
+    expect(fixCi).toBeTruthy();
+    expect(fixCi!.confidence).toBeGreaterThanOrEqual(0.6);
+    expect(fixCi!.evidence.length).toBeGreaterThan(0);
+  });
+
+  it("stores predicted reminders with correct metadata", async () => {
+    const store = createMockStore();
+    const embedder = createMockEmbedder();
+    const ctx = makePredictionContext();
+
+    const suggestions = await suggestPredictedReminders(store as any, embedder as any, ctx, "test");
+
+    expect(suggestions.length).toBeGreaterThan(0);
+    const entry = store.data.get(suggestions[0].entryId)!;
+    expect(entry).toBeTruthy();
+
+    const meta = JSON.parse(entry.metadata);
+    expect(meta.prospective.source).toBe("predicted");
+    expect(meta.prospective.status).toBe("pending");
+    expect(meta.prospective.confidence).toBeGreaterThanOrEqual(0.6);
+    expect(meta.prospective.evidence).toBeInstanceOf(Array);
+    expect(meta.prospective.lastSuggestedAt).toBeTruthy();
+    expect(meta.prospective.expiresAt).toBeTruthy();
+    expect(meta.privacyTier).toBe("ephemeral");
+    expect(meta.boundary.layer).toBe("ephemeral");
+    expect(meta.boundary.authority).toBe("system");
+  });
+
+  it("sets lower importance (0.5) for predicted vs explicit (0.75)", async () => {
+    const store = createMockStore();
+    const embedder = createMockEmbedder();
+    const ctx = makePredictionContext();
+
+    const suggestions = await suggestPredictedReminders(store as any, embedder as any, ctx, "test");
+    const entry = store.data.get(suggestions[0].entryId)!;
+    expect(entry.importance).toBe(0.5);
+  });
+
+  it("sets 7-day expiry on predicted reminders", async () => {
+    const store = createMockStore();
+    const embedder = createMockEmbedder();
+    const now = new Date("2026-04-11T12:00:00Z");
+    const ctx = makePredictionContext({ now });
+
+    const suggestions = await suggestPredictedReminders(store as any, embedder as any, ctx, "test");
+    const entry = store.data.get(suggestions[0].entryId)!;
+    const meta = JSON.parse(entry.metadata);
+    const expiresAt = new Date(meta.prospective.expiresAt);
+    const expectedExpiry = new Date(now.getTime() + 7 * 86_400_000);
+
+    // Within 1 minute tolerance
+    expect(Math.abs(expiresAt.getTime() - expectedExpiry.getTime())).toBeLessThan(60_000);
+  });
+
+  it("returns empty when feature flag is off", async () => {
+    disablePredictiveMemory();
+    const store = createMockStore();
+    const embedder = createMockEmbedder();
+    const ctx = makePredictionContext();
+
+    const suggestions = await suggestPredictedReminders(store as any, embedder as any, ctx, "test");
+    expect(suggestions).toEqual([]);
+  });
+
+  it("deduplicates against existing pending reminders", async () => {
+    const store = createMockStore();
+    // Override vectorSearch to return an existing pending reminder
+    store.vectorSearch = async () => {
+      const entry: MemoryEntry = {
+        id: "existing-1",
+        text: "[Reminder] Fix CI pipeline",
+        vector: [0.1, 0.2, 0.3],
+        category: "patterns",
+        scope: "test",
+        importance: 0.75,
+        timestamp: Date.now(),
+        metadata: JSON.stringify({
+          prospective: { trigger: "Fix CI", action: "Fix it", status: "pending", source: "explicit", createdAt: new Date().toISOString() },
+        }),
+      };
+      return [{ entry, score: 0.9 }];
+    };
+    const embedder = createMockEmbedder();
+    const ctx = makePredictionContext();
+
+    const suggestions = await suggestPredictedReminders(store as any, embedder as any, ctx, "test");
+    // All predictions should be filtered as duplicates since vectorSearch returns matches
+    expect(suggestions.length).toBe(0);
+  });
+
+  it("returns empty for empty prediction context", async () => {
+    const store = createMockStore();
+    const embedder = createMockEmbedder();
+    const ctx: PredictionContext = {
+      checkpoints: [],
+      workflowObservations: [],
+      frequentMemories: [],
+      uncoveredTopics: [],
+    };
+
+    const suggestions = await suggestPredictedReminders(store as any, embedder as any, ctx, "test");
+    expect(suggestions).toEqual([]);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// acceptPredictedReminder
+// ---------------------------------------------------------------------------
+
+describe("acceptPredictedReminder", () => {
+  beforeEach(enablePredictiveMemory);
+  afterEach(disablePredictiveMemory);
+
+  it("upgrades predicted reminder to explicit + durable", async () => {
+    const store = createMockStore();
+    const embedder = createMockEmbedder();
+    const ctx = makePredictionContext();
+
+    const suggestions = await suggestPredictedReminders(store as any, embedder as any, ctx, "test");
+    expect(suggestions.length).toBeGreaterThan(0);
+
+    const entryId = suggestions[0].entryId;
+    const result = await acceptPredictedReminder(store as any, entryId);
+    expect(result).toBe(true);
+
+    const entry = store.data.get(entryId)!;
+    const meta = JSON.parse(entry.metadata);
+    expect(meta.prospective.source).toBe("explicit");
+    expect(meta.prospective.acceptedAt).toBeTruthy();
+    expect(meta.privacyTier).toBe("durable");
+    expect(meta.boundary.layer).toBe("durable");
+    expect(meta.boundary.authority).toBe("user");
+    expect(entry.importance).toBe(0.75);
+  });
+
+  it("returns false for non-existent entry", async () => {
+    const store = createMockStore();
+    const result = await acceptPredictedReminder(store as any, "nonexistent");
+    expect(result).toBe(false);
+  });
+
+  it("returns false for explicit reminder", async () => {
+    const store = createMockStore();
+    const embedder = createMockEmbedder();
+
+    const entry = await setReminder(store as any, embedder as any, {
+      trigger: "test",
+      action: "test action",
+      scope: "test",
+    });
+
+    const result = await acceptPredictedReminder(store as any, entry.id);
+    expect(result).toBe(false);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// demotePredictedReminder
+// ---------------------------------------------------------------------------
+
+describe("demotePredictedReminder", () => {
+  beforeEach(enablePredictiveMemory);
+  afterEach(disablePredictiveMemory);
+
+  it("reduces confidence by penalty", async () => {
+    const store = createMockStore();
+    const embedder = createMockEmbedder();
+    const ctx = makePredictionContext();
+
+    const suggestions = await suggestPredictedReminders(store as any, embedder as any, ctx, "test");
+    expect(suggestions.length).toBeGreaterThan(0);
+
+    const entryId = suggestions[0].entryId;
+    const originalConfidence = suggestions[0].confidence;
+
+    const result = await demotePredictedReminder(store as any, entryId);
+    expect(result).toBe(true);
+
+    const entry = store.data.get(entryId)!;
+    const meta = JSON.parse(entry.metadata);
+    const newConfidence = meta.prospective.confidence;
+    expect(newConfidence).toBeLessThan(originalConfidence);
+  });
+
+  it("expires reminder when confidence drops below threshold", async () => {
+    const store = createMockStore();
+    const embedder = createMockEmbedder();
+    const ctx = makePredictionContext();
+
+    const suggestions = await suggestPredictedReminders(store as any, embedder as any, ctx, "test");
+    expect(suggestions.length).toBeGreaterThan(0);
+
+    const entryId = suggestions[0].entryId;
+
+    // Manually set confidence just above threshold so one demote pushes below
+    const entry = store.data.get(entryId)!;
+    const meta = JSON.parse(entry.metadata);
+    meta.prospective.confidence = 0.65;
+    entry.metadata = JSON.stringify(meta);
+
+    const result = await demotePredictedReminder(store as any, entryId);
+    expect(result).toBe(true);
+
+    const updated = JSON.parse(store.data.get(entryId)!.metadata);
+    expect(updated.prospective.status).toBe("expired");
+    expect(updated.prospective.confidence).toBeLessThan(0.6);
+  });
+
+  it("returns false for non-existent entry", async () => {
+    const store = createMockStore();
+    const result = await demotePredictedReminder(store as any, "nonexistent");
+    expect(result).toBe(false);
+  });
+
+  it("returns false for explicit reminder", async () => {
+    const store = createMockStore();
+    const embedder = createMockEmbedder();
+
+    const entry = await setReminder(store as any, embedder as any, {
+      trigger: "test",
+      action: "test action",
+      scope: "test",
+    });
+
+    const result = await demotePredictedReminder(store as any, entry.id);
+    expect(result).toBe(false);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// formatSuggestedReminders
+// ---------------------------------------------------------------------------
+
+describe("formatSuggestedReminders", () => {
+  it("formats suggestions with confidence labels", () => {
+    const suggestions: SuggestedReminder[] = [
+      { entryId: "r1", trigger: "CI", action: "Fix CI pipeline", confidence: 0.85, evidence: ["48h old open loop"] },
+      { entryId: "r2", trigger: "deploy", action: "Check deploy config", confidence: 0.72, evidence: ["workflow issue"] },
+      { entryId: "r3", trigger: "docs", action: "Update docs", confidence: 0.62, evidence: ["uncovered topic"] },
+    ];
+
+    const text = formatSuggestedReminders(suggestions);
+
+    expect(text).toContain("--- Suggested Reminders ---");
+    expect(text).toContain("[high]");
+    expect(text).toContain("[medium]");
+    expect(text).toContain("[low]");
+    expect(text).toContain("Fix CI pipeline");
+    expect(text).toContain("48h old open loop");
+  });
+
+  it("returns empty string for no suggestions", () => {
+    expect(formatSuggestedReminders([])).toBe("");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// setReminder source field
+// ---------------------------------------------------------------------------
+
+describe("setReminder source field", () => {
+  it("marks explicit reminders with source: explicit", async () => {
+    const store = createMockStore();
+    const embedder = createMockEmbedder();
+
+    const entry = await setReminder(store as any, embedder as any, {
+      trigger: "test",
+      action: "test action",
+      scope: "test",
+    });
+
+    const meta = JSON.parse(entry.metadata);
+    expect(meta.prospective.source).toBe("explicit");
+  });
+});

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

@@ -6,6 +6,7 @@ import {
   parseBrandItemPreference,
   inferReplyStylePreferenceSlot,
   inferToolChoicePreferenceSlot,
+  inferImplicitUsageSlot,
   samePreferenceSlot,
 } from "../preference-slots.js";
 
@@ -103,4 +104,102 @@ describe("preference slots", () => {
       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);
+  });
 });

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

@@ -0,0 +1,89 @@
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { expandQuery, setAliasMapPath, resetAliasMapCache } from "../query-expander.js";
+import { writeFileSync, unlinkSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+
+const TEST_DIR = join(import.meta.dir, "../../.test-data");
+const TEST_ALIAS = join(TEST_DIR, "test-alias-map.json");
+
+function cleanup() {
+  try { if (existsSync(TEST_ALIAS)) unlinkSync(TEST_ALIAS); } catch {}
+}
+
+describe("expandQuery with alias-map", () => {
+  beforeEach(() => {
+    if (!existsSync(TEST_DIR)) mkdirSync(TEST_DIR, { recursive: true });
+    cleanup();
+    resetAliasMapCache();
+  });
+  afterEach(() => {
+    cleanup();
+    resetAliasMapCache();
+  });
+
+  it("expands short query using alias-map", () => {
+    writeFileSync(TEST_ALIAS, JSON.stringify([
+      { trigger: "轮巡", expansions: ["仓库", "patrol", "repo", "每日检查"] },
+    ]));
+    setAliasMapPath(TEST_ALIAS);
+
+    const expanded = expandQuery("轮巡");
+    expect(expanded).toContain("轮巡");
+    expect(expanded).toContain("仓库");
+    expect(expanded).toContain("patrol");
+  });
+
+  it("does not expand when trigger not matched", () => {
+    writeFileSync(TEST_ALIAS, JSON.stringify([
+      { trigger: "轮巡", expansions: ["仓库", "patrol"] },
+    ]));
+    setAliasMapPath(TEST_ALIAS);
+
+    const expanded = expandQuery("部署");
+    // "部署" matches built-in synonym map, but should NOT match alias "轮巡"
+    expect(expanded).not.toContain("patrol");
+  });
+
+  it("works with empty alias-map file", () => {
+    writeFileSync(TEST_ALIAS, "[]");
+    setAliasMapPath(TEST_ALIAS);
+
+    const result = expandQuery("轮巡");
+    // Should still work (only built-in synonyms)
+    expect(result).toContain("轮巡");
+  });
+
+  it("works with missing alias-map file", () => {
+    setAliasMapPath(join(TEST_DIR, "nonexistent.json"));
+
+    const result = expandQuery("轮巡");
+    expect(result).toContain("轮巡");
+  });
+
+  it("skips expansion terms already in query", () => {
+    writeFileSync(TEST_ALIAS, JSON.stringify([
+      { trigger: "轮巡", expansions: ["轮巡", "仓库", "patrol"] },
+    ]));
+    setAliasMapPath(TEST_ALIAS);
+
+    const expanded = expandQuery("轮巡仓库");
+    // "仓库" already in query, should not be duplicated
+    const occurrences = expanded.split("仓库").length - 1;
+    expect(occurrences).toBe(1);
+  });
+
+  it("respects MAX_EXPANSION_TERMS cap", () => {
+    writeFileSync(TEST_ALIAS, JSON.stringify([
+      {
+        trigger: "测试",
+        expansions: ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"],
+      },
+    ]));
+    setAliasMapPath(TEST_ALIAS);
+
+    const expanded = expandQuery("测试");
+    // Built-in synonyms + alias expansions, but capped at MAX_EXPANSION_TERMS (5)
+    const addedTerms = expanded.replace("测试", "").trim().split(/\s+/);
+    expect(addedTerms.length).toBeLessThanOrEqual(5);
+  });
+});