@mingxy/cerebro 1.19.3 → 1.20.1

package/package.json

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

package/src/config.ts

@@ -39,6 +39,7 @@ export interface CerebroPluginConfig {
   };
   agentMemoryPolicy?: Record<string, "none" | "readonly" | "readwrite">;
   defaultPolicy?: "none" | "readonly" | "readwrite";
+  autoUpdate?: boolean;  // default false
 }
 
 // ── Defaults ─────────────────────────────────────────────────────────
@@ -75,6 +76,7 @@ const DEFAULTS: CerebroPluginConfig = {
   web: {
     enabled: true,
   },
+  autoUpdate: false,
 };
 
 // ── Flat-to-nested migration ─────────────────────────────────────────
@@ -146,6 +148,7 @@ function deepMerge(base: CerebroPluginConfig, overrides: Partial<CerebroPluginCo
   result.web = { ...base.web!, ...overrides.web };
   if (overrides.agentMemoryPolicy) result.agentMemoryPolicy = overrides.agentMemoryPolicy;
   if (overrides.defaultPolicy) result.defaultPolicy = overrides.defaultPolicy;
+  if (overrides.autoUpdate !== undefined) result.autoUpdate = overrides.autoUpdate;
   return result;
 }
 
@@ -174,7 +177,7 @@ function configLog(message: string, fields?: Record<string, unknown>, level: str
   if (lvl < CONFIGURED_MIN_LEVEL) return;
   try {
     const logDir = join(homedir(), ".config", "cerebro", "logs");
-    const logPath = join(logDir, "plugin.log");
+    const logPath = join(logDir, "cerebro.log");
     const ts = new Date().toISOString().replace("T", " ").replace(/\.\d+Z$/, "");
     const parts = [`${level.padEnd(5)} ${ts} service=cerebro ${message}`];
     if (fields) {

package/src/hooks.ts

@@ -226,6 +226,8 @@ interface InjectionResult {
   profileCount: number;
   memoryCount: number;
   projectMemoryCount: number;
+  maxScore: number;
+  confidence: number;
 }
 
 export async function buildMemoryInjection(
@@ -297,11 +299,16 @@ export async function buildMemoryInjection(
     text = text.slice(0, cutoff > 0 ? cutoff : maxChars) + "\n…\n[/CEREBRO-MEMORY]";
   }
 
+  const maxScore = searchResults.reduce((max, r) => Math.max(max, r.score), 0);
+  const confidence = Math.min(maxScore, 1.0);
+
   return {
     text,
     profileCount: profile?.preference_count ?? 0,
     memoryCount: dedupedResults?.length ?? 0,
     projectMemoryCount: projectMemories.length,
+    maxScore,
+    confidence,
   };
 }
 
@@ -371,8 +378,8 @@ export function chatMessageRecallHook(
           session_id: input.sessionID,
           recall_type: "auto",
           query_text: query,
-          max_score: 0,
-          llm_confidence: 0,
+          max_score: injection.maxScore,
+          llm_confidence: injection.confidence,
           profile_injected: injection.profileCount > 0,
           kept_count: injection.projectMemoryCount + injection.memoryCount,
           discarded_count: 0,

package/src/index.ts

@@ -3,15 +3,15 @@ import { readFileSync, writeFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
-import type { Server } from "node:http";
 import { CerebroClient } from "./client.js";
 import { chatMessageRecallHook, autocontinueHook, compactingHook, sessionIdleHook, createToast, sessionMessages, firstMessages } from "./hooks.js";
 import { detectSaveKeyword, detectRecallKeyword, KEYWORD_NUDGE, RECALL_NUDGE } from "./keywords.js";
 import { getUserTag, getProjectTag } from "./tags.js";
 import { buildTools } from "./tools.js";
-import { logInfo, logDebug, logError } from "./logger.js";
+import { logInfo, logDebug, logError, setOpencodeClient } from "./logger.js";
 import { loadPluginConfig, resolveAgentPolicy } from "./config.js";
-import { startWebServer, stopWebServer } from "./web-server.js";
+import { checkAndUpdate } from "./updater.js";
+import { startWebServer, stopWebServer, type WebServerHandle } from "./web-server.js";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -66,6 +66,8 @@ const OmemPlugin: Plugin = async (input) => {
   const config = loadPluginConfig(overrides as any);
   const toast = createToast(config);
 
+  setOpencodeClient(client);
+
   const cerebroClient = new CerebroClient(config.connection.apiUrl, config.connection.apiKey, config);
 
   try {
@@ -103,7 +105,7 @@ const OmemPlugin: Plugin = async (input) => {
 
   const chatMessageRecall = chatMessageRecallHook(cerebroClient, containerTags, tui, config, () => cachedAgentName || agentId, directory);
 
-  let webServer: Server | null = null;
+  let webServer: WebServerHandle | null = null;
   const webEnabled = config.web?.enabled !== false;
   let webPort: number | undefined;
   if (webEnabled) {
@@ -125,9 +127,12 @@ const OmemPlugin: Plugin = async (input) => {
   if (webPort) {
     toast(tui, `🧠 Cerebro Connected · v${pluginVersion}`, `🌐 Open in browser http://localhost:${webPort}`, "success");
   } else {
-    toast(tui, "🧠 Connected", `v${pluginVersion}`, "success");
+    toast(tui, `🧠 Cerebro Connected · v${pluginVersion}`, "No web server", "success");
   }
 
+  // Auto-update check (fire-and-forget, non-blocking)
+  checkAndUpdate(tui, pluginVersion).catch(() => {});
+
   const shutdown = async () => {
     try {
       if (webServer) {

package/src/logger.ts

@@ -1,66 +1,165 @@
-import { appendFileSync, mkdirSync, existsSync } from "node:fs";
-import { join } from "node:path";
-import { loadPluginConfig } from "./config.js";
-
-const LEVEL_MAP: Record<string, number> = {
-  DEBUG: 0,
-  INFO: 1,
-  WARN: 2,
-  ERROR: 3,
-};
-
-const cfg = loadPluginConfig();
-const MIN_LEVEL = LEVEL_MAP[cfg.logging.logLevel] ?? LEVEL_MAP.INFO;
-const LOG_DIR = cfg.logging.logDir;
-const LOG_FILE = join(LOG_DIR, "plugin.log");
-const LOG_ENABLED = cfg.logging.logEnabled;
-
-let lastLogTime = Date.now();
-
-function ensureLogDir(): void {
-  if (!existsSync(LOG_DIR)) {
-    try {
-      mkdirSync(LOG_DIR, { recursive: true });
-    } catch {}
-  }
-}
-
-function writeLog(level: string, message: string, fields?: Record<string, unknown>): void {
-  if (!LOG_ENABLED) return;
-  const lvl = LEVEL_MAP[level] ?? 0;
-  if (lvl < MIN_LEVEL) return;
-  ensureLogDir();
-  const now = new Date();
-  const nowMs = now.getTime();
-  const delta = ((nowMs - lastLogTime) / 1000).toFixed(2);
-  lastLogTime = nowMs;
-  const pad = (n: number) => String(n).padStart(2, "0");
-  const ts = `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())} ${pad(now.getHours())}:${pad(now.getMinutes())}:${pad(now.getSeconds())}`;
-  const parts = [`${level.padEnd(5)} ${ts} +${delta}s 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(message: string, fields?: Record<string, unknown>): void {
-  writeLog("INFO", message, fields);
-}
-
-export function logWarn(message: string, fields?: Record<string, unknown>): void {
-  writeLog("WARN", message, fields);
-}
-
-export function logError(message: string, fields?: Record<string, unknown>): void {
-  writeLog("ERROR", message, fields);
-}
-
-export function logDebug(message: string, fields?: Record<string, unknown>): void {
-  writeLog("DEBUG", message, fields);
-}
+import {
+  appendFileSync,
+  mkdirSync,
+  existsSync,
+  statSync,
+  renameSync,
+  readdirSync,
+  unlinkSync,
+} from "node:fs";
+import { join } from "node:path";
+import { loadPluginConfig } from "./config.js";
+
+// ── Level map ─────────────────────────────────────────────────────────
+
+const LEVEL_MAP: Record<string, number> = {
+  DEBUG: 0,
+  INFO: 1,
+  WARN: 2,
+  ERROR: 3,
+};
+
+// ── Config access with 30-second TTL cache ────────────────────────────
+
+let cachedConfig: ReturnType<typeof loadPluginConfig> | null = null;
+let configCacheTime = 0;
+const CONFIG_TTL_MS = 30_000;
+
+function getConfig() {
+  const now = Date.now();
+  if (cachedConfig && (now - configCacheTime) < CONFIG_TTL_MS) return cachedConfig;
+  cachedConfig = loadPluginConfig();
+  configCacheTime = now;
+  return cachedConfig;
+}
+
+function getLogFilePath(sessionId?: string): string {
+  const base = getConfig().logging.logDir;
+  if (sessionId) {
+    return join(base, `cerebro-${sessionId}.log`);
+  }
+  return join(base, "cerebro.log");
+}
+
+function getMinLevel(): number {
+  return LEVEL_MAP[getConfig().logging.logLevel] ?? LEVEL_MAP.INFO;
+}
+
+function isLogEnabled(): boolean {
+  return getConfig().logging.logEnabled;
+}
+
+// ── Opencode client for dual-track logging ────────────────────────────
+
+let opencodeClient: any = null;
+
+export function setOpencodeClient(client: any): void {
+  opencodeClient = client;
+}
+
+// ── Log file rotation (5 MB threshold) ────────────────────────────────
+// NOTE: multi-window concurrent rotate is a known limitation — the last
+// writer to rename wins; earlier writers will create a fresh file.
+
+const MAX_LOG_SIZE = 5 * 1024 * 1024; // 5 MB
+
+function rotateIfNeeded(logFile: string): void {
+  try {
+    const s = statSync(logFile);
+    if (s.size > MAX_LOG_SIZE) {
+      renameSync(logFile, logFile.replace(".log", ".old.log"));
+    }
+  } catch { /* file doesn't exist yet, first write */ }
+}
+
+// ── Startup cleanup (delete logs older than 7 days) ───────────────────
+
+const LOG_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000; // 7 days
+
+function cleanupOldLogs(): void {
+  const logDir = getConfig().logging.logDir;
+  try {
+    const files = readdirSync(logDir);
+    const cutoff = Date.now() - LOG_MAX_AGE_MS;
+    for (const f of files) {
+      if (!f.endsWith(".log") && !f.endsWith(".old.log")) continue;
+      const fp = join(logDir, f);
+      try {
+        const s = statSync(fp);
+        if (s.mtimeMs < cutoff) unlinkSync(fp);
+      } catch {}
+    }
+  } catch {}
+}
+
+// Run cleanup once at module load
+cleanupOldLogs();
+
+// ── Core logging ──────────────────────────────────────────────────────
+
+let lastLogTime = Date.now();
+
+function ensureLogDir(logDir: string): void {
+  if (!existsSync(logDir)) {
+    try {
+      mkdirSync(logDir, { recursive: true });
+    } catch {}
+  }
+}
+
+function writeLog(level: string, message: string, fields?: Record<string, unknown>): void {
+  if (!isLogEnabled()) return;
+  const lvl = LEVEL_MAP[level] ?? 0;
+  if (lvl < getMinLevel()) return;
+
+  const cfg = getConfig();
+  const sid = (fields?.sessionId ?? fields?.sessionID) as string | undefined;
+  const logFile = getLogFilePath(sid);
+  ensureLogDir(cfg.logging.logDir);
+
+  const now = new Date();
+  const nowMs = now.getTime();
+  const delta = ((nowMs - lastLogTime) / 1000).toFixed(2);
+  lastLogTime = nowMs;
+  const pad = (n: number) => String(n).padStart(2, "0");
+  const ts = `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())} ${pad(now.getHours())}:${pad(now.getMinutes())}:${pad(now.getSeconds())}`;
+  const parts = [`${level.padEnd(5)} ${ts} +${delta}s 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);
+
+  // Track 1: file
+  try {
+    rotateIfNeeded(logFile);
+    appendFileSync(logFile, parts.join(" ") + "\n");
+  } catch {}
+
+  // Track 2: opencode client
+  try {
+    opencodeClient?.app?.log({
+      body: { service: "cerebro", level: level.toLowerCase(), message, extra: fields },
+    });
+  } catch { /* opencode client not available, skip */ }
+}
+
+// ── Public API ────────────────────────────────────────────────────────
+
+export function logInfo(message: string, fields?: Record<string, unknown>): void {
+  writeLog("INFO", message, fields);
+}
+
+export function logWarn(message: string, fields?: Record<string, unknown>): void {
+  writeLog("WARN", message, fields);
+}
+
+export function logError(message: string, fields?: Record<string, unknown>): void {
+  writeLog("ERROR", message, fields);
+}
+
+export function logDebug(message: string, fields?: Record<string, unknown>): void {
+  writeLog("DEBUG", message, fields);
+}

package/src/updater.ts

@@ -0,0 +1,155 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { createRequire } from "node:module";
+import { join, dirname } from "node:path";
+import { homedir, tmpdir } from "node:os";
+import { openSync, closeSync, unlinkSync, statSync, writeSync, mkdtempSync, readdirSync, rmSync } from "node:fs";
+import { loadPluginConfig } from "./config.js";
+import { logInfo, logDebug, logError } from "./logger.js";
+
+const execFileAsync = promisify(execFile);
+const require = createRequire(import.meta.url);
+
+// ── Version fetching ────────────────────────────────────────────────
+
+async function getLatestVersion(): Promise<string | null> {
+  try {
+    const { stdout } = await execFileAsync("npm", ["view", "@mingxy/cerebro", "version"], { timeout: 10000 });
+    logDebug("updater: fetched latest version", { version: stdout.trim() });
+    return stdout.trim();
+  } catch {
+    logError("updater: failed to fetch latest version");
+    return null;
+  }
+}
+
+// ── Semantic version comparison ─────────────────────────────────────
+
+function compareVersions(a: string, b: string): number {
+  const pa = a.replace(/^v/, "").split(".").map(Number);
+  const pb = b.replace(/^v/, "").split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((pa[i] ?? 0) > (pb[i] ?? 0)) return 1;
+    if ((pa[i] ?? 0) < (pb[i] ?? 0)) return -1;
+  }
+  return 0;
+}
+
+// ── Install dir detection ───────────────────────────────────────────
+
+function getInstallDir(): string {
+  try {
+    const pkgPath = require.resolve("@mingxy/cerebro/package.json");
+    return dirname(pkgPath);
+  } catch {
+    return join(homedir(), ".cache", "opencode", "packages", "@mingxy", "cerebro");
+  }
+}
+
+// ── Install update via npm pack + tar ───────────────────────────────
+
+async function installUpdate(targetDir: string): Promise<boolean> {
+  const tmpDir = mkdtempSync(join(tmpdir(), "cerebro-update-"));
+  logInfo("updater: downloading update", { targetDir, tmpDir });
+  try {
+    // 1. Download tgz
+    await execFileAsync("npm", ["pack", "@mingxy/cerebro@latest", "--pack-destination", tmpDir], { timeout: 60000 });
+
+    // 2. Find the tgz file
+    const files = readdirSync(tmpDir);
+    const tgz = files.find(f => f.endsWith(".tgz"));
+    if (!tgz) {
+      logError("updater: no tgz found after npm pack", { tmpDir, files: files.join(",") });
+      return false;
+    }
+
+    // 3. Extract to target dir (strip the "package/" prefix from tgz)
+    await execFileAsync("tar", ["-xzf", join(tmpDir, tgz), "-C", targetDir, "--strip-components=1", "--no-same-owner", "--no-same-permissions"], { timeout: 30000 });
+
+    logInfo("updater: update installed successfully", { targetDir, tgz });
+    return true;
+  } catch (err) {
+    logError("updater: install failed", { error: err instanceof Error ? err.message : String(err) });
+    return false;
+  } finally {
+    try { rmSync(tmpDir, { recursive: true }); } catch {}
+  }
+}
+
+// ── File lock with stale lock cleanup ───────────────────────────────
+
+const LOCK_FILE = join(tmpdir(), "cerebro-update.lock");
+const STALE_LOCK_MS = 5 * 60 * 1000; // 5 minutes
+let lockFd: number | null = null;
+
+function acquireLock(): boolean {
+  try {
+    // Clean up stale lock first
+    try {
+      const s = statSync(LOCK_FILE);
+      if (Date.now() - s.mtimeMs > STALE_LOCK_MS) {
+        unlinkSync(LOCK_FILE);
+        logDebug("updater: cleaned stale lock", { ageMs: Date.now() - s.mtimeMs });
+      }
+    } catch { /* lock file doesn't exist, normal */ }
+
+    lockFd = openSync(LOCK_FILE, "wx");
+    writeSync(lockFd, String(process.pid));
+    logDebug("updater: lock acquired", { pid: process.pid });
+    return true;
+  } catch {
+    logDebug("updater: lock acquisition failed (another process updating?)");
+    return false;
+  }
+}
+
+function releaseLock(): void {
+  if (lockFd !== null) {
+    try { closeSync(lockFd); } catch {}
+    lockFd = null;
+    try { unlinkSync(LOCK_FILE); } catch {}
+    logDebug("updater: lock released");
+  }
+}
+
+// ── Main entry ──────────────────────────────────────────────────────
+
+export async function checkAndUpdate(tui: any, currentVersion: string): Promise<void> {
+  const config = loadPluginConfig();
+  if (!config.autoUpdate) {
+    logDebug("updater: autoUpdate disabled, skipping");
+    return;
+  }
+
+  logInfo("updater: checking for updates", { currentVersion });
+
+  const latest = await getLatestVersion();
+  if (!latest) return;
+
+  if (compareVersions(latest, currentVersion) <= 0) {
+    logInfo("updater: already up to date", { currentVersion, latest });
+    return;
+  }
+
+  logInfo("updater: new version available", { currentVersion, latest });
+
+  if (!acquireLock()) return;
+
+  try {
+    const targetDir = getInstallDir();
+    const success = await installUpdate(targetDir);
+
+    if (success) {
+      logInfo("updater: update completed", { from: currentVersion, to: latest });
+      try {
+        tui?.showToast?.({
+          body: { message: `Cerebro updated to v${latest} — restart opencode to apply`, variant: "info" }
+        });
+      } catch {}
+    } else {
+      logError("updater: update failed", { targetDir });
+    }
+  } finally {
+    releaseLock();
+  }
+}