recallnest 1.4.1

package/src/__tests__/capture-heuristic.test.ts

@@ -0,0 +1,171 @@
+import { describe, expect, it } from "bun:test";
+
+import { autoCapture, extractHeuristic, shouldCapture } from "../capture-heuristic.js";
+
+// =============================================================================
+// shouldCapture
+// =============================================================================
+
+describe("shouldCapture", () => {
+  it("rejects empty or very short text", () => {
+    expect(shouldCapture("")).toBe(false);
+    expect(shouldCapture("hi")).toBe(false);
+    expect(shouldCapture("short")).toBe(false);
+    expect(shouldCapture("a".repeat(19))).toBe(false);
+  });
+
+  it("rejects greetings (EN)", () => {
+    expect(shouldCapture("hello!")).toBe(false);
+    expect(shouldCapture("thanks!")).toBe(false);
+    expect(shouldCapture("ok")).toBe(false);
+    expect(shouldCapture("got it")).toBe(false);
+  });
+
+  it("rejects greetings (ZH)", () => {
+    expect(shouldCapture("好的")).toBe(false);
+    expect(shouldCapture("谢谢")).toBe(false);
+    expect(shouldCapture("嗯")).toBe(false);
+    expect(shouldCapture("是的")).toBe(false);
+    expect(shouldCapture("收到")).toBe(false);
+  });
+
+  it("rejects noise (denial patterns from noise-filter)", () => {
+    expect(shouldCapture("I don't have any information about that topic")).toBe(false);
+    expect(shouldCapture("No relevant memories found for your query")).toBe(false);
+  });
+
+  it("accepts meaningful text above threshold", () => {
+    expect(shouldCapture("I prefer using TypeScript for all my projects because it catches bugs early")).toBe(true);
+    expect(shouldCapture("我喜欢用 Docker 来管理本地开发环境，因为可以隔离依赖")).toBe(true);
+  });
+});
+
+// =============================================================================
+// extractHeuristic
+// =============================================================================
+
+describe("extractHeuristic", () => {
+  it("extracts preference signals (EN)", () => {
+    const items = extractHeuristic("I prefer dark mode for all my editors. The weather is nice today.");
+    expect(items.length).toBe(1);
+    expect(items[0].category).toBe("preferences");
+    expect(items[0].importance).toBe(0.8);
+    expect(items[0].sourceContext).toBe("preference signal");
+    expect(items[0].text).toContain("dark mode");
+  });
+
+  it("extracts preference signals (ZH)", () => {
+    const items = extractHeuristic("我喜欢用 Bun 而不是 Node.js 来运行 TypeScript 项目");
+    expect(items.length).toBe(1);
+    expect(items[0].category).toBe("preferences");
+    expect(items[0].text).toContain("Bun");
+  });
+
+  it("extracts identity / profile signals (EN)", () => {
+    const items = extractHeuristic("My name is Alice and I work at a cultural organization");
+    expect(items.length).toBe(1);
+    expect(items[0].category).toBe("profile");
+    expect(items[0].importance).toBe(0.9);
+  });
+
+  it("extracts identity / profile signals (ZH)", () => {
+    const items = extractHeuristic("我是一个医学出身的内容创作者，目前在做AI相关的公众号运营");
+    expect(items.length).toBe(1);
+    expect(items[0].category).toBe("profile");
+  });
+
+  it("extracts decision signals", () => {
+    const items = extractHeuristic("We decided to use LanceDB as the vector store for this project");
+    expect(items.length).toBe(1);
+    expect(items[0].category).toBe("events");
+    expect(items[0].importance).toBe(0.7);
+    expect(items[0].sourceContext).toBe("decision signal");
+  });
+
+  it("extracts correction signals with next sentence", () => {
+    const items = extractHeuristic(
+      "Actually, that's wrong. The rate limit is 200 per minute. And the sky is blue."
+    );
+    expect(items.length).toBe(1);
+    expect(items[0].category).toBe("cases");
+    expect(items[0].importance).toBe(0.85);
+    // Should include both the correction and the next sentence
+    expect(items[0].text).toContain("that's wrong");
+    expect(items[0].text).toContain("rate limit");
+  });
+
+  it("extracts explicit memory instruction signals (ZH)", () => {
+    const items = extractHeuristic("记住这个：我的 API key 过期日期是每月 15 号需要更新");
+    expect(items.length).toBe(1);
+    expect(items[0].sourceContext).toBe("explicit memory instruction");
+    expect(items[0].importance).toBe(0.85);
+  });
+
+  it("extracts pattern / workflow signals", () => {
+    const items = extractHeuristic("The workflow is: first run tests, then commit, then push to remote");
+    expect(items.length).toBe(1);
+    expect(items[0].category).toBe("patterns");
+    expect(items[0].importance).toBe(0.75);
+  });
+
+  it("extracts multiple signals from multi-sentence text", () => {
+    const items = extractHeuristic(
+      "I prefer using VS Code for editing. My name is Bob and I work at Acme Corp. We decided to migrate to AWS."
+    );
+    expect(items.length).toBe(3);
+    expect(items[0].category).toBe("preferences");
+    expect(items[1].category).toBe("profile");
+    expect(items[2].category).toBe("events");
+  });
+
+  it("caps at MAX_ITEMS_PER_TURN (5)", () => {
+    const text = [
+      "I prefer TypeScript over JavaScript.",
+      "I like dark mode.",
+      "I love coffee.",
+      "I want a fast editor.",
+      "I need good autocomplete.",
+      "I hate slow builds.",
+      "I always use ESLint.",
+    ].join(" ");
+    const items = extractHeuristic(text);
+    expect(items.length).toBeLessThanOrEqual(5);
+  });
+
+  it("returns empty for text with no signals", () => {
+    const items = extractHeuristic("The function calculates the sum of two numbers and returns the result to the caller");
+    expect(items.length).toBe(0);
+  });
+
+  it("filters out sentences shorter than minSentenceLen", () => {
+    // Short EN sentences below 15 chars should be skipped
+    const items = extractHeuristic("I like it. That is all there is to say about the matter.");
+    // "I like it" is 9 chars → filtered
+    expect(items.every((item) => item.text.length >= 15)).toBe(true);
+  });
+});
+
+// =============================================================================
+// autoCapture (integration)
+// =============================================================================
+
+describe("autoCapture", () => {
+  it("returns skippedSalience=true for noise", () => {
+    const result = autoCapture("hello!");
+    expect(result.skippedSalience).toBe(true);
+    expect(result.items.length).toBe(0);
+  });
+
+  it("returns skippedSalience=false with items for valid text", () => {
+    const result = autoCapture("I prefer using RecallNest for all my memory management needs");
+    expect(result.skippedSalience).toBe(false);
+    expect(result.items.length).toBe(1);
+    expect(result.items[0].category).toBe("preferences");
+  });
+
+  it("returns skippedSalience=false with empty items for text without signals", () => {
+    const result = autoCapture("The function calculates the sum of two numbers and returns the result to the caller");
+    expect(result.skippedSalience).toBe(false);
+    expect(result.items.length).toBe(0);
+  });
+});

package/src/__tests__/cascade-forget.test.ts

@@ -0,0 +1,210 @@
+import { describe, expect, it } from "bun:test";
+
+import {
+  cascadeForget,
+  DEFAULT_CASCADE_FORGET_CONFIG,
+  type CascadeForgetConfig,
+} from "../cascade-forget.js";
+import type { MemoryEntry, MemorySearchResult } from "../store.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeEntry(id: string, text: string, overrides: Partial<MemoryEntry> = {}): MemoryEntry {
+  return {
+    id,
+    text,
+    vector: [1, 0, 0],
+    category: "events",
+    scope: "project:test",
+    importance: 0.6,
+    timestamp: Date.now() - 7 * 86_400_000,
+    metadata: "{}",
+    ...overrides,
+  };
+}
+
+function createMockStore(
+  entries: MemoryEntry[],
+  searchResults: MemorySearchResult[] = [],
+) {
+  const data = new Map(entries.map(e => [e.id, { ...e }]));
+  const updates: Array<{ id: string; importance?: number; metadata?: string }> = [];
+
+  return {
+    updates,
+    data,
+    async vectorSearch(_vector: number[], limit = 5, minScore = 0.3, _scopeFilter?: string[]) {
+      return searchResults.filter(r => r.score >= minScore).slice(0, limit);
+    },
+    async update(id: string, upd: any, _scopeFilter?: string[]) {
+      const entry = data.get(id);
+      if (!entry) return null;
+      if (upd.importance !== undefined) entry.importance = upd.importance;
+      if (upd.metadata !== undefined) entry.metadata = upd.metadata;
+      updates.push({ id, ...upd });
+      return entry;
+    },
+  } as any;
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("cascade-forget", () => {
+  it("returns empty when forgotten entry has no vector", async () => {
+    const store = createMockStore([]);
+    const result = await cascadeForget(store, {
+      id: "forgotten-1",
+      vector: [],
+      scope: "project:test",
+    });
+    expect(result.demotedCount).toBe(0);
+  });
+
+  it("demotes related entries proportional to similarity", async () => {
+    const related1 = makeEntry("rel-1", "high similarity", { importance: 0.6 });
+    const related2 = makeEntry("rel-2", "medium similarity", { importance: 0.6 });
+
+    const searchResults: MemorySearchResult[] = [
+      { entry: related1, score: 0.95 }, // high sim → big demotion
+      { entry: related2, score: 0.75 }, // lower sim → small demotion
+    ];
+    const store = createMockStore([related1, related2], searchResults);
+
+    const result = await cascadeForget(store, {
+      id: "forgotten-1",
+      vector: [1, 0, 0],
+      scope: "project:test",
+    });
+
+    expect(result.demotedCount).toBe(2);
+
+    // High similarity (0.95): demotion = 0.3 * (0.95-0.70)/0.30 = 0.25
+    // New importance: 0.6 - 0.25 = 0.35
+    expect(store.data.get("rel-1")!.importance).toBeCloseTo(0.35, 1);
+
+    // Medium similarity (0.75): demotion = 0.3 * (0.75-0.70)/0.30 = 0.05
+    // New importance: 0.6 - 0.05 = 0.55
+    expect(store.data.get("rel-2")!.importance).toBeCloseTo(0.55, 1);
+  });
+
+  it("skips the forgotten entry itself", async () => {
+    const forgotten = makeEntry("forgotten-1", "to be forgotten", { importance: 0.6 });
+    const searchResults: MemorySearchResult[] = [
+      { entry: forgotten, score: 1.0 },
+    ];
+    const store = createMockStore([forgotten], searchResults);
+
+    const result = await cascadeForget(store, {
+      id: "forgotten-1",
+      vector: [1, 0, 0],
+      scope: "project:test",
+    });
+
+    expect(result.demotedCount).toBe(0);
+  });
+
+  it("skips already-archived entries", async () => {
+    const archived = makeEntry("arch-1", "archived", {
+      importance: 0.6,
+      metadata: JSON.stringify({ state: "archived" }),
+    });
+    const searchResults: MemorySearchResult[] = [
+      { entry: archived, score: 0.9 },
+    ];
+    const store = createMockStore([archived], searchResults);
+
+    const result = await cascadeForget(store, {
+      id: "forgotten-1",
+      vector: [1, 0, 0],
+      scope: "project:test",
+    });
+
+    expect(result.demotedCount).toBe(0);
+  });
+
+  it("respects importance floor", async () => {
+    const lowEntry = makeEntry("low-1", "already low", { importance: 0.1 });
+    const searchResults: MemorySearchResult[] = [
+      { entry: lowEntry, score: 0.95 },
+    ];
+    const store = createMockStore([lowEntry], searchResults);
+
+    const result = await cascadeForget(store, {
+      id: "forgotten-1",
+      vector: [1, 0, 0],
+      scope: "project:test",
+    });
+
+    expect(result.demotedCount).toBe(1);
+    // 0.1 - 0.25 = -0.15 → clamped to floor 0.05
+    expect(store.data.get("low-1")!.importance).toBe(0.05);
+  });
+
+  it("demotes tier when importance drops below threshold", async () => {
+    const workingEntry = makeEntry("w-1", "working tier", {
+      importance: 0.6,
+      metadata: JSON.stringify({ tier: "working" }),
+    });
+    const searchResults: MemorySearchResult[] = [
+      { entry: workingEntry, score: 0.95 },
+    ];
+    const store = createMockStore([workingEntry], searchResults);
+
+    const result = await cascadeForget(store, {
+      id: "forgotten-1",
+      vector: [1, 0, 0],
+      scope: "project:test",
+    });
+
+    expect(result.demotedCount).toBe(1);
+    const updatedMeta = JSON.parse(store.data.get("w-1")!.metadata!);
+    // Importance drops to ~0.35, below 0.5 → demoted to peripheral
+    expect(updatedMeta.tier).toBe("peripheral");
+    expect(updatedMeta.cascade_forget).toHaveLength(1);
+  });
+
+  it("respects maxDemotePerForget limit", async () => {
+    const entries: MemoryEntry[] = [];
+    const searchResults: MemorySearchResult[] = [];
+
+    for (let i = 0; i < 20; i++) {
+      const e = makeEntry(`rel-${i}`, `entry ${i}`, { importance: 0.6 });
+      entries.push(e);
+      searchResults.push({ entry: e, score: 0.85 });
+    }
+
+    const store = createMockStore(entries, searchResults);
+
+    const result = await cascadeForget(store, {
+      id: "forgotten-1",
+      vector: [1, 0, 0],
+      scope: "project:test",
+    });
+
+    expect(result.demotedCount).toBe(10); // default maxDemotePerForget
+  });
+
+  it("writes audit trail in metadata", async () => {
+    const related = makeEntry("rel-1", "related note", { importance: 0.6 });
+    const searchResults: MemorySearchResult[] = [
+      { entry: related, score: 0.85 },
+    ];
+    const store = createMockStore([related], searchResults);
+
+    await cascadeForget(store, {
+      id: "forgotten-1",
+      vector: [1, 0, 0],
+      scope: "project:test",
+    });
+
+    const meta = JSON.parse(store.data.get("rel-1")!.metadata!);
+    expect(meta.cascade_forget).toHaveLength(1);
+    expect(meta.cascade_forget[0].forgottenId).toBe("forgotte"); // first 8 chars
+    expect(meta.cascade_forget[0].from).toBe(0.6);
+    expect(typeof meta.cascade_forget[0].to).toBe("number");
+  });
+});

package/src/__tests__/category-min-scores.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it } from "bun:test";
+
+import { DEFAULT_CATEGORY_MIN_SCORES, DEFAULT_RETRIEVAL_CONFIG } from "../retriever.js";
+
+describe("DEFAULT_CATEGORY_MIN_SCORES", () => {
+  it("has entries for all 6 durable categories", () => {
+    const expected = ["profile", "preferences", "entities", "events", "cases", "patterns"];
+    for (const cat of expected) {
+      expect(DEFAULT_CATEGORY_MIN_SCORES[cat]).toBeNumber();
+    }
+  });
+
+  it("profile and preferences have lower thresholds than global hardMinScore", () => {
+    expect(DEFAULT_CATEGORY_MIN_SCORES.profile).toBeLessThan(DEFAULT_RETRIEVAL_CONFIG.hardMinScore);
+    expect(DEFAULT_CATEGORY_MIN_SCORES.preferences).toBeLessThan(DEFAULT_RETRIEVAL_CONFIG.hardMinScore);
+  });
+
+  it("cases and patterns have higher thresholds than global hardMinScore", () => {
+    expect(DEFAULT_CATEGORY_MIN_SCORES.cases).toBeGreaterThan(DEFAULT_RETRIEVAL_CONFIG.hardMinScore);
+    expect(DEFAULT_CATEGORY_MIN_SCORES.patterns).toBeGreaterThan(DEFAULT_RETRIEVAL_CONFIG.hardMinScore);
+  });
+
+  it("events threshold equals global hardMinScore", () => {
+    expect(DEFAULT_CATEGORY_MIN_SCORES.events).toBe(DEFAULT_RETRIEVAL_CONFIG.hardMinScore);
+  });
+
+  it("all thresholds are in valid range (0, 1)", () => {
+    for (const [, threshold] of Object.entries(DEFAULT_CATEGORY_MIN_SCORES)) {
+      expect(threshold).toBeGreaterThan(0);
+      expect(threshold).toBeLessThan(1);
+    }
+  });
+});

package/src/__tests__/confidence-tracker.test.ts

@@ -0,0 +1,196 @@
+import { describe, expect, it } from "bun:test";
+
+import {
+  confirmMemory,
+  correctMemory,
+  contradictMemory,
+  getConfidence,
+  applyConfidenceWeight,
+  CONFIDENCE_DEFAULT,
+  CONFIDENCE_CONFIRMED,
+  CONFIDENCE_CORRECTED,
+  CONFIDENCE_CONTRADICTED,
+} from "../confidence-tracker.js";
+import type { MemoryEntry } from "../store.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeEntry(id: string, text: string, overrides: Partial<MemoryEntry> = {}): MemoryEntry {
+  return {
+    id,
+    text,
+    vector: [1, 0, 0],
+    category: "events",
+    scope: "project:test",
+    importance: 0.7,
+    timestamp: Date.now(),
+    metadata: "{}",
+    ...overrides,
+  };
+}
+
+function createMockStore(entries: MemoryEntry[]) {
+  const data = new Map(entries.map(e => [e.id, { ...e }]));
+  const updates: Array<{ id: string; metadata?: string }> = [];
+
+  return {
+    updates,
+    data,
+    async getById(id: string) {
+      return data.get(id) ?? null;
+    },
+    async update(id: string, upd: any, _scopeFilter?: string[]) {
+      const entry = data.get(id);
+      if (!entry) return null;
+      if (upd.metadata !== undefined) entry.metadata = upd.metadata;
+      updates.push({ id, ...upd });
+      return entry;
+    },
+  } as any;
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("confidence-tracker", () => {
+  describe("getConfidence", () => {
+    it("returns default for entries without confidence", () => {
+      const entry = makeEntry("e1", "test");
+      expect(getConfidence(entry)).toBe(CONFIDENCE_DEFAULT);
+    });
+
+    it("returns stored confidence", () => {
+      const entry = makeEntry("e1", "test", {
+        metadata: JSON.stringify({ confidence: 0.9 }),
+      });
+      expect(getConfidence(entry)).toBe(0.9);
+    });
+
+    it("returns default for malformed metadata", () => {
+      const entry = makeEntry("e1", "test", { metadata: "not-json" });
+      expect(getConfidence(entry)).toBe(CONFIDENCE_DEFAULT);
+    });
+  });
+
+  describe("confirmMemory", () => {
+    it("sets confidence to 1.0", async () => {
+      const entry = makeEntry("e1", "user likes TypeScript");
+      const store = createMockStore([entry]);
+
+      const result = await confirmMemory(store, "e1", "project:test");
+      expect(result).not.toBeNull();
+      expect(result!.newConfidence).toBe(CONFIDENCE_CONFIRMED);
+      expect(result!.oldConfidence).toBe(CONFIDENCE_DEFAULT);
+
+      const meta = JSON.parse(store.data.get("e1")!.metadata!);
+      expect(meta.confidence).toBe(1.0);
+      expect(meta.confidence_history).toHaveLength(1);
+      expect(meta.confidence_history[0].action).toBe("confirmed");
+    });
+
+    it("returns null for missing entry", async () => {
+      const store = createMockStore([]);
+      const result = await confirmMemory(store, "missing", "project:test");
+      expect(result).toBeNull();
+    });
+  });
+
+  describe("correctMemory", () => {
+    it("drops confidence to 0.3", async () => {
+      const entry = makeEntry("e1", "user uses Python");
+      const store = createMockStore([entry]);
+
+      const result = await correctMemory(store, "e1", "project:test", "new-entry-id");
+      expect(result).not.toBeNull();
+      expect(result!.newConfidence).toBe(CONFIDENCE_CORRECTED);
+
+      const meta = JSON.parse(store.data.get("e1")!.metadata!);
+      expect(meta.confidence).toBe(0.3);
+      expect(meta.corrected_by).toBe("new-entry-id");
+      expect(meta.confidence_history[0].correctedBy).toBe("new-entr"); // 8 chars
+    });
+
+    it("works without correctedById", async () => {
+      const entry = makeEntry("e1", "old info");
+      const store = createMockStore([entry]);
+
+      const result = await correctMemory(store, "e1", "project:test");
+      expect(result!.newConfidence).toBe(CONFIDENCE_CORRECTED);
+
+      const meta = JSON.parse(store.data.get("e1")!.metadata!);
+      expect(meta.corrected_by).toBeUndefined();
+    });
+  });
+
+  describe("contradictMemory", () => {
+    it("drops confidence to 0.0", async () => {
+      const entry = makeEntry("e1", "wrong fact");
+      const store = createMockStore([entry]);
+
+      const result = await contradictMemory(store, "e1", "project:test");
+      expect(result).not.toBeNull();
+      expect(result!.newConfidence).toBe(CONFIDENCE_CONTRADICTED);
+
+      const meta = JSON.parse(store.data.get("e1")!.metadata!);
+      expect(meta.confidence).toBe(0.0);
+    });
+  });
+
+  describe("applyConfidenceWeight", () => {
+    it("no penalty at confidence=1.0", () => {
+      const entry = makeEntry("e1", "test", {
+        metadata: JSON.stringify({ confidence: 1.0 }),
+      });
+      expect(applyConfidenceWeight(1.0, entry)).toBe(1.0);
+    });
+
+    it("slight penalty at default confidence=0.7", () => {
+      const entry = makeEntry("e1", "test");
+      const weighted = applyConfidenceWeight(1.0, entry);
+      expect(weighted).toBeCloseTo(0.85, 2);
+    });
+
+    it("significant penalty at corrected confidence=0.3", () => {
+      const entry = makeEntry("e1", "test", {
+        metadata: JSON.stringify({ confidence: 0.3 }),
+      });
+      const weighted = applyConfidenceWeight(1.0, entry);
+      expect(weighted).toBeCloseTo(0.65, 2);
+    });
+
+    it("heavy penalty at contradicted confidence=0.0", () => {
+      const entry = makeEntry("e1", "test", {
+        metadata: JSON.stringify({ confidence: 0.0 }),
+      });
+      const weighted = applyConfidenceWeight(1.0, entry);
+      expect(weighted).toBe(0.5);
+    });
+
+    it("scales with input score", () => {
+      const entry = makeEntry("e1", "test", {
+        metadata: JSON.stringify({ confidence: 0.3 }),
+      });
+      const weighted = applyConfidenceWeight(0.8, entry);
+      expect(weighted).toBeCloseTo(0.8 * 0.65, 2);
+    });
+  });
+
+  describe("confidence history", () => {
+    it("accumulates multiple changes", async () => {
+      const entry = makeEntry("e1", "evolving fact");
+      const store = createMockStore([entry]);
+
+      await correctMemory(store, "e1", "project:test");
+      await confirmMemory(store, "e1", "project:test");
+
+      const meta = JSON.parse(store.data.get("e1")!.metadata!);
+      expect(meta.confidence_history).toHaveLength(2);
+      expect(meta.confidence_history[0].action).toBe("corrected");
+      expect(meta.confidence_history[1].action).toBe("confirmed");
+      expect(meta.confidence).toBe(CONFIDENCE_CONFIRMED);
+    });
+  });
+});