@mingxy/cerebro 1.20.4 → 1.20.6

package/src/hooks-tier2.test.ts

@@ -0,0 +1,275 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { buildMemoryInjection, chatMessageRecallHook } from "./hooks.js";
+import type { CerebroClient, SearchResult, MemoryDto } from "./client.js";
+
+// ── Helpers ──────────────────────────────────────────────────────────
+
+function makeMemoryDto(overrides: Partial<MemoryDto> = {}): MemoryDto {
+  return {
+    id: `mem-${Math.random().toString(36).slice(2, 8)}`,
+    content: "test memory content",
+    category: "cases",
+    memory_type: "WORK",
+    state: "active",
+    tags: [],
+    tenant_id: "test-tenant",
+    importance: 0.5,
+    created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
+    ...overrides,
+  };
+}
+
+function makeSearchResult(overrides: Partial<SearchResult> = {}): SearchResult {
+  return {
+    memory: makeMemoryDto(),
+    score: 0.8,
+    ...overrides,
+  };
+}
+
+function mockClient(overrides: Partial<CerebroClient> = {} as any): CerebroClient {
+  return {
+    getInjection: vi.fn().mockResolvedValue(null),
+    listRecent: vi.fn().mockResolvedValue([]),
+    searchMemories: vi.fn().mockResolvedValue([]),
+    createRecallEvent: vi.fn().mockResolvedValue(undefined),
+    ...overrides,
+  } as unknown as CerebroClient;
+}
+
+// ── buildMemoryInjection ─────────────────────────────────────────────
+
+describe("buildMemoryInjection", () => {
+  let client: CerebroClient;
+
+  beforeEach(() => {
+    client = mockClient();
+  });
+
+  it("returns injection with [CEREBRO-MEMORY] wrapper even when empty", async () => {
+    const result = await buildMemoryInjection(client, undefined, "test query", {});
+    expect(result.text).toContain("[CEREBRO-MEMORY]");
+    expect(result.text).toContain("[/CEREBRO-MEMORY]");
+    expect(result.profileCount).toBe(0);
+    expect(result.memoryCount).toBe(0);
+    expect(result.projectMemoryCount).toBe(0);
+  });
+
+  it("includes profile content when getInjection returns data", async () => {
+    client = mockClient({
+      getInjection: vi.fn().mockResolvedValue({
+        content: "User prefers TypeScript over JavaScript",
+        preference_count: 3,
+        estimated_tokens: 50,
+      }),
+    } as any);
+
+    const result = await buildMemoryInjection(client, undefined, "test query", {});
+    expect(result.text).toContain("User prefers TypeScript over JavaScript");
+    expect(result.profileCount).toBe(3);
+  });
+
+  it("includes project memories from listRecent", async () => {
+    const memories = [
+      makeMemoryDto({ id: "pm-1", content: "Fixed auth bug in login.ts" }),
+      makeMemoryDto({ id: "pm-2", content: "Added rate limiting middleware" }),
+    ];
+    client = mockClient({
+      listRecent: vi.fn().mockResolvedValue(memories),
+    } as any);
+
+    const result = await buildMemoryInjection(client, "/project", "query", {});
+    expect(result.text).toContain("## Recent Project Activity");
+    expect(result.text).toContain("Fixed auth bug in login.ts");
+    expect(result.text).toContain("Added rate limiting middleware");
+    expect(result.projectMemoryCount).toBe(2);
+  });
+
+  it("includes relevant search results deduped against project memories", async () => {
+    const projectMemory = makeMemoryDto({ id: "dup-1", content: "project memory" });
+    const searchHit: SearchResult = makeSearchResult({
+      memory: makeMemoryDto({ id: "dup-1", content: "project memory" }),
+      score: 0.9,
+    });
+    const searchHit2: SearchResult = makeSearchResult({
+      memory: makeMemoryDto({ id: "unique-1", content: "relevant search result" }),
+      score: 0.75,
+    });
+
+    client = mockClient({
+      listRecent: vi.fn().mockResolvedValue([projectMemory]),
+      searchMemories: vi.fn().mockResolvedValue([searchHit, searchHit2]),
+    } as any);
+
+    const result = await buildMemoryInjection(client, undefined, "test query", {});
+    // dup-1 should be deduped, only unique-1 in Relevant Memories
+    expect(result.text).toContain("## Relevant Memories");
+    expect(result.text).toContain("relevant search result");
+    // "project memory" appears in Recent Project Activity, not in Relevant Memories
+    const relevantIdx = result.text.indexOf("## Relevant Memories");
+    const projectIdx = result.text.indexOf("## Recent Project Activity");
+    expect(projectIdx).toBeLessThan(relevantIdx);
+    expect(result.memoryCount).toBe(1); // deduped from 2 to 1
+  });
+
+  it("respects maxContentChars config to truncate output", async () => {
+    // Return a very large memory to force truncation
+    const longContent = "A".repeat(5000);
+    client = mockClient({
+      listRecent: vi.fn().mockResolvedValue([
+        makeMemoryDto({ id: "long-1", content: longContent }),
+      ]),
+    } as any);
+
+    const result = await buildMemoryInjection(
+      client,
+      undefined,
+      "query",
+      { content: { maxContentChars: 200 } } as any,
+    );
+    expect(result.text.length).toBeLessThan(5000);
+    expect(result.text).toContain("[/CEREBRO-MEMORY]");
+  });
+
+  it("computes maxScore and confidence from search results", async () => {
+    const results: SearchResult[] = [
+      makeSearchResult({ score: 0.6 }),
+      makeSearchResult({ score: 0.9 }),
+      makeSearchResult({ score: 0.3 }),
+    ];
+    client = mockClient({
+      searchMemories: vi.fn().mockResolvedValue(results),
+    } as any);
+
+    const result = await buildMemoryInjection(client, undefined, "test", {});
+    expect(result.maxScore).toBe(0.9);
+    expect(result.confidence).toBe(0.9);
+  });
+
+  it("handles all client calls returning null/empty gracefully", async () => {
+    client = mockClient({
+      getInjection: vi.fn().mockRejectedValue(new Error("timeout")),
+      listRecent: vi.fn().mockRejectedValue(new Error("timeout")),
+      searchMemories: vi.fn().mockRejectedValue(new Error("timeout")),
+    } as any);
+
+    const result = await buildMemoryInjection(client, undefined, "test query", {});
+    expect(result.text).toContain("[CEREBRO-MEMORY]");
+    expect(result.profileCount).toBe(0);
+    expect(result.memoryCount).toBe(0);
+    expect(result.projectMemoryCount).toBe(0);
+    expect(result.maxScore).toBe(0);
+  });
+
+  it("skips search when query is empty", async () => {
+    const searchSpy = vi.fn().mockResolvedValue([]);
+    client = mockClient({ searchMemories: searchSpy } as any);
+
+    await buildMemoryInjection(client, undefined, "", {});
+    expect(searchSpy).not.toHaveBeenCalled();
+  });
+});
+
+// ── chatMessageRecallHook ────────────────────────────────────────────
+
+describe("chatMessageRecallHook", () => {
+  let client: CerebroClient;
+
+  beforeEach(() => {
+    client = mockClient();
+  });
+
+  it("returns a function", () => {
+    const hook = chatMessageRecallHook(client, [], null, {});
+    expect(typeof hook).toBe("function");
+  });
+
+  it("returned hook skips when sessionID is empty", async () => {
+    const hook = chatMessageRecallHook(client, [], null, {});
+    const input = { sessionID: "" };
+    const output = {
+      message: { id: "msg-1", content: "hello" } as any,
+      parts: [{ type: "text", text: "hello" } as any],
+    };
+    await hook(input, output);
+    expect(client.searchMemories).not.toHaveBeenCalled();
+  });
+
+  it("returned hook skips trivial messages", async () => {
+    const hook = chatMessageRecallHook(client, [], null, {});
+    const input = { sessionID: "sess-1" };
+    const output = {
+      message: { id: "msg-1", content: "hi" } as any,
+      parts: [{ type: "text", text: "hi" } as any],
+    };
+    await hook(input, output);
+    expect(client.searchMemories).not.toHaveBeenCalled();
+  });
+
+  it("returned hook injects memory for substantive messages", async () => {
+    const injectionClient = mockClient({
+      getInjection: vi.fn().mockResolvedValue({
+        content: "User profile info",
+        preference_count: 2,
+        estimated_tokens: 30,
+      }),
+      listRecent: vi.fn().mockResolvedValue([
+        makeMemoryDto({ id: "rm-1", content: "project note" }),
+      ]),
+      searchMemories: vi.fn().mockResolvedValue([
+        makeSearchResult({
+          memory: makeMemoryDto({ id: "sr-1", content: "relevant result" }),
+          score: 0.85,
+        }),
+      ]),
+    } as any);
+
+    const hook = chatMessageRecallHook(injectionClient, [], null, {});
+    const input = { sessionID: "sess-2" };
+    const output = {
+      message: { id: "msg-2", content: "how do I authenticate users?" } as any,
+      parts: [{ type: "text", text: "how do I authenticate users?" } as any],
+    };
+    await hook(input, output);
+
+    // Should have unshifted an injection part
+    expect(output.parts.length).toBe(2); // original + injected
+    expect(output.parts[0].type).toBe("text");
+    expect((output.parts[0] as any).text).toContain("[CEREBRO-MEMORY]");
+    expect((output.parts[0] as any).synthetic).toBe(true);
+  });
+
+  it("returned hook skips already-injected sessions", async () => {
+    const hook = chatMessageRecallHook(client, [], null, {});
+    const input = { sessionID: "sess-dup" };
+    const output = {
+      message: { id: "msg-3", content: "how do I authenticate?" } as any,
+      parts: [{ type: "text", text: "how do I authenticate?" } as any],
+    };
+
+    // First call may or may not inject depending on client mock,
+    // but after first injection, second call should be skipped
+    // We need a client that actually injects to add to injectedSessions
+    const richClient = mockClient({
+      getInjection: vi.fn().mockResolvedValue({
+        content: "profile",
+        preference_count: 1,
+        estimated_tokens: 10,
+      }),
+      listRecent: vi.fn().mockResolvedValue([makeMemoryDto({ id: "x", content: "m" })]),
+      searchMemories: vi.fn().mockResolvedValue([]),
+    } as any);
+
+    const hook2 = chatMessageRecallHook(richClient, [], null, {});
+    await hook2(input, output);
+    // Second call on same session should short-circuit
+    const output2 = {
+      message: { id: "msg-4", content: "another question" } as any,
+      parts: [{ type: "text", text: "another question" } as any],
+    };
+    await hook2(input, output2);
+    // getInjection should have been called only once (first call)
+    expect((richClient.getInjection as any).mock.calls.length).toBe(1);
+  });
+});