opencode-mempalace-persistence 1.1.1 → 1.2.1

package/README.md

@@ -1,6 +1,6 @@
 # opencode-mempalace-persistence
 
-> **Community plugin** — not officially maintained by the MemPalace team. Fully open source, ~120 lines of TypeScript.
+> **Community plugin** — not officially maintained by the MemPalace team. Fully open source, ~200 lines of TypeScript.
 
 An OpenCode plugin that automatically saves every conversation to MemPalace and uses stored memory to provide better, context-aware responses. Real-time, zero cron, zero external scripts.
 
@@ -104,7 +104,47 @@ This is loaded automatically at session start via `instructions` in opencode.jso
 }
 ```
 
-### 5. MemPalace (if not already installed)
+### 5. (Optional) Auto-inject memory context
+
+By default, the model must search MemPalace on its own via AGENTS.md instructions. For models with poor tool-use discipline, enable auto-injection — the plugin injects identity + relevant memories directly into the prompt:
+
+```json
+{
+  "plugin": ["opencode-mempalace-persistence"],
+  "mempalace": {
+    "autoInjectContext": true
+  }
+}
+```
+
+When enabled, on every user message:
+- **First message**: Injects your identity from `~/.mempalace/identity.txt`
+- **Every message**: Runs `mempalace search` and injects relevant results
+
+The context is guaranteed regardless of model discipline. Since the plugin handles search and identity injection, you can simplify AGENTS.md — keep only the Knowledge Graph management steps:
+
+```markdown
+# Memory & Knowledge instructions
+
+### Step 1 — Query Knowledge Graph
+Call `mempalace_mempalace_kg_query` for entity "user" to retrieve relevant facts.
+
+### Step 2 — Record Knowledge Graph facts
+After responding, call `mempalace_mempalace_kg_add` for any new facts found.
+```
+
+And remove `"~/.mempalace/identity.txt"` from `instructions` in your opencode.json — the plugin injects it automatically.
+
+**Summary: with vs without autoInjectContext**
+
+| Feature | Without (default) | With `autoInjectContext: true` |
+|---------|:-:|:-:|
+| Memory search | Model calls `mempalace_search` (AGENTS.md) | Plugin injects automatically |
+| Identity | `instructions: ["identity.txt"]` | Plugin injects automatically |
+| AGENTS.md needed | Full (search + KG + identity) | Minimal (KG management only) |
+| Depends on model discipline | Yes | No |
+
+### 6. MemPalace (if not already installed)
 
 ```bash
 # Install (requires mempalace>=3.3.5 for HNSW corruption fix)

package/dist/index.d.ts

@@ -12,6 +12,12 @@ declare const _default: () => Promise<{
         message: import("@opencode-ai/sdk").UserMessage;
         parts: import("@opencode-ai/sdk").Part[];
     }) => Promise<void>;
+    "experimental.chat.messages.transform": (_input: {}, output: {
+        messages: {
+            info: import("@opencode-ai/sdk").Message;
+            parts: import("@opencode-ai/sdk").Part[];
+        }[];
+    }) => Promise<void>;
     event: ({ event }: any) => Promise<void>;
 }>;
 export default _default;

package/dist/index.js

@@ -8,10 +8,14 @@ const VENV_PYTHON = join(HOME, ".local/share/pipx/venvs/mempalace/bin/python3");
 const MEMPALACE_BIN = join(HOME, ".local/bin/mempalace");
 const OPENCODE_DB = join(HOME, ".local/share/opencode/opencode.db");
 const STATE_FILE = join(HOME, ".mempalace/sync_state.json");
+const OPENCODE_CONFIG = join(HOME, ".config/opencode/opencode.json");
+const IDENTITY_FILE = join(HOME, ".mempalace/identity.txt");
 const OUT_DIR = "/tmp/oc-sessions";
 const TMP_SCRIPT = "/tmp/oc-plugin-query.py";
 const DEBUG = !!process.env.OPENCODE_MEMPALACE_DEBUG;
 const LOG_FILE = "/tmp/opencode-mempalace.log";
+const MAX_INJECT_CHARS = 900;
+const MAX_SEARCH_RESULTS = 3;
 function log(msg) {
     if (!DEBUG)
         return;
@@ -23,6 +27,7 @@ function log(msg) {
 }
 let miningLock = false;
 let lastSyncTs = 0;
+let wakeupDone = false;
 function runPython(code) {
     writeFileSync(TMP_SCRIPT, code);
     try {
@@ -38,6 +43,40 @@ function hasText(parts) {
         .map((p) => p.text.trim())
         .join("\n");
 }
+function isAutoInjectEnabled() {
+    try {
+        const raw = readFileSync(OPENCODE_CONFIG, "utf-8");
+        const cfg = JSON.parse(raw);
+        return !!cfg?.mempalace?.autoInjectContext;
+    }
+    catch {
+        return false;
+    }
+}
+function readIdentity() {
+    if (!existsSync(IDENTITY_FILE))
+        return "";
+    try {
+        return readFileSync(IDENTITY_FILE, "utf-8").trim();
+    }
+    catch {
+        return "";
+    }
+}
+function mempalaceSearch(query) {
+    try {
+        const out = execSync(`${MEMPALACE_BIN} search "${query.replace(/"/g, '\\"')}" --results ${MAX_SEARCH_RESULTS}`, {
+            encoding: "utf-8",
+            timeout: 15000,
+        }).trim();
+        if (!out || out.includes("No results"))
+            return "";
+        return out.slice(0, MAX_INJECT_CHARS);
+    }
+    catch {
+        return "";
+    }
+}
 function getLastSync() {
     if (!existsSync(STATE_FILE))
         return 0;
@@ -174,7 +213,9 @@ print(json.dumps(texts))
 }
 export default (async () => {
     mkdirSync(OUT_DIR, { recursive: true });
-    log("loaded");
+    const autoInject = isAutoInjectEnabled();
+    const identity = readIdentity();
+    log(`loaded (autoInjectContext: ${autoInject})`);
     return {
         "chat.message": async (_input, output) => {
             const role = output.message.role;
@@ -186,6 +227,43 @@ export default (async () => {
             log("user msg - queue sync");
             setTimeout(() => dbSync(), 500);
         },
+        "experimental.chat.messages.transform": async (_input, output) => {
+            if (!autoInject)
+                return;
+            if (!output?.messages?.length)
+                return;
+            const lastUser = [...output.messages].reverse().find((m) => m.info?.role === "user");
+            if (!lastUser)
+                return;
+            const query = hasText(lastUser.parts || []);
+            if (!query)
+                return;
+            const injectParts = [];
+            if (!wakeupDone) {
+                wakeupDone = true;
+                if (identity) {
+                    injectParts.push({
+                        id: `mp-identity-${Date.now()}`,
+                        type: "text",
+                        synthetic: true,
+                        text: `[MemPalace Identity]\n${identity}\n[/MemPalace Identity]`,
+                    });
+                }
+            }
+            const memories = mempalaceSearch(query);
+            if (memories) {
+                injectParts.push({
+                    id: `mp-recall-${Date.now()}`,
+                    type: "text",
+                    synthetic: true,
+                    text: `[MemPalace Recall]\n${memories}\n[/MemPalace Recall]`,
+                });
+            }
+            if (injectParts.length > 0) {
+                lastUser.parts.push(...injectParts);
+                log(`injected ${injectParts.length} context blocks`);
+            }
+        },
         event: async ({ event }) => {
             if (event?.type !== "session.idle")
                 return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-mempalace-persistence",
-  "version": "1.1.1",
+  "version": "1.2.1",
   "description": "OpenCode plugin — auto-sync conversations to MemPalace memory in real-time. No forced wings, KG extraction via MCP tools.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",