@ephemushroom/opencode-claude-mem 0.2.0 → 0.2.2

package/README.md

@@ -8,10 +8,30 @@ Enables OpenCode to share the same memory database as Claude Code — observatio
 
 This plugin communicates with the Claude-Mem worker service (HTTP API on port 37777) to:
 
+- **Inject memory context** — previous session context is injected into the system prompt on every LLM call
 - **Capture tool observations** — every tool execution is recorded as a structured observation
-- **Inject memory context** — previous session context is injected into the system prompt via `/api/context/inject`
 - **Summarize sessions** — when a session goes idle, the last user/assistant messages are sent for summarization
-- **Search memory** — `mem-search` tool lets the LLM query project history
+- **Search memory** — memory search is available via claude-mem's MCP server
+- **View context on demand** — `/memory` command displays the current memory context in the chat flow
+
+## Differences from Claude Code Version
+
+The Claude Code version of claude-mem uses shell-based hooks where `SessionStart` stdout is automatically injected into the system prompt — one-time, at session start.
+
+This OpenCode version works differently:
+
+| | Claude Code | OpenCode (this plugin) |
+|---|---|---|
+| **Architecture** | Shell commands (`node script.js`) | JavaScript plugin API |
+| **Context injection** | `SessionStart` hook stdout → system prompt (once) | `experimental.chat.system.transform` → system prompt (every LLM call, session-level cache) |
+| **Context freshness** | Snapshot at session start | Cached once per session (same as Claude Code) |
+| **User-visible context** | Displayed in TUI automatically | `/memory` command to view on demand |
+| **Session init** | `UserPromptSubmit` hook | `chat.message` hook with real user prompt |
+| **Observations** | `PostToolUse` hook | `tool.execute.after` hook (with circular memory protection) |
+| **Summarization** | `Stop` hook | `session.idle` event |
+| **Memory search** | MCP server | MCP server (same — no custom tool needed) |
+
+Both versions behave the same way: context is fetched once per session and cached. The OpenCode plugin uses `experimental.chat.system.transform` which fires on every LLM call, but the context is session-level cached so the worker is only called once.
 
 ## Prerequisites
 
@@ -52,6 +72,25 @@ curl -s http://127.0.0.1:37777/api/health
 # Restart OpenCode — you should see toast: "Memory active · {project}"
 ```
 
+## Usage
+
+### Automatic (no action needed)
+
+Once installed, the plugin works automatically:
+
+- **System prompt injection** — memory context is injected into every LLM call via `experimental.chat.system.transform`. The LLM sees your project's observation history, past decisions, and session summaries. Context is cached once per session to avoid redundant worker calls.
+- **Tool observation capture** — every tool execution (file reads, edits, searches, etc.) is recorded as an observation in the memory database. Claude-mem's own MCP tools are automatically filtered to prevent circular memory.
+- **Session summarization** — when a session goes idle, the last user/assistant exchange is summarized and stored.
+- **Toast notification** — on session start, a "Memory active · {project}" toast confirms the plugin is connected to the worker.
+
+### `/memory` Command
+
+Type `/memory` in the chat to display the current memory context inline. This shows you exactly what the LLM sees in its system prompt — the observation index, token economics, and session history.
+
+### Memory Search
+
+Memory search is provided by claude-mem's MCP server. If you have the claude-mem MCP configured in OpenCode, the LLM can search project history directly via MCP tools — no plugin-level tool needed.
+
 ### Alternative: Manual Installation (from source)
 
 If you prefer to install from source instead of npm:
@@ -217,11 +256,12 @@ The plugin is a thin HTTP client. All heavy lifting (LLM processing, storage, se
 
 | Claude Code Hook | OpenCode Hook | Purpose |
 |-----------------|---------------|---------|
-| `SessionStart` → context | `experimental.chat.system.transform` | Inject memory into system prompt |
+| `SessionStart` → context | `experimental.chat.system.transform` | Inject memory into system prompt (every LLM call, session-level cache) |
 | `UserPromptSubmit` → session-init | `chat.message` | Init session with real user prompt |
 | `PostToolUse` → observation | `tool.execute.after` | Capture tool executions |
 | `Stop` → summarize | `event` (session.idle) | Summarize with real message content |
 | `Stop` → session-complete | `event` (session.idle) | Mark session complete |
+| *(no equivalent)* | `config` + `command.execute.before` | `/memory` command for user-visible context |
 
 ### Worker API Endpoints Used
 
@@ -233,7 +273,6 @@ The plugin is a thin HTTP client. All heavy lifting (LLM processing, storage, se
 | `POST` | `/api/sessions/observations` | Send tool observation |
 | `POST` | `/api/sessions/summarize` | Trigger summarization |
 | `POST` | `/api/sessions/complete` | Complete session |
-| `GET` | `/api/search?q={query}&project={name}` | Search memory |
 
 ## Key Implementation Details
 
@@ -242,6 +281,11 @@ The plugin is a thin HTTP client. All heavy lifting (LLM processing, storage, se
 - **Deferred toast**: `client.tui.showToast()` is deferred to first hook invocation (TUI not ready during plugin init, calling it crashes OpenCode)
 - **Real prompt**: `chat.message` hook extracts actual user input instead of hardcoded "SESSION_START"
 - **Real summarize**: `session.idle` fetches last user/assistant messages via `client.session.messages()` for meaningful summaries
+- **Context caching**: `getCachedContext()` caches context once per session (invalidated on `session.created`) to avoid redundant worker calls
+- **Content-type handling**: Worker returns `text/plain` markdown — `getContext()` checks content-type and uses `response.text()` instead of `response.json()`
+- **Context tag wrapping**: Injected context is wrapped in `<claude-mem-context>` tags so the worker's tag-stripping logic can remove it from observations, preventing circular memory
+- **Circular memory protection**: `tool.execute.after` filters out claude-mem's own MCP tools (`claude-mem_mcp-search_*`) to prevent search results from being re-recorded as observations
+- **`/memory` command**: Registered via `config` hook, handled by `command.execute.before` — displays context as an `ignored: true` message (visible to user, not sent to LLM)
 
 ## Troubleshooting
 

package/dist/index.d.ts

@@ -3,12 +3,17 @@ import { type Plugin } from '@opencode-ai/plugin';
  * OpenCode Plugin for Claude-Mem
  *
  * Hooks used:
+ * - `config` — register /memory command
+ * - `command.execute.before` — handle /memory command
  * - `event` — session lifecycle (session.created, session.idle)
  * - `tool.execute.after` — capture tool observations
  * - `experimental.chat.system.transform` — inject memory context into system prompt
- * - `chat.message` — fallback session init when event hook doesn't fire
- * - `tool` — mem-search custom tool
+ * - `chat.message` — session init with real user prompt
  *
  * Uses TUI toast notifications for status feedback.
  */
 export declare const ClaudeMemPlugin: Plugin;
+declare const _default: {
+    server: Plugin;
+};
+export default _default;

package/dist/index.js

@@ -1,7 +1,4 @@
 // @bun
-// src/index.ts
-import { tool } from "@opencode-ai/plugin";
-
 // src/worker-client.ts
 class WorkerClient {
   static PORT = 37777;
@@ -80,31 +77,24 @@ class WorkerClient {
       if (!response.ok) {
         return null;
       }
-      const data = await response.json();
-      if (typeof data === "string") {
-        return data;
-      }
-      if (data && typeof data.content === "string") {
-        return data.content;
+      const contentType = response.headers.get("content-type") || "";
+      if (contentType.includes("application/json")) {
+        const data = await response.json();
+        if (typeof data === "string") {
+          return data;
+        }
+        if (data && typeof data.content === "string") {
+          return data.content;
+        }
+        const text2 = JSON.stringify(data, null, 2);
+        return text2 === "{}" || text2 === "null" ? null : text2;
       }
-      const text = JSON.stringify(data, null, 2);
-      return text === "{}" || text === "null" ? null : text;
+      const text = await response.text();
+      return text.trim() || null;
     } catch {
       return null;
     }
   }
-  static async search(query, project) {
-    try {
-      const response = await fetch(`${this.BASE_URL}/api/search?q=${encodeURIComponent(query)}&project=${encodeURIComponent(project)}`);
-      if (!response.ok) {
-        return "Search failed";
-      }
-      const data = await response.json();
-      return JSON.stringify(data, null, 2);
-    } catch (error) {
-      return `Error performing search: ${error}`;
-    }
-  }
 }
 
 // src/index.ts
@@ -132,19 +122,17 @@ var ClaudeMemPlugin = async (ctx) => {
       await toast(text.slice(0, 200), "info");
     }
   }
-  const CONTEXT_CACHE_TTL = 30000;
-  let contextCache = null;
+  let contextCache = undefined;
   async function getCachedContext() {
-    if (contextCache && Date.now() < contextCache.expiry) {
-      return contextCache.value;
+    if (contextCache !== undefined) {
+      return contextCache;
     }
     const context = await WorkerClient.getContext(projectName);
-    contextCache = { value: context, expiry: Date.now() + CONTEXT_CACHE_TTL };
+    contextCache = context;
     return context;
   }
   let workerHealthy = null;
   let initToastShown = false;
-  let contextDisplayedInline = false;
   async function checkWorkerAndToast() {
     if (workerHealthy === null) {
       workerHealthy = await WorkerClient.isHealthy();
@@ -152,9 +140,7 @@ var ClaudeMemPlugin = async (ctx) => {
     if (!initToastShown) {
       initToastShown = true;
       if (workerHealthy) {
-        if (!contextDisplayedInline) {
-          await toast(`Memory active \xB7 ${projectName}`, "success");
-        }
+        await toast(`Memory active \xB7 ${projectName}`, "success");
       } else {
         await toast("Worker offline \u2014 start Claude Code first", "warning", 5000);
       }
@@ -188,6 +174,34 @@ var ClaudeMemPlugin = async (ctx) => {
 `).trim();
   }
   return {
+    config: async (input) => {
+      input.command ??= {};
+      input.command["memory"] = {
+        template: "/memory",
+        description: "Show memory context from Claude-Mem"
+      };
+    },
+    "command.execute.before": async (input) => {
+      if (input.command !== "memory") {
+        return;
+      }
+      const sessionId = input.sessionID || currentSessionId;
+      if (!sessionId) {
+        throw new Error("__MEMORY_NO_SESSION__");
+      }
+      const isHealthy = await checkWorkerAndToast();
+      if (!isHealthy) {
+        await sendStatusMessage(sessionId, "\u26A0 Claude-Mem worker is offline");
+        throw new Error("__MEMORY_HANDLED__");
+      }
+      const context = await getCachedContext();
+      if (context) {
+        await sendStatusMessage(sessionId, context);
+      } else {
+        await sendStatusMessage(sessionId, `No memory context available for ${projectName}`);
+      }
+      throw new Error("__MEMORY_HANDLED__");
+    },
     event: async ({ event }) => {
       if (event.type === "session.created") {
         const sessionId = event.properties?.info?.id;
@@ -195,18 +209,8 @@ var ClaudeMemPlugin = async (ctx) => {
           return;
         }
         currentSessionId = sessionId;
-        const context = await getCachedContext();
-        if (context) {
-          contextDisplayedInline = true;
-        }
-        const isHealthy = await checkWorkerAndToast();
-        if (isHealthy) {
-          if (context) {
-            await sendStatusMessage(sessionId, context);
-          } else {
-            await toast(`Memory active \xB7 ${projectName}`, "success", 2000);
-          }
-        }
+        contextCache = undefined;
+        await checkWorkerAndToast();
       }
       if (event.type === "session.idle") {
         const sessionId = event.properties?.sessionID || currentSessionId;
@@ -261,8 +265,10 @@ var ClaudeMemPlugin = async (ctx) => {
       try {
         const context = await getCachedContext();
         if (context) {
-          output.system.push(`[Claude-Mem] Memory Active. Previous Context:
-${context}`);
+          output.system.push(`<claude-mem-context>
+[Claude-Mem] Memory Active. Previous Context:
+${context}
+</claude-mem-context>`);
         }
       } catch {}
     },
@@ -271,22 +277,18 @@ ${context}`);
       if (!sessionId) {
         return;
       }
+      if (input.tool.startsWith("claude-mem_mcp-search_")) {
+        return;
+      }
       await ensureSessionInit(sessionId);
       try {
         await WorkerClient.sendObservation(sessionId, input.tool, input.args || {}, output.output, projectRoot);
       } catch {}
-    },
-    tool: {
-      "mem-search": tool({
-        description: "Search project history and memory. Use this to find information about past decisions, code changes, or bug fixes.",
-        args: {
-          query: tool.schema.string()
-        },
-        execute: async (args) => await WorkerClient.search(args.query, projectName)
-      })
     }
   };
 };
+var src_default = { server: ClaudeMemPlugin };
 export {
+  src_default as default,
   ClaudeMemPlugin
 };

package/dist/worker-client.d.ts

@@ -37,8 +37,4 @@ export declare class WorkerClient {
      * Uses /api/context/inject which returns rich markdown with observations + session summaries.
      */
     static getContext(project: string): Promise<string | null>;
-    /**
-     * Perform Search (used by mem-search tool)
-     */
-    static search(query: string, project: string): Promise<string>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ephemushroom/opencode-claude-mem",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "OpenCode plugin for Claude-Mem persistent memory system",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -12,6 +12,10 @@
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
+    },
+    "./server": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
     }
   },
   "scripts": {
@@ -45,7 +49,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@opencode-ai/plugin": "latest"
+    "@opencode-ai/plugin": "^1.3.0"
   },
   "devDependencies": {
     "@types/bun": "latest",