@mingxy/cerebro 1.5.11 → 1.6.2

package/package.json

@@ -1,11 +1,22 @@
 {
   "name": "@mingxy/cerebro",
-  "version": "1.5.11",
+  "version": "1.6.2",
   "description": "Cerebro persistent memory plugin for OpenCode — auto-recall, auto-capture, 9 memory tools with clustering",
   "type": "module",
   "main": "src/index.ts",
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "default": "./src/index.ts"
+    },
+    "./tui": {
+      "types": "./src/tui.tsx",
+      "default": "./src/tui.tsx"
+    }
+  },
   "oc-plugin": [
-    "server"
+    "server",
+    "tui"
   ],
   "keywords": [
     "opencode",
@@ -24,7 +35,10 @@
     "directory": "plugins/opencode"
   },
   "dependencies": {
-    "@opencode-ai/plugin": "^1.0.162"
+    "@opencode-ai/plugin": "^1.0.162",
+    "@opentui/core": "^0.1.92",
+    "@opentui/solid": "^0.1.92",
+    "solid-js": "^1.9.10"
   },
   "devDependencies": {
     "@types/node": "^25.5.0",

package/src/hooks.ts

@@ -143,7 +143,7 @@ export function autoRecallHook(client: OmemClient, containerTags: string[], tui:
       const shouldRecallRes = await client.shouldRecall(query_text, last_query_text, input.sessionID, similarityThreshold, maxRecallResults, projectTags.length > 0 ? projectTags : undefined);
 
       if (!shouldRecallRes) {
-        showToast(tui, "🧠 Omem Service Unavailable", "Unable to reach memory API · check connection", "error", toastDelayMs);
+        showToast(tui, "🧠 Cerebro Service Unavailable", "Unable to reach memory API · check connection", "error", toastDelayMs);
         return;
       }
 
@@ -250,14 +250,14 @@ export function autoRecallHook(client: OmemClient, containerTags: string[], tui:
         // Server returned error (500, etc.) with details
         const cleanMsg = errMsg.replace(/^\[omem\]\s*/, "");
         if (cleanMsg.startsWith("500")) {
-          showToast(tui, "🧠 Omem Server Error", cleanMsg.substring(0, 200), "error");
+          showToast(tui, "🧠 Cerebro Server Error", cleanMsg.substring(0, 200), "error");
         } else if (cleanMsg.includes("timed out")) {
-          showToast(tui, "🧠 Omem Service Timeout", cleanMsg.substring(0, 100), "error");
+          showToast(tui, "🧠 Cerebro Service Timeout", cleanMsg.substring(0, 100), "error");
         } else {
-          showToast(tui, "🧠 Omem Error", cleanMsg.substring(0, 150), "error");
+          showToast(tui, "🧠 Cerebro Error", cleanMsg.substring(0, 150), "error");
         }
       } else if (errMsg.includes("fetch") || errMsg.includes("network")) {
-        showToast(tui, "🧠 Omem Service Unavailable", "Network error · check API connection", "error");
+        showToast(tui, "🧠 Cerebro Service Unavailable", "Network error · check API connection", "error");
       } else {
         showToast(tui, "🧠 Memory Recall Error", errMsg.substring(0, 100), "error");
       }
@@ -302,29 +302,33 @@ export function keywordDetectionHook(_client: OmemClient, _containerTags: string
   };
 }
 
-export function compactingHook(client: OmemClient, containerTags: string[], tui: any, ingestMode: "smart" | "raw" = "smart") {
+export function compactingHook(client: OmemClient, containerTags: string[], tui: any, ingestMode: "smart" | "raw" = "smart", isAutoStoreEnabled?: (sessionId: string | undefined) => boolean) {
   return async (
     input: { sessionID?: string },
     output: { context: string[]; prompt?: string },
   ) => {
     if (input.sessionID && sessionMessages.has(input.sessionID)) {
-      const messages = sessionMessages.get(input.sessionID)!;
-      if (messages.length > 0) {
-        try {
-          const result = await client.ingestMessages(messages, {
-            mode: ingestMode,
-            tags: [...containerTags, "auto-capture"],
-            sessionId: input.sessionID,
-          });
-          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");
+      if (isAutoStoreEnabled && !isAutoStoreEnabled(input.sessionID)) {
+        sessionMessages.delete(input.sessionID);
+      } else {
+        const messages = sessionMessages.get(input.sessionID)!;
+        if (messages.length > 0) {
+          try {
+            const result = await client.ingestMessages(messages, {
+              mode: ingestMode,
+              tags: [...containerTags, "auto-capture"],
+              sessionId: input.sessionID,
+            });
+            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 {
+            showToast(tui, "🔴 Archive Failed", "Session archive blocked · spiritual pulse anomaly", "error");
           }
-        } catch {
-          showToast(tui, "🔴 Archive Failed", "Session archive blocked · spiritual pulse anomaly", "error");
+          sessionMessages.delete(input.sessionID);
         }
-        sessionMessages.delete(input.sessionID);
       }
     }
 
@@ -350,6 +354,7 @@ export function sessionIdleHook(
   _ingestMode: "smart" | "raw" = "smart",
   threshold: number = 0,
   getMainSessionId?: () => string | undefined,
+  isAutoStoreEnabled?: (sessionId: string | undefined) => boolean,
 ) {
   let idleTimeout: ReturnType<typeof setTimeout> | null = null;
   let isCapturing = false;
@@ -360,6 +365,8 @@ export function sessionIdleHook(
     const sessionID = input.event.properties?.sessionID;
     if (!sessionID) return;
 
+    if (isAutoStoreEnabled && !isAutoStoreEnabled(sessionID)) return;
+
     if (getMainSessionId) {
       const mainId = getMainSessionId();
       if (mainId && sessionID !== mainId) return;

package/src/index.ts

@@ -20,7 +20,22 @@ try {
   }
 } catch {}
 
-function showToast(tui: any, title: string, message: string, variant: string = "info", duration: number = 5000) {
+// Per-session auto-store toggle: sessionId → enabled (default: true = auto-store on)
+const autoStoreSessions = new Map<string, boolean>();
+
+export function isAutoStoreEnabled(sessionId: string | undefined): boolean {
+  if (!sessionId) return true;
+  return autoStoreSessions.get(sessionId) ?? true;
+}
+
+export function setAutoStoreEnabled(sessionId: string, enabled: boolean): void {
+  autoStoreSessions.set(sessionId, enabled);
+}
+
+// Bridge for TUI plugin (same process, different module graph)
+(globalThis as any).__cerebro_autoStore = isAutoStoreEnabled;
+
+function showToast(tui: any, title: string, message?: string, variant: string = "info", duration: number = 5000) {
   if (!tui) return;
   setTimeout(() => {
     try {
@@ -48,13 +63,7 @@ const OmemPlugin: Plugin = async (input) => {
   // 启动时检测连接状态
   try {
     await omemClient.getStats();
-    showToast(
-      tui,
-      `🧠 Omem v${pluginVersion} · Connected`,
-      `${config.apiUrl.replace(/^https?:\/\//, "")}`,
-      "success",
-      6000
-    );
+    showToast(tui, `🧠 Cerebro v${pluginVersion} · Connected`, undefined, "success", 6000);
     logInfo(`Connected to ${config.apiUrl}`);
   } catch (err) {
     const errMsg = err instanceof Error ? err.message : String(err);
@@ -63,7 +72,7 @@ const OmemPlugin: Plugin = async (input) => {
       const cleanMsg = errMsg.replace(/^\[omem\]\s*/, "");
       showToast(
         tui,
-        `🧠 Omem v${pluginVersion} · Server Error`,
+        `🧠 Cerebro v${pluginVersion} · Server Error`,
         cleanMsg.substring(0, 150),
         "error",
         8000
@@ -71,7 +80,7 @@ const OmemPlugin: Plugin = async (input) => {
     } else {
       showToast(
         tui,
-        `🧠 Omem v${pluginVersion} · Connection Failed`,
+        `🧠 Cerebro v${pluginVersion} · Connection Failed`,
         `Unable to reach ${config.apiUrl}`,
         "error",
         8000
@@ -89,14 +98,36 @@ const OmemPlugin: Plugin = async (input) => {
   const recallHook = autoRecallHook(omemClient, containerTags, tui, config);
 
   return {
+    config: async (cfg: any) => {
+      cfg.command ??= {};
+      cfg.command["memory-toggle"] = {
+        template: "/memory-toggle <on|off>",
+        description: "Toggle Cerebro auto-store ON or OFF for current session",
+      };
+    },
+    "command.execute.before": async (input: { command: string; sessionID: string; arguments: string }, output: { parts: any[] }) => {
+      if (input.command !== "memory-toggle") return;
+      const arg = input.arguments.trim().toLowerCase();
+      const sessionId = input.sessionID;
+      if (arg === "off") {
+        setAutoStoreEnabled(sessionId, false);
+        output.parts = [{ type: "text", text: "⏸️ Cerebro auto-store: OFF — manual memory_store still works" }];
+      } else if (arg === "on") {
+        setAutoStoreEnabled(sessionId, true);
+        output.parts = [{ type: "text", text: "✅ Cerebro auto-store: ON" }];
+      } else {
+        const current = isAutoStoreEnabled(sessionId);
+        output.parts = [{ type: "text", text: `Cerebro auto-store: ${current ? "✅ ON" : "⏸️ OFF"}\nUsage: /memory-toggle on | off` }];
+      }
+    },
     "experimental.chat.system.transform": async (input: any, output: any) => {
       if (input.sessionID) currentSessionId = input.sessionID;
       return recallHook(input, output);
     },
     "chat.message": keywordDetectionHook(omemClient, containerTags, config.autoCaptureThreshold, tui, config.ingestMode),
-    "experimental.session.compacting": compactingHook(omemClient, containerTags, tui, config.ingestMode),
+    "experimental.session.compacting": compactingHook(omemClient, containerTags, tui, config.ingestMode, isAutoStoreEnabled),
     tool: buildTools(omemClient, containerTags, { agentId, getSessionId: () => currentSessionId }),
-    event: sessionIdleHook(omemClient, containerTags, tui, client, config.ingestMode, config.autoCaptureThreshold, () => currentSessionId),
+    event: sessionIdleHook(omemClient, containerTags, tui, client, config.ingestMode, config.autoCaptureThreshold, () => currentSessionId, isAutoStoreEnabled),
     "shell.env": async (_input: any, output: any) => {
       if (directory) {
         output.env.OMEM_PROJECT_DIR = directory;
@@ -107,6 +138,8 @@ const OmemPlugin: Plugin = async (input) => {
 
 export { OmemPlugin };
 
+export { default as tui } from "./tui.js";
+
 export default {
   id: "ourmem",
   server: OmemPlugin,

package/src/tools.ts

@@ -1,5 +1,6 @@
 import { tool } from "@opencode-ai/plugin";
 import type { OmemClient } from "./client.js";
+import { isAutoStoreEnabled, setAutoStoreEnabled } from "./index.js";
 
 function extractMemoryIds(result: unknown): string[] {
   if (!result) return [];
@@ -373,5 +374,31 @@ export function buildTools(client: OmemClient, containerTags: string[], context:
         return JSON.stringify({ ok: true, result });
       },
     }),
+
+    memory_toggle: tool({
+      description:
+        "Toggle Cerebro auto-store ON or OFF for current session. Does NOT affect manual memory_store calls.",
+      args: {
+        state: tool.schema
+          .string()
+          .optional()
+          .describe("Set to 'on' or 'off'. Omit to check current status."),
+      },
+      async execute(args) {
+        const sessionId = context.getSessionId();
+        if (!sessionId) return JSON.stringify({ ok: false, error: "No active session" });
+
+        if (args.state === "on") {
+          setAutoStoreEnabled(sessionId, true);
+          return JSON.stringify({ ok: true, auto_store: true, message: "Cerebro auto-store: ON" });
+        } else if (args.state === "off") {
+          setAutoStoreEnabled(sessionId, false);
+          return JSON.stringify({ ok: true, auto_store: false, message: "Cerebro auto-store: OFF" });
+        } else {
+          const current = isAutoStoreEnabled(sessionId);
+          return JSON.stringify({ ok: true, auto_store: current, message: `Cerebro auto-store: ${current ? "ON" : "OFF"}` });
+        }
+      },
+    }),
   };
 }

package/src/tui.tsx

@@ -0,0 +1,72 @@
+// @ts-nocheck — TUI JSX is resolved at runtime by opencode (same as quota plugin)
+/** @jsxImportSource @opentui/solid */
+import type { TuiPlugin, TuiPluginApi, TuiPluginModule } from "@opencode-ai/plugin/tui";
+import { createEffect, createSignal, onCleanup } from "solid-js";
+
+const id = "@mingxy/cerebro";
+const SIDEBAR_ORDER = 160;
+
+function SidebarContentView(props: {
+  api: TuiPluginApi;
+  sessionID: string;
+}) {
+  const [autoStore, setAutoStore] = createSignal(true);
+
+  const unsubscribers = [
+    props.api.event.on("session.updated", () => {
+      setAutoStore(globalThis.__cerebro_autoStore?.(props.sessionID) ?? true);
+    }),
+    props.api.event.on("tui.session.select", (event) => {
+      if (event.properties?.sessionID === props.sessionID) {
+        setAutoStore(globalThis.__cerebro_autoStore?.(props.sessionID) ?? true);
+      }
+    }),
+  ];
+
+  createEffect(() => {
+    props.sessionID;
+    setAutoStore(globalThis.__cerebro_autoStore?.(props.sessionID) ?? true);
+  });
+
+  const interval = setInterval(() => {
+    setAutoStore(globalThis.__cerebro_autoStore?.(props.sessionID) ?? true);
+  }, 2000);
+
+  onCleanup(() => {
+    clearInterval(interval);
+    for (const unsubscribe of unsubscribers) unsubscribe();
+  });
+
+  const enabled = autoStore();
+
+  return (
+    <box gap={0}>
+      <text fg={props.api.theme.current.text}>
+        <b>Cerebro</b>
+      </text>
+      <box gap={0}>
+        <text fg={props.api.theme.current.text} wrapMode="none">
+          {enabled ? "✅ Auto-store: ON" : "⏸️  Auto-store: OFF"}
+        </text>
+      </box>
+    </box>
+  );
+}
+
+const tui: TuiPlugin = async (api) => {
+  api.slots.register({
+    order: SIDEBAR_ORDER,
+    slots: {
+      sidebar_content(_ctx, props: { session_id: string }) {
+        return <SidebarContentView api={api} sessionID={props.session_id} />;
+      },
+    },
+  });
+};
+
+const pluginModule: TuiPluginModule & { id: string } = {
+  id,
+  tui,
+};
+
+export default pluginModule;

package/tsconfig.json

@@ -17,8 +17,10 @@
     "noFallthroughCasesInSwitch": true,
     "resolveJsonModule": true,
     "isolatedModules": true,
+    "jsx": "react-jsx",
+    "jsxImportSource": "@opentui/solid",
     "types": ["node"]
   },
-  "include": ["src/**/*.ts"],
+  "include": ["src/**/*.ts", "src/**/*.tsx"],
   "exclude": ["node_modules", "dist"]
 }