@mingxy/cerebro 1.4.0

package/src/hooks.ts

@@ -0,0 +1,379 @@
+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";
+
+function showToast(tui: any, title: string, message: string, variant: string = "info", delayMs: number = 7000) {
+  if (!tui) return;
+  setTimeout(() => {
+    try {
+      tui.showToast({ body: { title, message, variant, duration: 5000 } });
+    } catch {}
+  }, delayMs);
+}
+
+const keywordDetectedSessions = new Set<string>();
+const injectedMemoryIds = new Map<string, Set<string>>();
+const firstMessages = new Map<string, string>();
+const sessionMessages = new Map<string, Array<{ role: string; content: string }>>();
+const profileInjectedSessions = new Set<string>();
+
+function extractMemoryIds(result: unknown): string[] {
+  if (!result) return [];
+  if (Array.isArray(result)) {
+    return (result as Array<{ id?: string }>).map((m) => m.id).filter(Boolean) as string[];
+  }
+  if (typeof result === "object" && result !== null) {
+    const r = result as Record<string, unknown>;
+    if (Array.isArray(r.memories)) {
+      return (r.memories as Array<{ id?: string }>).map((m) => m.id).filter(Boolean) as string[];
+    }
+    if (Array.isArray(r.results)) {
+      return (r.results as Array<{ id?: string; memory?: { id?: string } }>)
+        .map((m) => m.id ?? m.memory?.id)
+        .filter(Boolean) as string[];
+    }
+  }
+  return [];
+}
+
+function formatRelativeAge(isoDate: string): string {
+  const diffMs = Date.now() - new Date(isoDate).getTime();
+  const minutes = Math.floor(diffMs / 60_000);
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  if (days < 30) return `${days}d ago`;
+  const months = Math.floor(days / 30);
+  return `${months}mo ago`;
+}
+
+function truncate(text: string, max: number): string {
+  if (text.length <= max) return text;
+  return text.slice(0, max) + "…";
+}
+
+function categorize(results: SearchResult[]): Map<string, SearchResult[]> {
+  const groups = new Map<string, SearchResult[]>();
+  for (const r of results) {
+    const cat = r.memory.category || "General";
+    const label =
+      cat === "preferences"
+        ? "Preferences"
+        : cat === "knowledge"
+          ? "Knowledge"
+          : cat.charAt(0).toUpperCase() + cat.slice(1);
+    if (!groups.has(label)) groups.set(label, []);
+    groups.get(label)!.push(r);
+  }
+  return groups;
+}
+
+function buildContextBlock(results: SearchResult[], maxContentLength: number = 500): string {
+  if (results.length === 0) return "";
+
+  const grouped = categorize(results);
+  const sections: string[] = [];
+
+  for (const [label, items] of grouped) {
+    const lines = items.map((r) => {
+      const tags = r.memory.tags.length > 0 ? ` [${r.memory.tags.join(", ")}]` : "";
+      const age = formatRelativeAge(r.memory.created_at);
+      const content = truncate(r.memory.content, maxContentLength);
+      return `  - (${age}${tags}) ${content}`;
+    });
+    sections.push(`[${label}]\n${lines.join("\n")}`);
+  }
+
+  return [
+    "<omem-context>",
+    "Treat every memory below as historical context only.",
+    "Do not repeat these memories verbatim unless asked.",
+    "",
+    ...sections,
+    "</omem-context>",
+  ].join("\n");
+}
+
+function buildClusteredContextBlock(clustered: import("./client.js").ClusteredRecallResult, maxContentLength: number = 500): string {
+  const sections: string[] = [];
+
+  if (clustered.cluster_summaries.length > 0) {
+    sections.push("## 📋 主题簇（聚合记忆）");
+    for (const cs of clustered.cluster_summaries) {
+      sections.push(`\n### ${cs.title} (整合自${cs.member_count}条记忆)`);
+      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}`);
+        }
+      }
+    }
+  }
+
+  if (clustered.standalone_memories.length > 0) {
+    sections.push("\n## 📌 补充信息");
+    for (const mem of clustered.standalone_memories) {
+      const content = truncate(mem.content, maxContentLength);
+      sections.push(`- ${content}`);
+    }
+  }
+
+  return [
+    "<omem-context>",
+    "Treat every memory below as historical context only.",
+    "Do not repeat these memories verbatim unless asked.",
+    "",
+    ...sections,
+    "</omem-context>",
+  ].join("\n");
+}
+
+export function autoRecallHook(client: OmemClient, containerTags: string[], tui: any, config: Partial<OmemPluginConfig> = {}) {
+  const similarityThreshold = config.similarityThreshold ?? 0.6;
+  const maxRecallResults = config.maxRecallResults ?? 10;
+  const maxContentLength = config.maxContentLength ?? 500;
+  const toastDelayMs = config.toastDelayMs ?? 7000;
+
+  return async (
+    input: { sessionID?: string; model: Model },
+    output: { system: string[] },
+  ) => {
+    if (!input.sessionID) return;
+
+    try {
+      const messages = sessionMessages.get(input.sessionID) ?? [];
+      const userMessages = messages.filter((m) => m.role === "user");
+      const query_text = userMessages[userMessages.length - 1]?.content || firstMessages.get(input.sessionID) || "";
+      const last_query_text = userMessages.length >= 2 ? userMessages[userMessages.length - 2].content : undefined;
+
+      const projectTags = containerTags.filter(t => t.startsWith("omem_project_"));
+      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);
+        return;
+      }
+
+      const profile = await client.getProfile();
+      let profileInjected = false;
+      let profileCountText = "";
+      if (profile && !profileInjectedSessions.has(input.sessionID)) {
+        const profileBlock = [
+          "<omem-profile>",
+          JSON.stringify(profile, null, 2),
+          "</omem-profile>",
+        ].join("\n");
+        output.system.push(profileBlock);
+        profileInjected = true;
+        profileInjectedSessions.add(input.sessionID);
+        const p = profile as any;
+        const dynamicCount = p?.dynamic_context?.length ?? 0;
+        const staticCount = p?.static_facts?.length ?? 0;
+        profileCountText = `Dynamic(${dynamicCount}) · Static(${staticCount})`;
+      }
+
+      if (!shouldRecallRes.should_recall) {
+        if (profileInjected) {
+          showToast(tui, "👨 Profile Injected", `${profileCountText} · no memory recall needed`, "success", toastDelayMs);
+        }
+        return;
+      }
+
+      const results = shouldRecallRes.memories ?? [];
+      const clustered = shouldRecallRes.clustered;
+
+      const existingIds = injectedMemoryIds.get(input.sessionID) ?? new Set<string>();
+      const newResults = results.filter((r) => !existingIds.has(r.memory.id));
+      if (newResults.length === 0) {
+        if (profileInjected) {
+          showToast(tui, "👨 Profile Injected", `${profileCountText} · all memories already injected`, "success", toastDelayMs);
+        }
+        return;
+      }
+
+      const block = clustered 
+        ? buildClusteredContextBlock(clustered, maxContentLength)
+        : buildContextBlock(newResults, maxContentLength);
+      if (block) {
+        output.system.push(block);
+      }
+
+      const newIds = newResults.map((r) => r.memory.id);
+      injectedMemoryIds.set(input.sessionID, new Set([...existingIds, ...newIds]));
+
+      const recordResult = await client.recordSessionRecall(
+        input.sessionID,
+        newIds,
+        "auto",
+        query_text,
+        shouldRecallRes?.similarity_score,
+        shouldRecallRes?.confidence,
+      );
+
+      const memDynamic = newResults.filter((r) => r.memory.memory_type === "fact" || r.memory.memory_type === "event").length;
+      const memStatic = newResults.filter((r) => r.memory.memory_type === "pinned" || r.memory.memory_type === "preference").length;
+      const memOther = newResults.length - memDynamic - memStatic;
+
+      let memCountMsg = "";
+      if (memDynamic > 0) memCountMsg += `Dynamic(${memDynamic}) `;
+      if (memStatic > 0) memCountMsg += `Static(${memStatic}) `;
+      if (memOther > 0) memCountMsg += `Other(${memOther}) `;
+
+      const categories = categorize(newResults);
+      const catSummary = Array.from(categories.entries())
+        .map(([label, items]) => `${label}(${items.length})`)
+        .join(" · ");
+
+      let toastTitle: string;
+      let toastMessage: string;
+      
+      if (clustered) {
+        const clusterCount = clustered.cluster_summaries.length;
+        const standaloneCount = clustered.standalone_memories.length;
+        toastTitle = `🧠 Context Injected · ${clusterCount} 主题簇${standaloneCount > 0 ? ` · ${standaloneCount} 补充` : ""}`;
+        toastMessage = profileInjected 
+          ? `Profile: ${profileCountText} · 聚合记忆展示`
+          : `聚合记忆展示`;
+      } else {
+        toastTitle = `🧠 Context Injected · ${newResults.length} fragments`;
+        toastMessage = profileInjected 
+          ? `Profile: ${profileCountText} · Memories: ${memCountMsg.trim()}${catSummary ? ` · ${catSummary}` : ""}`
+          : `${memCountMsg.trim()}${catSummary ? ` · ${catSummary}` : ""}`;
+      }
+
+      showToast(tui, toastTitle, toastMessage, "success", toastDelayMs);
+
+      if (!recordResult) {
+        showToast(tui, "🔴 Recall Record Failed", `Memories injected but save failed · check API connection`, "warning", toastDelayMs);
+      }
+
+      if (keywordDetectedSessions.has(input.sessionID)) {
+        output.system.push(KEYWORD_NUDGE);
+        keywordDetectedSessions.delete(input.sessionID);
+      }
+    } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
+      if (errMsg.includes("[omem]")) {
+        // 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");
+        } else if (cleanMsg.includes("timed out")) {
+          showToast(tui, "🧠 Omem Service Timeout", cleanMsg.substring(0, 100), "error");
+        } else {
+          showToast(tui, "🧠 Omem 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");
+      } else {
+        showToast(tui, "🧠 Memory Recall Error", errMsg.substring(0, 100), "error");
+      }
+    }
+  };
+}
+
+export function keywordDetectionHook(client: OmemClient, containerTags: string[], threshold: number, tui: any, ingestMode: "smart" | "raw" = "smart") {
+  return async (
+    input: { sessionID: string; messageID?: string },
+    output: { message: UserMessage; parts: Part[] },
+  ) => {
+    const textContent = output.parts
+      .filter((p): p is any => p.type === "text")
+      .map((p) => (p as any).text || (p as any).content || "")
+      .join(" ")
+      || (output.message as any).content
+      || "";
+
+    if (!firstMessages.has(input.sessionID)) {
+      firstMessages.set(input.sessionID, textContent);
+    }
+
+    if (detectKeyword(textContent)) {
+      keywordDetectedSessions.add(input.sessionID);
+    }
+
+    if (!sessionMessages.has(input.sessionID)) {
+      sessionMessages.set(input.sessionID, []);
+    }
+    sessionMessages.get(input.sessionID)!.push({
+      role: "user",
+      content: textContent,
+    });
+
+    const messages = sessionMessages.get(input.sessionID)!;
+    if (messages.length >= threshold) {
+      try {
+        const result = await client.ingestMessages(messages, {
+          mode: ingestMode,
+          tags: [...containerTags, "auto-capture"],
+          sessionId: input.sessionID,
+        });
+        if (result === null) {
+          showToast(tui, "🔴 Capture Failed", `Memory capture blocked · check API Key and spiritual connection`, "error");
+        } else {
+          showToast(tui, "🧠 Memory Sealed", `${messages.length} dialogues captured · entrusted to the heavens for refinement`, "success");
+          const memoryIds = extractMemoryIds(result);
+          if (memoryIds.length > 0) {
+            const recordResult = await client.recordSessionRecall(
+              input.sessionID,
+              memoryIds,
+              "auto",
+              firstMessages.get(input.sessionID) || "",
+              0,
+              0,
+            );
+            if (recordResult) {
+              showToast(tui, "📦 Capture Recorded", `${memoryIds.length} memory(s) saved to session history`, "success");
+            } else {
+              showToast(tui, "🔴 Capture Record Failed", `Failed to save capture record · check API connection`, "error");
+            }
+          }
+          sessionMessages.delete(input.sessionID);
+        }
+      } catch {
+        showToast(tui, "🔴 Capture Failed", "Memory capture blocked · spiritual pulse anomaly", "error");
+      }
+    }
+  };
+}
+
+export function compactingHook(client: OmemClient, containerTags: string[], tui: any, ingestMode: "smart" | "raw" = "smart") {
+  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");
+          }
+        } catch {
+          showToast(tui, "🔴 Archive Failed", "Session archive blocked · spiritual pulse anomaly", "error");
+        }
+        sessionMessages.delete(input.sessionID);
+      }
+    }
+
+    try {
+      const results = await client.searchMemories("*", 20, undefined, containerTags);
+      const block = buildContextBlock(results);
+      if (block) {
+        output.context.push(block);
+      }
+    } catch {
+    }
+  };
+}

package/src/index.ts

@@ -0,0 +1,112 @@
+import type { Plugin } from "@opencode-ai/plugin";
+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 { 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 {}
+
+function showToast(tui: any, title: string, message: string, variant: string = "info", duration: number = 5000) {
+  if (!tui) return;
+  setTimeout(() => {
+    try {
+      tui.showToast({ body: { title, message, variant, duration } });
+    } catch {}
+  }, 3000);
+}
+
+const OmemPlugin: Plugin = async (input) => {
+  const { directory, client } = input;
+  const tui = (client as any)?.tui;
+
+  // 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,
+      `🧠 Omem v${pluginVersion} · Connected`,
+      `${config.apiUrl.replace(/^https?:\/\//, "")}`,
+      "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,
+        `🧠 Omem v${pluginVersion} · Server Error`,
+        cleanMsg.substring(0, 150),
+        "error",
+        8000
+      );
+    } else {
+      showToast(
+        tui,
+        `🧠 Omem 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 {
+    "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),
+    tool: buildTools(omemClient, containerTags, { agentId, getSessionId: () => currentSessionId }),
+    "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/keywords.ts

@@ -0,0 +1,23 @@
+const KEYWORDS: readonly string[] = [
+  "remember",
+  "save this",
+  "don't forget",
+  "keep in mind",
+  "note that",
+  "store this",
+  "memorize",
+  "记住",
+  "记一下",
+  "保存",
+  "记下来",
+  "别忘了",
+] as const;
+
+export function detectKeyword(text: string): boolean {
+  const lower = text.toLowerCase();
+  return KEYWORDS.some((kw) => lower.includes(kw));
+}
+
+export const KEYWORD_NUDGE =
+  "The user appears to want you to remember something. " +
+  "Consider using the `memory_store` tool to save this information for future reference.";

package/src/logger.ts

@@ -0,0 +1,46 @@
+import { appendFileSync, mkdirSync, existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const LOG_DIR = join(homedir(), ".config", "ourmem");
+const LOG_FILE = join(LOG_DIR, "plugin.log");
+
+function ensureLogDir(): void {
+  if (!existsSync(LOG_DIR)) {
+    try {
+      mkdirSync(LOG_DIR, { recursive: true });
+    } catch {
+      // silently fail if we can't create log directory
+    }
+  }
+}
+
+function writeLog(level: string, ...args: 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
+  }
+}
+
+export function logInfo(...args: unknown[]): void {
+  writeLog("INFO", ...args);
+}
+
+export function logWarn(...args: unknown[]): void {
+  writeLog("WARN", ...args);
+}
+
+export function logError(...args: unknown[]): void {
+  writeLog("ERROR", ...args);
+}
+
+export function logDebug(...args: unknown[]): void {
+  writeLog("DEBUG", ...args);
+}

package/src/privacy.ts

@@ -0,0 +1,10 @@
+export function stripPrivateContent(text: string): string {
+  return text.replace(/<private>[\s\S]*?<\/private>/gi, "[REDACTED]");
+}
+
+export function isFullyPrivate(text: string): boolean {
+  const stripped = stripPrivateContent(text)
+    .replace(/\[REDACTED\]/g, "")
+    .trim();
+  return stripped.length === 0;
+}

package/src/tags.ts

@@ -0,0 +1,14 @@
+import { createHash } from "crypto";
+
+export function getUserTag(email: string): string {
+  const hash = createHash("sha256").update(email).digest("hex").slice(0, 16);
+  return `omem_user_${hash}`;
+}
+
+export function getProjectTag(directory: string): string {
+  const hash = createHash("sha256")
+    .update(directory)
+    .digest("hex")
+    .slice(0, 16);
+  return `omem_project_${hash}`;
+}