@mingxy/cerebro 1.4.0

package/omem.example.jsonc

@@ -0,0 +1,27 @@
+{
+  // omem server connection
+  "apiUrl": "https://www.mengxy.cc",
+  "apiKey": "your-tenant-id",
+
+  // request timeout in milliseconds
+  "requestTimeoutMs": 15000,
+
+  // content limits
+  "maxQueryLength": 200,
+  "maxContentChars": 30000,
+  "maxContentLength": 500,
+
+  // auto capture settings
+  "autoCaptureThreshold": 5,
+  "ingestMode": "smart",
+
+  // recall tuning
+  "similarityThreshold": 0.4,
+  "maxRecallResults": 10,
+
+  // UI settings
+  "toastDelayMs": 7000,
+
+  // container tag prefix (used for user/project scoping)
+  "containerTagPrefix": "omem"
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@mingxy/cerebro",
+  "version": "1.4.0",
+  "description": "Cerebro persistent memory plugin for OpenCode — auto-recall, auto-capture, 9 memory tools with clustering",
+  "type": "module",
+  "main": "src/index.ts",
+  "oc-plugin": [
+    "server"
+  ],
+  "keywords": [
+    "opencode",
+    "memory",
+    "ai-agent",
+    "persistent-memory",
+    "cerebro",
+    "clustering"
+  ],
+  "author": "mingxy-cerebro",
+  "license": "Apache-2.0",
+  "homepage": "https://github.com/mingxy-cerebro/cerebro-server",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mingxy-cerebro/cerebro-server.git",
+    "directory": "plugins/opencode"
+  },
+  "dependencies": {
+    "@opencode-ai/plugin": "^1.0.162"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "typescript": "^5.7.0"
+  }
+}

package/src/client.ts

@@ -0,0 +1,359 @@
+import { logWarn, logError } from "./logger.js";
+import type { OmemPluginConfig } from "./config.js";
+
+function sanitizeContent(text: string, maxLen: number): string {
+  let clean = text.replace(/<[\w-]+[^>]*>[\s\S]*?<\/[\w-]+>/g, "");
+  clean = clean.replace(/<[\w-]+[^>]*\/>/g, "");
+  clean = clean.replace(/\s+/g, " ").trim();
+  if (clean.length <= maxLen) return clean;
+  return clean.slice(0, maxLen) + "…[truncated]";
+}
+
+function truncateQuery(query: string, maxLen: number): string {
+  if (query.length <= maxLen) return query;
+  return query.slice(0, maxLen);
+}
+
+export interface IngestOptions {
+  mode?: "smart" | "raw";
+  agentId?: string;
+  sessionId?: string;
+  entityContext?: string;
+  tags?: string[];
+}
+
+export interface SearchResult {
+  memory: MemoryDto;
+  score: number;
+}
+
+export interface SearchResponse {
+  results: SearchResult[];
+  trace?: unknown;
+}
+
+export interface ListResponse {
+  memories: MemoryDto[];
+  limit: number;
+  offset: number;
+}
+
+export interface ClusterSummary {
+  cluster_id: string;
+  title: string;
+  summary: string;
+  member_count: number;
+  relevance_score: number;
+  key_memories: MemoryDto[];
+}
+
+export interface ClusteredRecallResult {
+  cluster_summaries: ClusterSummary[];
+  standalone_memories: MemoryDto[];
+}
+
+export interface ShouldRecallResponse {
+  should_recall: boolean;
+  query?: string;
+  reason?: string;
+  similarity_score?: number;
+  confidence?: number;
+  memories?: SearchResult[];
+  clustered?: ClusteredRecallResult;
+}
+
+export interface SessionRecallRecord {
+  session_id: string;
+  memory_ids: string[];
+  recall_type: string;
+  created_at: string;
+}
+
+export interface SessionRecallListResponse {
+  recalls: SessionRecallRecord[];
+}
+
+export interface MemoryDto {
+  id: string;
+  content: string;
+  l2_content?: string;
+  category: string;
+  memory_type: string;
+  state: string;
+  tags: string[];
+  source?: string;
+  tenant_id: string;
+  agent_id?: string;
+  created_at: string;
+  updated_at: string;
+}
+
+export class OmemClient {
+  constructor(
+    private baseUrl: string,
+    private apiKey: string,
+    private config?: Partial<OmemPluginConfig>,
+  ) {
+    this.baseUrl = baseUrl.replace(/\/+$/, "");
+  }
+
+  private getCfg<K extends keyof OmemPluginConfig>(key: K, fallback: OmemPluginConfig[K]): OmemPluginConfig[K] {
+    return this.config?.[key] ?? fallback;
+  }
+
+  private async request<T>(
+    path: string,
+    init: RequestInit = {},
+    timeoutMs?: number,
+  ): Promise<T | null> {
+    const url = `${this.baseUrl}${path}`;
+    const controller = new AbortController();
+    const timeout = setTimeout(
+      () => controller.abort(),
+      timeoutMs ?? this.getCfg("requestTimeoutMs", 15000),
+    );
+
+    try {
+      const res = await fetch(url, {
+        ...init,
+        signal: controller.signal,
+        headers: {
+          "Content-Type": "application/json",
+          "X-API-Key": this.apiKey,
+          ...(init.headers as Record<string, string>),
+        },
+      });
+
+      if (!res.ok) {
+        const errorBody = await res.text().catch(() => "");
+        logWarn(`${init.method ?? "GET"} ${path} → ${res.status} ${res.statusText}: ${errorBody}`);
+        throw new Error(`[omem] ${res.status} ${res.statusText}${errorBody ? ": " + errorBody : ""}`);
+      }
+
+      if (res.status === 204) return null;
+
+      return (await res.json()) as T;
+    } catch (err) {
+      if ((err as Error).name === "AbortError") {
+        logWarn(`${init.method ?? "GET"} ${path} timed out`);
+        throw new Error(`[omem] Request timed out (${timeoutMs ?? this.getCfg("requestTimeoutMs", 15000)}ms)`);
+      } else {
+        logError(`${init.method ?? "GET"} ${path} failed:`, err);
+        throw err;
+      }
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+
+  private post<T>(path: string, body: unknown, timeoutMs?: number): Promise<T | null> {
+    return this.request<T>(path, {
+      method: "POST",
+      body: JSON.stringify(body),
+    }, timeoutMs);
+  }
+
+  private put<T>(path: string, body: unknown): Promise<T | null> {
+    return this.request<T>(path, {
+      method: "PUT",
+      body: JSON.stringify(body),
+    });
+  }
+
+  private del<T>(path: string): Promise<T | null> {
+    return this.request<T>(path, { method: "DELETE" });
+  }
+
+  async createMemory(
+    content: string,
+    tags?: string[],
+    source?: string,
+    scope?: string,
+    agentId?: string,
+    sessionId?: string,
+  ): Promise<MemoryDto | null> {
+    const safeContent = sanitizeContent(content, this.getCfg("maxContentChars", 30000));
+    return this.post<MemoryDto>("/v1/memories", {
+      content: safeContent,
+      tags,
+      source,
+      scope,
+      agent_id: agentId,
+      session_id: sessionId,
+    });
+  }
+
+  async searchMemories(
+    query: string,
+    limit = 10,
+    scope?: string,
+    tags?: string[],
+  ): Promise<SearchResult[]> {
+    const safeQ = truncateQuery(query, this.getCfg("maxQueryLength", 200));
+    const params = new URLSearchParams({ q: safeQ, limit: String(limit) });
+    if (scope) params.set("scope", scope);
+    if (tags && tags.length > 0) params.set("tags", tags.join(","));
+    const res = await this.request<SearchResponse>(
+      `/v1/memories/search?${params}`,
+      {},
+      20_000,
+    );
+    return res?.results ?? [];
+  }
+
+  async getMemory(id: string): Promise<MemoryDto | null> {
+    return this.request<MemoryDto>(`/v1/memories/${encodeURIComponent(id)}`);
+  }
+
+  async updateMemory(
+    id: string,
+    content: string,
+    tags?: string[],
+  ): Promise<MemoryDto | null> {
+    return this.put<MemoryDto>(
+      `/v1/memories/${encodeURIComponent(id)}`,
+      { content, tags },
+    );
+  }
+
+  async deleteMemory(id: string): Promise<void> {
+    await this.del(`/v1/memories/${encodeURIComponent(id)}`);
+  }
+
+  async ingestMessages(
+    messages: Array<{ role: string; content: string }>,
+    opts: IngestOptions = {},
+  ): Promise<unknown> {
+    const safeMessages = messages.map(m => ({
+      role: m.role,
+      content: sanitizeContent(m.content, this.getCfg("maxContentChars", 30000)),
+    }));
+    return this.post("/v1/memories", {
+      messages: safeMessages,
+      mode: opts.mode ?? "smart",
+      agent_id: opts.agentId,
+      session_id: opts.sessionId,
+      entity_context: opts.entityContext,
+      tags: opts.tags,
+    });
+  }
+
+  async getProfile(_query?: string): Promise<unknown> {
+    return this.request("/v1/profile");
+  }
+
+  async getStats(): Promise<unknown> {
+    return this.request("/v1/stats");
+  }
+
+  async listRecent(limit = 20): Promise<MemoryDto[]> {
+    const res = await this.request<ListResponse>(
+      `/v1/memories?limit=${limit}&offset=0`,
+    );
+    return res?.memories ?? [];
+  }
+
+  async createSpace(
+    name: string,
+    spaceType: string,
+    members?: Array<{ user_id: string; role: string }>,
+  ): Promise<unknown> {
+    return this.post("/v1/spaces", { name, space_type: spaceType, members });
+  }
+
+  async listSpaces(): Promise<unknown[]> {
+    const res = await this.request<{ spaces: unknown[] }>("/v1/spaces");
+    return res?.spaces ?? [];
+  }
+
+  async addSpaceMember(
+    spaceId: string,
+    userId: string,
+    role: string,
+  ): Promise<unknown> {
+    return this.post(
+      `/v1/spaces/${encodeURIComponent(spaceId)}/members`,
+      { user_id: userId, role },
+    );
+  }
+
+  async shareMemory(
+    memoryId: string,
+    targetSpace: string,
+  ): Promise<unknown> {
+    return this.post(
+      `/v1/memories/${encodeURIComponent(memoryId)}/share`,
+      { target_space: targetSpace },
+    );
+  }
+
+  async pullMemory(
+    memoryId: string,
+    sourceSpace: string,
+    visibility?: string,
+  ): Promise<unknown> {
+    return this.post(
+      `/v1/memories/${encodeURIComponent(memoryId)}/pull`,
+      { source_space: sourceSpace, visibility },
+    );
+  }
+
+  async reshareMemory(
+    memoryId: string,
+    targetSpace?: string,
+  ): Promise<unknown> {
+    return this.post(
+      `/v1/memories/${encodeURIComponent(memoryId)}/reshare`,
+      { target_space: targetSpace },
+    );
+  }
+
+  async shouldRecall(
+    query_text: string,
+    last_query_text: string | undefined,
+    session_id: string,
+    similarity_threshold?: number,
+    max_results?: number,
+    project_tags?: 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,
+    }, 20_000);
+    return res;
+  }
+
+  async recordSessionRecall(
+    session_id: string,
+    memory_ids: string[],
+    recall_type: string,
+    query_text?: string,
+    similarity_score?: number,
+    llm_confidence?: number,
+  ): Promise<unknown | null> {
+    const body = {
+      session_id,
+      memory_ids,
+      recall_type,
+      query_text: query_text ?? "",
+      similarity_score: similarity_score ?? 0,
+      llm_confidence: llm_confidence ?? 0,
+    };
+    const res = await this.post("/v1/session-recalls", body, 20_000);
+    return res;
+  }
+
+  async listSessionRecalls(
+    session_id: string,
+  ): Promise<SessionRecallRecord[]> {
+    const params = new URLSearchParams({ session_id });
+    const res = await this.request<SessionRecallListResponse>(
+      `/v1/session-recalls?${params}`,
+    );
+    return res?.recalls ?? [];
+  }
+}

package/src/config.ts

@@ -0,0 +1,89 @@
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+export interface OmemPluginConfig {
+  // Connection
+  apiUrl: string;
+  apiKey: string;
+  // Timeouts (milliseconds)
+  requestTimeoutMs: number;
+  // Content limits
+  maxQueryLength: number;
+  maxContentChars: number;
+  maxContentLength: number;
+  // Auto capture
+  autoCaptureThreshold: number;
+  ingestMode: "smart" | "raw";
+  // Recall settings
+  similarityThreshold: number;
+  maxRecallResults: number;
+  // UI settings
+  toastDelayMs: number;
+}
+
+const DEFAULTS: OmemPluginConfig = {
+  apiUrl: "https://www.mengxy.cc",
+  apiKey: "",
+  requestTimeoutMs: 15000,
+  maxQueryLength: 200,
+  maxContentChars: 30000,
+  maxContentLength: 500,
+  autoCaptureThreshold: 5,
+  ingestMode: "smart",
+  similarityThreshold: 0.4,
+  maxRecallResults: 10,
+  toastDelayMs: 7000,
+};
+
+export function loadPluginConfig(overrides?: Partial<OmemPluginConfig>): OmemPluginConfig {
+  const config: Partial<OmemPluginConfig> = { ...DEFAULTS };
+
+  // Try loading from config file
+  try {
+    const cfgPath = join(homedir(), ".config", "ourmem", "config.json");
+    const cfg = JSON.parse(readFileSync(cfgPath, "utf-8"));
+
+    if (cfg.apiUrl) config.apiUrl = cfg.apiUrl;
+    if (cfg.apiKey) config.apiKey = cfg.apiKey;
+    if (typeof cfg.requestTimeoutMs === "number") config.requestTimeoutMs = cfg.requestTimeoutMs;
+    if (typeof cfg.maxQueryLength === "number") config.maxQueryLength = cfg.maxQueryLength;
+    if (typeof cfg.maxContentChars === "number") config.maxContentChars = cfg.maxContentChars;
+    if (typeof cfg.maxContentLength === "number") config.maxContentLength = cfg.maxContentLength;
+    if (typeof cfg.autoCaptureThreshold === "number") config.autoCaptureThreshold = cfg.autoCaptureThreshold;
+    if (cfg.ingestMode === "raw" || cfg.ingestMode === "smart") config.ingestMode = cfg.ingestMode;
+    if (typeof cfg.similarityThreshold === "number") config.similarityThreshold = cfg.similarityThreshold;
+    if (typeof cfg.maxRecallResults === "number") config.maxRecallResults = cfg.maxRecallResults;
+    if (typeof cfg.toastDelayMs === "number") config.toastDelayMs = cfg.toastDelayMs;
+  } catch {
+    // Config file doesn't exist or is invalid, use defaults
+  }
+
+  // Apply environment variable overrides
+  if (process.env.OMEM_API_URL) config.apiUrl = process.env.OMEM_API_URL;
+  if (process.env.OMEM_API_KEY) config.apiKey = process.env.OMEM_API_KEY;
+  if (process.env.OMEM_REQUEST_TIMEOUT_MS) {
+    config.requestTimeoutMs = parseInt(process.env.OMEM_REQUEST_TIMEOUT_MS, 10) || DEFAULTS.requestTimeoutMs;
+  }
+  if (process.env.OMEM_AUTO_CAPTURE_THRESHOLD) {
+    config.autoCaptureThreshold = parseInt(process.env.OMEM_AUTO_CAPTURE_THRESHOLD, 10) || DEFAULTS.autoCaptureThreshold;
+  }
+  if (process.env.OMEM_INGEST_MODE === "raw" || process.env.OMEM_INGEST_MODE === "smart") {
+    config.ingestMode = process.env.OMEM_INGEST_MODE;
+  }
+  if (process.env.OMEM_SIMILARITY_THRESHOLD) {
+    config.similarityThreshold = parseFloat(process.env.OMEM_SIMILARITY_THRESHOLD) || DEFAULTS.similarityThreshold;
+  }
+  if (process.env.OMEM_MAX_RECALL_RESULTS) {
+    config.maxRecallResults = parseInt(process.env.OMEM_MAX_RECALL_RESULTS, 10) || DEFAULTS.maxRecallResults;
+  }
+
+  // Apply explicit overrides (from opencode.json)
+  if (overrides) {
+    Object.assign(config, overrides);
+  }
+
+  return config as OmemPluginConfig;
+}
+
+export { DEFAULTS };