recallnest 2.2.0 → 2.2.1

package/src/__tests__/context-collapse-renderer.test.ts

@@ -1,214 +0,0 @@
-/**
- * Tests for CC-7 Context Collapse Renderer + CC-2 Staleness Hints.
- */
-import { describe, expect, test } from "bun:test";
-import {
-  collapseResults,
-  extractL0,
-  extractL1,
-  extractL2,
-  estimateTokens,
-  buildStalenessHint,
-  DEFAULT_COLLAPSE_CONFIG,
-  type CollapseInput,
-} from "../context-collapse-renderer.js";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function makeInput(overrides: Partial<CollapseInput> = {}): CollapseInput {
-  return {
-    entryId: "test-id",
-    text: "This is the full text of the memory entry with details about the project.",
-    metadata: JSON.stringify({
-      l0_abstract: "Short summary of the memory",
-      l1_overview: "Overview: This is a medium-length structured overview of the memory entry.",
-    }),
-    score: 0.9,
-    timestamp: Date.now(),
-    ...overrides,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Text extraction
-// ---------------------------------------------------------------------------
-
-describe("extractL0", () => {
-  test("uses l0_abstract from metadata", () => {
-    const meta = JSON.stringify({ l0_abstract: "L0 summary text" });
-    expect(extractL0("full text here", meta)).toBe("L0 summary text");
-  });
-
-  test("uses anchor as fallback", () => {
-    const meta = JSON.stringify({ anchor: "anchor text here" });
-    expect(extractL0("full text here", meta)).toBe("anchor text here");
-  });
-
-  test("falls back to first sentence", () => {
-    expect(extractL0("First sentence here. Second sentence.", undefined)).toBe("First sentence here.");
-  });
-
-  test("truncates long text without metadata", () => {
-    const longText = "A".repeat(200);
-    const result = extractL0(longText, undefined);
-    expect(result.length).toBeLessThanOrEqual(81); // 80 + "…"
-  });
-});
-
-describe("extractL1", () => {
-  test("uses core_summary from metadata", () => {
-    const meta = JSON.stringify({ core_summary: "Core summary text" });
-    expect(extractL1("full text", meta)).toBe("Core summary text");
-  });
-
-  test("uses l1_overview from metadata", () => {
-    const meta = JSON.stringify({ l1_overview: "L1 overview text" });
-    expect(extractL1("full text", meta)).toBe("L1 overview text");
-  });
-
-  test("falls back to truncated full text", () => {
-    const longText = "A".repeat(500);
-    const result = extractL1(longText, undefined);
-    expect(result.length).toBeLessThanOrEqual(301); // 300 + "…"
-  });
-});
-
-describe("extractL2", () => {
-  test("returns full text", () => {
-    expect(extractL2("full text content")).toBe("full text content");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Token estimation
-// ---------------------------------------------------------------------------
-
-describe("estimateTokens", () => {
-  test("estimates English text", () => {
-    const tokens = estimateTokens("Hello world");
-    expect(tokens).toBeGreaterThan(0);
-    expect(tokens).toBeLessThan(20);
-  });
-
-  test("CJK characters cost more", () => {
-    const cjk = estimateTokens("你好世界");
-    const ascii = estimateTokens("abcd");
-    expect(cjk).toBeGreaterThan(ascii);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Staleness hint (CC-2)
-// ---------------------------------------------------------------------------
-
-describe("buildStalenessHint", () => {
-  test("returns undefined for recent items", () => {
-    const now = Date.now();
-    expect(buildStalenessHint(now - 3 * 86_400_000, 7, now)).toBeUndefined();
-  });
-
-  test("returns hint for old items", () => {
-    const now = Date.now();
-    const hint = buildStalenessHint(now - 30 * 86_400_000, 7, now);
-    expect(hint).toContain("30 days ago");
-    expect(hint).toContain("verify");
-  });
-
-  test("returns undefined at exact threshold", () => {
-    const now = Date.now();
-    expect(buildStalenessHint(now - 7 * 86_400_000, 7, now)).toBeUndefined();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Core collapse rendering
-// ---------------------------------------------------------------------------
-
-describe("collapseResults", () => {
-  test("renders high-score items at L2", () => {
-    const items = [makeInput({ score: 0.95 })];
-    const result = collapseResults(items);
-    expect(result).toHaveLength(1);
-    expect(result[0].renderLevel).toBe("L2");
-    expect(result[0].text).toBe(items[0].text); // Full text
-  });
-
-  test("renders medium-score items at L1", () => {
-    const items = [makeInput({ score: 0.75 })];
-    const result = collapseResults(items);
-    expect(result).toHaveLength(1);
-    expect(result[0].renderLevel).toBe("L1");
-  });
-
-  test("renders low-score items at L0", () => {
-    const items = [makeInput({ score: 0.55 })];
-    const result = collapseResults(items);
-    expect(result).toHaveLength(1);
-    expect(result[0].renderLevel).toBe("L0");
-  });
-
-  test("excludes items below L0 threshold", () => {
-    const items = [makeInput({ score: 0.30 })];
-    const result = collapseResults(items);
-    expect(result).toHaveLength(0);
-  });
-
-  test("sorts by score descending", () => {
-    const items = [
-      makeInput({ entryId: "low", score: 0.55 }),
-      makeInput({ entryId: "high", score: 0.95 }),
-      makeInput({ entryId: "mid", score: 0.75 }),
-    ];
-    const result = collapseResults(items);
-    expect(result.map(r => r.entryId)).toEqual(["high", "mid", "low"]);
-  });
-
-  test("respects token budget — downgrades when over budget", () => {
-    const longText = "A".repeat(2000);
-    const items = [
-      makeInput({ entryId: "big", text: longText, score: 0.95 }),
-      makeInput({ entryId: "small", score: 0.90 }),
-    ];
-    // Very small budget forces downgrade
-    const result = collapseResults(items, { tokenBudget: 100 });
-    // At least one should be downgraded or excluded
-    const levels = result.map(r => r.renderLevel);
-    expect(levels.some(l => l !== "L2") || result.length < 2).toBe(true);
-  });
-
-  test("adds staleness hints for old items", () => {
-    const oldTimestamp = Date.now() - 30 * 86_400_000;
-    const items = [makeInput({ score: 0.95, timestamp: oldTimestamp })];
-    const result = collapseResults(items);
-    expect(result[0].stalenessHint).toBeDefined();
-    expect(result[0].stalenessHint).toContain("30 days ago");
-  });
-
-  test("no staleness hint for recent items", () => {
-    const items = [makeInput({ score: 0.95, timestamp: Date.now() })];
-    const result = collapseResults(items);
-    expect(result[0].stalenessHint).toBeUndefined();
-  });
-
-  test("custom thresholds work", () => {
-    const items = [makeInput({ score: 0.70 })];
-    // With custom thresholds where 0.70 is L2
-    const result = collapseResults(items, {
-      thresholds: { l2: 0.60, l1: 0.40, l0: 0.20 },
-    });
-    expect(result[0].renderLevel).toBe("L2");
-  });
-
-  test("empty input returns empty output", () => {
-    expect(collapseResults([])).toEqual([]);
-  });
-
-  test("handles missing metadata gracefully", () => {
-    const items = [makeInput({ score: 0.75, metadata: undefined })];
-    const result = collapseResults(items);
-    expect(result).toHaveLength(1);
-    expect(result[0].renderLevel).toBe("L1");
-  });
-});

package/src/__tests__/context-composer-pins.test.ts

@@ -1,64 +0,0 @@
-import { describe, expect, it } from "bun:test";
-
-import type { PinAsset } from "../memory-assets.js";
-import { selectPinnedContext } from "../context-composer-pins.js";
-
-function buildPinnedAsset(overrides: Partial<PinAsset> = {}): PinAsset & { path: string } {
-  return {
-    id: overrides.id || "pin-1",
-    type: "pinned-memory",
-    createdAt: overrides.createdAt || "2026-03-20T00:00:00.000Z",
-    updatedAt: overrides.updatedAt || "2026-03-20T00:00:00.000Z",
-    title: overrides.title || "Pinned continuity note",
-    summary: overrides.summary || "Pinned continuity reminder",
-    tags: overrides.tags || [],
-    source: overrides.source || {
-      memoryId: "memory-1",
-      scope: "memory:project:recallnest",
-      timestamp: Date.parse("2026-03-20T00:00:00.000Z"),
-      metadata: {},
-    },
-    retrieval: overrides.retrieval,
-    snippet: overrides.snippet || "",
-    path: "/tmp/pin-1.json",
-  };
-}
-
-describe("context composer pins", () => {
-  it("keeps later task-specific cues from long maintenance prompts", () => {
-    const taskSeed =
-      "继续 RecallNest continuity helper boundary audit ranking scoring selection orchestration context composer stable query fallback profile forwarding gap runner isolation";
-
-    const pinnedContext = selectPinnedContext([
-      buildPinnedAsset({
-        title: "Eval runner isolation note",
-        summary: "Fresh-window replay still needs explicit runner isolation to avoid shared component skew.",
-        tags: ["recallnest", "runner", "isolation"],
-        snippet: "Runner isolation is the key safeguard when continuity previews diverge across fresh-window replay.",
-      }),
-    ], {
-      taskSeed,
-      limit: 1,
-    });
-
-    expect(pinnedContext).toHaveLength(1);
-    expect(pinnedContext[0]).toContain("Pinned: Eval runner isolation note: Fresh-window replay still needs explicit runner isolation to avoid shared component skew.");
-  });
-
-  it("ignores conversational continuation filler for vague memory-layer prompts", () => {
-    const pinnedContext = selectPinnedContext([
-      buildPinnedAsset({
-        id: "pin-visual",
-        title: "用户视觉审美偏好",
-        summary: "用户常用视觉风格是手绘涂鸦风加高对比撞色；在内容包装和配图生成时，应优先沿用这一审美方向。",
-        tags: ["审美偏好", "手绘涂鸦", "高对比撞色", "给刚才写的文章生成配图"],
-        snippet: "给刚才写的文章生成配图，风格：手绘涂鸦风+高对比撞色。",
-      }),
-    ], {
-      taskSeed: "把刚才那个 memory layer 接回去",
-      limit: 1,
-    });
-
-    expect(pinnedContext).toEqual([]);
-  });
-});

package/src/__tests__/context-composer-task-selection.test.ts

@@ -1,24 +0,0 @@
-import { describe, expect, it } from "bun:test";
-
-import { countTaskSpecificTextMatches } from "../context-composer-task-selection.js";
-
-describe("context composer task selection", () => {
-  it("keeps later task-specific cues from long maintenance prompts", () => {
-    const taskSeed =
-      "继续 RecallNest continuity helper boundary audit ranking scoring selection orchestration context composer stable query fallback profile forwarding gap runner isolation";
-
-    expect(
-      countTaskSpecificTextMatches(
-        "Case: Continuity eval profile forwarding gap Problem: sparse writing prompts still failed until the eval profile was forwarded correctly.",
-        taskSeed,
-      ),
-    ).toBeGreaterThan(0);
-
-    expect(
-      countTaskSpecificTextMatches(
-        "Case: Eval runner shared components skewed later continuity previews Problem: runner isolation broke when shared component state leaked across fresh-window replay.",
-        taskSeed,
-      ),
-    ).toBeGreaterThan(0);
-  });
-});

package/src/__tests__/context-reconstructor.test.ts

@@ -1,65 +0,0 @@
-import { describe, test, expect } from "bun:test";
-import {
-  shouldReconstruct,
-  extractCitedIds,
-  removeSentencesWithId,
-  computeCoverage,
-} from "../context-reconstructor.js";
-
-describe("reconstruction gate", () => {
-  test("false when flag off", () => {
-    expect(shouldReconstruct({ flagEnabled: false, callerOptIn: true, resultCount: 5, llmAvailable: true })).toBe(false);
-  });
-  test("false when no opt-in", () => {
-    expect(shouldReconstruct({ flagEnabled: true, callerOptIn: false, resultCount: 5, llmAvailable: true })).toBe(false);
-  });
-  test("false when too few results", () => {
-    expect(shouldReconstruct({ flagEnabled: true, callerOptIn: true, resultCount: 2, llmAvailable: true })).toBe(false);
-  });
-  test("false when LLM down", () => {
-    expect(shouldReconstruct({ flagEnabled: true, callerOptIn: true, resultCount: 5, llmAvailable: false })).toBe(false);
-  });
-  test("true when all conditions met", () => {
-    expect(shouldReconstruct({ flagEnabled: true, callerOptIn: true, resultCount: 5, llmAvailable: true })).toBe(true);
-  });
-});
-
-describe("extractCitedIds", () => {
-  test("extracts [src:ID] references", () => {
-    expect(extractCitedIds("A [src:abc]. B [src:def].")).toEqual(["abc", "def"]);
-  });
-  test("empty for no citations", () => {
-    expect(extractCitedIds("No refs.")).toEqual([]);
-  });
-  test("deduplicates", () => {
-    expect(extractCitedIds("A [src:abc]. B [src:abc].")).toEqual(["abc"]);
-  });
-});
-
-describe("removeSentencesWithId", () => {
-  test("removes sentence with invalid ID", () => {
-    const text = "Valid [src:real]. Fake [src:bad]. Also valid [src:ok].";
-    const result = removeSentencesWithId(text, "bad");
-    expect(result).toContain("[src:real]");
-    expect(result).toContain("[src:ok]");
-    expect(result).not.toContain("[src:bad]");
-  });
-  test("unchanged if ID not found", () => {
-    const text = "All valid [src:a].";
-    expect(removeSentencesWithId(text, "nope")).toBe(text);
-  });
-});
-
-describe("computeCoverage", () => {
-  test("high for identical text", () => {
-    expect(computeCoverage("user prefers dark mode and typescript", ["user prefers dark mode and typescript"])).toBeGreaterThan(0.5);
-  });
-  test("low for unrelated text", () => {
-    expect(computeCoverage("quantum physics wave function particles", ["user prefers dark mode"])).toBeLessThan(0.3);
-  });
-  test("partial for mixed", () => {
-    const cov = computeCoverage("User likes TypeScript. Weather is sunny today.", ["User likes TypeScript", "User uses Bun"]);
-    expect(cov).toBeGreaterThan(0.3);
-    expect(cov).toBeLessThan(0.9);
-  });
-});

package/src/__tests__/context-renderer.test.ts

@@ -1,91 +0,0 @@
-import { describe, expect, it } from "bun:test";
-
-import { computeTermOverlap, extractTerms, renderMemories, type RenderableMemory } from "../context-renderer.js";
-
-const MEMORIES: RenderableMemory[] = [
-  { id: "a", text: "I prefer TypeScript for all projects", score: 0.8, category: "preferences" },
-  { id: "b", text: "Docker deployment pipeline for RecallNest", score: 0.75, category: "patterns" },
-  { id: "c", text: "Fixed a LanceDB indexing bug yesterday", score: 0.9, category: "cases" },
-];
-
-describe("extractTerms", () => {
-  it("removes stop words and short words", () => {
-    const terms = extractTerms("The quick brown fox is a great animal");
-    expect(terms.has("the")).toBe(false);
-    expect(terms.has("is")).toBe(false);
-    expect(terms.has("a")).toBe(false);
-    expect(terms.has("quick")).toBe(true);
-    expect(terms.has("brown")).toBe(true);
-  });
-
-  it("handles CJK text", () => {
-    const terms = extractTerms("我喜欢用 TypeScript 写代码");
-    expect(terms.has("typescript")).toBe(true);
-  });
-
-  it("lowercases all terms", () => {
-    const terms = extractTerms("TypeScript Docker LanceDB");
-    expect(terms.has("typescript")).toBe(true);
-    expect(terms.has("docker")).toBe(true);
-  });
-});
-
-describe("computeTermOverlap", () => {
-  it("returns 0 for empty sets", () => {
-    expect(computeTermOverlap(new Set(), new Set(["a"]))).toBe(0);
-    expect(computeTermOverlap(new Set(["a"]), new Set())).toBe(0);
-  });
-
-  it("returns 1 for identical sets", () => {
-    const s = new Set(["typescript", "docker"]);
-    expect(computeTermOverlap(s, s)).toBe(1);
-  });
-
-  it("returns partial overlap correctly", () => {
-    const a = new Set(["typescript", "docker", "lancedb"]);
-    const b = new Set(["typescript", "lancedb", "react"]);
-    // overlap=2, max(3,3)=3 → 2/3 ≈ 0.667
-    expect(computeTermOverlap(a, b)).toBeCloseTo(0.667, 2);
-  });
-});
-
-describe("renderMemories", () => {
-  it("verbatim mode preserves original order", () => {
-    const result = renderMemories(MEMORIES, "anything");
-    expect(result.mode).toBe("verbatim");
-    expect(result.memories.map(m => m.id)).toEqual(["a", "b", "c"]);
-    expect(result.memories[0].relevance).toBe(0.8);
-  });
-
-  it("highlight mode reorders by contextual relevance", () => {
-    const result = renderMemories(MEMORIES, "LanceDB indexing bug fix", "highlight");
-    expect(result.mode).toBe("highlight");
-    // Memory "c" should rank highest because it has strong term overlap with query
-    expect(result.memories[0].id).toBe("c");
-  });
-
-  it("highlight mode uses taskContext for scoring", () => {
-    const result = renderMemories(MEMORIES, "deployment", "highlight", "Docker pipeline");
-    // Memory "b" should rank high due to Docker + deployment + pipeline overlap
-    expect(result.memories[0].id).toBe("b");
-  });
-
-  it("synthesize mode processes memories", () => {
-    const result = renderMemories(MEMORIES, "TypeScript preferences", "synthesize");
-    expect(result.mode).toBe("synthesize");
-    expect(result.memories.length).toBe(3);
-  });
-
-  it("returns empty for empty input", () => {
-    const result = renderMemories([], "query", "highlight");
-    expect(result.memories.length).toBe(0);
-  });
-
-  it("relevance scores are rounded to 3 decimals in highlight mode", () => {
-    const result = renderMemories(MEMORIES, "test query", "highlight");
-    for (const m of result.memories) {
-      const decimals = String(m.relevance).split(".")[1]?.length ?? 0;
-      expect(decimals).toBeLessThanOrEqual(3);
-    }
-  });
-});