@mingxy/cerebro 1.20.4 → 1.20.6

package/src/hooks-tier3.test.ts

@@ -0,0 +1,461 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+// --- Mocks ---
+vi.mock("./logger.js", () => ({
+  logInfo: vi.fn(),
+  logDebug: vi.fn(),
+  logError: vi.fn(),
+  setOpencodeClient: vi.fn(),
+}));
+
+vi.mock("./config.js", () => ({
+  DEFAULTS: {
+    ui: { toastDelayMs: 7000 },
+    logging: { logEnabled: false },
+    content: { maxContentChars: 6000 },
+  },
+  resolveAgentPolicy: vi.fn(() => "readwrite"),
+}));
+
+vi.mock("node:fs/promises", () => ({
+  readFile: vi.fn().mockRejectedValue("not found"),
+}));
+
+import { compactingHook, autocontinueHook, sessionIdleHook } from "./hooks.js";
+import { resolveAgentPolicy } from "./config.js";
+
+const mockCerebroClient = {
+  searchMemories: vi.fn().mockResolvedValue([]),
+  ingestMessages: vi.fn().mockResolvedValue({ id: "mem1" }),
+  sessionIngest: vi.fn().mockResolvedValue(undefined),
+};
+
+const mockTui = { showToast: vi.fn() };
+const containerTags = ["test-project"];
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  mockCerebroClient.searchMemories.mockResolvedValue([]);
+  mockCerebroClient.ingestMessages.mockResolvedValue({ id: "mem1" });
+  mockCerebroClient.sessionIngest.mockResolvedValue(undefined);
+  (resolveAgentPolicy as ReturnType<typeof vi.fn>).mockReturnValue("readwrite");
+});
+
+// ========================================
+// compactingHook
+// ========================================
+describe("compactingHook", () => {
+  it("returns an async function", () => {
+    const hook = compactingHook(mockCerebroClient as any, containerTags, mockTui);
+    expect(typeof hook).toBe("function");
+  });
+
+  it("searches memories and injects compaction prompt into output", async () => {
+    const hook = compactingHook(mockCerebroClient as any, containerTags, mockTui);
+    const input = { sessionID: "sess1" };
+    const output = { context: ["existing"], prompt: "old" };
+    await hook(input, output);
+    expect(mockCerebroClient.searchMemories).toHaveBeenCalledWith("*", 20, undefined, containerTags);
+    // output.prompt should be replaced with compaction prompt
+    expect(output.prompt).toContain("[Cerebro Compaction Context]");
+  });
+
+  it("appends to context when output.prompt is undefined", async () => {
+    const hook = compactingHook(mockCerebroClient as any, containerTags, mockTui);
+    const input = { sessionID: "sess1" };
+    const output = { context: ["existing"] };
+    await hook(input, output);
+    expect(output.context.some((c: string) => c.includes("[Cerebro Compaction Context]"))).toBe(true);
+  });
+
+  it("skips ingest when sessionMessages is empty for session", async () => {
+    const hook = compactingHook(mockCerebroClient as any, containerTags, mockTui);
+    await hook({ sessionID: "no-messages-session" }, { context: [] });
+    expect(mockCerebroClient.searchMemories).toHaveBeenCalled();
+    expect(mockCerebroClient.ingestMessages).not.toHaveBeenCalled();
+  });
+
+  it("skips write when policy is readonly", async () => {
+    (resolveAgentPolicy as ReturnType<typeof vi.fn>).mockReturnValue("readonly");
+    const hook = compactingHook(
+      mockCerebroClient as any, containerTags, mockTui, "smart",
+      undefined, undefined, undefined, {},
+    );
+    await hook({ sessionID: "readonly-sess" }, { context: [] });
+    expect(mockCerebroClient.searchMemories).toHaveBeenCalled();
+    expect(mockCerebroClient.ingestMessages).not.toHaveBeenCalled();
+  });
+
+  it("skips non-main session when getMainSessionId mismatches", async () => {
+    const getMainSessionId = vi.fn(() => "main-sess");
+    const hook = compactingHook(
+      mockCerebroClient as any, containerTags, mockTui, "smart",
+      undefined, getMainSessionId,
+    );
+    await hook({ sessionID: "sub-sess" }, { context: [] });
+    // Should return early after search phase
+    expect(mockCerebroClient.ingestMessages).not.toHaveBeenCalled();
+  });
+
+  it("gracefully handles searchMemories failure", async () => {
+    mockCerebroClient.searchMemories.mockRejectedValue(new Error("network"));
+    const hook = compactingHook(mockCerebroClient as any, containerTags, mockTui);
+    const output = { context: [] };
+    await expect(hook({ sessionID: "s1" }, output)).resolves.toBeUndefined();
+    expect(mockCerebroClient.ingestMessages).not.toHaveBeenCalled();
+  });
+});
+
+// ========================================
+// autocontinueHook
+// ========================================
+describe("autocontinueHook", () => {
+  const makeInput = (overrides = {}) => ({
+    sessionID: "sess1",
+    agent: "opencode",
+    model: { id: "test" } as any,
+    message: { id: "msg1" } as any,
+    overflow: false,
+    ...overrides,
+  });
+
+  it("returns an async function", () => {
+    const hook = autocontinueHook(mockCerebroClient as any, containerTags, mockTui);
+    expect(typeof hook).toBe("function");
+  });
+
+  it("stores summary when sdkClient returns messages with matching id (level 1 fallback)", async () => {
+    const sdkClient = {
+      session: {
+        messages: vi.fn().mockResolvedValue({
+          data: [{
+            info: { id: "msg1", role: "assistant" },
+            parts: [{ type: "text", text: "This is a summary of the session." }],
+          }],
+        }),
+        get: vi.fn().mockResolvedValue({ data: { directory: "/tmp/project" } }),
+      },
+    };
+    const hook = autocontinueHook(
+      mockCerebroClient as any, containerTags, mockTui, "smart",
+      undefined, undefined, sdkClient,
+    );
+    await hook(makeInput(), { enabled: true });
+    expect(mockCerebroClient.ingestMessages).toHaveBeenCalledTimes(1);
+    expect(mockCerebroClient.ingestMessages.mock.calls[0][0][0].content).toBe("This is a summary of the session.");
+  });
+
+  it("falls back to summary-flagged message (level 2)", async () => {
+    const sdkClient = {
+      session: {
+        messages: vi.fn().mockResolvedValue({
+          data: [
+            { info: { id: "msg-other", role: "user" } },
+            {
+              info: { id: "msg2", role: "assistant", summary: true },
+              parts: [{ type: "text", text: "Summary from flag that is long enough to pass." }],
+            },
+          ],
+        }),
+        get: vi.fn().mockResolvedValue({ data: { directory: "/tmp" } }),
+      },
+    };
+    const hook = autocontinueHook(
+      mockCerebroClient as any, containerTags, mockTui, "smart",
+      undefined, undefined, sdkClient,
+    );
+    await hook(makeInput({ message: { id: "not-found" } as any }), { enabled: true });
+    expect(mockCerebroClient.ingestMessages).toHaveBeenCalledTimes(1);
+  });
+
+  it("falls back to last assistant message (level 3)", async () => {
+    const sdkClient = {
+      session: {
+        messages: vi.fn().mockResolvedValue({
+          data: [
+            {
+              info: { id: "a1", role: "assistant" },
+              parts: [{ type: "text", text: "Last assistant response here with enough content." }],
+            },
+          ],
+        }),
+        get: vi.fn().mockResolvedValue({ data: {} }),
+      },
+    };
+    const hook = autocontinueHook(
+      mockCerebroClient as any, containerTags, mockTui, "smart",
+      undefined, undefined, sdkClient,
+    );
+    await hook(makeInput({ message: { id: "none" } as any }), { enabled: true });
+    expect(mockCerebroClient.ingestMessages).toHaveBeenCalledTimes(1);
+  });
+
+  it("skips when no sdkClient", async () => {
+    const hook = autocontinueHook(mockCerebroClient as any, containerTags, mockTui);
+    await hook(makeInput(), { enabled: true });
+    expect(mockCerebroClient.ingestMessages).not.toHaveBeenCalled();
+  });
+
+  it("skips when policy is readonly", async () => {
+    (resolveAgentPolicy as ReturnType<typeof vi.fn>).mockReturnValue("readonly");
+    const sdkClient = {
+      session: { messages: vi.fn(), get: vi.fn() },
+    };
+    const hook = autocontinueHook(
+      mockCerebroClient as any, containerTags, mockTui, "smart",
+      undefined, undefined, sdkClient,
+    );
+    await hook(makeInput(), { enabled: true });
+    expect(mockCerebroClient.ingestMessages).not.toHaveBeenCalled();
+  });
+
+  it("skips when autoStore is disabled", async () => {
+    const isAutoStoreEnabled = vi.fn(() => false);
+    const hook = autocontinueHook(
+      mockCerebroClient as any, containerTags, mockTui, "smart",
+      isAutoStoreEnabled,
+    );
+    await hook(makeInput(), { enabled: true });
+    expect(mockCerebroClient.ingestMessages).not.toHaveBeenCalled();
+  });
+
+  it("skips when summaryText is empty", async () => {
+    const sdkClient = {
+      session: {
+        messages: vi.fn().mockResolvedValue({ data: [] }),
+        get: vi.fn(),
+      },
+    };
+    const hook = autocontinueHook(
+      mockCerebroClient as any, containerTags, mockTui, "smart",
+      undefined, undefined, sdkClient,
+    );
+    await hook(makeInput(), { enabled: true });
+    expect(mockCerebroClient.ingestMessages).not.toHaveBeenCalled();
+  });
+
+  it("shows error toast when ingestMessages throws", async () => {
+    mockCerebroClient.ingestMessages.mockRejectedValue(new Error("fail"));
+    const sdkClient = {
+      session: {
+        messages: vi.fn().mockResolvedValue({
+          data: [{
+            info: { id: "msg1", role: "assistant" },
+            parts: [{ type: "text", text: "Summary text here that is definitely long enough to pass." }],
+          }],
+        }),
+        get: vi.fn().mockResolvedValue({ data: {} }),
+      },
+    };
+    const hook = autocontinueHook(
+      mockCerebroClient as any, containerTags, mockTui, "smart",
+      undefined, undefined, sdkClient,
+    );
+    await hook(makeInput(), { enabled: true });
+    // Should not throw
+  });
+});
+
+// ========================================
+// sessionIdleHook
+// ========================================
+describe("sessionIdleHook", () => {
+  const makeEvent = (type: string, properties: any = {}) => ({
+    event: { type, properties },
+  });
+
+  it("returns an async function", () => {
+    const hook = sessionIdleHook(mockCerebroClient as any, containerTags, mockTui, {});
+    expect(typeof hook).toBe("function");
+  });
+
+  it("handles message.updated event", async () => {
+    const sdkClient = {
+      session: {
+        messages: vi.fn().mockResolvedValue({
+          data: [{
+            info: { role: "assistant", summary: true },
+            parts: [{ type: "text", text: "This is a decent summary of the session content." }],
+          }],
+        }),
+        get: vi.fn().mockResolvedValue({ data: { directory: "/tmp/project" } }),
+      },
+    };
+    const hook = sessionIdleHook(
+      mockCerebroClient as any, containerTags, mockTui, sdkClient,
+    );
+    await hook(makeEvent("message.updated", {
+      info: { role: "assistant", sessionID: "s1", finish: true },
+    }));
+    // Should trigger handleSummaryCapture → ingestMessages
+    expect(mockCerebroClient.ingestMessages).toHaveBeenCalledTimes(1);
+  });
+
+  it("skips message.updated for non-assistant role", async () => {
+    const hook = sessionIdleHook(mockCerebroClient as any, containerTags, mockTui, {});
+    await hook(makeEvent("message.updated", {
+      info: { role: "user", sessionID: "s1" },
+    }));
+    expect(mockCerebroClient.ingestMessages).not.toHaveBeenCalled();
+  });
+
+  it("skips message.updated when finish is false", async () => {
+    const hook = sessionIdleHook(mockCerebroClient as any, containerTags, mockTui, {});
+    await hook(makeEvent("message.updated", {
+      info: { role: "assistant", sessionID: "s1", finish: false },
+    }));
+    expect(mockCerebroClient.ingestMessages).not.toHaveBeenCalled();
+  });
+
+  it("handles session.deleted event (cleanup)", async () => {
+    const hook = sessionIdleHook(mockCerebroClient as any, containerTags, mockTui, {});
+    // Should not throw
+    await hook(makeEvent("session.deleted", {
+      info: { id: "s1" },
+    }));
+    expect(mockCerebroClient.ingestMessages).not.toHaveBeenCalled();
+  });
+
+  it("ignores unknown event types", async () => {
+    const hook = sessionIdleHook(mockCerebroClient as any, containerTags, mockTui, {});
+    await hook(makeEvent("unknown.event", {}));
+    expect(mockCerebroClient.ingestMessages).not.toHaveBeenCalled();
+  });
+
+  it("handles session.idle event with setTimeout", async () => {
+    vi.useFakeTimers();
+    const sdkClient = {
+      session: {
+        messages: vi.fn().mockResolvedValue({
+          data: [{
+            info: { id: "m1", role: "user", createdAt: new Date().toISOString() },
+            parts: [{ type: "text", text: "hello world" }],
+          }],
+        }),
+        get: vi.fn().mockResolvedValue({ data: { directory: "/tmp", agent: "opencode" } }),
+      },
+    };
+    const onAgentResolved = vi.fn();
+    const hook = sessionIdleHook(
+      mockCerebroClient as any, containerTags, mockTui, sdkClient,
+      "smart", 0, undefined, undefined, "opencode", {}, onAgentResolved,
+    );
+
+    await hook(makeEvent("session.idle", { sessionID: "s1" }));
+
+    // Not yet called (10s timeout)
+    expect(mockCerebroClient.sessionIngest).not.toHaveBeenCalled();
+
+    // Advance past 10s
+    await vi.advanceTimersByTimeAsync(11000);
+
+    expect(mockCerebroClient.sessionIngest).toHaveBeenCalledTimes(1);
+    expect(onAgentResolved).toHaveBeenCalledWith("opencode");
+
+    vi.useRealTimers();
+  });
+
+  it("skips session.idle when autoStore is disabled", async () => {
+    vi.useFakeTimers();
+    const isAutoStoreEnabled = vi.fn(() => false);
+    const hook = sessionIdleHook(
+      mockCerebroClient as any, containerTags, mockTui, {},
+      "smart", 0, undefined, isAutoStoreEnabled,
+    );
+    await hook(makeEvent("session.idle", { sessionID: "s1" }));
+    await vi.advanceTimersByTimeAsync(11000);
+    expect(mockCerebroClient.sessionIngest).not.toHaveBeenCalled();
+    vi.useRealTimers();
+  });
+
+  it("skips session.idle for non-main session", async () => {
+    vi.useFakeTimers();
+    const getMainSessionId = vi.fn(() => "main-sess");
+    const hook = sessionIdleHook(
+      mockCerebroClient as any, containerTags, mockTui, {},
+      "smart", 0, getMainSessionId,
+    );
+    await hook(makeEvent("session.idle", { sessionID: "sub-sess" }));
+    await vi.advanceTimersByTimeAsync(11000);
+    expect(mockCerebroClient.sessionIngest).not.toHaveBeenCalled();
+    vi.useRealTimers();
+  });
+
+  it("skips session.idle when policy is readonly", async () => {
+    vi.useFakeTimers();
+    (resolveAgentPolicy as ReturnType<typeof vi.fn>).mockReturnValue("readonly");
+    const sdkClient = {
+      session: {
+        messages: vi.fn().mockResolvedValue({
+          data: [{
+            info: { id: "policy-m1", role: "user", createdAt: new Date().toISOString() },
+            parts: [{ type: "text", text: "hello" }],
+          }],
+        }),
+        get: vi.fn().mockResolvedValue({ data: { directory: "/tmp" } }),
+      },
+    };
+    const hook = sessionIdleHook(
+      mockCerebroClient as any, containerTags, mockTui, sdkClient,
+      "smart", 0, undefined, undefined, "opencode", {},
+    );
+    await hook(makeEvent("session.idle", { sessionID: "policy-sess" }));
+    await vi.advanceTimersByTimeAsync(11000);
+    expect(mockCerebroClient.sessionIngest).not.toHaveBeenCalled();
+    vi.useRealTimers();
+  });
+
+  it("skips session.idle when no sessionID", async () => {
+    const hook = sessionIdleHook(mockCerebroClient as any, containerTags, mockTui, {});
+    await hook(makeEvent("session.idle", {}));
+    expect(mockCerebroClient.sessionIngest).not.toHaveBeenCalled();
+  });
+
+  it("skips messages below threshold", async () => {
+    vi.useFakeTimers();
+    const sdkClient = {
+      session: {
+        messages: vi.fn().mockResolvedValue({
+          data: [{
+            info: { id: "thresh-m1", role: "user", createdAt: new Date().toISOString() },
+            parts: [{ type: "text", text: "just one msg" }],
+          }],
+        }),
+        get: vi.fn().mockResolvedValue({ data: { directory: "/tmp", agent: "opencode" } }),
+      },
+    };
+    const hook = sessionIdleHook(
+      mockCerebroClient as any, containerTags, mockTui, sdkClient,
+      "smart", 5,
+      undefined, undefined, "opencode", {},
+    );
+    await hook(makeEvent("session.idle", { sessionID: "thresh-sess" }));
+    await vi.advanceTimersByTimeAsync(11000);
+    expect(mockCerebroClient.sessionIngest).not.toHaveBeenCalled();
+    vi.useRealTimers();
+  });
+
+  it("shows error toast on sessionIngest failure", async () => {
+    vi.useFakeTimers();
+    mockCerebroClient.sessionIngest.mockRejectedValue(new Error("server error"));
+    const sdkClient = {
+      session: {
+        messages: vi.fn().mockResolvedValue({
+          data: [{
+            info: { id: "err-m1", role: "user", createdAt: new Date().toISOString() },
+            parts: [{ type: "text", text: "hello world test" }],
+          }],
+        }),
+        get: vi.fn().mockResolvedValue({ data: { directory: "/tmp", agent: "opencode" } }),
+      },
+    };
+    const hook = sessionIdleHook(
+      mockCerebroClient as any, containerTags, mockTui, sdkClient,
+      "smart", 0, undefined, undefined, "opencode", {},
+    );
+    await hook(makeEvent("session.idle", { sessionID: "err-sess" }));
+    await vi.advanceTimersByTimeAsync(11000);
+    expect(mockCerebroClient.sessionIngest).toHaveBeenCalled();
+    vi.useRealTimers();
+  });
+});

package/src/hooks.ts

@@ -4,6 +4,13 @@ import { type CerebroPluginConfig, DEFAULTS, resolveAgentPolicy } from "./config
 import { logDebug, logInfo, logError as logErr } from "./logger.js";
 import { readFile } from "node:fs/promises";
 
+/** Sanitize session ID to prevent path traversal */
+function sanitizeSessionId(id: string | undefined): string | undefined {
+  if (!id) return id;
+  // Remove any path separators or traversal attempts
+  return id.replace(/[/\\]/g, "_").replace(/\.\./g, "");
+}
+
 const BOUNDARY_SEARCH_RATIO = 0.6;
 
 const projectNameCache = new Map<string, string>();
@@ -504,7 +511,7 @@ export function compactingHook(client: CerebroClient, containerTags: string[], t
       return;
     }
 
-    const effectiveSessionId = (getMainSessionId?.() || input.sessionID);
+    const effectiveSessionId = sanitizeSessionId(getMainSessionId?.() || input.sessionID);
 
     // Resolve project name (shared by ingest + poll)
     let projectName: string | undefined;
@@ -615,7 +622,7 @@ export function autocontinueHook(
         return;
       }
 
-      const effectiveSessionId = getMainSessionId?.() || input.sessionID;
+      const effectiveSessionId = sanitizeSessionId(getMainSessionId?.() || input.sessionID);
 
       if (!sdkClient) {
         logInfo("autocontinueHook skipped: no sdkClient", { sessionId: input.sessionID });
@@ -626,9 +633,21 @@ export function autocontinueHook(
       try {
         const response = await sdkClient.session.messages({ path: { id: input.sessionID } });
         if (response?.data) {
-          const targetMsg = response.data.find(
+          let targetMsg = response.data.find(
             (msg: any) => msg.info?.id === input.message.id,
           );
+
+          if (!targetMsg?.parts) {
+            targetMsg = response.data.find(
+              (msg: any) => msg.info?.role === "assistant" && msg.info?.summary === true,
+            );
+          }
+
+          if (!targetMsg?.parts) {
+            const assistants = response.data.filter((msg: any) => msg.info?.role === "assistant");
+            if (assistants.length > 0) targetMsg = assistants[assistants.length - 1];
+          }
+
           if (targetMsg?.parts) {
             const textParts = (targetMsg.parts as any[])
               .filter((p: any) => p.type === "text" && p.text)
@@ -640,8 +659,8 @@ export function autocontinueHook(
         logErr("autocontinueHook failed to fetch message parts", { error: String(e) });
       }
 
-      if (!summaryText) {
-        logInfo("autocontinueHook skipped: no summary text found", { sessionId: input.sessionID, messageId: input.message.id });
+      if (!summaryText || summaryText.length < 30) {
+        logInfo("autocontinueHook skipped: summary too short", { sessionId: input.sessionID, messageId: input.message.id, summaryLen: summaryText?.length ?? 0 });
         return;
       }
 
@@ -713,11 +732,21 @@ export function sessionIdleHook(
   async function handleSummaryCapture(props: any) {
     const info = props?.info;
     if (!info) return;
-    if (info.role !== "assistant" || !info.summary || !info.finish) return;
+    if (info.role !== "assistant") return;
+    // info.summary may be missing in some SDK versions — handle below
+    // info.finish check: only process on finish, but allow missing field
+    if (info.finish === false) return;
 
-    const sessionID = info.sessionID;
+    const sessionID = sanitizeSessionId(info.sessionID);
     if (!sessionID) return;
 
+    logInfo("handleSummaryCapture checking", {
+      sessionID,
+      role: info?.role,
+      hasSummary: !!info?.summary,
+      finish: info?.finish,
+    });
+
     if (summarizedSessions.has(sessionID)) return;
     summarizedSessions.add(sessionID);
 
@@ -749,24 +778,31 @@ export function sessionIdleHook(
       const resp = await sdkClient.session.messages({ path: { id: sessionID } });
       const messages = resp?.data ?? resp;
 
-      const summaryMsg = (messages as Array<{ info: any; parts?: Array<{ type: string; text?: string }> }>).find((m) =>
+      let summaryMsg = (messages as Array<{ info: any; parts?: Array<{ type: string; text?: string }> }>).find((m) =>
         m.info?.role === "assistant" && m.info?.summary === true
       );
 
       if (!summaryMsg?.parts) {
-        logInfo("handleSummaryCapture: no summary parts found", { sessionID });
+        logInfo("handleSummaryCapture: no summary-flagged message, trying last assistant message", { sessionID });
+        const assistantMsgs = (messages as Array<{ info: any; parts?: Array<{ type: string; text?: string }> }>)
+          .filter(m => m.info?.role === "assistant");
+        summaryMsg = assistantMsgs.length > 0 ? assistantMsgs[assistantMsgs.length - 1] : undefined;
+      }
+
+      if (!summaryMsg?.parts) {
+        logInfo("handleSummaryCapture: no assistant message parts found", { sessionID });
         return;
       }
 
       const textParts = summaryMsg.parts.filter((p) => p.type === "text" && p.text).map((p) => p.text);
       const summaryContent = textParts.join("\n").trim();
 
-      if (!summaryContent || summaryContent.length < 100) {
+      if (!summaryContent || summaryContent.length < 30) {
         logInfo("handleSummaryCapture: summary too short", { sessionID, length: summaryContent?.length ?? 0 });
         return;
       }
 
-      const effectiveSessionId = getMainSessionId?.() || sessionID;
+      const effectiveSessionId = sanitizeSessionId(getMainSessionId?.() || sessionID);
 
       let projectName: string | undefined;
       let projectPath: string | undefined;
@@ -829,7 +865,7 @@ export function sessionIdleHook(
 
     logDebug("sessionIdleHook event.properties dump", { keys: Object.keys(input.event.properties || {}), raw: JSON.stringify(input.event.properties).substring(0, 2000) });
 
-    const sessionID = input.event.properties?.sessionID;
+    const sessionID = sanitizeSessionId(input.event.properties?.sessionID);
     if (!sessionID) return;
 
     if (isAutoStoreEnabled && !isAutoStoreEnabled(sessionID)) return;