recallnest 3.0.0 → 3.0.1

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

@@ -1,171 +0,0 @@
-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

@@ -1,210 +0,0 @@
-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({ evolution: { status: "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

@@ -1,116 +0,0 @@
-import { describe, expect, it } from "bun:test";
-
-import { DEFAULT_CATEGORY_MIN_SCORES, DEFAULT_RETRIEVAL_CONFIG } from "../retriever.js";
-import { RETRIEVAL_PROFILES, applyRetrievalProfile } from "../retrieval-profiles.js";
-
-const ALL_CATEGORIES = ["profile", "preferences", "entities", "events", "cases", "patterns"];
-
-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);
-    }
-  });
-});
-
-describe("retrieval profiles carry scaled category thresholds", () => {
-  const scopedProfiles = ["writing", "debug", "fact-check"] as const;
-
-  it("default profile does not override category thresholds", () => {
-    expect(RETRIEVAL_PROFILES.default.overrides.categoryMinScores).toBeUndefined();
-    const { config } = applyRetrievalProfile(DEFAULT_RETRIEVAL_CONFIG, "default");
-    expect(config.categoryMinScores).toEqual(DEFAULT_RETRIEVAL_CONFIG.categoryMinScores);
-  });
-
-  // A partial map is the trap here: Retriever.minScoreFor() falls back to
-  // hardMinScore — not to DEFAULT_CATEGORY_MIN_SCORES — for unlisted categories.
-  it("every scoped profile supplies a COMPLETE category map", () => {
-    for (const name of scopedProfiles) {
-      const map = RETRIEVAL_PROFILES[name].overrides.categoryMinScores;
-      expect(map).toBeDefined();
-      expect(Object.keys(map!).sort()).toEqual([...ALL_CATEGORIES].sort());
-    }
-  });
-
-  it("thresholds track each profile's overall looseness", () => {
-    for (const name of scopedProfiles) {
-      const { overrides } = RETRIEVAL_PROFILES[name];
-      const looser = overrides.hardMinScore! < DEFAULT_RETRIEVAL_CONFIG.hardMinScore;
-      for (const category of ALL_CATEGORIES) {
-        const scaled = overrides.categoryMinScores![category];
-        const base = DEFAULT_CATEGORY_MIN_SCORES[category];
-        if (looser) {
-          expect(scaled).toBeLessThan(base);
-        } else {
-          expect(scaled).toBeGreaterThan(base);
-        }
-      }
-    }
-  });
-
-  it("preserves the relative ordering of the default map", () => {
-    const defaultOrder = [...ALL_CATEGORIES].sort(
-      (a, b) => DEFAULT_CATEGORY_MIN_SCORES[a] - DEFAULT_CATEGORY_MIN_SCORES[b],
-    );
-    for (const name of scopedProfiles) {
-      const map = RETRIEVAL_PROFILES[name].overrides.categoryMinScores!;
-      const scaledOrder = [...ALL_CATEGORIES].sort((a, b) => map[a] - map[b]);
-      expect(scaledOrder).toEqual(defaultOrder);
-    }
-  });
-
-  it("keeps every scaled threshold in valid range (0, 1)", () => {
-    for (const name of scopedProfiles) {
-      const map = RETRIEVAL_PROFILES[name].overrides.categoryMinScores!;
-      for (const threshold of Object.values(map)) {
-        expect(threshold).toBeGreaterThan(0);
-        expect(threshold).toBeLessThan(1);
-      }
-    }
-  });
-
-  it("applyRetrievalProfile propagates the map into the resolved config", () => {
-    const { config } = applyRetrievalProfile(DEFAULT_RETRIEVAL_CONFIG, "debug");
-    expect(config.categoryMinScores).toEqual(
-      RETRIEVAL_PROFILES.debug.overrides.categoryMinScores,
-    );
-  });
-
-  it("loosening and tightening both reach category admission", () => {
-    // debug (0.34) and writing (0.24) are looser than the 0.35 default …
-    const debug = applyRetrievalProfile(DEFAULT_RETRIEVAL_CONFIG, "debug").config;
-    const writing = applyRetrievalProfile(DEFAULT_RETRIEVAL_CONFIG, "writing").config;
-    expect(debug.categoryMinScores!.patterns).toBeLessThan(DEFAULT_CATEGORY_MIN_SCORES.patterns);
-    expect(writing.categoryMinScores!.events).toBeLessThan(DEFAULT_CATEGORY_MIN_SCORES.events);
-    // … and writing, being loosest, must admit more than debug.
-    expect(writing.categoryMinScores!.patterns).toBeLessThan(debug.categoryMinScores!.patterns);
-
-    // fact-check (0.38) is the only tighter profile.
-    const factCheck = applyRetrievalProfile(DEFAULT_RETRIEVAL_CONFIG, "fact-check").config;
-    expect(factCheck.categoryMinScores!.patterns).toBeGreaterThan(
-      DEFAULT_CATEGORY_MIN_SCORES.patterns,
-    );
-  });
-});