opencode-memsearch 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Jeremy Dormitzer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,125 @@
+# opencode-memsearch
+
+Persistent cross-session memory for [OpenCode](https://opencode.ai), powered by [memsearch](https://github.com/nicobako/memsearch).
+
+This plugin gives your OpenCode agent long-term memory. It automatically summarizes each conversation turn and stores it in a local vector database. On session start, recent context is injected into the system prompt, and the agent can search all past memories with semantic search.
+
+## Features
+
+- **Automatic memory capture** — each conversation turn is summarized by an LLM and appended to daily memory files in `.memsearch/memory/`
+- **Cold-start context** — the last 30 lines of the 2 most recent memory files are injected into the system prompt when a new session starts
+- **Semantic search** — two custom tools (`memsearch_search` and `memsearch_expand`) let the agent search and drill into past memories
+- **Per-project isolation** — memory collections are scoped by project directory
+- **Local embeddings** — uses memsearch's local embedding provider, so no API calls are needed for vector search
+- **Memory protocol** — a system prompt directive instructs the agent to check memory at session start and whenever it encounters a topic that might have prior context
+
+## Prerequisites
+
+You need the `memsearch` CLI installed. The easiest way is via [uv](https://docs.astral.sh/uv/):
+
+```bash
+# Install uv (if you don't have it)
+curl -LsSf https://astral.sh/uv/install.sh | sh
+
+# Install memsearch with local embeddings
+uv tool install 'memsearch[local]'
+```
+
+Or install directly with pip:
+
+```bash
+pip install 'memsearch[local]'
+```
+
+If `memsearch` is not installed, the plugin's tools will return a clear error message asking the agent to tell you to install it.
+
+## Install
+
+Add `opencode-memsearch` to the plugin list in your OpenCode config:
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugin": ["opencode-memsearch"]
+}
+```
+
+This can go in either:
+- `opencode.json` in your project root (project-level)
+- `~/.config/opencode/opencode.json` (global)
+
+OpenCode will install the npm package automatically on startup.
+
+## How it works
+
+### Memory capture
+
+When the agent finishes responding (session goes idle), the plugin:
+
+1. Extracts the last conversation turn (user message + agent response)
+2. Summarizes it into 2-6 bullet points using Claude Haiku via `opencode run`
+3. Appends the summary to `.memsearch/memory/YYYY-MM-DD.md`
+4. Re-indexes the memory directory into the vector database
+
+Summaries are written in third person (e.g. "User asked about...", "Agent edited file X...") and include specific file names, function names, and outcomes.
+
+### Memory recall
+
+On session start, the plugin:
+
+1. Reads the tail of the 2 most recent memory files and injects them into the system prompt as `<memsearch-context>`
+2. Adds a MEMORY PROTOCOL to the system prompt instructing the agent to use `memsearch_search` at session start and whenever relevant
+
+The agent can also search memories on demand:
+
+- **`memsearch_search`** — semantic search across all past memory chunks. Returns ranked results with content previews and chunk hashes.
+- **`memsearch_expand`** — expand a specific chunk to see full context, source file location, and session IDs for deeper investigation.
+
+### Storage
+
+Memory data is stored per-project in `.memsearch/`:
+
+```
+your-project/
+  .memsearch/
+    memory/
+      2025-03-28.md    # Daily memory summaries
+      2025-03-27.md
+      ...
+```
+
+You should add `.memsearch/` to your `.gitignore`.
+
+## Seed script
+
+The repo includes a seed script (`scripts/seed-memories.ts`) that can backfill memory from existing OpenCode sessions. This is useful when first installing the plugin on a project you've already been working on:
+
+```bash
+# Seed from the last 14 days of sessions (default)
+bun run scripts/seed-memories.ts
+
+# Seed from the last 30 days
+bun run scripts/seed-memories.ts --days 30
+```
+
+The script reads directly from the OpenCode SQLite database, summarizes each conversation turn with Claude Haiku, and writes the results to `.memsearch/memory/`.
+
+## Configuration
+
+The plugin auto-configures memsearch to use local embeddings. If you want to use a remote Milvus instance instead of the default local database, configure it via the memsearch CLI:
+
+```bash
+memsearch config set milvus.uri http://localhost:19530
+```
+
+In remote mode, the plugin starts a file watcher process that automatically re-indexes memory files when they change.
+
+## Environment variables
+
+| Variable | Description |
+|----------|-------------|
+| `MEMSEARCH_DISABLE` | Set to any value to disable the plugin (used internally to prevent recursion during summarization) |
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import { type Plugin } from "@opencode-ai/plugin";
+declare const memsearchPlugin: Plugin;
+export default memsearchPlugin;

package/dist/index.js

@@ -0,0 +1,530 @@
+// src/index.ts
+import { tool } from "@opencode-ai/plugin";
+import { createHash } from "crypto";
+import { readdir, readFile, appendFile, mkdir, writeFile, unlink } from "fs/promises";
+import { join, basename, resolve } from "path";
+import { tmpdir } from "os";
+function deriveCollectionName(directory) {
+  const abs = resolve(directory);
+  const sanitized = basename(abs).toLowerCase().replace(/[^a-z0-9]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "").slice(0, 40);
+  const hash = createHash("sha256").update(abs).digest("hex").slice(0, 8);
+  return `ms_${sanitized}_${hash}`;
+}
+function todayDate() {
+  const d = new Date;
+  const yyyy = d.getFullYear();
+  const mm = String(d.getMonth() + 1).padStart(2, "0");
+  const dd = String(d.getDate()).padStart(2, "0");
+  return `${yyyy}-${mm}-${dd}`;
+}
+function nowTime() {
+  const d = new Date;
+  return `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`;
+}
+var SUMMARIZE_PROMPT = `You are a third-person note-taker. The attached file contains a transcript of ONE conversation turn between a human and an AI coding agent. Tool calls are labeled [Tool Call] and their results [Tool Result] or [Tool Error].
+
+Your job is to record what happened as factual third-person notes. You are an EXTERNAL OBSERVER. Do NOT answer the human's question, do NOT give suggestions, do NOT offer help. ONLY record what occurred.
+
+Output 2-6 bullet points, each starting with '- '. NOTHING else.
+
+Rules:
+- Write in third person: 'User asked...', 'Agent read file X', 'Agent ran command Y'
+- First bullet: what the user asked or wanted (one sentence)
+- Remaining bullets: what the agent did — tools called, files read/edited, commands run, key findings
+- Be specific: mention file names, function names, tool names, and concrete outcomes
+- Do NOT answer the human's question yourself — just note what was discussed
+- Do NOT add any text before or after the bullet points
+- Do NOT continue the conversation after the bullet points
+- Do NOT ask follow-up questions
+- STOP immediately after the last bullet point`;
+var HAIKU_MODEL = "anthropic/claude-haiku-4-5";
+var TEMP_DIR = join(tmpdir(), "memsearch-plugin");
+var memsearchPlugin = async ({ client, $, directory }) => {
+  if (process.env.MEMSEARCH_DISABLE) {
+    return {};
+  }
+  const sessions = new Map;
+  let memsearchCmd = null;
+  async function detectMemsearch() {
+    try {
+      await $`which memsearch`.quiet();
+      return ["memsearch"];
+    } catch {}
+    try {
+      await $`which uvx`.quiet();
+      return ["uvx", "--from", "memsearch[local]", "memsearch"];
+    } catch {}
+    return null;
+  }
+  async function ensureMemsearch() {
+    if (memsearchCmd)
+      return memsearchCmd;
+    memsearchCmd = await detectMemsearch();
+    return memsearchCmd;
+  }
+  const MEMSEARCH_NOT_FOUND_ERROR = "memsearch is not installed. Tell the user to install it by running: pip install 'memsearch[local]' — or, if they have uv: uv tool install 'memsearch[local]'. See https://github.com/jdormit/opencode-memsearch for details.";
+  async function runMemsearch(args, collectionName) {
+    const cmd = memsearchCmd;
+    if (!cmd)
+      return "";
+    const fullArgs = [...cmd, ...args, "--collection", collectionName];
+    try {
+      return await $`${fullArgs}`.quiet().text();
+    } catch {
+      return "";
+    }
+  }
+  async function getMemsearchConfig(key) {
+    const cmd = memsearchCmd;
+    if (!cmd)
+      return "";
+    try {
+      return (await $`${[...cmd, "config", "get", key]}`.quiet().text()).trim();
+    } catch {
+      return "";
+    }
+  }
+  async function configureLocalEmbedding() {
+    const cmd = memsearchCmd;
+    if (!cmd)
+      return;
+    const provider = await getMemsearchConfig("embedding.provider");
+    if (provider !== "local") {
+      try {
+        await $`${[...cmd, "config", "set", "embedding.provider", "local"]}`.quiet();
+      } catch {}
+    }
+  }
+  async function stopWatch(memsearchDir) {
+    const pidFile = join(memsearchDir, ".watch.pid");
+    try {
+      const pidStr = await readFile(pidFile, "utf-8");
+      const pid = parseInt(pidStr.trim(), 10);
+      if (pid) {
+        try {
+          process.kill(pid);
+        } catch {}
+      }
+      await unlink(pidFile);
+    } catch {}
+  }
+  async function startWatch(memoryDir, memsearchDir, collectionName) {
+    const cmd = memsearchCmd;
+    if (!cmd)
+      return;
+    const milvusUri = await getMemsearchConfig("milvus.uri");
+    if (!milvusUri.startsWith("http") && !milvusUri.startsWith("tcp")) {
+      return;
+    }
+    await stopWatch(memsearchDir);
+    const pidFile = join(memsearchDir, ".watch.pid");
+    try {
+      const watchProc = Bun.spawn([...cmd, "watch", memoryDir, "--collection", collectionName], {
+        stdout: "ignore",
+        stderr: "ignore",
+        stdin: "ignore"
+      });
+      await writeFile(pidFile, String(watchProc.pid));
+    } catch {}
+  }
+  async function getRecentMemory(memoryDir) {
+    try {
+      const files = await readdir(memoryDir);
+      const mdFiles = files.filter((f) => f.endsWith(".md")).sort().reverse().slice(0, 2);
+      if (mdFiles.length === 0)
+        return "";
+      let context = `# Recent Memory
+
+`;
+      for (const f of mdFiles) {
+        const content = await readFile(join(memoryDir, f), "utf-8");
+        const lines = content.split(`
+`);
+        const tail = lines.slice(-30).join(`
+`).trim();
+        if (tail) {
+          context += `## ${f}
+${tail}
+
+`;
+        }
+      }
+      return context;
+    } catch {
+      return "";
+    }
+  }
+  function formatTurnTranscript(messages) {
+    let lastUserIdx = -1;
+    for (let i = messages.length - 1;i >= 0; i--) {
+      if (messages[i].info.role === "user") {
+        lastUserIdx = i;
+        break;
+      }
+    }
+    if (lastUserIdx === -1)
+      return "";
+    const turn = messages.slice(lastUserIdx);
+    const lines = [
+      "=== Transcript of a conversation turn between a human and an AI coding agent ==="
+    ];
+    for (const msg of turn) {
+      const role = msg.info.role;
+      for (const part of msg.parts) {
+        if (part.type === "text" && part.text?.trim()) {
+          if (role === "user") {
+            lines.push(`[Human]: ${part.text.trim()}`);
+          } else if (role === "assistant") {
+            lines.push(`[Assistant]: ${part.text.trim()}`);
+          }
+        } else if (part.type === "tool-invocation" || part.type === "tool_use") {
+          const name = part.toolName || part.name || "unknown";
+          const args = part.args || part.input || {};
+          const argParts = [];
+          for (const [k, v] of Object.entries(args)) {
+            let vStr = String(v);
+            if (vStr.length > 120)
+              vStr = vStr.slice(0, 120) + "...";
+            argParts.push(`${k}=${vStr}`);
+          }
+          let argSummary = argParts.join(", ");
+          if (argSummary.length > 400)
+            argSummary = argSummary.slice(0, 400) + "...";
+          lines.push(`[Tool Call]: ${name}(${argSummary})`);
+        } else if (part.type === "tool-result" || part.type === "tool_result") {
+          const output = String(part.output || part.content || "").slice(0, 1000);
+          const isError = part.isError || part.is_error;
+          const label = isError ? "[Tool Error]" : "[Tool Result]";
+          lines.push(`${label}: ${output}`);
+        }
+      }
+    }
+    return lines.join(`
+`);
+  }
+  async function summarizeTranscript(transcript, sessionID, turnIdx) {
+    const tempFile = join(TEMP_DIR, `turn-${sessionID}-${turnIdx}.txt`);
+    await mkdir(TEMP_DIR, { recursive: true });
+    await writeFile(tempFile, transcript);
+    try {
+      const rawOutput = await $`opencode run -f ${tempFile} --model ${HAIKU_MODEL} --format json ${SUMMARIZE_PROMPT}`.env({ ...process.env, MEMSEARCH_DISABLE: "1" }).nothrow().quiet().text();
+      let summarizationSessionID;
+      const textParts = [];
+      for (const line of rawOutput.split(`
+`)) {
+        if (!line.trim())
+          continue;
+        try {
+          const event = JSON.parse(line);
+          if (!summarizationSessionID && event.sessionID) {
+            summarizationSessionID = event.sessionID;
+          }
+          if (event.type === "text" && event.part?.text) {
+            textParts.push(event.part.text);
+          }
+        } catch {}
+      }
+      if (summarizationSessionID) {
+        try {
+          await client.session.delete({ path: { id: summarizationSessionID } });
+        } catch {}
+      }
+      const combined = textParts.join("");
+      const bulletLines = combined.split(`
+`).filter((l) => l.trimStart().startsWith("- ")).filter((l) => {
+        const content = l.trimStart().slice(2);
+        return content.startsWith("User ") || content.startsWith("Agent ");
+      });
+      return bulletLines.join(`
+`).trim();
+    } finally {
+      try {
+        await unlink(tempFile);
+      } catch {}
+    }
+  }
+  function formatConciseSummary(messages) {
+    let lastUserIdx = -1;
+    for (let i = messages.length - 1;i >= 0; i--) {
+      if (messages[i].info.role === "user") {
+        lastUserIdx = i;
+        break;
+      }
+    }
+    if (lastUserIdx === -1)
+      return "";
+    const turn = messages.slice(lastUserIdx);
+    const lines = [];
+    for (const msg of turn) {
+      const role = msg.info.role;
+      for (const part of msg.parts) {
+        if (part.type === "text" && part.text?.trim()) {
+          if (role === "user") {
+            const text = part.text.trim();
+            lines.push(`- User asked: ${text.length > 200 ? text.slice(0, 200) + "..." : text}`);
+          } else if (role === "assistant") {
+            const text = part.text.trim();
+            if (text.length > 0) {
+              lines.push(`- Agent responded: ${text.length > 200 ? text.slice(0, 200) + "..." : text}`);
+            }
+          }
+        } else if (part.type === "tool-invocation" || part.type === "tool_use") {
+          const name = part.toolName || part.name || "unknown";
+          const args = part.args || part.input || {};
+          const keyArgs = [];
+          for (const [k, v] of Object.entries(args)) {
+            const vStr = String(v);
+            if (vStr.length <= 100) {
+              keyArgs.push(`${k}=${vStr}`);
+            } else {
+              keyArgs.push(`${k}=${vStr.slice(0, 80)}...`);
+            }
+          }
+          lines.push(`- Tool: ${name}(${keyArgs.join(", ").slice(0, 300)})`);
+        }
+      }
+    }
+    return lines.slice(0, 20).join(`
+`);
+  }
+  await ensureMemsearch();
+  if (memsearchCmd) {
+    await configureLocalEmbedding();
+  }
+  return {
+    event: async ({ event }) => {
+      if (event.type === "session.created") {
+        const sessionInfo = event.properties.info;
+        const sessionID = sessionInfo.id;
+        if (sessionInfo.parentID)
+          return;
+        const sessionDir = sessionInfo.directory || directory;
+        const memsearchDir = join(sessionDir, ".memsearch");
+        const memoryDir = join(memsearchDir, "memory");
+        const collectionName = deriveCollectionName(sessionDir);
+        if (!memsearchCmd) {
+          await ensureMemsearch();
+        }
+        await mkdir(memoryDir, { recursive: true });
+        sessions.set(sessionID, {
+          directory: sessionDir,
+          memoryDir,
+          collectionName,
+          isSummarizing: false,
+          lastSummarizedMessageCount: 0,
+          headingWritten: false
+        });
+        await startWatch(memoryDir, memsearchDir, collectionName);
+        const milvusUri = await getMemsearchConfig("milvus.uri");
+        if (!milvusUri.startsWith("http") && !milvusUri.startsWith("tcp")) {
+          runMemsearch(["index", memoryDir], collectionName);
+        }
+        const coldStart = await getRecentMemory(memoryDir);
+        if (coldStart) {
+          const state = sessions.get(sessionID);
+          if (state) {
+            state.coldStartContext = `<memsearch-context>
+# Recent Memory
+
+${coldStart}</memsearch-context>
+
+The above is recent memory context from past sessions. Use the memsearch_search tool to search for more specific memories when needed.`;
+          }
+        }
+      }
+      if (event.type === "session.status") {
+        const props = event.properties;
+        const sessionID = props.sessionID;
+        const status = props.status;
+        if (status.type !== "idle")
+          return;
+        let state = sessions.get(sessionID);
+        if (!state) {
+          try {
+            const listResp = await client.session.list();
+            const allSessions = listResp.data || listResp || [];
+            const sessionInfo = allSessions.find((s) => s.id === sessionID);
+            if (!sessionInfo)
+              return;
+            if (sessionInfo.parentID)
+              return;
+            const sessionDir = sessionInfo.directory || directory;
+            const memsearchDir = join(sessionDir, ".memsearch");
+            const memoryDir = join(memsearchDir, "memory");
+            const collectionName = deriveCollectionName(sessionDir);
+            await mkdir(memoryDir, { recursive: true });
+            state = {
+              directory: sessionDir,
+              memoryDir,
+              collectionName,
+              isSummarizing: false,
+              lastSummarizedMessageCount: 0,
+              headingWritten: false
+            };
+            sessions.set(sessionID, state);
+          } catch {
+            return;
+          }
+        }
+        if (state.isSummarizing)
+          return;
+        state.isSummarizing = true;
+        try {
+          const messagesResp = await client.session.messages({
+            path: { id: sessionID }
+          });
+          const messages = messagesResp.data || messagesResp;
+          if (!Array.isArray(messages) || messages.length < 2)
+            return;
+          if (messages.length <= state.lastSummarizedMessageCount)
+            return;
+          let lastUserText = "";
+          for (let i = messages.length - 1;i >= 0; i--) {
+            if (messages[i].info.role === "user") {
+              for (const part of messages[i].parts) {
+                if (part.type === "text" && part.text) {
+                  lastUserText = part.text.trim();
+                  break;
+                }
+              }
+              break;
+            }
+          }
+          if (lastUserText.length < 10)
+            return;
+          const transcript = formatTurnTranscript(messages);
+          if (!transcript || transcript.split(`
+`).length < 3)
+            return;
+          let summary;
+          try {
+            summary = await summarizeTranscript(transcript, sessionID, state.lastSummarizedMessageCount);
+          } catch {
+            summary = "";
+          }
+          if (!summary) {
+            summary = formatConciseSummary(messages);
+          }
+          if (!summary)
+            return;
+          const today = todayDate();
+          const now = nowTime();
+          const memoryFile = join(state.memoryDir, `${today}.md`);
+          if (!state.headingWritten) {
+            await appendFile(memoryFile, `
+## Session ${now}
+
+`);
+            state.headingWritten = true;
+          }
+          const entry = `### ${now}
+<!-- session:${sessionID} -->
+${summary}
+
+`;
+          await appendFile(memoryFile, entry);
+          state.lastSummarizedMessageCount = messages.length;
+          runMemsearch(["index", state.memoryDir], state.collectionName);
+        } catch {} finally {
+          state.isSummarizing = false;
+        }
+      }
+    },
+    tool: {
+      memsearch_search: tool({
+        description: "Search past session memories using semantic search. Returns relevant memory chunks from previous conversations, including decisions made, bugs debugged, files edited, and other contextual information. Use this at the start of a session and whenever you encounter a topic that might have prior context.",
+        args: {
+          query: tool.schema.string().describe("Natural language search query describing what you want to recall from past sessions"),
+          top_k: tool.schema.number().optional().default(5).describe("Number of results to return (default: 5)")
+        },
+        async execute(args, context) {
+          await ensureMemsearch();
+          if (!memsearchCmd) {
+            return MEMSEARCH_NOT_FOUND_ERROR;
+          }
+          const collectionName = deriveCollectionName(context.directory);
+          const raw = await runMemsearch([
+            "search",
+            args.query,
+            "--top-k",
+            String(args.top_k ?? 5),
+            "--json-output"
+          ], collectionName);
+          if (!raw.trim()) {
+            return "No results found.";
+          }
+          try {
+            const results = JSON.parse(raw);
+            if (!Array.isArray(results) || results.length === 0) {
+              return "No results found.";
+            }
+            return JSON.stringify(results, null, 2);
+          } catch {
+            return raw;
+          }
+        }
+      }),
+      memsearch_expand: tool({
+        description: "Expand a memory search result to show its full context. Takes a chunk_hash from a memsearch_search result and returns the complete markdown section with surrounding content, plus guidance on how to dig deeper into the original session.",
+        args: {
+          chunk_hash: tool.schema.string().describe("The chunk_hash from a memsearch_search result to expand")
+        },
+        async execute(args, context) {
+          await ensureMemsearch();
+          if (!memsearchCmd) {
+            return MEMSEARCH_NOT_FOUND_ERROR;
+          }
+          const collectionName = deriveCollectionName(context.directory);
+          const raw = await runMemsearch(["expand", args.chunk_hash, "--json-output"], collectionName);
+          if (!raw.trim()) {
+            return "Chunk not found.";
+          }
+          try {
+            const result = JSON.parse(raw);
+            const lines = [];
+            lines.push(result.content || "");
+            lines.push("");
+            lines.push("--- Deep drill ---");
+            if (result.source) {
+              lines.push(`Source file: ${result.source} (lines ${result.start_line}-${result.end_line})`);
+            }
+            const sessionMatches = (result.content || "").matchAll(/<!-- session:(ses_[a-zA-Z0-9]+) -->/g);
+            const sessionIDs = [...new Set([...sessionMatches].map((m) => m[1]))];
+            if (sessionIDs.length > 0) {
+              lines.push(`Session IDs found: ${sessionIDs.join(", ")}`);
+            }
+            lines.push("To get more context:");
+            if (result.source) {
+              lines.push(`- Read the source file "${result.source}" with the Read tool around lines ${result.start_line}-${result.end_line} for surrounding entries`);
+              const memoryDir = result.source.replace(/\/[^/]+$/, "");
+              lines.push(`- Search for a session ID in "${memoryDir}/" to find all entries from the same session`);
+            }
+            return lines.join(`
+`);
+          } catch {
+            return raw;
+          }
+        }
+      })
+    },
+    "experimental.chat.system.transform": async (input, output) => {
+      const sessionID = input.sessionID;
+      if (sessionID) {
+        const state = sessions.get(sessionID);
+        if (state?.coldStartContext) {
+          output.system.push(state.coldStartContext);
+        }
+      }
+      output.system.push(`MEMORY PROTOCOL:
+1. Check the <memsearch-context> in the system prompt for recent memory from past sessions.
+2. ALWAYS use the memsearch_search tool to search for relevant memories before starting work in a session. The injected context only contains the last 30 lines of the 2 most recent memory files — it is not comprehensive. The memsearch_search tool performs semantic search across ALL past memories and is much more thorough. You don't need to recall memories for every conversation turn, but you should check for relevant memories at the start of a session and whenever you encounter a topic that might have prior context — past decisions, debugging sessions, user preferences, or earlier work on the same files or features.
+3. Search memory again whenever you encounter a topic that might have prior context — past decisions, debugging sessions, user preferences, or earlier work on the same files or features.
+4. Use memsearch_expand to get full context for any relevant search results. It will also provide guidance on how to dig deeper into the original session data.
+5. Memories are automatically recorded as you work — you do not need to write them manually.`);
+    }
+  };
+};
+var src_default = memsearchPlugin;
+export {
+  src_default as default
+};

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "opencode-memsearch",
+  "version": "0.1.0",
+  "description": "Persistent cross-session memory for OpenCode, powered by memsearch",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "scripts"
+  ],
+  "scripts": {
+    "build": "bun build ./src/index.ts --outdir ./dist --target node --external @opencode-ai/plugin && tsc --emitDeclarationOnly",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "opencode",
+    "memory",
+    "memsearch",
+    "ai",
+    "coding",
+    "persistent-memory",
+    "semantic-search"
+  ],
+  "author": "Jeremy Dormitzer <jeremy.dormitzer@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jdormit/opencode-memsearch.git"
+  },
+  "bugs": {
+    "url": "https://github.com/jdormit/opencode-memsearch/issues"
+  },
+  "homepage": "https://github.com/jdormit/opencode-memsearch#readme",
+  "peerDependencies": {
+    "@opencode-ai/plugin": ">=1.0.0"
+  },
+  "devDependencies": {
+    "@opencode-ai/plugin": "^1.3.3",
+    "@types/bun": "latest",
+    "typescript": "^5.8.0"
+  }
+}

package/scripts/seed-memories.ts

@@ -0,0 +1,481 @@
+#!/usr/bin/env bun
+/**
+ * seed-memories.ts — Seed memsearch memory files from recent OpenCode sessions.
+ *
+ * Usage:
+ *   bun run ~/.config/opencode/scripts/seed-memories.ts [--days 14]
+ *
+ * This script:
+ * 1. Reads session + message data directly from the OpenCode SQLite database
+ * 2. For each session, formats each conversation turn as a transcript
+ * 3. Summarizes each turn via `opencode run` with claude-haiku (one process per turn)
+ * 4. Writes summaries to .memsearch/memory/YYYY-MM-DD.md files per project
+ * 5. Indexes all memory files with memsearch
+ */
+
+import { Database } from "bun:sqlite"
+import { createHash } from "crypto"
+import { appendFile, mkdir, writeFile, unlink } from "fs/promises"
+import { join, basename, resolve } from "path"
+import { homedir, tmpdir } from "os"
+import { $ } from "bun"
+
+// --- Config ---
+
+const SUMMARIZE_PROMPT = `You are a third-person note-taker. The attached file contains a transcript of ONE conversation turn between a human and an AI coding agent. Tool calls are labeled [Tool Call] and their results [Tool Result] or [Tool Error].
+
+Your job is to record what happened as factual third-person notes. You are an EXTERNAL OBSERVER. Do NOT answer the human's question, do NOT give suggestions, do NOT offer help. ONLY record what occurred.
+
+Output 2-6 bullet points, each starting with '- '. NOTHING else.
+
+Rules:
+- Write in third person: 'User asked...', 'Agent read file X', 'Agent ran command Y'
+- First bullet: what the user asked or wanted (one sentence)
+- Remaining bullets: what the agent did — tools called, files read/edited, commands run, key findings
+- Be specific: mention file names, function names, tool names, and concrete outcomes
+- Do NOT answer the human's question yourself — just note what was discussed
+- Do NOT add any text before or after the bullet points
+- Do NOT continue the conversation after the bullet points
+- Do NOT ask follow-up questions
+- STOP immediately after the last bullet point`
+
+const HAIKU_MODEL = "anthropic/claude-haiku-4-5"
+
+const DB_PATH = join(homedir(), ".local", "share", "opencode", "opencode.db")
+const TEMP_DIR = join(tmpdir(), "memsearch-seed")
+
+// --- Helpers ---
+
+function deriveCollectionName(directory: string): string {
+  const abs = resolve(directory)
+  const sanitized = basename(abs)
+    .toLowerCase()
+    .replace(/[^a-z0-9]/g, "_")
+    .replace(/_+/g, "_")
+    .replace(/^_|_$/g, "")
+    .slice(0, 40)
+  const hash = createHash("sha256").update(abs).digest("hex").slice(0, 8)
+  return `ms_${sanitized}_${hash}`
+}
+
+function formatDate(epochMs: number): string {
+  const d = new Date(epochMs)
+  const yyyy = d.getFullYear()
+  const mm = String(d.getMonth() + 1).padStart(2, "0")
+  const dd = String(d.getDate()).padStart(2, "0")
+  return `${yyyy}-${mm}-${dd}`
+}
+
+function formatTime(epochMs: number): string {
+  const d = new Date(epochMs)
+  return `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`
+}
+
+function parseArgs(): { days: number } {
+  const args = process.argv.slice(2)
+  let days = 14
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--days" && args[i + 1]) {
+      days = parseInt(args[i + 1], 10)
+      if (isNaN(days) || days < 1) {
+        console.error("Invalid --days value, using default 14")
+        days = 14
+      }
+    }
+  }
+  return { days }
+}
+
+// --- Database types ---
+
+interface DbSession {
+  id: string
+  directory: string
+  title: string
+  parent_id: string | null
+  time_created: number
+  time_updated: number
+}
+
+interface DbMessage {
+  id: string
+  session_id: string
+  time_created: number
+  data: string // JSON
+}
+
+interface DbPart {
+  id: string
+  message_id: string
+  time_created: number
+  data: string // JSON
+}
+
+// --- Database access ---
+
+function listSessionsFromDb(db: Database, cutoffMs: number): DbSession[] {
+  return db.query<DbSession, [number]>(`
+    SELECT id, directory, title, parent_id, time_created, time_updated
+    FROM session
+    WHERE time_created >= ?
+      AND parent_id IS NULL
+    ORDER BY time_created ASC
+  `).all(cutoffMs)
+}
+
+function getSessionMessages(
+  db: Database,
+  sessionId: string,
+): { info: any; parts: any[] }[] {
+  // Get messages
+  const dbMessages = db.query<DbMessage, [string]>(`
+    SELECT id, session_id, time_created, data
+    FROM message
+    WHERE session_id = ?
+    ORDER BY time_created ASC
+  `).all(sessionId)
+
+  if (dbMessages.length === 0) return []
+
+  // Get all parts for this session in one query
+  const dbParts = db.query<DbPart, [string]>(`
+    SELECT id, message_id, time_created, data
+    FROM part
+    WHERE session_id = ?
+    ORDER BY time_created ASC
+  `).all(sessionId)
+
+  // Group parts by message_id
+  const partsByMessage = new Map<string, any[]>()
+  for (const p of dbParts) {
+    if (!partsByMessage.has(p.message_id)) partsByMessage.set(p.message_id, [])
+    partsByMessage.get(p.message_id)!.push(JSON.parse(p.data))
+  }
+
+  // Assemble messages with their parts
+  return dbMessages.map((m) => ({
+    info: JSON.parse(m.data),
+    parts: partsByMessage.get(m.id) || [],
+  }))
+}
+
+// --- Message processing ---
+
+function splitIntoTurns(
+  messages: { info: any; parts: any[] }[],
+): { info: any; parts: any[] }[][] {
+  const turns: { info: any; parts: any[] }[][] = []
+  let current: { info: any; parts: any[] }[] = []
+
+  for (const msg of messages) {
+    if (msg.info.role === "user" && current.length > 0) {
+      turns.push(current)
+      current = []
+    }
+    current.push(msg)
+  }
+  if (current.length > 0) {
+    turns.push(current)
+  }
+
+  return turns
+}
+
+function formatTurnTranscript(
+  turn: { info: any; parts: any[] }[],
+): string {
+  const lines: string[] = [
+    "=== Transcript of a conversation turn between a human and an AI coding agent ===",
+  ]
+
+  for (const msg of turn) {
+    const role = msg.info.role
+    for (const part of msg.parts) {
+      if (part.type === "text" && part.text?.trim()) {
+        if (role === "user") {
+          lines.push(`[Human]: ${part.text.trim()}`)
+        } else if (role === "assistant") {
+          lines.push(`[Assistant]: ${part.text.trim()}`)
+        }
+      } else if (part.type === "tool-invocation" || part.type === "tool_use") {
+        const name = part.toolName || part.name || "unknown"
+        const args = part.args || part.input || {}
+        const argParts: string[] = []
+        for (const [k, v] of Object.entries(args)) {
+          let vStr = String(v)
+          if (vStr.length > 120) vStr = vStr.slice(0, 120) + "..."
+          argParts.push(`${k}=${vStr}`)
+        }
+        let argSummary = argParts.join(", ")
+        if (argSummary.length > 400)
+          argSummary = argSummary.slice(0, 400) + "..."
+        lines.push(`[Tool Call]: ${name}(${argSummary})`)
+      } else if (part.type === "tool-result" || part.type === "tool_result") {
+        const output = String(part.output || part.content || "").slice(0, 1000)
+        const isError = part.isError || part.is_error
+        const label = isError ? "[Tool Error]" : "[Tool Result]"
+        lines.push(`${label}: ${output}`)
+      }
+    }
+  }
+
+  return lines.join("\n")
+}
+
+function formatConciseSummary(
+  turn: { info: any; parts: any[] }[],
+): string {
+  const lines: string[] = []
+
+  for (const msg of turn) {
+    const role = msg.info.role
+    for (const part of msg.parts) {
+      if (part.type === "text" && part.text?.trim()) {
+        if (role === "user") {
+          const text = part.text.trim()
+          lines.push(`- User asked: ${text.length > 200 ? text.slice(0, 200) + "..." : text}`)
+        } else if (role === "assistant") {
+          const text = part.text.trim()
+          if (text.length > 0) {
+            lines.push(`- Agent responded: ${text.length > 200 ? text.slice(0, 200) + "..." : text}`)
+          }
+        }
+      } else if (part.type === "tool-invocation" || part.type === "tool_use") {
+        const name = part.toolName || part.name || "unknown"
+        const args = part.args || part.input || {}
+        const keyArgs: string[] = []
+        for (const [k, v] of Object.entries(args)) {
+          const vStr = String(v)
+          if (vStr.length <= 100) {
+            keyArgs.push(`${k}=${vStr}`)
+          } else {
+            keyArgs.push(`${k}=${vStr.slice(0, 80)}...`)
+          }
+        }
+        lines.push(`- Tool: ${name}(${keyArgs.join(", ").slice(0, 300)})`)
+      }
+    }
+  }
+
+  return lines.slice(0, 20).join("\n")
+}
+
+function getUserText(turn: { info: any; parts: any[] }[]): string {
+  for (const msg of turn) {
+    if (msg.info.role === "user") {
+      for (const part of msg.parts) {
+        if (part.type === "text" && part.text) {
+          return part.text.trim()
+        }
+      }
+    }
+  }
+  return ""
+}
+
+// Detect memsearch command
+async function detectMemsearch(): Promise<string[]> {
+  try {
+    await $`which memsearch`.quiet()
+    return ["memsearch"]
+  } catch {}
+  try {
+    await $`which uvx`.quiet()
+    return ["uvx", "--from", "memsearch[local]", "memsearch"]
+  } catch {}
+  throw new Error("memsearch not found. Install it with: pip install 'memsearch[local]' or install uv")
+}
+
+// Summarize a transcript via `opencode run`
+async function summarizeWithOpencode(transcript: string, tempFile: string): Promise<string> {
+  // Write transcript to temp file
+  await writeFile(tempFile, transcript)
+
+  try {
+    // Disable all plugins during summarization to avoid memsearch plugin
+    // interfering with the LLM output (e.g. injecting "[memsearch] Memory available")
+    const rawOutput = await $`opencode run -f ${tempFile} --model ${HAIKU_MODEL} ${SUMMARIZE_PROMPT}`
+      .env({ ...process.env, OPENCODE_CONFIG_CONTENT: JSON.stringify({ plugin: [] }) })
+      .nothrow()
+      .quiet()
+      .text()
+
+    // Parse output: only keep bullet lines that start with "User " or "Agent "
+    // (matching the third-person format from the prompt). The agent sometimes
+    // appends conversational junk like "- Do you want me to..." which we discard.
+    const lines = rawOutput.split("\n")
+    const bulletLines = lines
+      .filter((l) => l.trimStart().startsWith("- "))
+      .filter((l) => {
+        const content = l.trimStart().slice(2) // strip "- "
+        return content.startsWith("User ") || content.startsWith("Agent ")
+      })
+    return bulletLines.join("\n").trim()
+  } finally {
+    try {
+      await unlink(tempFile)
+    } catch {}
+  }
+}
+
+// --- Main ---
+
+async function main() {
+  const { days } = parseArgs()
+  const cutoff = Date.now() - days * 24 * 60 * 60 * 1000
+
+  console.log(`Seeding memories from the last ${days} days...`)
+  console.log()
+
+  // Setup
+  const memsearchCmd = await detectMemsearch()
+  console.log(`Using memsearch: ${memsearchCmd.join(" ")}`)
+
+  await mkdir(TEMP_DIR, { recursive: true })
+
+  // Open database (read-only)
+  const db = new Database(DB_PATH, { readonly: true })
+
+  try {
+    // List sessions
+    const allSessions = listSessionsFromDb(db, cutoff)
+    console.log(`Found ${allSessions.length} sessions in the last ${days} days.`)
+    console.log()
+
+    if (allSessions.length === 0) {
+      console.log("No sessions to process.")
+      return
+    }
+
+    // Group by directory for display
+    const byDir = new Map<string, DbSession[]>()
+    for (const s of allSessions) {
+      if (!byDir.has(s.directory)) byDir.set(s.directory, [])
+      byDir.get(s.directory)!.push(s)
+    }
+
+    console.log(`Projects:`)
+    for (const [dir, sessions] of byDir) {
+      console.log(`  ${dir} (${sessions.length} sessions)`)
+    }
+    console.log()
+
+    // Track which memory dirs we need to index at the end
+    const memoryDirs = new Map<string, string>() // memoryDir -> collectionName
+
+    let sessionNum = 0
+    let totalTurns = 0
+    let totalSummarized = 0
+
+    for (const session of allSessions) {
+      sessionNum++
+      const sessionDir = session.directory
+      const memsearchDir = join(sessionDir, ".memsearch")
+      const memoryDir = join(memsearchDir, "memory")
+      const collectionName = deriveCollectionName(sessionDir)
+      memoryDirs.set(memoryDir, collectionName)
+
+      await mkdir(memoryDir, { recursive: true })
+
+      const titleDisplay = session.title.length > 50
+        ? session.title.slice(0, 50) + "..."
+        : session.title
+
+      // Read messages from DB
+      const messages = getSessionMessages(db, session.id)
+
+      if (messages.length < 2) {
+        console.log(`  [${sessionNum}/${allSessions.length}] "${titleDisplay}" — ${messages.length} messages, skipping`)
+        continue
+      }
+
+      // Split into turns
+      const turns = splitIntoTurns(messages)
+      const substantiveTurns = turns.filter((t) => {
+        const userText = getUserText(t)
+        return userText.length >= 10 && t.length >= 2
+      })
+
+      if (substantiveTurns.length === 0) {
+        console.log(`  [${sessionNum}/${allSessions.length}] "${titleDisplay}" — no substantive turns, skipping`)
+        continue
+      }
+
+      console.log(`  [${sessionNum}/${allSessions.length}] "${titleDisplay}" — ${substantiveTurns.length} turns`)
+
+      const sessionDate = formatDate(session.time_created)
+      const sessionTime = formatTime(session.time_created)
+      const memoryFile = join(memoryDir, `${sessionDate}.md`)
+
+      // Write session heading
+      await appendFile(memoryFile, `\n## Session ${sessionTime} — ${session.title}\n\n`)
+
+      // Process each turn
+      for (let turnIdx = 0; turnIdx < substantiveTurns.length; turnIdx++) {
+        const turn = substantiveTurns[turnIdx]
+        totalTurns++
+
+        const turnTime = turn[0].info.time?.created
+          ? formatTime(turn[0].info.time.created)
+          : sessionTime
+
+        const transcript = formatTurnTranscript(turn)
+        if (!transcript || transcript.split("\n").length < 3) continue
+
+        // Summarize via opencode run (separate process per turn, no memory accumulation)
+        const tempFile = join(TEMP_DIR, `turn-${sessionNum}-${turnIdx}.txt`)
+        let summary = ""
+        try {
+          summary = await summarizeWithOpencode(transcript, tempFile)
+          if (summary) totalSummarized++
+        } catch {
+          // LLM failed
+        }
+
+        if (!summary) {
+          summary = formatConciseSummary(turn)
+        }
+
+        if (!summary) continue
+
+        const entry = `### ${turnTime}\n<!-- session:${session.id} -->\n${summary}\n\n`
+        await appendFile(memoryFile, entry)
+
+        // Print progress on long sessions
+        if (substantiveTurns.length > 5 && (turnIdx + 1) % 5 === 0) {
+          process.stdout.write(`    (${turnIdx + 1}/${substantiveTurns.length} turns)\n`)
+        }
+      }
+    }
+
+    console.log()
+    console.log(`Processed ${totalTurns} turns, summarized ${totalSummarized} with LLM.`)
+    console.log()
+
+    // Index all memory directories
+    for (const [memDir, collectionName] of memoryDirs) {
+      console.log(`Indexing ${memDir} (collection: ${collectionName})...`)
+      try {
+        const fullArgs = [...memsearchCmd, "index", memDir, "--collection", collectionName]
+        await $`${fullArgs}`.nothrow().quiet()
+        console.log(`  Done.`)
+      } catch (err) {
+        console.error(`  Failed to index: ${err}`)
+      }
+    }
+
+    console.log()
+    console.log("Seeding complete!")
+  } finally {
+    db.close()
+    // Clean up temp dir
+    try {
+      await $`rm -rf ${TEMP_DIR}`.nothrow().quiet()
+    } catch {}
+  }
+}
+
+main().catch((err) => {
+  console.error("Fatal error:", err)
+  process.exit(1)
+})