@mingxy/cerebro 1.11.9 → 1.11.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mingxy/cerebro",
-  "version": "1.11.9",
+  "version": "1.11.10",
   "description": "Cerebro persistent memory plugin for OpenCode — auto-recall, auto-capture, 9 memory tools with clustering",
   "type": "module",
   "main": "src/index.ts",

package/src/hooks.ts

@@ -653,6 +653,109 @@ export function compactingHook(client: CerebroClient, containerTags: string[], t
   };
 }
 
+export function autocontinueHook(
+  client: CerebroClient,
+  containerTags: string[],
+  tui: any,
+  ingestMode: "smart" | "raw" = "smart",
+  isAutoStoreEnabled?: (sessionId: string | undefined) => boolean,
+  getMainSessionId?: () => string | undefined,
+  sdkClient?: any,
+  config: Partial<OmemPluginConfig> = {},
+  agentId?: string,
+) {
+  const effectiveAgentId = agentId || process.env.OMEM_AGENT_ID || "opencode";
+  return async (
+    input: {
+      sessionID: string;
+      agent: string;
+      model: Model;
+      message: UserMessage;
+      overflow: boolean;
+    },
+    _output: { enabled: boolean },
+  ) => {
+    try {
+      const policy = resolveAgentPolicy(effectiveAgentId, config);
+      if (policy !== "readwrite") {
+        logInfo("autocontinueHook blocked by policy", { agentId: effectiveAgentId, policy });
+        return;
+      }
+
+      if (isAutoStoreEnabled && !isAutoStoreEnabled(input.sessionID)) {
+        logInfo("autocontinueHook skipped: auto-store disabled", { sessionId: input.sessionID });
+        return;
+      }
+
+      const effectiveSessionId = getMainSessionId?.() || input.sessionID;
+
+      if (!sdkClient) {
+        logInfo("autocontinueHook skipped: no sdkClient", { sessionId: input.sessionID });
+        return;
+      }
+
+      let summaryText: string | undefined;
+      try {
+        const response = await sdkClient.session.messages({ path: { id: input.sessionID } });
+        if (response?.data) {
+          const targetMsg = response.data.find(
+            (msg: any) => msg.info?.id === input.message.id,
+          );
+          if (targetMsg?.parts) {
+            const textParts = (targetMsg.parts as any[])
+              .filter((p: any) => p.type === "text" && p.text)
+              .map((p: any) => p.text);
+            summaryText = textParts.join("\n").trim();
+          }
+        }
+      } catch (e) {
+        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 });
+        return;
+      }
+
+      let projectName: string | undefined;
+      try {
+        const sessionInfo = await sdkClient.session.get({ path: { id: input.sessionID } });
+        projectName = sessionInfo?.data?.directory
+          ? await detectProjectName(sessionInfo.data.directory)
+          : undefined;
+      } catch (e) {
+        logErr("autocontinueHook detectProjectName failed", { error: String(e) });
+      }
+
+      const messages = [{ role: "user" as const, content: summaryText }];
+      logInfo("autocontinueHook storing compact summary", {
+        summaryLen: summaryText.length,
+        sessionId: effectiveSessionId,
+        agentId: effectiveAgentId,
+        overflow: input.overflow,
+        projectName,
+      });
+
+      const result = await client.ingestMessages(messages, {
+        mode: ingestMode,
+        tags: [...containerTags, "auto-capture", "compact-summary"],
+        sessionId: effectiveSessionId,
+        projectName: projectName,
+        agentId: effectiveAgentId,
+      });
+
+      logInfo("autocontinueHook store result", { result: result === null ? "null(blocked)" : "ok" });
+      if (result === null) {
+        showToast(tui, "🔴 Compact Summary Failed", "Storage blocked · check server status", "error");
+      } else {
+        showToast(tui, "📦 Compact Summary Stored", "Session summary archived to memory", "success");
+      }
+    } catch (e) {
+      logErr("autocontinueHook failed", { error: String(e) });
+    }
+  };
+}
+
 const processedMessageIds = new Set<string>();
 const pluginStartTime = Date.now();
 

package/src/index.ts

@@ -4,7 +4,7 @@ import { join, dirname } from "node:path";
 import { tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
 import { CerebroClient } from "./client.js";
-import { autoRecallHook, compactingHook, keywordDetectionHook, sessionIdleHook } from "./hooks.js";
+import { autoRecallHook, autocontinueHook, compactingHook, keywordDetectionHook, sessionIdleHook } from "./hooks.js";
 import { getUserTag, getProjectTag } from "./tags.js";
 import { buildTools } from "./tools.js";
 import { logInfo, logDebug, logError } from "./logger.js";
@@ -140,6 +140,7 @@ const OmemPlugin: Plugin = async (input) => {
     },
     "chat.message": keywordDetectionHook(cerebroClient, containerTags, config.ingest.autoCaptureThreshold, tui, config.ingest.ingestMode, config, agentId),
     "experimental.session.compacting": compactingHook(cerebroClient, containerTags, tui, config.ingest.ingestMode, isAutoStoreEnabled, () => mainSessionId, client, config, agentId),
+    "experimental.compaction.autocontinue": autocontinueHook(cerebroClient, containerTags, tui, config.ingest.ingestMode, isAutoStoreEnabled, () => mainSessionId, client, config, agentId),
     tool: buildTools(cerebroClient, containerTags, { agentId, getSessionId: () => mainSessionId, getAgentName: () => cachedAgentName || agentId }),
     event: sessionIdleHook(cerebroClient, containerTags, tui, client, config.ingest.ingestMode, config.ingest.autoCaptureThreshold, () => mainSessionId, isAutoStoreEnabled, agentId, config, (name: string) => { cachedAgentName = name; }),
     "shell.env": async (_input: any, output: any) => {