@zilliz/memsearch-opencode 0.1.2 → 0.2.1

package/README.md

@@ -30,6 +30,8 @@ uv tool install 'memsearch[onnx]'
 }
 ```
 
+> Windows note: the current plugin shells out to `bash` and `python3` helper scripts. Plain Windows installs are not supported yet; use WSL2 (recommended) or a POSIX-compatible shell such as Git Bash. See issue #387.
+
 ### Install from Source (development)
 
 ```bash
@@ -73,6 +75,17 @@ OpenCode Session
         └── memory_transcript ──→ parse-transcript.py (SQLite reader)
 ```
 
+## Verify It Works
+
+After restarting OpenCode, chat for a few turns in a project and confirm memory capture is happening:
+
+```bash
+ls .memsearch/memory/
+cat .memsearch/memory/$(date +%Y-%m-%d).md
+```
+
+If the plugin is active, daily markdown files should appear and grow as conversations finish.
+
 ## Recall Memories
 
 **Manual invocation** — explicitly invoke the skill with a query:
@@ -130,6 +143,14 @@ memsearch config set embedding.provider openai
 export OPENAI_API_KEY=sk-...
 ```
 
+To override only the OpenCode capture summarization model:
+
+```bash
+memsearch config set plugins.opencode.summarize.model anthropic/claude-haiku
+```
+
+Leave it empty or unset to keep the current `small_model` / plugin default behavior. This setting does not fall back to `llm.model`.
+
 ## How It Works
 
 1. **Capture**: After each conversation turn, the plugin extracts the user+assistant exchange, summarizes it via LLM, and appends to a daily markdown file.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zilliz/memsearch-opencode",
-  "version": "0.1.2",
+  "version": "0.2.1",
   "description": "memsearch plugin for OpenCode — semantic memory search across sessions",
   "type": "module",
   "main": "index.ts",
@@ -9,8 +9,10 @@
   },
   "files": [
     "index.ts",
-    "scripts/",
+    "scripts/*.py",
+    "scripts/*.sh",
     "skills/",
+    "prompts/",
     "README.md"
   ],
   "keywords": [

package/prompts/summarize.txt

@@ -0,0 +1,14 @@
+You are a third-person note-taker. You will receive a transcript of ONE conversation turn between a human and {{AGENT_NAME}}.
+
+Your job is to record what happened as factual third-person notes. You are an EXTERNAL OBSERVER — you are NOT {{AGENT_NAME}}, NOT an assistant. 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_NAME}} read file X', '{{AGENT_NAME}} ran command Y'
+- First bullet: what the user asked or wanted (one sentence)
+- Remaining bullets: what was done — 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
+- Write in the same language as the human's message in the transcript

package/scripts/capture-daemon.py

@@ -11,19 +11,26 @@ extracts the last turn, summarizes it as bullet points, and writes to
 It also triggers memsearch indexing after writing.
 """
 
-import sqlite3
+import argparse
+import contextlib
 import json
-import sys
 import os
-import time
+import shlex
 import shutil
-import subprocess
-import argparse
 import signal
+import sqlite3
+import subprocess
+import sys
+import time
 from datetime import datetime
 from pathlib import Path
 
 
+def split_memsearch_cmd(memsearch_cmd):
+    """Split the configured memsearch command preserving quoted arguments."""
+    return shlex.split(memsearch_cmd)
+
+
 def get_small_model():
     """Read small_model from opencode.json config (fallback to model, then empty)."""
     config_paths = [
@@ -41,6 +48,20 @@ def get_small_model():
     return ""
 
 
+def get_plugin_summarize_model(memsearch_cmd=None):
+    """Read the memsearch OpenCode summarize model override."""
+    if not memsearch_cmd:
+        return ""
+    try:
+        result = subprocess.run(
+            [*split_memsearch_cmd(memsearch_cmd), "config", "get", "plugins.opencode.summarize.model"],
+            capture_output=True, text=True, timeout=5,
+        )
+        return result.stdout.strip()
+    except Exception:
+        return ""
+
+
 def ensure_isolated_config():
     """Create isolated config dir without plugins/ to prevent recursion."""
     isolated = "/tmp/opencode-memsearch-summarize/opencode"
@@ -48,31 +69,56 @@ def ensure_isolated_config():
     # Copy opencode.json (provider config) but NOT plugins/
     src = os.path.expanduser("~/.config/opencode/opencode.json")
     dst = os.path.join(isolated, "opencode.json")
+    if os.path.islink(dst) or (os.path.lexists(dst) and not os.path.isfile(dst)):
+        with contextlib.suppress(OSError):
+            os.remove(dst)
     if os.path.exists(src) and not os.path.exists(dst):
         shutil.copy2(src, dst)
     return os.path.dirname(isolated)  # /tmp/opencode-memsearch-summarize
 
 
-def summarize_with_llm(turn_text, small_model):
+def _load_summarize_prompt(agent_name, memsearch_cmd=None):
+    """Load summarization prompt: user custom > plugin built-in > inline fallback."""
+    # Try user-custom prompt via config
+    if memsearch_cmd:
+        try:
+            result = subprocess.run(
+                [*split_memsearch_cmd(memsearch_cmd), "config", "get", "prompts.summarize"],
+                capture_output=True, text=True, timeout=5,
+            )
+            custom_path = result.stdout.strip()
+            if custom_path and os.path.isfile(custom_path):
+                template = Path(custom_path).read_text(encoding="utf-8")
+                return template.replace("{{AGENT_NAME}}", agent_name)
+        except Exception:
+            pass
+
+    # Plugin built-in template
+    builtin = Path(__file__).resolve().parent.parent / "prompts" / "summarize.txt"
+    if builtin.is_file():
+        template = builtin.read_text(encoding="utf-8")
+        return template.replace("{{AGENT_NAME}}", agent_name)
+
+    # Inline fallback
+    return (
+        "You are a third-person note-taker. Summarize the transcript as "
+        "2-6 bullet points. Write in third person. Output ONLY bullet points."
+    )
+
+
+def summarize_with_llm(turn_text, small_model, memsearch_cmd=None):
     """Summarize using opencode run in isolated env (no plugins -> no recursion)."""
-    # Keep the instruction short and put it AFTER the transcript to avoid
-    # the LLM treating the instruction itself as the conversation content.
-    # Clear delimiters (===) separate the transcript from the task.
+    system_prompt = _load_summarize_prompt("OpenCode", memsearch_cmd)
     full_prompt = (
-        f"===TRANSCRIPT START===\n"
-        f"{turn_text}\n"
-        f"===TRANSCRIPT END===\n\n"
-        f"Summarize the transcript above as 2-6 third-person bullet points (each starting with '- '). "
-        f"Write 'User asked/did...' and 'OpenCode replied/did...'. "
-        f"Be specific (file names, tools, outcomes). "
-        f"Same language as the human. "
-        f"Output ONLY bullet points, nothing else."
+        f"{system_prompt}\n\n"
+        f"Transcript:\n{turn_text}"
     )
     isolated_dir = ensure_isolated_config()
 
+    summarize_model = get_plugin_summarize_model(memsearch_cmd) or small_model
     cmd = ["opencode", "run"]
-    if small_model:
-        cmd += ["-m", small_model]
+    if summarize_model:
+        cmd += ["-m", summarize_model]
     cmd.append(full_prompt)
 
     try:
@@ -89,7 +135,7 @@ def summarize_with_llm(turn_text, small_model):
         output = result.stdout.strip()
         # Extract bullet points (skip any opencode run header lines)
         lines = output.split("\n")
-        bullets = [l for l in lines if l.strip().startswith("- ")]
+        bullets = [line for line in lines if line.strip().startswith("- ")]
         if bullets:
             return "\n".join(bullets)
     except Exception:
@@ -239,7 +285,7 @@ def main():
 
     db_path = get_db_path()
     if not os.path.exists(db_path):
-        print(f"OpenCode database not found at {db_path}", file=sys.stderr)
+        sys.stderr.write(f"OpenCode database not found at {db_path}\n")
         sys.exit(1)
 
     memory_dir = os.path.join(args.project_dir, ".memsearch", "memory")
@@ -252,10 +298,8 @@ def main():
 
     # Clean up on exit
     def cleanup(signum=None, frame=None):
-        try:
+        with contextlib.suppress(OSError):
             os.remove(pid_file)
-        except OSError:
-            pass
         sys.exit(0)
 
     signal.signal(signal.SIGTERM, cleanup)
@@ -266,10 +310,8 @@ def main():
     state_file = os.path.join(args.project_dir, ".memsearch", ".last_msg_time")
     last_msg_time = 0
     if os.path.exists(state_file):
-        try:
-            last_msg_time = int(open(state_file).read().strip())
-        except (ValueError, OSError):
-            pass
+        with contextlib.suppress(ValueError, OSError), open(state_file) as f:
+            last_msg_time = int(f.read().strip())
 
     while True:
         try:
@@ -279,7 +321,7 @@ def main():
             for session_id, turn_text, msg_time in new_turns:
                 if turn_text and len(turn_text) > 10:
                     # Summarize with LLM, fallback to raw text
-                    summary = summarize_with_llm(turn_text, small_model)
+                    summary = summarize_with_llm(turn_text, small_model, args.memsearch_cmd)
                     write_capture(memory_dir, summary if summary else turn_text, session_id, db_path)
                     if msg_time > last_msg_time:
                         last_msg_time = msg_time