recallnest 1.4.1

package/src/__tests__/result-synthesizer.test.ts

@@ -0,0 +1,198 @@
+/**
+ * Tests for Tier 3.5: Result Synthesizer
+ *
+ * Validates:
+ * 1. synthesize() with enough fragments calls LLM
+ * 2. synthesize() returns fragments when below threshold
+ * 3. synthesize() returns fragments when no LLM
+ * 4. synthesize() handles LLM failure gracefully
+ * 5. synthesizeSection() respects RECALLNEST_SYNTHESIZE env
+ * 6. synthesizeSection() passes through when disabled
+ * 7. Single fragment returned as-is (no LLM call)
+ */
+import { describe, expect, it, beforeEach, afterEach } from "bun:test";
+import {
+  synthesize,
+  synthesizeSection,
+  isSynthesisEnabled,
+  DEFAULT_SYNTHESIZER_CONFIG,
+} from "../result-synthesizer.js";
+import type { LLMClient } from "../llm-client.js";
+
+// ---------------------------------------------------------------------------
+// Mock LLM Client
+// ---------------------------------------------------------------------------
+
+function createMockLLM(response: string | null = "Synthesized narrative."): LLMClient & { calls: Array<{ fragments: string[]; query: string }> } {
+  const calls: Array<{ fragments: string[]; query: string }> = [];
+  return {
+    calls,
+    async synthesizeFragments(fragments: string[], query: string) {
+      calls.push({ fragments, query });
+      return response;
+    },
+  } as any;
+}
+
+function createFailingLLM(): LLMClient {
+  return {
+    async synthesizeFragments() {
+      throw new Error("LLM connection failed");
+    },
+  } as any;
+}
+
+// ---------------------------------------------------------------------------
+// synthesize() tests
+// ---------------------------------------------------------------------------
+
+describe("synthesize", () => {
+  it("calls LLM when fragments >= minFragments", async () => {
+    const llm = createMockLLM("Combined narrative about user preferences.");
+    const fragments = ["Pref A: dark mode", "Pref B: vim keys", "Pref C: compact layout"];
+
+    const result = await synthesize(fragments, "user preferences", llm);
+
+    expect(result.synthesized).toBe(true);
+    expect(result.text).toBe("Combined narrative about user preferences.");
+    expect(result.reason).toBe("ok");
+    expect(llm.calls.length).toBe(1);
+    expect(llm.calls[0].query).toBe("user preferences");
+  });
+
+  it("skips synthesis when fragments < minFragments", async () => {
+    const llm = createMockLLM();
+    const fragments = ["Only one", "Two items"];
+
+    const result = await synthesize(fragments, "test", llm);
+
+    expect(result.synthesized).toBe(false);
+    expect(result.reason).toBe("below-threshold");
+    expect(result.fragments).toEqual(fragments);
+    expect(llm.calls.length).toBe(0);
+  });
+
+  it("skips synthesis when no LLM provided", async () => {
+    const fragments = ["A", "B", "C"];
+    const result = await synthesize(fragments, "test", null);
+
+    expect(result.synthesized).toBe(false);
+    expect(result.reason).toBe("no-llm");
+  });
+
+  it("handles LLM failure gracefully", async () => {
+    const llm = createFailingLLM();
+    const fragments = ["A", "B", "C"];
+
+    const result = await synthesize(fragments, "test", llm);
+
+    expect(result.synthesized).toBe(false);
+    expect(result.reason).toBe("error");
+    expect(result.fragments).toEqual(fragments);
+  });
+
+  it("handles empty LLM response", async () => {
+    const llm = createMockLLM(null);
+    const fragments = ["A", "B", "C"];
+
+    const result = await synthesize(fragments, "test", llm);
+
+    expect(result.synthesized).toBe(false);
+    expect(result.reason).toBe("empty-response");
+  });
+
+  it("handles empty fragments array", async () => {
+    const llm = createMockLLM();
+    const result = await synthesize([], "test", llm);
+
+    expect(result.synthesized).toBe(false);
+    expect(result.reason).toBe("below-threshold");
+  });
+
+  it("respects custom minFragments config", async () => {
+    const llm = createMockLLM("ok");
+    const fragments = ["A", "B"];
+
+    // Default minFragments=3, so 2 items would be below threshold
+    const result2 = await synthesize(fragments, "test", llm, { ...DEFAULT_SYNTHESIZER_CONFIG, minFragments: 2 });
+    expect(result2.synthesized).toBe(true);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// synthesizeSection() tests
+// ---------------------------------------------------------------------------
+
+describe("synthesizeSection", () => {
+  const originalEnv = process.env.RECALLNEST_SYNTHESIZE;
+
+  afterEach(() => {
+    if (originalEnv !== undefined) {
+      process.env.RECALLNEST_SYNTHESIZE = originalEnv;
+    } else {
+      delete process.env.RECALLNEST_SYNTHESIZE;
+    }
+  });
+
+  it("returns original items when RECALLNEST_SYNTHESIZE is not set", async () => {
+    delete process.env.RECALLNEST_SYNTHESIZE;
+    const items = ["A", "B", "C", "D"];
+    const llm = createMockLLM("synthesized");
+
+    const result = await synthesizeSection(items, "test", llm);
+
+    expect(result).toEqual(items);
+    expect(llm.calls.length).toBe(0);
+  });
+
+  it("synthesizes when RECALLNEST_SYNTHESIZE=true", async () => {
+    process.env.RECALLNEST_SYNTHESIZE = "true";
+    const items = ["Profile: developer", "Preference: dark mode", "Entity: project X"];
+    const llm = createMockLLM("User is a developer who prefers dark mode and works on project X.");
+
+    const result = await synthesizeSection(items, "user context", llm);
+
+    expect(result).toEqual(["User is a developer who prefers dark mode and works on project X."]);
+  });
+
+  it("returns original items when synthesis fails", async () => {
+    process.env.RECALLNEST_SYNTHESIZE = "true";
+    const items = ["A", "B", "C"];
+    const llm = createFailingLLM();
+
+    const result = await synthesizeSection(items, "test", llm);
+
+    expect(result).toEqual(items);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// isSynthesisEnabled() tests
+// ---------------------------------------------------------------------------
+
+describe("isSynthesisEnabled", () => {
+  const originalEnv = process.env.RECALLNEST_SYNTHESIZE;
+
+  afterEach(() => {
+    if (originalEnv !== undefined) {
+      process.env.RECALLNEST_SYNTHESIZE = originalEnv;
+    } else {
+      delete process.env.RECALLNEST_SYNTHESIZE;
+    }
+  });
+
+  it("returns false when env not set", () => {
+    delete process.env.RECALLNEST_SYNTHESIZE;
+    expect(isSynthesisEnabled()).toBe(false);
+  });
+
+  it("returns true when env is 'true'", () => {
+    process.env.RECALLNEST_SYNTHESIZE = "true";
+    expect(isSynthesisEnabled()).toBe(true);
+  });
+
+  it("returns false when env is other value", () => {
+    process.env.RECALLNEST_SYNTHESIZE = "false";
+    expect(isSynthesisEnabled()).toBe(false);
+  });
+});