opencode-claude-mem-capture 1.0.0

package/README.md

@@ -0,0 +1,47 @@
+# OpenCode adapter
+
+A capture-only OpenCode plugin. It talks directly to the claude-mem worker over HTTP (pure Node/Bun built-in `fetch`, zero dependencies) and never summarizes locally — the worker at `127.0.0.1:37701` does summarization, embeddings and vector search.
+
+## Files
+
+| File | Purpose |
+|---|---|
+| `index.js` | The plugin (`export default { id, server }`) |
+| `index.test.js` | Unit tests (run with `bun run index.test.js` or `node index.test.js`) |
+| `package.json` | Plugin package metadata |
+
+## Captured events
+
+- `chat.message` — user message -> session init; assistant reply -> observation
+- `tool.execute.after` — tool calls (name + input/output) -> observation
+- `session.idle` — trigger worker summarization (polled, with toast feedback)
+- `session.deleted` — clear local session maps
+- `tool.claude_mem_search` — recall tool, proxies `GET /api/search/observations`
+
+POSTs use exponential backoff (up to 3 tries: 2s / 4s / 8s) so a transient worker hiccup or rate limit does not drop observations. Every payload is tagged `platformSource: "opencode"`.
+
+## Enable
+
+Add this directory to the `"plugin"` array of `~/.config/opencode/opencode.json`:
+
+```json
+{
+  "plugin": [
+    "/ABS/PATH/agent-memory-bridge/agents/opencode"
+  ]
+}
+```
+
+Restart opencode; on load it logs `[claude-mem] capture plugin loading`.
+
+**Double-capture pitfall:** remove the official shim `./plugins/claude-mem.js` from the `plugin` array — keep exactly one memory plugin.
+
+See [`../../docs/INSTALL.md`](../../docs/INSTALL.md) §3.1 for the copy-based alternative.
+
+## License
+
+[MIT](../../LICENSE). This is an **independent implementation** written against
+the public OpenCode plugin contract and the claude-mem worker HTTP protocol; it
+contains no source copied from the official claude-mem OpenCode plugin. It only
+interoperates, over local HTTP, with the separately installed Apache-2.0-licensed
+claude-mem worker (which is not bundled here). See the root [NOTICE](../../NOTICE).

package/index.js

@@ -0,0 +1,562 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2026 yeah <camplus360@163.com>
+//
+// opencode-claude-mem: capture-only plugin for claude-mem.
+// Independent implementation written against the public OpenCode plugin
+// contract and the claude-mem worker HTTP protocol; no third-party source
+// is copied into this file (see ../../NOTICE).
+//
+// Responsibility (capture and send only; no summarization):
+//   - tool.execute.after      -> POST /api/sessions/observations (tool calls)
+//   - chat.message (assistant)-> POST /api/sessions/observations (assistant replies)
+//   - session.idle            -> POST /api/sessions/summarize    (worker summarizes)
+//   - session.deleted         -> clear local session maps
+//   - tool.claude_mem_search  -> GET  /api/search/observations   (recall)
+//
+// Summarization, embedding and vector search all happen in the claude-mem worker (127.0.0.1:37701).
+// Zero dependencies; pure Node/Bun built-in fetch.
+
+import { spawn } from "node:child_process";
+
+const DEFAULT_HOST = "127.0.0.1";
+const DEFAULT_PORT = 37701;
+const MAX_RESPONSE_CHARS = 1000;
+const MAX_SESSIONS_TRACKED = 1000;
+const TOAST_DONE_MS = 4000;
+const TOAST_ERROR_MS = 5000;
+const POLL_INTERVAL_MS = 3000;
+const POLL_TIMEOUT_MS = 120000;
+
+function workerBase() {
+  const host = process.env.CLAUDE_MEM_WORKER_HOST || DEFAULT_HOST;
+  const port = Number(process.env.CLAUDE_MEM_WORKER_PORT || DEFAULT_PORT);
+  return `http://${host}:${port}`;
+}
+
+const JSON_HEADERS = { "Content-Type": "application/json" };
+
+// Exponential-backoff retries: transient worker hiccups / OpenRouter rate limits can fail a POST;
+// a one-shot request would lose observations. Up to 3 tries (2s / 4s / 8s).
+const POST_MAX_RETRIES = 3;
+const POST_BACKOFF_MS = [2000, 4000, 8000];
+
+// ---- Transport: unified claude-mem-worker.py vs in-process fetch ------------
+// CLAUDE_MEM_TRANSPORT=py (default): every call is proxied through the unified
+//   claude-mem-worker.py `api` passthrough (spawned), i.e. opencode -> .py -> worker.
+// CLAUDE_MEM_TRANSPORT=http: force the original direct-fetch path.
+// Either way, if the .py shim is missing / exits non-zero / cannot reach the
+// worker, the call transparently falls back to direct fetch, so memory capture
+// is never broken by the migration. Override the shim path with CLAUDE_MEM_WORKER_PY.
+const TRANSPORT = (process.env.CLAUDE_MEM_TRANSPORT || "py").toLowerCase();
+const WORKER_PY =
+  process.env.CLAUDE_MEM_WORKER_PY ||
+  (process.env.HOME ? `${process.env.HOME}/.local/share/claude-mem/claude-mem-worker.py` : "");
+const PY_CALL_TIMEOUT_MS = 15000;
+
+// Call the .py shim. Resolves { ok, text } on delivery, or null on any failure
+// (missing interpreter/script, timeout, unreachable worker -> exit 4, etc.).
+function callWorkerPy(method, path, body) {
+  return new Promise((resolve) => {
+    if (!WORKER_PY) return resolve(null);
+    let child;
+    try {
+      child = spawn("python3", [WORKER_PY, "api", method, path], {
+        stdio: ["pipe", "pipe", "ignore"],
+      });
+    } catch {
+      return resolve(null);
+    }
+    const chunks = [];
+    let settled = false;
+    const finish = (v) => {
+      if (!settled) {
+        settled = true;
+        resolve(v);
+      }
+    };
+    const timer = setTimeout(() => {
+      try {
+        child.kill();
+      } catch {}
+      finish(null);
+    }, PY_CALL_TIMEOUT_MS);
+    child.stdout.on("data", (d) => chunks.push(d));
+    child.on("error", () => {
+      clearTimeout(timer);
+      finish(null);
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      finish(code === 0 ? { ok: true, text: Buffer.concat(chunks).toString("utf8") } : null);
+    });
+    try {
+      if (method === "POST" && body !== undefined) {
+        child.stdin.end(Buffer.from(JSON.stringify(body), "utf8"));
+      } else {
+        child.stdin.end();
+      }
+    } catch {
+      clearTimeout(timer);
+      finish(null);
+    }
+  });
+}
+
+async function workerPostHttp(path, payload, attempt = 0) {
+  try {
+    const res = await fetch(`${workerBase()}${path}`, {
+      method: "POST",
+      headers: JSON_HEADERS,
+      body: JSON.stringify(payload),
+    });
+    if (!res.ok) {
+      throw new Error(`worker returned ${res.status}`);
+    }
+    return true;
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    if (msg.includes("ECONNREFUSED")) {
+      // Worker not running: give up immediately, no retry (avoids spinning)
+      return false;
+    }
+    if (attempt < POST_MAX_RETRIES - 1) {
+      console.warn(
+        `[claude-mem] Worker POST ${path} failed (attempt ${attempt + 1}): ${msg} — retrying`
+      );
+      await new Promise((r) => setTimeout(r, POST_BACKOFF_MS[attempt] ?? 8000));
+      return workerPostHttp(path, payload, attempt + 1);
+    }
+    console.warn(`[claude-mem] Worker POST ${path} failed: ${msg}`);
+    return false;
+  }
+}
+
+async function workerGetHttp(path) {
+  try {
+    const res = await fetch(`${workerBase()}${path}`, { headers: JSON_HEADERS });
+    if (!res.ok) {
+      console.warn(`[claude-mem] Worker GET ${path} returned ${res.status}`);
+      return null;
+    }
+    return await res.text();
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    if (!msg.includes("ECONNREFUSED")) {
+      console.warn(`[claude-mem] Worker GET ${path} failed: ${msg}`);
+    }
+    return null;
+  }
+}
+
+async function workerPost(path, body, attempt = 0) {
+  // Always tag the source as opencode, otherwise the worker defaults it to claude and source stats are wrong.
+  const payload = body && typeof body === "object" && !body.platformSource
+    ? { ...body, platformSource: "opencode" }
+    : body;
+  if (TRANSPORT === "py") {
+    const r = await callWorkerPy("POST", path, payload);
+    if (r?.ok) return true;
+    // Shim failed/missing -> fall back to direct fetch for this call (and its retries).
+    return workerPostHttp(path, payload, 0);
+  }
+  return workerPostHttp(path, payload, attempt);
+}
+
+async function workerGet(path) {
+  if (TRANSPORT === "py") {
+    const r = await callWorkerPy("GET", path, undefined);
+    if (r) return r.text;
+    return workerGetHttp(path);
+  }
+  return workerGetHttp(path);
+}
+
+// opencode sessionID -> claude-mem contentSessionId (matches the official shim)
+const sessionIdMap = new Map();
+const initializedSessions = new Set();
+// opencode sessionID -> latest assistant text, passed as last_assistant_message on summarize
+const assistantLastMessage = new Map();
+// opencode messageID -> role of that message ("user" / "assistant"), used to filter user text parts
+const messageRoles = new Map();
+// opencode sessionID -> Map<messageID, Map<partID, text>>: streamed-but-not-yet-stored assistant text
+const assistantText = new Map();
+
+// Record one assistant text part. The same part is pushed repeatedly (delta -> complete);
+// keyed by partID we overwrite, keeping the final complete text.
+function recordAssistantText(sessionId, messageId, partId, text) {
+  if (!sessionId || !messageId || !text) return;
+  let byMessage = assistantText.get(sessionId);
+  if (!byMessage) {
+    byMessage = new Map();
+    assistantText.set(sessionId, byMessage);
+  }
+  let byPart = byMessage.get(messageId);
+  if (!byPart) {
+    byPart = new Map();
+    byMessage.set(messageId, byPart);
+  }
+  byPart.set(partId ?? `part-${byPart.size}`, text);
+}
+
+// Take (and remove) the complete text of an assistant message; empty string if already taken.
+function takeAssistantText(sessionId, messageId) {
+  const byMessage = assistantText.get(sessionId);
+  const byPart = byMessage?.get(messageId);
+  if (!byPart || byPart.size === 0) return "";
+  byMessage.delete(messageId);
+  return [...byPart.values()].join("\n").trim();
+}
+
+function contentSessionId(opencodeSessionId) {
+  let id = sessionIdMap.get(opencodeSessionId);
+  if (!id) {
+    if (sessionIdMap.size >= MAX_SESSIONS_TRACKED) {
+      const oldest = sessionIdMap.keys().next().value;
+      if (oldest !== undefined) {
+        sessionIdMap.delete(oldest);
+        initializedSessions.delete(oldest);
+        assistantLastMessage.delete(oldest);
+        assistantText.delete(oldest);
+      }
+    }
+    id = `opencode-${opencodeSessionId}-${Date.now()}`;
+    sessionIdMap.set(opencodeSessionId, id);
+  }
+  return id;
+}
+
+function ensureSession(opencodeSessionId, project) {
+  // Only resolve/generate the contentSessionId; never send an empty init. The real init (with the
+  // user prompt) fires from the user branch of chat.message, avoiding an empty "[media prompt]" fallback.
+  return contentSessionId(opencodeSessionId);
+}
+
+function truncate(text) {
+  return text.length > MAX_RESPONSE_CHARS
+    ? text.slice(0, MAX_RESPONSE_CHARS)
+    : text;
+}
+
+// opencode tui.showToast accepts { title, description, variant?, duration? }.
+// Also tolerate the { title, message, ... } shape; silent when the TUI is unavailable.
+async function toast(ctx, body) {
+  const payload = {
+    title: body.title ?? body.message ?? "claude-mem",
+    description: body.description ?? body.message ?? "",
+    variant: body.variant ?? "success",
+    duration: body.duration ?? TOAST_DONE_MS,
+  };
+  try {
+    await ctx?.client?.tui?.showToast?.(payload);
+  } catch {
+    // Silent when the TUI is unavailable (e.g. headless / test environments)
+  }
+}
+
+async function getStats() {
+  const text = await workerGet("/api/stats");
+  if (!text) return null;
+  try {
+    const data = JSON.parse(text);
+    return data?.database ?? null;
+  } catch {
+    return null;
+  }
+}
+
+// After idle, poll stats until the worker writes the summary, then show a visible toast
+const watchingSessions = new Set();
+// Never trigger summarize twice for one session while a poll is in flight
+const summarizeInflight = new Set();
+
+function watchSummary(ctx, sessionId, baselineSummaries, baselineObservations) {
+  if (watchingSessions.has(sessionId)) return;
+  watchingSessions.add(sessionId);
+  const started = Date.now();
+  const finish = () => watchingSessions.delete(sessionId);
+  const tick = async () => {
+    const db = await getStats();
+    if (!db) {
+      if (Date.now() - started < POLL_TIMEOUT_MS) {
+        setTimeout(tick, POLL_INTERVAL_MS);
+        return;
+      }
+      await toast(ctx, {
+        title: "claude-mem not responding",
+        message: "Cannot reach the worker; the memory summary may not have completed (systemctl --user status claude-mem-worker)",
+        variant: "error",
+        duration: TOAST_ERROR_MS,
+      });
+      finish();
+      return;
+    }
+
+    const newSummaries = (db.summaries ?? 0) - baselineSummaries;
+    const newObservations = (db.observations ?? 0) - baselineObservations;
+
+    if (newSummaries > 0) {
+      await toast(ctx, {
+        title: "Memory saved (claude-mem)",
+        description: `This turn was summarized and stored (+${newSummaries} summary${newSummaries > 1 ? "ies" : ""}${newObservations > 0 ? ` / +${newObservations} observation(s)` : ""}, ${db.summaries} total)`,
+        variant: "success",
+        duration: TOAST_DONE_MS,
+      });
+      finish();
+      return;
+    }
+
+    if (Date.now() - started < POLL_TIMEOUT_MS) {
+      setTimeout(tick, POLL_INTERVAL_MS);
+    } else {
+      finish();
+    }
+  };
+  setTimeout(tick, POLL_INTERVAL_MS);
+}
+
+// Minimal zod-compatible shim: the opencode plugin SDK describes tool args with zod schemas.
+// Implement only the interface string() needs to avoid a dependency.
+function zodString() {
+  const schema = {
+    _def: { typeName: "ZodString" },
+    isOptional: false,
+    description: undefined,
+    describe(text) {
+      this.description = text;
+      return this;
+    },
+    optional() {
+      this.isOptional = true;
+      return this;
+    },
+    safeParse(value) {
+      if (typeof value === "string") return { success: true, data: value };
+      if (value === undefined && this.isOptional) return { success: true, data: undefined };
+      return { success: false, error: new Error("expected string") };
+    },
+    parse(value) {
+      const result = this.safeParse(value);
+      if (!result.success) throw result.error;
+      return result.data;
+    },
+  };
+  return schema;
+}
+
+function parseSearchResponse(raw, query) {
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch (error) {
+    console.warn(
+      "[claude-mem] Failed to parse search results:",
+      error instanceof Error ? error.message : String(error)
+    );
+    return "Failed to parse search results.";
+  }
+  const content = data.content;
+  if (!Array.isArray(content) || content.length === 0) {
+    return `No results found for "${query}".`;
+  }
+  const text = content
+    .filter((part) => part.type === "text" && typeof part.text === "string")
+    .map((part) => part.text)
+    .join("\n")
+    .trim();
+  return text || `No results found for "${query}".`;
+}
+
+export const ClaudeMemCapturePlugin = async (ctx) => {
+  const project = ctx?.project?.name || "opencode";
+  const directory = ctx?.directory || process.cwd();
+
+  console.log(`[claude-mem] capture plugin loading (project: ${project}, worker: ${workerBase()})`);
+
+  // Store one assistant reply: POST a chat.message observation + update the last_assistant_message cache.
+  async function flushAssistantMessage(opencodeSessionId, messageId) {
+    const text = takeAssistantText(opencodeSessionId, messageId);
+    if (!text) return;
+    assistantLastMessage.set(opencodeSessionId, text);
+    await workerPost("/api/sessions/observations", {
+      contentSessionId: contentSessionId(opencodeSessionId),
+      tool_name: "chat.message",
+      tool_input: {},
+      tool_response: truncate(text),
+      cwd: directory,
+    });
+  }
+
+  // Fallback: flush all not-yet-stored assistant text for the session (in message order).
+  // Called before summarize to guarantee last_assistant_message is non-empty.
+  async function flushPendingAssistant(opencodeSessionId) {
+    const byMessage = assistantText.get(opencodeSessionId);
+    if (!byMessage || byMessage.size === 0) return;
+    for (const messageId of [...byMessage.keys()]) {
+      await flushAssistantMessage(opencodeSessionId, messageId);
+    }
+  }
+
+  return {
+    "tool.execute.after": async (input, output) => {
+      const session = ensureSession(input.sessionID, project);
+      const raw = output?.output;
+      // Tool results can be objects (e.g. {content:[...]}); stringify them instead of [object Object]
+      const respText =
+        typeof raw === "string" ? raw : JSON.stringify(raw ?? {});
+      await workerPost("/api/sessions/observations", {
+        contentSessionId: session,
+        tool_name: input.tool,
+        tool_input: input?.args || {},
+        tool_response: truncate(respText),
+        cwd: directory,
+      });
+    },
+
+    // opencode chat.message trigger: input = {sessionID, agent, model, messageID, variant},
+    // output = {message, parts}. sessionID is on input (first arg), not on output.message.
+    //
+    // Note (observed on opencode 1.18.x): chat.message fires only when a **user message** is enqueued;
+    // the binary has no assistant-side trigger, so output.message.role is always "user".
+    // Assistant replies are captured via experimental.text.complete + message.part.updated (below).
+    "chat.message": async (input, output) => {
+      const sessionId = input?.sessionID;
+      if (!sessionId) return;
+      const text = (output?.parts || [])
+        .filter((part) => part.type === "text" && typeof part.text === "string")
+        .map((part) => part.text)
+        .join("\n");
+      if (!text) return;
+      const role = output?.message?.role || input?.role;
+      if (role === "user") {
+        // User prompt: init WITH the prompt creates the session and writes user_prompts (same as pi);
+        // never use prompt:"" or it falls back to "[media prompt]".
+        const csid = contentSessionId(sessionId);
+        initializedSessions.add(sessionId);
+        await workerPost("/api/sessions/init", {
+          contentSessionId: csid,
+          project,
+          prompt: truncate(text),
+        });
+        return;
+      }
+      // If opencode ever adds assistant-side chat.message, route it through the same path to avoid duplicates.
+      messageRoles.set(output?.message?.id, "assistant");
+      recordAssistantText(sessionId, output?.message?.id, null, text);
+    },
+
+    // One assistant text part finished streaming: input = {sessionID, messageID, partID},
+    // output = {text}. This is the most reliable source of assistant text.
+    "experimental.text.complete": async (input, output) => {
+      const text = output?.text;
+      if (typeof text !== "string" || !text.trim()) return;
+      const messageId = input?.messageID;
+      if (messageId) messageRoles.set(messageId, "assistant");
+      recordAssistantText(input?.sessionID, messageId, input?.partID, text);
+    },
+
+    "experimental.session.compacting": async (input) => {
+      await flushPendingAssistant(input.sessionID);
+      const session = ensureSession(input.sessionID, project);
+      await workerPost("/api/sessions/summarize", {
+        contentSessionId: session,
+        last_assistant_message: assistantLastMessage.get(input.sessionID) ?? "",
+      });
+    },
+
+    event: async ({ event }) => {
+      const type = event?.type;
+      const props = event?.properties ?? {};
+      const part = props.part;
+      const info = props.info;
+      const sessionId =
+        props.sessionID ?? info?.sessionID ?? info?.id ?? part?.sessionID;
+      if (!sessionId) return;
+
+      switch (type) {
+        // Track each message role to exclude text parts belonging to user messages
+        case "message.updated": {
+          const role = info?.role;
+          if (info?.id && role) messageRoles.set(info.id, role);
+          // time.completed on an assistant message means the reply is fully done -> store it
+          if (role === "assistant" && info?.time?.completed) {
+            await flushAssistantMessage(sessionId, info.id);
+          }
+          break;
+        }
+        case "message.part.updated": {
+          if (part?.type !== "text" || typeof part.text !== "string") break;
+          // Take only when the part is complete (time.end present); part.text is then full, not a delta
+          if (!part.time?.end) break;
+          if (messageRoles.get(part.messageID) === "user") break;
+          recordAssistantText(sessionId, part.messageID, part.id, part.text);
+          break;
+        }
+        case "session.idle": {
+          // Dedupe: do not trigger summarize again for a session while a poll is in flight;
+          // avoids duplicate summaries / worker queue buildup from repeated idle events.
+          if (summarizeInflight.has(sessionId)) break;
+          summarizeInflight.add(sessionId);
+
+          // Flush pending assistant text first, then summarize;
+          // otherwise last_assistant_message is empty -> worker reports Missing last_assistant_message.
+          await flushPendingAssistant(sessionId);
+
+          const session = ensureSession(sessionId, project);
+          const before = await getStats();
+          const baselineSummaries = before?.summaries ?? 0;
+          const baselineObservations = before?.observations ?? 0;
+          const ok = await workerPost("/api/sessions/summarize", {
+            contentSessionId: session,
+            last_assistant_message: assistantLastMessage.get(sessionId) ?? "",
+          });
+          if (ok) {
+            watchSummary(ctx, sessionId, baselineSummaries, baselineObservations);
+          } else {
+            summarizeInflight.delete(sessionId);
+            await toast(ctx, {
+              title: "claude-mem worker not running",
+              description: "Memory capture skipped: systemctl --user start claude-mem-worker",
+              variant: "error",
+              duration: TOAST_ERROR_MS,
+            });
+          }
+          break;
+        }
+        case "session.deleted": {
+          sessionIdMap.delete(sessionId);
+          initializedSessions.delete(sessionId);
+          assistantLastMessage.delete(sessionId);
+          assistantText.delete(sessionId);
+          summarizeInflight.delete(sessionId);
+          break;
+        }
+        default:
+          break;
+      }
+    },
+
+    tool: {
+      claude_mem_search: {
+        description:
+          "Search claude-mem memory database for past observations, sessions, and context",
+        args: {
+          query: zodString().describe("Search query for memory observations"),
+        },
+        async execute(args) {
+          const query = String(args?.query || "");
+          if (!query) return "Please provide a search query.";
+          const raw = await workerGet(
+            `/api/search/observations?query=${encodeURIComponent(query)}&limit=10`
+          );
+          return raw
+            ? parseSearchResponse(raw, query)
+            : "claude-mem worker is not running. Start it with: systemctl --user start claude-mem-worker";
+        },
+      },
+    },
+  };
+};
+
+// Align with the official opencode-mem plugin (the PluginModule contract of @opencode-ai/plugin):
+// default export { id, server }; the opencode loader takes the plugin factory from default.server.
+export default { id: "opencode-claude-mem", server: ClaudeMemCapturePlugin };

package/index.test.js

@@ -0,0 +1,254 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2026 yeah <camplus360@163.com>
+
+// Mocked tests for the opencode-claude-mem capture plugin.
+// Run: bun test index.test.js   (or: node index.test.js)
+//
+// These are transport-level unit tests: they assert the event -> endpoint
+// mapping (init/observation/summarize), dedupe and retry against a fetch mock,
+// so they pin the mockable in-process HTTP transport. The production default is
+// the spawned claude-mem-worker.py shim (CLAUDE_MEM_TRANSPORT=py), which is
+// covered by real E2E; force http here so every request goes through the mock.
+// This MUST be set before the dynamic import() below (TRANSPORT is read once at
+// module load).
+process.env.CLAUDE_MEM_TRANSPORT = "http";
+
+let served = []; // {method, path, body}
+let toastCalls = [];
+
+// Worker behaviour switches: 200 by default; inject failure counts as needed.
+let failNext = 0; // next N non-ECONNREFUSED calls fail
+let connRefused = false;
+
+globalThis.fetch = async (url, opts) => {
+  const u = String(url);
+  let body = opts?.body ? JSON.parse(opts.body) : undefined;
+
+  if (connRefused) {
+    // Connection refused: record nothing (worker down; the plugin must give up).
+    throw new Error("fetch failed: ECONNREFUSED");
+  }
+  served.push({ method: opts?.method ?? "GET", path: u, body });
+  if (failNext > 0) {
+    failNext -= 1;
+    served.push({ failed: true });
+    return new Response("boom", { status: 500 });
+  }
+  // /api/stats returns counters used by watchSummary to detect completion.
+  if (u.endsWith("/api/stats")) {
+    const summaries = served.filter(
+      (s) => s.method === "POST" && s.path.endsWith("/api/sessions/summarize")
+    ).length;
+    const observations = served.filter(
+      (s) => s.method === "POST" && s.path.endsWith("/api/sessions/observations")
+    ).length;
+    return new Response(
+      JSON.stringify({ database: { summaries, observations, sessions: 1 } }),
+      { status: 200 }
+    );
+  }
+  return new Response("{}", { status: 200 });
+};
+
+const ctx = {
+  project: { name: "opencode" },
+  directory: "/home/yourname/test-project",
+  client: {
+    tui: {
+      async showToast(p) {
+        toastCalls.push(p);
+      },
+    },
+  },
+};
+
+const mod = await import("./index.js");
+// PluginModule shape: export default { id, server }
+const ClaudeMemCapturePlugin = mod.default.server;
+const plugin = await ClaudeMemCapturePlugin(ctx);
+// The plugin returns a flat object: top-level keys are the hooks
+// ("chat.message" / "tool.execute.after" / "experimental.session.compacting"
+// / "event" / "tool"); there is no nested hooks key.
+const hooks = plugin;
+
+function assert(cond, msg) {
+  if (!cond) throw new Error("ASSERT FAILED: " + msg);
+}
+
+const reset = () => {
+  served = [];
+  toastCalls = [];
+  failNext = 0;
+  connRefused = false;
+};
+
+const SID = "test-session-1";
+
+// ---- 1. assistant text part -> observation (flushed on message.updated) ----
+await (async () => {
+  reset();
+  // A streamed assistant text part completes...
+  await hooks["experimental.text.complete"](
+    { sessionID: SID, messageID: "m1", partID: "p1" },
+    { text: "We switched the memory backend to claude-mem; the worker listens on 37701." }
+  );
+  // ...and the assistant message is marked complete -> flush to observations.
+  await hooks["event"]({
+    event: {
+      type: "message.updated",
+      properties: {
+        sessionID: SID,
+        info: { id: "m1", role: "assistant", time: { completed: 1 } },
+      },
+    },
+  });
+  const obs = served.filter(
+    (s) => s.method === "POST" && s.path.endsWith("/api/sessions/observations")
+  );
+  assert(obs.length === 1, "assistant message should yield 1 observation, got " + obs.length);
+  assert(
+    obs[0].body && typeof obs[0].body.tool_response === "string",
+    "observation body.tool_response must be a string"
+  );
+  assert(
+    obs[0].body.tool_response.includes("37701"),
+    "observation should carry the original text, got: " + obs[0].body.tool_response
+  );
+  assert(
+    obs[0].body.contentSessionId && obs[0].body.contentSessionId.length > 0,
+    "contentSessionId must be a non-empty string"
+  );
+  console.log("PASS 1. assistant part -> observation");
+})();
+
+// ---- 2. user message -> init, never an observation ----
+await (async () => {
+  reset();
+  await hooks["chat.message"](
+    { sessionID: SID },
+    {
+      message: { id: "u1", role: "user" },
+      parts: [{ type: "text", text: "please remember this for me" }],
+    }
+  );
+  const obs = served.filter((s) => s.path.endsWith("/api/sessions/observations"));
+  const inits = served.filter((s) => s.path.endsWith("/api/sessions/init"));
+  assert(obs.length === 0, "user message must not yield an observation, got " + obs.length);
+  assert(inits.length === 1, "user message should yield exactly 1 init, got " + inits.length);
+  assert(
+    inits[0].body.prompt && inits[0].body.prompt.includes("remember"),
+    "init should carry the user prompt"
+  );
+  console.log("PASS 2. user message -> init (no observation)");
+})();
+
+// ---- 3. tool.execute.after -> observation (tool name + result) ----
+await (async () => {
+  reset();
+  const input = { sessionID: SID, tool: "write" };
+  const output = {
+    args: { file_path: "/tmp/x.txt" },
+    output: { content: [{ type: "text", text: "file written" }] },
+  };
+  await hooks["tool.execute.after"](input, output);
+  const obs = served.filter((s) => s.path.endsWith("/api/sessions/observations"));
+  assert(obs.length === 1, "tool result should yield 1 observation, got " + obs.length);
+  assert(
+    obs[0].body.tool_name === "write",
+    "tool observation should record tool name write, got: " + obs[0].body.tool_name
+  );
+  assert(
+    obs[0].body.tool_response.includes("file written"),
+    "tool observation should contain the result text, got: " + obs[0].body.tool_response
+  );
+  console.log("PASS 3. tool.execute.after -> observation");
+})();
+
+// ---- 4. session.idle -> summarize (dedupe: two idles fire once) ----
+await (async () => {
+  reset();
+  const idleEvent = {
+    event: {
+      type: "session.idle",
+      properties: { sessionID: SID },
+    },
+  };
+  await hooks["event"](idleEvent);
+  await hooks["event"](idleEvent); // immediate repeat: the dedupe lock must block it
+  const sum = served.filter((s) => s.path.endsWith("/api/sessions/summarize"));
+  assert(sum.length === 1, "two consecutive idles should trigger 1 summarize, got " + sum.length);
+  console.log("PASS 4. session.idle dedupe");
+})();
+
+// ---- 5. claude_mem_search tool ----
+await (async () => {
+  reset();
+  const res = await plugin.tool.claude_mem_search.execute({ query: "memory backend" });
+  assert(
+    served.some((s) => s.path.includes("/api/search/observations")),
+    "the search tool must call /api/search/observations"
+  );
+  assert(typeof res === "string" && res.length > 0, "search should return text");
+  console.log("PASS 5. claude_mem_search");
+})();
+
+// ---- 6. worker flakiness: exponential-backoff retries then success ----
+await (async () => {
+  reset();
+  failNext = 2; // first two calls 500, third succeeds
+  await hooks["experimental.text.complete"](
+    { sessionID: SID, messageID: "m6", partID: "p6" },
+    { text: "retry test content" }
+  );
+  await hooks["event"]({
+    event: {
+      type: "message.updated",
+      properties: {
+        sessionID: SID,
+        info: { id: "m6", role: "assistant", time: { completed: 1 } },
+      },
+    },
+  });
+  const failedAttempts = served.filter((s) => s.failed).length;
+  const okObs = served.filter(
+    (s) => s.method === "POST" && s.path.endsWith("/api/sessions/observations")
+  ).length;
+  assert(failedAttempts === 2, "expected 2 failed attempts, got " + failedAttempts);
+  assert(okObs >= 1, "expected at least 1 successful observation after retry, got " + okObs);
+  console.log("PASS 6. backoff retry");
+})();
+
+// ---- 7. ECONNREFUSED: give up immediately, no retries, no writes ----
+await (async () => {
+  reset();
+  connRefused = true;
+  await hooks["chat.message"](
+    { sessionID: SID },
+    {
+      message: { id: "u7", role: "user" },
+      parts: [{ type: "text", text: "x" }],
+    }
+  );
+  const writes = served.filter(
+    (s) =>
+      s.method === "POST" &&
+      (s.path.endsWith("/api/sessions/observations") ||
+        s.path.endsWith("/api/sessions/summarize") ||
+        s.path.endsWith("/api/sessions/init"))
+  );
+  assert(writes.length === 0, "ECONNREFUSED must not produce any write request (no retries)");
+  console.log("PASS 7. ECONNREFUSED give up");
+})();
+
+// ---- 8. compacting -> summarize ----
+await (async () => {
+  reset();
+  await hooks["experimental.session.compacting"]({ sessionID: SID });
+  assert(
+    served.some((s) => s.path.endsWith("/api/sessions/summarize")),
+    "compacting should trigger summarize"
+  );
+  console.log("PASS 8. session.compacting -> summarize");
+})();
+
+console.log("\nALL TESTS PASSED");

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "opencode-claude-mem-capture",
+  "version": "1.0.0",
+  "description": "OpenCode capture-only plugin: sends conversation observations to the local claude-mem worker; summarization/embedding/search stay in claude-mem.",
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "claude-mem",
+    "memory",
+    "persistent-memory",
+    "cross-session"
+  ],
+  "author": "camplus <camplus360@163.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/camplus360/agent-memory-bridge.git",
+    "directory": "agents/opencode"
+  },
+  "type": "module",
+  "main": "index.js",
+  "scripts": {
+    "test": "bun run index.test.js"
+  }
+}