@mingxy/cerebro 1.5.8 → 1.5.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mingxy/cerebro",
-  "version": "1.5.8",
+  "version": "1.5.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/client.ts

@@ -359,16 +359,4 @@ export class OmemClient {
     );
     return res?.recalls ?? [];
   }
-
-  async sessionIngest(
-    messages: Array<{ role: string; content: string }>,
-    sessionId?: string,
-    agentId?: string,
-  ): Promise<unknown> {
-    return this.post("/v1/memories/session-ingest", {
-      messages,
-      session_id: sessionId,
-      agent_id: agentId,
-    }, 60000);
-  }
 }

package/src/hooks.ts

@@ -18,6 +18,25 @@ const firstMessages = new Map<string, string>();
 const sessionMessages = new Map<string, Array<{ role: string; content: string }>>();
 const profileInjectedSessions = new Set<string>();
 
+function extractMemoryIds(result: unknown): string[] {
+  if (!result) return [];
+  if (Array.isArray(result)) {
+    return (result as Array<{ id?: string }>).map((m) => m.id).filter(Boolean) as string[];
+  }
+  if (typeof result === "object" && result !== null) {
+    const r = result as Record<string, unknown>;
+    if (Array.isArray(r.memories)) {
+      return (r.memories as Array<{ id?: string }>).map((m) => m.id).filter(Boolean) as string[];
+    }
+    if (Array.isArray(r.results)) {
+      return (r.results as Array<{ id?: string; memory?: { id?: string } }>)
+        .map((m) => m.id ?? m.memory?.id)
+        .filter(Boolean) as string[];
+    }
+  }
+  return [];
+}
+
 function formatRelativeAge(isoDate: string): string {
   const diffMs = Date.now() - new Date(isoDate).getTime();
   const minutes = Math.floor(diffMs / 60_000);
@@ -259,7 +278,7 @@ export function autoRecallHook(client: OmemClient, containerTags: string[], tui:
   };
 }
 
-export function keywordDetectionHook(_client: OmemClient, _containerTags: string[], threshold: number, _tui: any, _ingestMode: "smart" | "raw" = "smart") {
+export function keywordDetectionHook(client: OmemClient, containerTags: string[], threshold: number, tui: any, ingestMode: "smart" | "raw" = "smart") {
   return async (
     input: { sessionID: string; messageID?: string },
     output: { message: UserMessage; parts: Part[] },
@@ -288,10 +307,38 @@ export function keywordDetectionHook(_client: OmemClient, _containerTags: string
     });
 
     const messages = sessionMessages.get(input.sessionID)!;
-    // Ingest is now handled by sessionIdleHook (session.idle → sessionIngest API).
-    // This hook only collects messages and detects keywords for recall.
     if (messages.length >= threshold) {
-      // Threshold reached — messages will be processed on next session.idle
+      try {
+        const result = await client.ingestMessages(messages, {
+          mode: ingestMode,
+          tags: [...containerTags, "auto-capture"],
+          sessionId: input.sessionID,
+        });
+        if (result === null) {
+          showToast(tui, "🔴 Capture Failed", `Memory capture blocked · check API Key and spiritual connection`, "error");
+        } else {
+          showToast(tui, "🧠 Memory Sealed", `${messages.length} dialogues captured · entrusted to the heavens for refinement`, "success");
+          const memoryIds = extractMemoryIds(result);
+          if (memoryIds.length > 0) {
+            const recordResult = await client.recordSessionRecall(
+              input.sessionID,
+              memoryIds,
+              "auto",
+              firstMessages.get(input.sessionID) || "",
+              0,
+              0,
+            );
+            if (recordResult) {
+              showToast(tui, "📦 Capture Recorded", `${memoryIds.length} memory(s) saved to session history`, "success");
+            } else {
+              showToast(tui, "🔴 Capture Record Failed", `Failed to save capture record · check API connection`, "error");
+            }
+          }
+          sessionMessages.delete(input.sessionID);
+        }
+      } catch {
+        showToast(tui, "🔴 Capture Failed", "Memory capture blocked · spiritual pulse anomaly", "error");
+      }
     }
   };
 }
@@ -332,88 +379,3 @@ export function compactingHook(client: OmemClient, containerTags: string[], tui:
     }
   };
 }
-
-const processedMessageIds = new Set<string>();
-
-export function sessionIdleHook(
-  omemClient: OmemClient,
-  _containerTags: string[],
-  tui: any,
-  sdkClient: any,
-  _ingestMode: "smart" | "raw" = "smart",
-  threshold: number = 0,
-  getMainSessionId?: () => string | undefined,
-) {
-  let idleTimeout: ReturnType<typeof setTimeout> | null = null;
-  let isCapturing = false;
-
-  return async (input: { event: { type: string; properties?: any } }) => {
-    if (input.event.type !== "session.idle") return;
-
-    const sessionID = input.event.properties?.sessionID;
-    if (!sessionID) return;
-
-    if (getMainSessionId) {
-      const mainId = getMainSessionId();
-      if (mainId && sessionID !== mainId) return;
-    }
-
-    if (idleTimeout) clearTimeout(idleTimeout);
-
-    idleTimeout = setTimeout(async () => {
-      if (isCapturing) return;
-      isCapturing = true;
-
-      try {
-        const response = await sdkClient.session.messages({ path: { id: sessionID } });
-        if (!response?.data) return;
-
-        const messages = response.data;
-        const conversationMessages: Array<{ role: string; content: string }> = [];
-        const newMessageIds: string[] = [];
-        let hasNewMessages = false;
-
-        for (const msg of messages) {
-          const msgId = msg.info?.id;
-          if (!msgId || processedMessageIds.has(msgId)) continue;
-
-          const role = msg.info?.role;
-          if (role !== "user" && role !== "assistant") continue;
-
-          const textParts = (msg.parts || [])
-            .filter((p: any) => p.type === "text" && p.text)
-            .map((p: any) => p.text);
-          const text = textParts.join("\n").trim();
-          if (!text) continue;
-
-          hasNewMessages = true;
-          newMessageIds.push(msgId);
-          conversationMessages.push({ role, content: text });
-        }
-
-        if (!hasNewMessages || conversationMessages.length === 0) return;
-
-        if (threshold > 1 && conversationMessages.length < threshold) {
-          // Log that we're waiting for more messages
-          return;
-        }
-
-        try {
-          await omemClient.sessionIngest(conversationMessages, sessionID);
-          for (const id of newMessageIds) {
-            processedMessageIds.add(id);
-          }
-          showToast(tui, "🧠 Memory Sealed", `${conversationMessages.length} dialogues captured · entrusted to the heavens for refinement`, "success");
-        } catch (err) {
-          showToast(tui, "🔴 Session Capture Failed", String(err).substring(0, 100), "error");
-        }
-      } catch (err) {
-        const errMsg = err instanceof Error ? err.message : String(err);
-        showToast(tui, "🔴 Idle Capture Error", errMsg.substring(0, 100), "error");
-      } finally {
-        isCapturing = false;
-        idleTimeout = null;
-      }
-    }, 10000);
-  };
-}

package/src/index.ts

@@ -3,7 +3,7 @@ import { readFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { OmemClient } from "./client.js";
-import { autoRecallHook, compactingHook, keywordDetectionHook, sessionIdleHook } from "./hooks.js";
+import { autoRecallHook, compactingHook, keywordDetectionHook } from "./hooks.js";
 import { getUserTag, getProjectTag } from "./tags.js";
 import { buildTools } from "./tools.js";
 import { logInfo, logError } from "./logger.js";
@@ -96,7 +96,6 @@ const OmemPlugin: Plugin = async (input) => {
     "chat.message": keywordDetectionHook(omemClient, containerTags, config.autoCaptureThreshold, tui, config.ingestMode),
     "experimental.session.compacting": compactingHook(omemClient, containerTags, tui, config.ingestMode),
     tool: buildTools(omemClient, containerTags, { agentId, getSessionId: () => currentSessionId }),
-    event: sessionIdleHook(omemClient, containerTags, tui, client, config.ingestMode, config.autoCaptureThreshold, () => currentSessionId),
     "shell.env": async (_input: any, output: any) => {
       if (directory) {
         output.env.OMEM_PROJECT_DIR = directory;