@mingxy/cerebro 1.18.20 → 1.19.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mingxy/cerebro",
-  "version": "1.18.20",
+  "version": "1.19.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/client.ts

@@ -1,5 +1,5 @@
-import { logInfo, logWarn, logError } from "./logger.js";
-import type { OmemPluginConfig } from "./config.js";
+import { logWarn, logError } from "./logger.js";
+import type { CerebroPluginConfig } from "./config.js";
 
 function sanitizeContent(text: string, maxLen: number): string {
   let clean = text.replace(/<[\w-]+[^>]*>[\s\S]*?<\/[\w-]+>/g, "");
@@ -42,25 +42,6 @@ export interface ListResponse {
   offset: number;
 }
 
-
-export interface DiscardedItem {
-  memory_id: string;
-  content: string;
-  score: number;
-  refine_relevance?: string;
-  refine_reasoning?: string;
-}
-
-export interface ShouldRecallResponse {
-  should_recall: boolean;
-  query?: string;
-  reason?: string;
-  similarity_score?: number;
-  confidence?: number;
-  memories?: SearchResult[];
-  discarded?: DiscardedItem[];
-}
-
 export interface PreferenceDto {
   id: string;
   slot: string;
@@ -101,16 +82,16 @@ export class CerebroClient {
   constructor(
     private baseUrl: string,
     private apiKey: string,
-    private config?: Partial<OmemPluginConfig>,
+    private config?: Partial<CerebroPluginConfig>,
   ) {
     this.baseUrl = baseUrl.replace(/\/+$/, "");
   }
 
-  private getCfg<S extends keyof OmemPluginConfig, K extends string & keyof OmemPluginConfig[S]>(
-    section: S, key: K, fallback: OmemPluginConfig[S][K],
-  ): OmemPluginConfig[S][K] {
+  private getCfg<S extends keyof CerebroPluginConfig, K extends string & keyof CerebroPluginConfig[S]>(
+    section: S, key: K, fallback: CerebroPluginConfig[S][K],
+  ): CerebroPluginConfig[S][K] {
     const sec = this.config?.[section] as Record<string, unknown> | undefined;
-    return (sec?.[key] ?? fallback) as OmemPluginConfig[S][K];
+    return (sec?.[key] ?? fallback) as CerebroPluginConfig[S][K];
   }
 
   private async request<T>(
@@ -202,7 +183,7 @@ export class CerebroClient {
     category?: string,
     projectPath?: string,
   ): Promise<MemoryDto | null> {
-    const safeContent = sanitizeContent(content, this.getCfg("content", "maxContentChars", 30000));
+    const safeContent = sanitizeContent(content, this.getCfg("content", "maxContentLength", 3000));
     return this.post<MemoryDto>("/v1/memories", {
       content: safeContent,
       tags,
@@ -261,7 +242,7 @@ export class CerebroClient {
   ): Promise<unknown> {
     const safeMessages = messages.map(m => ({
       role: m.role,
-      content: sanitizeContent(m.content, this.getCfg("content", "maxContentChars", 30000)),
+      content: sanitizeContent(m.content, this.getCfg("content", "maxContentLength", 3000)),
     }));
     return this.post("/v1/memories", {
       messages: safeMessages,
@@ -362,49 +343,6 @@ export class CerebroClient {
     );
   }
 
-  async shouldRecall(
-    query_text: string,
-    last_query_text: string | undefined,
-    session_id: string,
-    similarity_threshold?: number,
-    max_results?: number,
-    project_tags?: string[],
-    conversation_context?: string[],
-    recall_overrides?: {
-      fetch_multiplier?: number;
-      topk_cap_multiplier?: number;
-      mmr_jaccard_threshold?: number;
-      mmr_penalty_factor?: number;
-      phase2_multiplier?: number;
-      llm_max_eval?: number;
-      refine_strategy?: string;
-      skip_llm_gate?: boolean;
-    },
-    projectPath?: string,
-  ): Promise<ShouldRecallResponse | null> {
-    const res = await this.post<ShouldRecallResponse>("/v1/should-recall", {
-      query_text,
-      last_query_text,
-      session_id,
-      similarity_threshold,
-      max_results,
-      project_tags,
-      conversation_context,
-      ...recall_overrides,
-      project_path: projectPath,
-    }, 20_000);
-    logInfo("shouldRecall raw response", {
-      should_recall: res?.should_recall,
-      memCount: res?.memories?.length ?? 0,
-      discardedCount: res?.discarded?.length ?? 0,
-      confidence: res?.confidence,
-      reason: res?.reason,
-      rawKeys: res ? Object.keys(res) : "null",
-      rawJSON: JSON.stringify(res).slice(0, 500),
-    });
-    return res;
-  }
-
   async updateProfileInjected(
     event_id: string,
     profile_injected: boolean,

package/src/config.ts

@@ -4,7 +4,7 @@ import { join } from "node:path";
 
 // ── Nested config interface ──────────────────────────────────────────
 
-export interface OmemPluginConfig {
+export interface CerebroPluginConfig {
   connection: {
     apiUrl: string;
     apiKey: string;
@@ -15,21 +15,16 @@ export interface OmemPluginConfig {
     maxContentChars: number;
     maxContentLength: number;
   };
+  injection: {
+    recentCount: number;
+    searchCount: number;
+    recentTruncateChars: number;
+    searchTruncateChars: number;
+  };
   ingest: {
     autoCaptureThreshold: number;
     ingestMode: "smart" | "raw";
   };
-  recall: {
-    similarityThreshold: number;
-    maxRecallResults: number;
-    fetchMultiplier: number;
-    topkCapMultiplier: number;
-    mmrJaccardThreshold: number;
-    mmrPenaltyFactor: number;
-    phase2Multiplier: number;
-    llmMaxEval: number;
-    refineStrategy: "strict" | "balanced" | "loose";
-  };
   logging: {
     logEnabled: boolean;
     logLevel: "DEBUG" | "INFO" | "WARN" | "ERROR";
@@ -42,16 +37,13 @@ export interface OmemPluginConfig {
     enabled?: boolean;
     port?: number;
   };
-  profile?: {
-    ttlMs?: number;
-  };
   agentMemoryPolicy?: Record<string, "none" | "readonly" | "readwrite">;
   defaultPolicy?: "none" | "readonly" | "readwrite";
 }
 
 // ── Defaults ─────────────────────────────────────────────────────────
 
-const DEFAULTS: OmemPluginConfig = {
+const DEFAULTS: CerebroPluginConfig = {
   connection: {
     apiUrl: "https://www.mengxy.cc",
     apiKey: "",
@@ -60,23 +52,18 @@ const DEFAULTS: OmemPluginConfig = {
   content: {
     maxQueryLength: 200,
     maxContentChars: 30000,
-    maxContentLength: 500,
+    maxContentLength: 3000,
+  },
+  injection: {
+    recentCount: 5,
+    searchCount: 10,
+    recentTruncateChars: 0,   // 0 = 不截断
+    searchTruncateChars: 0,   // 0 = 不截断
   },
   ingest: {
     autoCaptureThreshold: 5,
     ingestMode: "smart",
   },
-  recall: {
-    similarityThreshold: 0.4,
-    maxRecallResults: 10,
-    fetchMultiplier: 3,
-    topkCapMultiplier: 2,
-    mmrJaccardThreshold: 0.85,
-    mmrPenaltyFactor: 0.5,
-    phase2Multiplier: 2,
-    llmMaxEval: 15,
-    refineStrategy: "loose",
-  },
   logging: {
     logEnabled: true,
     logLevel: "INFO",
@@ -88,9 +75,6 @@ const DEFAULTS: OmemPluginConfig = {
   web: {
     enabled: true,
   },
-  profile: {
-    ttlMs: 300000,
-  },
 };
 
 // ── Flat-to-nested migration ─────────────────────────────────────────
@@ -105,8 +89,6 @@ interface FlatConfig {
   maxContentLength?: number;
   autoCaptureThreshold?: number;
   ingestMode?: "smart" | "raw";
-  similarityThreshold?: number;
-  maxRecallResults?: number;
   toastDelayMs?: number;
   logEnabled?: boolean;
   logLevel?: "DEBUG" | "INFO" | "WARN" | "ERROR";
@@ -119,7 +101,7 @@ function isFlatConfig(cfg: Record<string, unknown>): boolean {
   return "apiUrl" in cfg && !("connection" in cfg);
 }
 
-function migrateFlatToNested(flat: FlatConfig): OmemPluginConfig {
+function migrateFlatToNested(flat: FlatConfig): CerebroPluginConfig {
   return {
     connection: {
       apiUrl: flat.apiUrl ?? DEFAULTS.connection.apiUrl,
@@ -131,21 +113,11 @@ function migrateFlatToNested(flat: FlatConfig): OmemPluginConfig {
       maxContentChars: flat.maxContentChars ?? DEFAULTS.content.maxContentChars,
       maxContentLength: flat.maxContentLength ?? DEFAULTS.content.maxContentLength,
     },
+    injection: { ...DEFAULTS.injection },
     ingest: {
       autoCaptureThreshold: flat.autoCaptureThreshold ?? DEFAULTS.ingest.autoCaptureThreshold,
       ingestMode: flat.ingestMode ?? DEFAULTS.ingest.ingestMode,
     },
-    recall: {
-      similarityThreshold: flat.similarityThreshold ?? DEFAULTS.recall.similarityThreshold,
-      maxRecallResults: flat.maxRecallResults ?? DEFAULTS.recall.maxRecallResults,
-      fetchMultiplier: DEFAULTS.recall.fetchMultiplier,
-      topkCapMultiplier: DEFAULTS.recall.topkCapMultiplier,
-      mmrJaccardThreshold: DEFAULTS.recall.mmrJaccardThreshold,
-      mmrPenaltyFactor: DEFAULTS.recall.mmrPenaltyFactor,
-      phase2Multiplier: DEFAULTS.recall.phase2Multiplier,
-      llmMaxEval: DEFAULTS.recall.llmMaxEval,
-      refineStrategy: DEFAULTS.recall.refineStrategy,
-    },
     logging: {
       logEnabled: flat.logEnabled ?? DEFAULTS.logging.logEnabled,
       logLevel: flat.logLevel ?? DEFAULTS.logging.logLevel,
@@ -162,17 +134,16 @@ function migrateFlatToNested(flat: FlatConfig): OmemPluginConfig {
 type IngestMode = "smart" | "raw";
 const INGEST_MODES: ReadonlySet<string> = new Set<IngestMode>(["smart", "raw"]);
 
-function deepMerge(base: OmemPluginConfig, overrides: Partial<OmemPluginConfig>): OmemPluginConfig {
-  const result: OmemPluginConfig = {
+function deepMerge(base: CerebroPluginConfig, overrides: Partial<CerebroPluginConfig>): CerebroPluginConfig {
+  const result: CerebroPluginConfig = {
     connection: { ...base.connection, ...overrides.connection },
     content: { ...base.content, ...overrides.content },
+    injection: { ...base.injection, ...overrides.injection },
     ingest: { ...base.ingest, ...overrides.ingest },
-    recall: { ...base.recall, ...overrides.recall },
     logging: { ...base.logging, ...overrides.logging },
     ui: { ...base.ui, ...overrides.ui },
   };
   result.web = { ...base.web!, ...overrides.web };
-  result.profile = { ...base.profile!, ...overrides.profile };
   if (overrides.agentMemoryPolicy) result.agentMemoryPolicy = overrides.agentMemoryPolicy;
   if (overrides.defaultPolicy) result.defaultPolicy = overrides.defaultPolicy;
   return result;
@@ -218,8 +189,8 @@ function configLog(message: string, fields?: Record<string, unknown>, level: str
   }
 }
 
-export function loadPluginConfig(overrides?: Partial<OmemPluginConfig>): OmemPluginConfig {
-  let config: OmemPluginConfig = structuredClone(DEFAULTS);
+export function loadPluginConfig(overrides?: Partial<CerebroPluginConfig>): CerebroPluginConfig {
+  let config: CerebroPluginConfig = structuredClone(DEFAULTS);
 
   // Try loading from config file
   try {
@@ -227,7 +198,7 @@ export function loadPluginConfig(overrides?: Partial<OmemPluginConfig>): OmemPlu
     const raw = JSON.parse(readFileSync(cfgPath, "utf-8")) as Record<string, unknown>;
 
     // Auto-migrate flat format
-    const parsed: OmemPluginConfig = isFlatConfig(raw) ? migrateFlatToNested(raw as FlatConfig) : raw as unknown as OmemPluginConfig;
+    const parsed: CerebroPluginConfig = isFlatConfig(raw) ? migrateFlatToNested(raw as FlatConfig) : raw as unknown as CerebroPluginConfig;
 
     // Merge nested groups with defaults for safety
     config = deepMerge(config, parsed);
@@ -252,12 +223,6 @@ export function loadPluginConfig(overrides?: Partial<OmemPluginConfig>): OmemPlu
   if (INGEST_MODES.has(process.env.OMEM_INGEST_MODE ?? "")) {
     config.ingest.ingestMode = process.env.OMEM_INGEST_MODE as IngestMode;
   }
-  if (process.env.OMEM_SIMILARITY_THRESHOLD) {
-    config.recall.similarityThreshold = parseFloat(process.env.OMEM_SIMILARITY_THRESHOLD) || DEFAULTS.recall.similarityThreshold;
-  }
-  if (process.env.OMEM_MAX_RECALL_RESULTS) {
-    config.recall.maxRecallResults = parseInt(process.env.OMEM_MAX_RECALL_RESULTS, 10) || DEFAULTS.recall.maxRecallResults;
-  }
 
   if (process.env.OMEM_WEB_ENABLED === "false" || process.env.OMEM_WEB_ENABLED === "0") {
     config.web = { ...config.web!, enabled: false };
@@ -280,7 +245,7 @@ export type AgentPolicy = "none" | "readonly" | "readwrite";
 
 export function resolveAgentPolicy(
   agentName: string,
-  config: Partial<OmemPluginConfig>,
+  config: Partial<CerebroPluginConfig>,
 ): AgentPolicy {
   const policies = config.agentMemoryPolicy;
   if (policies) {

package/src/hooks.ts

@@ -1,6 +1,6 @@
 import type { Model, UserMessage, Part } from "@opencode-ai/sdk";
 import type { CerebroClient, SearchResult } from "./client.js";
-import { type OmemPluginConfig, resolveAgentPolicy } from "./config.js";
+import { type CerebroPluginConfig, DEFAULTS, resolveAgentPolicy } from "./config.js";
 import { logDebug, logInfo, logError as logErr } from "./logger.js";
 import { readFile } from "node:fs/promises";
 
@@ -111,15 +111,23 @@ async function detectProjectName(rootPath: string): Promise<string | undefined>
   return result;
 }
 
-export function showToast(tui: any, title: string, message: string, variant: string = "info", delayMs: number = 7000) {
+export function showToast(tui: any, title: string, message: string, variant: string = "info", delayMs?: number) {
   if (!tui) return;
+  const effectiveDelay = delayMs ?? DEFAULTS.ui.toastDelayMs;
   setTimeout(() => {
     try {
       tui.showToast({ body: { title, message, variant, duration: 5000 } });
     } catch (err) {
       logErr("showToast failed", { error: String(err) });
     }
-  }, delayMs);
+  }, effectiveDelay);
+}
+
+export function createToast(config: Partial<CerebroPluginConfig>) {
+  const defaultDelay = config.ui?.toastDelayMs ?? DEFAULTS.ui.toastDelayMs;
+  return (tui: any, title: string, message: string, variant: string = "info", delayMs?: number) => {
+    showToast(tui, title, message, variant, delayMs ?? defaultDelay);
+  };
 }
 
 const SYSTEM_INJECTION_PATTERNS: RegExp[] = [
@@ -211,7 +219,7 @@ const FETCH_POLICY = [
   "</cerebro-fetch-policy>",
 ].join("\n");
 
-const INJECTION_MAX_CHARS_FALLBACK = 4000;
+const MAX_INJECTION_CHARS_FALLBACK = DEFAULTS.content.maxContentChars;
 
 interface InjectionResult {
   text: string;
@@ -224,9 +232,14 @@ export async function buildMemoryInjection(
   client: CerebroClient,
   projectPath: string | undefined,
   query: string,
-  config: Partial<OmemPluginConfig>,
+  config: Partial<CerebroPluginConfig>,
 ): Promise<InjectionResult> {
-  const maxChars = config.content?.maxContentLength ?? INJECTION_MAX_CHARS_FALLBACK;
+  const maxChars = config.content?.maxContentChars ?? MAX_INJECTION_CHARS_FALLBACK;
+  const ic = config.injection ?? DEFAULTS.injection;
+  const recentCount = ic.recentCount || DEFAULTS.injection.recentCount;
+  const searchCount = ic.searchCount || DEFAULTS.injection.searchCount;
+  const recentTruncate = ic.recentTruncateChars || 0;   // 0 = 不截断
+  const searchTruncate = ic.searchTruncateChars || 0;    // 0 = 不截断
 
   const [profile, projectMemories, searchResults] = await Promise.all([
     Promise.race([
@@ -234,12 +247,12 @@ export async function buildMemoryInjection(
       new Promise<null>((resolve) => setTimeout(() => resolve(null), 1000)),
     ]).catch(() => null),
     Promise.race([
-      client.listRecent(5, projectPath),
+      client.listRecent(recentCount, projectPath),
       new Promise<never[]>((resolve) => setTimeout(() => resolve([]), 1000)),
     ]).catch(() => []),
     query
       ? Promise.race([
-          client.searchMemories(query, 10, undefined, undefined, projectPath),
+          client.searchMemories(query, searchCount, undefined, undefined, projectPath),
           new Promise<never[]>((resolve) => setTimeout(() => resolve([]), 1500)),
         ]).catch(() => [])
       : Promise.resolve([]),
@@ -259,7 +272,7 @@ export async function buildMemoryInjection(
     for (const m of projectMemories) {
       seenIds.add(m.id);
       const age = formatRelativeAge(m.updated_at || m.created_at) || "unknown";
-      const content = truncate(m.content, 200);
+      const content = recentTruncate > 0 ? truncate(m.content, recentTruncate) : m.content;
       sections.push(`- (${age}) ${content}`);
     }
     sections.push("");
@@ -270,7 +283,7 @@ export async function buildMemoryInjection(
     sections.push("## Relevant Memories");
     for (const r of dedupedResults) {
       const age = formatRelativeAge(r.memory.created_at) || "unknown";
-      const content = truncate(r.memory.content, 300);
+      const content = searchTruncate > 0 ? truncate(r.memory.content, searchTruncate) : r.memory.content;
       sections.push(`- (${age}) ${content}`);
     }
     sections.push("");
@@ -298,7 +311,7 @@ export function chatMessageRecallHook(
   client: CerebroClient,
   _containerTags: string[],
   tui: any,
-  config: Partial<OmemPluginConfig> = {},
+  config: Partial<CerebroPluginConfig> = {},
   getAgentName?: () => string,
   directory?: string,
 ) {
@@ -435,7 +448,7 @@ export function createCerebroCompactionPrompt(
   return sections.join("\n");
 }
 
-export function compactingHook(client: CerebroClient, containerTags: string[], tui: any, ingestMode: "smart" | "raw" = "smart", isAutoStoreEnabled?: (sessionId: string | undefined) => boolean, getMainSessionId?: () => string | undefined, sdkClient?: any, config: Partial<OmemPluginConfig> = {}, agentId?: string, directory?: string) {
+export function compactingHook(client: CerebroClient, containerTags: string[], tui: any, ingestMode: "smart" | "raw" = "smart", isAutoStoreEnabled?: (sessionId: string | undefined) => boolean, getMainSessionId?: () => string | undefined, sdkClient?: any, config: Partial<CerebroPluginConfig> = {}, agentId?: string, directory?: string) {
   const effectiveAgentId = agentId || process.env.OMEM_AGENT_ID || "opencode";
   return async (
     input: { sessionID?: string },
@@ -568,7 +581,7 @@ export function autocontinueHook(
   isAutoStoreEnabled?: (sessionId: string | undefined) => boolean,
   getMainSessionId?: () => string | undefined,
   sdkClient?: any,
-  config: Partial<OmemPluginConfig> = {},
+  config: Partial<CerebroPluginConfig> = {},
   agentId?: string,
   directory?: string,
 ) {
@@ -683,7 +696,7 @@ export function sessionIdleHook(
   getMainSessionId?: () => string | undefined,
   isAutoStoreEnabled?: (sessionId: string | undefined) => boolean,
   agentId?: string,
-  config: Partial<OmemPluginConfig> = {},
+  config: Partial<CerebroPluginConfig> = {},
   onAgentResolved?: (name: string) => void,
   directory?: string,
 ) {

package/src/index.ts

@@ -5,7 +5,7 @@ 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, showToast as hooksShowToast, sessionMessages, firstMessages } from "./hooks.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";
@@ -64,33 +64,30 @@ const OmemPlugin: Plugin = async (input) => {
   } catch {}
 
   const config = loadPluginConfig(overrides as any);
+  const toast = createToast(config);
 
   const cerebroClient = new CerebroClient(config.connection.apiUrl, config.connection.apiKey, config);
 
-  // 启动时检测连接状态
   try {
     await cerebroClient.getStats();
-    hooksShowToast(tui, "🧠 Cerebro · Connected", `Version v${pluginVersion}`, "success", 6000);
     logInfo(`Connected to ${config.connection.apiUrl}`);
   } catch (err) {
     const errMsg = err instanceof Error ? err.message : String(err);
     logError(`Connection failed: ${errMsg}`);
     if (errMsg.includes("[cerebro]")) {
       const cleanMsg = errMsg.replace(/^\[cerebro\]\s*/, "");
-      hooksShowToast(
+      toast(
         tui,
         `🧠 Cerebro v${pluginVersion} · Server Error`,
         cleanMsg.substring(0, 150),
-        "error",
-        8000
+        "error"
       );
     } else {
-      hooksShowToast(
+      toast(
         tui,
         `🧠 Cerebro v${pluginVersion} · Connection Failed`,
         `Unable to reach ${config.connection.apiUrl}`,
-        "error",
-        8000
+        "error"
       );
     }
   }
@@ -108,6 +105,7 @@ const OmemPlugin: Plugin = async (input) => {
 
   let webServer: Server | null = null;
   const webEnabled = config.web?.enabled !== false;
+  let webPort: number | undefined;
   if (webEnabled) {
     try {
       webServer = await startWebServer({
@@ -116,15 +114,20 @@ const OmemPlugin: Plugin = async (input) => {
       });
       if (webServer) {
         const addr = webServer.address();
-        const actualPort = typeof addr === "object" && addr ? addr.port : config.web?.port || 5212;
-        hooksShowToast(tui, "🌐 Cerebro Web", `http://localhost:${actualPort}`, "info", 8000);
-        logInfo(`Web UI available at http://localhost:${actualPort}`);
+        webPort = typeof addr === "object" && addr ? addr.port : config.web?.port || 5212;
+        logInfo(`Web UI available at http://localhost:${webPort}`);
       }
     } catch (err) {
       logError(`Web server start failed: ${err instanceof Error ? err.message : String(err)}`);
     }
   }
 
+  if (webPort) {
+    toast(tui, `🧠 Cerebro Connected · v${pluginVersion}`, `\n🌐 Open in browser http://localhost:${webPort}`, "success");
+  } else {
+    toast(tui, "🧠 Connected", `v${pluginVersion}`, "success");
+  }
+
   const shutdown = async () => {
     try {
       if (webServer) {