opencode-memelord 0.0.1

package/README.md

@@ -0,0 +1,74 @@
+# opencode-memelord
+
+[OpenCode](https://opencode.ai) plugin for [memelord](https://github.com/glommer/memelord) -- persistent memory for coding agents.
+
+## What it does
+
+Gives your OpenCode agent persistent memory that improves over time. Memories from past sessions are injected at session start, tool failures are tracked, and transcripts are analyzed for self-corrections and discoveries.
+
+| OpenCode event | memelord hook | Purpose |
+|---|---|---|
+| `session.created` | `session-start` | Inject top memories into context |
+| `tool.execute.after` | `post-tool-use` | Record tool failures for pattern detection |
+| `session.idle` | `stop` | Analyze transcript for corrections and discoveries |
+| `session.deleted` | `session-end` | Embed pending memories, run weight decay |
+
+## Install
+
+### Quick start (with memelord init)
+
+```bash
+npm install -g memelord
+cd your-project
+memelord init
+```
+
+This configures both the MCP server (for memory tools) and the plugin (for hooks).
+
+### Manual setup
+
+Add to your `opencode.json`:
+
+```json
+{
+  "plugin": ["opencode-memelord"],
+  "mcp": {
+    "memelord": {
+      "type": "local",
+      "command": ["memelord", "serve"],
+      "environment": { "MEMELORD_DIR": ".memelord" },
+      "enabled": true
+    }
+  }
+}
+```
+
+Make sure memelord is installed globally:
+
+```bash
+npm install -g memelord
+```
+
+Then initialize the project database:
+
+```bash
+memelord init
+```
+
+## How it works
+
+This plugin is a thin wrapper around the `memelord hook` CLI. It translates OpenCode's plugin events into the same hook commands that memelord uses for Claude Code, so all the analysis, storage, embedding, and decay logic stays in memelord.
+
+- **No logic is duplicated** -- the plugin delegates everything to the memelord CLI
+- **Automatic upstream updates** -- when memelord improves its hooks, this plugin benefits without changes
+- **MCP tools still work** -- the plugin handles lifecycle hooks, the MCP server provides memory tools (`memory_start_task`, `memory_report`, `memory_end_task`, `memory_contradict`, `memory_status`)
+
+## Requirements
+
+- [memelord](https://github.com/glommer/memelord) installed globally (`npm install -g memelord`)
+- [OpenCode](https://opencode.ai) v1.0+
+- A `.memelord/` directory in your project (created by `memelord init`)
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * opencode-memelord: OpenCode plugin for memelord persistent memory.
+ *
+ * Thin wrapper that delegates to `memelord hook <event>` CLI commands.
+ * No business logic is ported — all analysis, storage, embedding, and
+ * decay happens in the memelord CLI.
+ *
+ * Hook mapping:
+ *   session.created  → memelord hook session-start
+ *   tool.execute.after → memelord hook post-tool-use
+ *   session.idle     → memelord hook stop
+ *   session.deleted  → memelord hook session-end
+ */
+import type { Plugin } from "@opencode-ai/plugin";
+export declare const MemelordPlugin: Plugin;

package/dist/index.js

@@ -0,0 +1,154 @@
+// src/index.ts
+import { dirname, join } from "path";
+import { createRequire } from "module";
+import { writeFileSync, unlinkSync, existsSync } from "fs";
+import { tmpdir } from "os";
+function resolveMemelordBin() {
+  try {
+    const require2 = createRequire(import.meta.url);
+    const pkgPath = require2.resolve("memelord/package.json");
+    return join(dirname(pkgPath), "dist", "cli.mjs");
+  } catch {
+    return "";
+  }
+}
+var MemelordPlugin = async ({ client, directory, worktree, $ }) => {
+  const cwd = worktree || directory;
+  const memelordBin = resolveMemelordBin();
+  let currentSessionId = "";
+  async function callHook(event, stdinData) {
+    const json = JSON.stringify(stdinData);
+    try {
+      if (memelordBin) {
+        return await $`echo ${json} | node ${memelordBin} hook ${event}`.quiet().nothrow().text();
+      }
+      return await $`echo ${json} | memelord hook ${event}`.quiet().nothrow().text();
+    } catch {
+      return "";
+    }
+  }
+  function convertTranscript(messages) {
+    const lines = [];
+    for (const { info, parts } of messages) {
+      const content = [];
+      for (const part of parts) {
+        if (part.type === "text") {
+          content.push({ type: "text", text: part.text });
+        } else if (part.type === "tool") {
+          content.push({
+            type: "tool_use",
+            name: part.tool,
+            input: part.state.status !== "pending" ? part.state.input : {}
+          });
+          if (part.state.status === "completed") {
+            content.push({ type: "tool_result", content: part.state.output });
+          } else if (part.state.status === "error") {
+            content.push({
+              type: "tool_result",
+              content: part.state.error,
+              is_error: true
+            });
+          }
+        }
+      }
+      const msg = { role: info.role, content };
+      if (info.role === "assistant") {
+        const a = info;
+        msg.usage = {
+          input_tokens: a.tokens.input,
+          output_tokens: a.tokens.output,
+          cache_creation_input_tokens: a.tokens.cache.write
+        };
+      }
+      lines.push(JSON.stringify(msg));
+    }
+    return lines.join(`
+`);
+  }
+  async function onSessionCreated(sessionId) {
+    currentSessionId = sessionId;
+    if (!existsSync(join(cwd, ".memelord")))
+      return;
+    const stdout = await callHook("session-start", {
+      session_id: sessionId,
+      cwd
+    });
+    if (!stdout.trim())
+      return;
+    try {
+      const parsed = JSON.parse(stdout);
+      const context = parsed?.hookSpecificOutput?.additionalContext;
+      if (context) {
+        await client.session.prompt({
+          path: { id: sessionId },
+          body: {
+            noReply: true,
+            parts: [{ type: "text", text: context }]
+          }
+        });
+      }
+    } catch {}
+  }
+  async function onSessionIdle(sessionId) {
+    if (!existsSync(join(cwd, ".memelord")))
+      return;
+    const stdinData = {
+      session_id: sessionId,
+      cwd
+    };
+    try {
+      const response = await client.session.messages({
+        path: { id: sessionId }
+      });
+      const messages = response.data;
+      if (messages && messages.length > 0) {
+        const transcript = convertTranscript(messages);
+        const tmpFile = join(tmpdir(), `memelord-transcript-${sessionId}.jsonl`);
+        writeFileSync(tmpFile, transcript);
+        stdinData.transcript_path = tmpFile;
+        await callHook("stop", stdinData);
+        try {
+          unlinkSync(tmpFile);
+        } catch {}
+        return;
+      }
+    } catch {}
+    await callHook("stop", stdinData);
+  }
+  async function onSessionDeleted(sessionId) {
+    if (!existsSync(join(cwd, ".memelord")))
+      return;
+    await callHook("session-end", {
+      session_id: sessionId,
+      cwd
+    });
+  }
+  return {
+    "tool.execute.after": async (input, output) => {
+      if (!existsSync(join(cwd, ".memelord")))
+        return;
+      if (!currentSessionId)
+        return;
+      callHook("post-tool-use", {
+        session_id: currentSessionId,
+        cwd,
+        tool_name: input.tool,
+        tool_input: input.args,
+        tool_response: output.output ?? ""
+      }).catch(() => {});
+    },
+    event: async (input) => {
+      const { event } = input;
+      if (event.type === "session.created") {
+        await onSessionCreated(event.properties.info.id);
+      } else if (event.type === "session.idle") {
+        onSessionIdle(event.properties.sessionID).catch(() => {});
+      } else if (event.type === "session.deleted") {
+        await onSessionDeleted(event.properties.info.id);
+      }
+    }
+  };
+};
+export {
+  MemelordPlugin
+};

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "opencode-memelord",
+  "version": "0.0.1",
+  "description": "OpenCode plugin for memelord - persistent memory for coding agents",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "bun build ./src/index.ts --outdir ./dist --target node && tsc --emitDeclarationOnly",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [
+    "opencode",
+    "plugin",
+    "memelord",
+    "memory",
+    "ai",
+    "coding-agent"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/buzinas/opencode-memelord"
+  },
+  "dependencies": {
+    "@opencode-ai/plugin": "^1.2.10",
+    "memelord": "^0.1.4"
+  },
+  "devDependencies": {
+    "@opencode-ai/sdk": "^1.2.10",
+    "@types/bun": "latest",
+    "typescript": "^5.0.0"
+  },
+  "opencode": {
+    "type": "plugin",
+    "hooks": [
+      "event",
+      "tool.execute.after"
+    ]
+  },
+  "files": [
+    "dist"
+  ]
+}