@mingxy/cerebro 1.4.0 → 1.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mingxy/cerebro",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "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

@@ -84,6 +84,7 @@ export interface MemoryDto {
   source?: string;
   tenant_id: string;
   agent_id?: string;
+  importance: number;
   created_at: string;
   updated_at: string;
 }
@@ -171,6 +172,7 @@ export class OmemClient {
     scope?: string,
     agentId?: string,
     sessionId?: string,
+    visibility?: string,
   ): Promise<MemoryDto | null> {
     const safeContent = sanitizeContent(content, this.getCfg("maxContentChars", 30000));
     return this.post<MemoryDto>("/v1/memories", {
@@ -180,6 +182,7 @@ export class OmemClient {
       scope,
       agent_id: agentId,
       session_id: sessionId,
+      visibility,
     });
   }
 
@@ -356,4 +359,16 @@ export class OmemClient {
     );
     return res?.recalls ?? [];
   }
+
+  async sessionIngest(
+    summaries: Array<{ topic: string; content: string }>,
+    sessionId?: string,
+    agentId?: string,
+  ): Promise<unknown> {
+    return this.post("/v1/memories/session-ingest", {
+      summaries,
+      session_id: sessionId,
+      agent_id: agentId,
+    });
+  }
 }

package/src/hooks.ts

@@ -102,13 +102,15 @@ function buildClusteredContextBlock(clustered: import("./client.js").ClusteredRe
   if (clustered.cluster_summaries.length > 0) {
     sections.push("## 📋 主题簇（聚合记忆）");
     for (const cs of clustered.cluster_summaries) {
-      sections.push(`\n### ${cs.title} (整合自${cs.member_count}条记忆)`);
+      const scoreIndicator = cs.relevance_score >= 0.8 ? "★★★" : cs.relevance_score >= 0.6 ? "★★" : "★";
+      sections.push(`\n### ${cs.title} (整合自${cs.member_count}条记忆) ${scoreIndicator}`);
       sections.push(`> ${cs.summary}`);
       if (cs.key_memories.length > 0) {
         sections.push("**核心要点：**");
         for (const mem of cs.key_memories) {
           const content = truncate(mem.content, maxContentLength);
-          sections.push(`- ${content}`);
+          const importanceBar = mem.importance >= 0.7 ? "●" : mem.importance >= 0.4 ? "◐" : "○";
+          sections.push(`- ${importanceBar} ${content}`);
         }
       }
     }
@@ -341,6 +343,105 @@ export function keywordDetectionHook(client: OmemClient, containerTags: string[]
   };
 }
 
+const processedMessageIds = new Set<string>();
+
+export function sessionIdleHook(
+  omemClient: OmemClient,
+  containerTags: string[],
+  tui: any,
+  sdkClient: any,
+  ingestMode: "smart" | "raw" = "smart",
+) {
+  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 (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 dcpSummaries: Array<{ topic: string; content: 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;
+          processedMessageIds.add(msgId);
+
+          if (text.includes("[Compressed conversation section]")) {
+            const blockRegex = /\[Compressed conversation section\]\n([\s\S]*?)(?=<dcp-block|$)/g;
+            let match;
+            while ((match = blockRegex.exec(text)) !== null) {
+              const summary = match[1].trim();
+              if (summary) {
+                dcpSummaries.push({ topic: "session-compress", content: summary });
+              }
+            }
+          }
+
+          conversationMessages.push({ role, content: text });
+        }
+
+        if (!hasNewMessages) return;
+
+        if (dcpSummaries.length > 0) {
+          try {
+            await omemClient.sessionIngest(dcpSummaries, sessionID);
+            showToast(tui, "🧠 DCP Summary Captured", `${dcpSummaries.length} compress summaries stored (zero-LLM)`, "success");
+          } catch (err) {
+            showToast(tui, "🔴 DCP Capture Failed", String(err).substring(0, 100), "error");
+          }
+        }
+
+        if (conversationMessages.length > 0) {
+          try {
+            const result = await omemClient.ingestMessages(conversationMessages, {
+              mode: ingestMode,
+              tags: [...containerTags, "session-idle"],
+              sessionId: sessionID,
+            });
+            if (result) {
+              showToast(tui, "🧠 Session Captured", `${conversationMessages.length} messages captured via session.idle`, "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);
+  };
+}
+
 export function compactingHook(client: OmemClient, containerTags: string[], tui: any, ingestMode: "smart" | "raw" = "smart") {
   return async (
     input: { sessionID?: string },

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 } from "./hooks.js";
+import { autoRecallHook, compactingHook, keywordDetectionHook, sessionIdleHook } from "./hooks.js";
 import { getUserTag, getProjectTag } from "./tags.js";
 import { buildTools } from "./tools.js";
 import { logInfo, logError } from "./logger.js";
@@ -96,6 +96,7 @@ 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),
     "shell.env": async (_input: any, output: any) => {
       if (directory) {
         output.env.OMEM_PROJECT_DIR = directory;

package/src/tools.ts

@@ -45,6 +45,10 @@ export function buildTools(client: OmemClient, containerTags: string[], context:
           .string()
           .optional()
           .describe("Memory scope: 'project' (default, only visible in this project) or 'global' (visible across all projects)"),
+        visibility: tool.schema
+          .string()
+          .optional()
+          .describe("Memory visibility: 'global' (default, visible to all agents) or 'private' (only visible to the storing agent). Use 'private' for sensitive data like credentials, personal info, or anything the user wouldn't want shared."),
       },
       async execute(args) {
         const allTags = [...containerTags, ...(args.tags ?? [])];
@@ -55,6 +59,7 @@ export function buildTools(client: OmemClient, containerTags: string[], context:
           args.scope ?? "project",
           context.agentId,
           context.getSessionId(),
+          args.visibility,
         );
         if (!result) return JSON.stringify({ ok: false, error: "The omem server may be unavailable." });
         return JSON.stringify({ ok: true, id: result.id, tags: result.tags });