@mingxy/cerebro 1.10.0 → 1.10.1

package/package.json

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

@@ -129,7 +129,7 @@ export class OmemClient {
 
       if (!res.ok) {
         const errorBody = await res.text().catch(() => "");
-        logWarn(`${init.method ?? "GET"} ${path} → ${res.status} ${res.statusText}: ${errorBody}`);
+        logWarn("HTTP error", { method: init.method ?? "GET", path, status: res.status, statusText: res.statusText, errorBody });
         throw new Error(`[omem] ${res.status} ${res.statusText}${errorBody ? ": " + errorBody : ""}`);
       }
 
@@ -138,10 +138,10 @@ export class OmemClient {
       return (await res.json()) as T;
     } catch (err) {
       if ((err as Error).name === "AbortError") {
-        logWarn(`${init.method ?? "GET"} ${path} timed out`);
+        logWarn("Request timed out", { method: init.method ?? "GET", path, timeoutMs: timeoutMs ?? this.getCfg("requestTimeoutMs", 15000) });
         throw new Error(`[omem] Request timed out (${timeoutMs ?? this.getCfg("requestTimeoutMs", 15000)}ms)`);
       } else {
-        logError(`${init.method ?? "GET"} ${path} failed:`, err);
+        logError("Request failed", { method: init.method ?? "GET", path, error: String(err) });
         throw err;
       }
     } finally {

package/src/hooks.ts

@@ -2,35 +2,38 @@ import type { Model, UserMessage, Part } from "@opencode-ai/sdk";
 import type { OmemClient, SearchResult } from "./client.js";
 import type { OmemPluginConfig } from "./config.js";
 import { detectKeyword, KEYWORD_NUDGE } from "./keywords.js";
+import { logDebug, logError as logErr } from "./logger.js";
 import { readFile } from "node:fs/promises";
 
 const projectNameCache = new Map<string, string>();
 
 async function detectProjectName(rootPath: string): Promise<string | undefined> {
   const cached = projectNameCache.get(rootPath);
-  if (cached !== undefined) return cached;
+  if (cached !== undefined) {
+    logDebug("detectProjectName cache hit", { rootPath, result: cached });
+    return cached;
+  }
 
   let result: string | undefined;
 
-  // 1. AGENTS.md — first-line heading
   try {
     const agents = await readFile(`${rootPath}/AGENTS.md`, "utf-8");
     const headingMatch = agents.match(/^#\s+(.+)/m);
     if (headingMatch) {
       result = headingMatch[1].replace(/\s*\(.*?\)/g, "").trim() || undefined;
     }
+    logDebug("detectProjectName step1 AGENTS.md", { rootPath, result });
   } catch {}
 
-  // 2. package.json
   if (!result) {
     try {
       const pkg = await readFile(`${rootPath}/package.json`, "utf-8");
       const nameMatch = pkg.match(/"name"\s*:\s*"([^"]+)"/);
       if (nameMatch) result = nameMatch[1].trim() || undefined;
+      logDebug("detectProjectName step2 package.json", { rootPath, result });
     } catch {}
   }
 
-  // 3. Cargo.toml — name in [package]
   if (!result) {
     try {
       const cargo = await readFile(`${rootPath}/Cargo.toml`, "utf-8");
@@ -47,10 +50,10 @@ async function detectProjectName(rootPath: string): Promise<string | undefined>
         { inSection: false, name: undefined as string | undefined },
       );
       result = inPackage.name?.trim() || undefined;
+      logDebug("detectProjectName step3 Cargo.toml", { rootPath, result });
     } catch {}
   }
 
-  // 4. go.mod — module last segment
   if (!result) {
     try {
       const gomod = await readFile(`${rootPath}/go.mod`, "utf-8");
@@ -59,10 +62,10 @@ async function detectProjectName(rootPath: string): Promise<string | undefined>
         const segments = modMatch[1].split("/");
         result = segments.pop()?.trim() || undefined;
       }
+      logDebug("detectProjectName step4 go.mod", { rootPath, result });
     } catch {}
   }
 
-  // 5. pyproject.toml — name in [project]
   if (!result) {
     try {
       const pyproj = await readFile(`${rootPath}/pyproject.toml`, "utf-8");
@@ -79,21 +82,22 @@ async function detectProjectName(rootPath: string): Promise<string | undefined>
         { inSection: false, name: undefined as string | undefined },
       );
       result = inProject.name?.trim() || undefined;
+      logDebug("detectProjectName step5 pyproject.toml", { rootPath, result });
     } catch {}
   }
 
-  // 6. composer.json
   if (!result) {
     try {
       const composer = await readFile(`${rootPath}/composer.json`, "utf-8");
       const nameMatch = composer.match(/"name"\s*:\s*"([^"]+)"/);
       if (nameMatch) result = nameMatch[1].trim() || undefined;
+      logDebug("detectProjectName step6 composer.json", { rootPath, result });
     } catch {}
   }
 
-  // 7. Fallback — directory name
   if (!result) {
     result = rootPath.split("/").pop() || rootPath.split("\\").pop() || undefined;
+    logDebug("detectProjectName step7 fallback dirname", { rootPath, result });
   }
 
   if (result) {
@@ -427,15 +431,19 @@ export function compactingHook(client: OmemClient, containerTags: string[], tui:
           try {
             if (sdkClient && input.sessionID) {
               const sessionInfo = await sdkClient.session.get({ path: { id: input.sessionID } });
+              logDebug("compactingHook sessionInfo", { sessionInfo: JSON.stringify(sessionInfo) });
+              logDebug("compactingHook project.rootPath", { rootPath: sessionInfo?.project?.rootPath });
               projectName = sessionInfo?.project?.rootPath
                 ? await detectProjectName(sessionInfo.project.rootPath)
                 : undefined;
+              logDebug("compactingHook projectName", { projectName: String(projectName) });
             }
-          } catch {
-            // Detection failure should not block ingestion
+          } catch (e) {
+            logErr("compactingHook detectProjectName failed", { error: String(e) });
           }
 
           try {
+            logDebug("compactingHook ingestMessages called", { msgCount: messages.length, projectName: String(projectName), sessionId: effectiveSessionId });
             const result = await client.ingestMessages(messages, {
               mode: ingestMode,
               tags: [...containerTags, "auto-capture"],
@@ -443,12 +451,14 @@ export function compactingHook(client: OmemClient, containerTags: string[], tui:
               parentSessionId: isSubAgent ? input.sessionID : undefined,
               projectName: projectName,
             });
+            logDebug("compactingHook ingestMessages result", { result: result === null ? "null(blocked)" : "ok" });
             if (result === null) {
               showToast(tui, "🔴 Archive Failed", "Session archive blocked · check spiritual realm status", "error");
             } else {
               showToast(tui, "📦 Session Archived", `${messages.length} residual dialogues archived · merged into the realm`, "success");
             }
-          } catch {
+          } catch (e) {
+            logErr("compactingHook ingestMessages failed", { error: String(e) });
             showToast(tui, "🔴 Archive Failed", "Session archive blocked · spiritual pulse anomaly", "error");
           }
           sessionMessages.delete(input.sessionID);
@@ -546,21 +556,27 @@ export function sessionIdleHook(
         let projectName: string | undefined;
         try {
           const sessionInfo = await sdkClient.session.get({ path: { id: sessionID } });
+          logDebug("sessionIdleHook sessionInfo", { sessionInfo: JSON.stringify(sessionInfo) });
+          logDebug("sessionIdleHook project.rootPath", { rootPath: sessionInfo?.project?.rootPath });
           sessionTitle = sessionInfo?.title;
           projectName = sessionInfo?.project?.rootPath
             ? await detectProjectName(sessionInfo.project.rootPath)
             : undefined;
+          logDebug("sessionIdleHook projectName", { projectName: String(projectName) });
         } catch (e) {
-          // 获取失败不影响主流程
+          logErr("sessionIdleHook detectProjectName failed", { error: String(e) });
         }
 
         try {
+          logDebug("sessionIdleHook sessionIngest called", { msgCount: conversationMessages.length, projectName: String(projectName), sessionId: sessionID, title: String(sessionTitle) });
           await omemClient.sessionIngest(conversationMessages, sessionID, agentId, sessionTitle, projectName);
+          logDebug("sessionIdleHook sessionIngest ok");
           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) {
+          logErr("sessionIdleHook sessionIngest failed", { error: String(err) });
           showToast(tui, "🔴 Session Capture Failed", String(err).substring(0, 100), "error");
         }
       } catch (err) {

package/src/logger.ts

@@ -5,42 +5,46 @@ import { join } from "node:path";
 const LOG_DIR = join(homedir(), ".config", "ourmem");
 const LOG_FILE = join(LOG_DIR, "plugin.log");
 
+const START_TIME = Date.now();
+
 function ensureLogDir(): void {
   if (!existsSync(LOG_DIR)) {
     try {
       mkdirSync(LOG_DIR, { recursive: true });
-    } catch {
-      // silently fail if we can't create log directory
-    }
+    } catch {}
   }
 }
 
-function writeLog(level: string, ...args: unknown[]): void {
+function writeLog(level: string, message: string, fields?: Record<string, unknown>): void {
   ensureLogDir();
-  const timestamp = new Date().toISOString();
-  const message = args
-    .map((a) => (typeof a === "string" ? a : JSON.stringify(a)))
-    .join(" ");
-  const line = `[${timestamp}] [${level}] ${message}\n`;
-  try {
-    appendFileSync(LOG_FILE, line);
-  } catch {
-    // silently fail if we can't write to log file
+  const now = new Date();
+  const ts = now.toISOString().replace("T", " ").replace(/\.\d+Z$/, "");
+  const offset = Date.now() - START_TIME;
+  const parts = [`${level.padEnd(5)} ${ts} +${offset}ms service=cerebro`];
+  if (fields) {
+    for (const [k, v] of Object.entries(fields)) {
+      const val = typeof v === "string" ? v : JSON.stringify(v);
+      parts.push(`${k}=${val}`);
+    }
   }
+  parts.push(message);
+  try {
+    appendFileSync(LOG_FILE, parts.join(" ") + "\n");
+  } catch {}
 }
 
-export function logInfo(...args: unknown[]): void {
-  writeLog("INFO", ...args);
+export function logInfo(message: string, fields?: Record<string, unknown>): void {
+  writeLog("INFO", message, fields);
 }
 
-export function logWarn(...args: unknown[]): void {
-  writeLog("WARN", ...args);
+export function logWarn(message: string, fields?: Record<string, unknown>): void {
+  writeLog("WARN", message, fields);
 }
 
-export function logError(...args: unknown[]): void {
-  writeLog("ERROR", ...args);
+export function logError(message: string, fields?: Record<string, unknown>): void {
+  writeLog("ERROR", message, fields);
 }
 
-export function logDebug(...args: unknown[]): void {
-  writeLog("DEBUG", ...args);
+export function logDebug(message: string, fields?: Record<string, unknown>): void {
+  writeLog("DEBUG", message, fields);
 }