@mingxy/cerebro 1.8.3 → 1.10.0

package/src/index.ts

@@ -1,151 +1,151 @@
-import type { Plugin } from "@opencode-ai/plugin";
-import { readFileSync, writeFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { tmpdir } from "node:os";
-import { fileURLToPath } from "node:url";
-import { OmemClient } from "./client.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";
-import { loadPluginConfig } from "./config.js";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-let pluginVersion = "unknown";
-try {
-  const pkg = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf-8"));
-  if (pkg?.version && typeof pkg.version === "string") {
-    pluginVersion = pkg.version;
-  }
-} catch {}
-
-// Per-session auto-store toggle: sessionId → enabled (default: true = auto-store on)
-const autoStoreSessions = new Map<string, boolean>();
-
-function getStateFilePath(sessionId: string): string {
-  return join(tmpdir(), `cerebro_autostore_${sessionId}.json`);
-}
-
-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);
-  try {
-    writeFileSync(getStateFilePath(sessionId), JSON.stringify({ enabled }));
-  } catch {}
-}
-
-(globalThis as any).__cerebro_autoStoreMap = autoStoreSessions;
-
-function showToast(tui: any, title: string, message?: string, variant: string = "info", duration: number = 5000) {
-  if (!tui) return;
-  setTimeout(() => {
-    try {
-      const body: any = { variant, duration };
-      if (message) {
-        body.title = title;
-        body.message = message;
-      } else {
-        body.message = title;
-      }
-      tui.showToast({ body });
-    } catch (err) {
-      console.error("[cerebro] showToast failed:", err);
-    }
-  }, 3000);
-}
-
-const OmemPlugin: Plugin = async (input) => {
-  const { directory, client } = input;
-  // Proxy: dynamically resolve client.tui on each access so toast works
-  // even if client.tui isn't ready yet at plugin init time
-  const tui = new Proxy({} as any, {
-    get(_, prop) {
-      return (client as any)?.tui?.[prop];
-    },
-  });
-
-  // Load overrides from opencode.json plugin_config
-  let overrides: Record<string, unknown> = {};
-  try {
-    const ocCfg = JSON.parse(readFileSync(join(directory, "opencode.json"), "utf-8"));
-    const pc = ocCfg?.plugin_config?.["@mingxy/omem"] || ocCfg?.plugin_config?.["@ourmem/opencode"];
-    if (pc) overrides = pc;
-  } catch {}
-
-  const config = loadPluginConfig(overrides as any);
-
-  const omemClient = new OmemClient(config.apiUrl, config.apiKey, config);
-
-  // 启动时检测连接状态
-  try {
-    await omemClient.getStats();
-    showToast(tui, "🧠 Cerebro · Connected", `Version v${pluginVersion}`, "success", 6000);
-    logInfo(`Connected to ${config.apiUrl}`);
-  } catch (err) {
-    const errMsg = err instanceof Error ? err.message : String(err);
-    logError(`Connection failed: ${errMsg}`);
-    if (errMsg.includes("[omem]")) {
-      const cleanMsg = errMsg.replace(/^\[omem\]\s*/, "");
-      showToast(
-        tui,
-        `🧠 Cerebro v${pluginVersion} · Server Error`,
-        cleanMsg.substring(0, 150),
-        "error",
-        8000
-      );
-    } else {
-      showToast(
-        tui,
-        `🧠 Cerebro v${pluginVersion} · Connection Failed`,
-        `Unable to reach ${config.apiUrl}`,
-        "error",
-        8000
-      );
-    }
-  }
-
-  const email = process.env.GIT_AUTHOR_EMAIL || process.env.USER || "unknown";
-  const cwd = directory || process.cwd();
-  const containerTags = [getUserTag(email), getProjectTag(cwd)];
-  const agentId = process.env.OMEM_AGENT_ID || "opencode";
-
-  let currentSessionId: string | undefined;
-
-  const recallHook = autoRecallHook(omemClient, containerTags, tui, config);
-
-  return {
-    config: async (cfg: any) => {
-      cfg.command ??= {};
-      cfg.command["memory-toggle"] = {
-        template: "Use the memory_toggle tool with state='$ARGUMENTS' to toggle Cerebro auto-store for this session. You MUST call the memory_toggle tool, do not just acknowledge.",
-        description: "Toggle Cerebro auto-store ON or OFF for current session",
-      };
-    },
-    "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, isAutoStoreEnabled),
-    tool: buildTools(omemClient, containerTags, { agentId, getSessionId: () => currentSessionId }),
-    event: sessionIdleHook(omemClient, containerTags, tui, client, config.ingestMode, config.autoCaptureThreshold, () => currentSessionId, isAutoStoreEnabled, agentId),
-    "shell.env": async (_input: any, output: any) => {
-      if (directory) {
-        output.env.OMEM_PROJECT_DIR = directory;
-      }
-    },
-  };
-};
-
-export { OmemPlugin };
-
-export default {
-  id: "ourmem",
-  server: OmemPlugin,
-};
+import type { Plugin } from "@opencode-ai/plugin";
+import { readFileSync, writeFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { tmpdir } from "node:os";
+import { fileURLToPath } from "node:url";
+import { OmemClient } from "./client.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";
+import { loadPluginConfig } from "./config.js";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+let pluginVersion = "unknown";
+try {
+  const pkg = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf-8"));
+  if (pkg?.version && typeof pkg.version === "string") {
+    pluginVersion = pkg.version;
+  }
+} catch {}
+
+// Per-session auto-store toggle: sessionId → enabled (default: true = auto-store on)
+const autoStoreSessions = new Map<string, boolean>();
+
+function getStateFilePath(sessionId: string): string {
+  return join(tmpdir(), `cerebro_autostore_${sessionId}.json`);
+}
+
+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);
+  try {
+    writeFileSync(getStateFilePath(sessionId), JSON.stringify({ enabled }));
+  } catch {}
+}
+
+(globalThis as any).__cerebro_autoStoreMap = autoStoreSessions;
+
+function showToast(tui: any, title: string, message?: string, variant: string = "info", duration: number = 5000) {
+  if (!tui) return;
+  setTimeout(() => {
+    try {
+      const body: any = { variant, duration };
+      if (message) {
+        body.title = title;
+        body.message = message;
+      } else {
+        body.message = title;
+      }
+      tui.showToast({ body });
+    } catch (err) {
+      console.error("[cerebro] showToast failed:", err);
+    }
+  }, 3000);
+}
+
+const OmemPlugin: Plugin = async (input) => {
+  const { directory, client } = input;
+  // Proxy: dynamically resolve client.tui on each access so toast works
+  // even if client.tui isn't ready yet at plugin init time
+  const tui = new Proxy({} as any, {
+    get(_, prop) {
+      return (client as any)?.tui?.[prop];
+    },
+  });
+
+  // Load overrides from opencode.json plugin_config
+  let overrides: Record<string, unknown> = {};
+  try {
+    const ocCfg = JSON.parse(readFileSync(join(directory, "opencode.json"), "utf-8"));
+    const pc = ocCfg?.plugin_config?.["@mingxy/omem"] || ocCfg?.plugin_config?.["@ourmem/opencode"];
+    if (pc) overrides = pc;
+  } catch {}
+
+  const config = loadPluginConfig(overrides as any);
+
+  const omemClient = new OmemClient(config.apiUrl, config.apiKey, config);
+
+  // 启动时检测连接状态
+  try {
+    await omemClient.getStats();
+    showToast(tui, "🧠 Cerebro · Connected", `Version v${pluginVersion}`, "success", 6000);
+    logInfo(`Connected to ${config.apiUrl}`);
+  } catch (err) {
+    const errMsg = err instanceof Error ? err.message : String(err);
+    logError(`Connection failed: ${errMsg}`);
+    if (errMsg.includes("[omem]")) {
+      const cleanMsg = errMsg.replace(/^\[omem\]\s*/, "");
+      showToast(
+        tui,
+        `🧠 Cerebro v${pluginVersion} · Server Error`,
+        cleanMsg.substring(0, 150),
+        "error",
+        8000
+      );
+    } else {
+      showToast(
+        tui,
+        `🧠 Cerebro v${pluginVersion} · Connection Failed`,
+        `Unable to reach ${config.apiUrl}`,
+        "error",
+        8000
+      );
+    }
+  }
+
+  const email = process.env.GIT_AUTHOR_EMAIL || process.env.USER || "unknown";
+  const cwd = directory || process.cwd();
+  const containerTags = [getUserTag(email), getProjectTag(cwd)];
+  const agentId = process.env.OMEM_AGENT_ID || "opencode";
+
+  let currentSessionId: string | undefined;
+
+  const recallHook = autoRecallHook(omemClient, containerTags, tui, config);
+
+  return {
+    config: async (cfg: any) => {
+      cfg.command ??= {};
+      cfg.command["memory-toggle"] = {
+        template: "Use the memory_toggle tool with state='$ARGUMENTS' to toggle Cerebro auto-store for this session. You MUST call the memory_toggle tool, do not just acknowledge.",
+        description: "Toggle Cerebro auto-store ON or OFF for current session",
+      };
+    },
+    "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, isAutoStoreEnabled, () => currentSessionId, client),
+    tool: buildTools(omemClient, containerTags, { agentId, getSessionId: () => currentSessionId }),
+    event: sessionIdleHook(omemClient, containerTags, tui, client, config.ingestMode, config.autoCaptureThreshold, () => currentSessionId, isAutoStoreEnabled, agentId),
+    "shell.env": async (_input: any, output: any) => {
+      if (directory) {
+        output.env.OMEM_PROJECT_DIR = directory;
+      }
+    },
+  };
+};
+
+export { OmemPlugin };
+
+export default {
+  id: "ourmem",
+  server: OmemPlugin,
+};

package/src/tools.ts

@@ -32,28 +32,56 @@ export function buildTools(client: OmemClient, containerTags: string[], context:
       description:
         "Store a new memory in the user's long-term memory. " +
         "Use when the user explicitly asks to remember something, " +
-        "or when you identify important preferences, facts, or decisions worth preserving.",
+        "or when you identify important preferences, facts, or decisions worth preserving. " +
+        "IMPORTANT: Before calling, you MUST analyze: (1) Which category fits best? (2) Is this project-specific or cross-project? (3) Does it contain sensitive data? (4) Are tags accurate and descriptive? " +
+        "Every memory MUST have a correct category and at least 1 meaningful tag.",
       args: {
-        content: tool.schema.string().describe("The information to remember"),
+        content: tool.schema.string().describe(
+          "The information to remember. MUST be: atomic (one fact per memory), complete (self-contained without context), and precise (no ambiguity). " +
+          "BAD: 'fixed some bugs'. GOOD: 'Fixed memory_type validation bug in memory.rs:1480 - LLM returns illegal \"pinned\" value, added match guard to normalize to WORK/EMOTIONAL fallback'."
+        ),
         tags: tool.schema
           .array(tool.schema.string())
           .optional()
-          .describe("Optional categorization tags"),
+          .describe(
+            "REQUIRED. At least 1 tag in snake_case. Tags describe the memory's topic/domain for future retrieval. " +
+          "Examples: rust_backend, memory_system, bug_fix, user_preference, project_config. " +
+          "NEVER leave empty — if unsure, use a broad tag like the project name or topic area."
+          ),
         source: tool.schema
           .string()
-          .describe("Origin context, e.g. 'conversation', 'code-review', 'user-input'"),
+          .describe("Origin context, e.g. 'conversation', 'code-review', 'user-input', 'debugging', 'architecture-decision'"),
         scope: tool.schema
           .string()
           .optional()
-          .describe("Memory scope: 'project' (default, only visible in this project) or 'global' (visible across all projects)"),
+          .describe(
+            "'project' (default) = only visible in current project context. 'global' = visible across all projects. " +
+          "Rule: if the memory applies generally (user preferences, general knowledge, cross-project patterns) use 'global'. " +
+          "If it's specific to one project's code/architecture, use 'project'."
+          ),
         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."),
+          .describe(
+            "'global' (default) = all agents can see and recall this memory. 'private' = ONLY the current agent can see it. " +
+          "MUST use 'private' when content contains: passwords, API keys, tokens, database credentials, SSH keys, personal information (phone, email, address), " +
+          "internal company details, or anything the user would NOT want other agents to access. " +
+          "WARNING: private memories are invisible to ALL other agents — if in doubt, ask the user. " +
+          "Do NOT overuse 'private' for normal work notes — default 'global' is correct for most cases."
+          ),
         category: tool.schema
           .string()
           .optional()
-          .describe("Memory category: 'cases' (default, for work/facts/decisions), 'preferences' (likes/dislikes), 'entities' (projects/tools/people), 'events' (milestones), 'profile' (identity traits), 'patterns' (workflows)"),
+          .describe(
+            "MUST be one of (choose the BEST fit): " +
+          "'cases' (default) = work records, bug fixes, architecture decisions, implementation notes, meeting conclusions; " +
+          "'preferences' = user likes/dislikes, coding style preferences, tool choices (e.g. 'prefers Vim over VSCode'); " +
+          "'entities' = projects, tools, people, concepts — defining what something IS (e.g. 'omem-server: Rust memory backend using LanceDB'); " +
+          "'events' = time-bound milestones (deployments, releases, incidents); " +
+          "'profile' = user identity traits (role, skills, team membership); " +
+          "'patterns' = workflows, methodologies, best practices, recurring solutions. " +
+          "When in doubt, use 'cases'."
+          ),
       },
       async execute(args) {
         const allTags = [...containerTags, ...(args.tags ?? [])];