recallnest 1.4.1 → 2.2.0

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

@@ -0,0 +1,214 @@
+/**
+ * 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-reconstructor.test.ts

@@ -0,0 +1,65 @@
+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);
+  });
+});