opencode-claude-memory 1.7.2 → 1.7.4

package/dist/index.js

@@ -234,6 +234,184 @@ function getCallID(ctx) {
     const v = ctx.callID;
     return typeof v === "string" ? v : undefined;
 }
+// ─── Native post-session extraction (optional) ───────────────────────────────
+// Architecture follows opencode-mem's proven pattern: hook `session.idle`,
+// fetch the conversation via ctx.client.session.messages(), then run extraction
+// in an isolated sub-session (create + prompt + delete via ctx.client). No shell,
+// no `opencode run --fork` subprocess — those don't work cross-platform from a
+// plugin and `ctx.$` is not reliably populated.
+// Enabled by default on Windows (bash wrapper can't run there); opt-in elsewhere
+// via OPENCODE_MEMORY_NATIVE_EXTRACT=1; =0 force-disables.
+// 10s debounce collapses rapid idle events. Recursion guard via an in-process
+// Set of sub-session IDs. Extraction is additive only (memory_save).
+const EXTRACT_PROMPT = `You are now acting as the memory extraction subagent. The conversation below is reviewed for anything worth remembering for future sessions.
+
+## What to save
+
+Use the \`memory_save\` tool to persist memories. There are four types:
+
+1. **user** — Who the user is: role, expertise, preferences, communication style. Helps tailor future interactions.
+2. **feedback** — Guidance on how to work: corrections ("don't do X"), confirmations ("yes, keep doing that"), approach preferences. Include *why* so edge cases can be judged.
+3. **project** — Ongoing work context: goals, deadlines, initiatives, decisions, bugs. NOT derivable from code/git. Convert relative dates to absolute.
+4. **reference** — Pointers to external resources: URLs, tool names, where to find information outside the codebase.
+
+## What NOT to save
+
+- Code patterns, architecture, file structure — derivable from the codebase
+- Git history, recent changes — use \`git log\`/\`git blame\`
+- Debugging solutions — the fix is in the code
+- Anything already in AGENTS.md / project config files
+- Ephemeral task details or current conversation context
+- Information that was already saved in a previous extraction
+
+## How to save
+
+For each memory worth saving, call \`memory_save\` with:
+- \`file_name\`: descriptive slug (e.g., \`user_role\`, \`feedback_testing_approach\`)
+- \`name\`: short title
+- \`description\`: one-line description (used for relevance matching in future sessions)
+- \`type\`: one of user, feedback, project, reference
+- \`content\`: the memory content. For feedback/project types, structure as: rule/fact, then **Why:** and **How to apply:** lines.
+
+## Instructions
+
+1. Analyze the conversation for memorable information
+2. Check existing memories first (use \`memory_list\`) to avoid duplicates — update existing ones if needed
+3. Save each distinct memory as a separate entry
+4. If the conversation was trivial (e.g., just "hello" or a quick lookup), save nothing — that's fine
+5. Be selective: 0-3 memories per session is typical. Quality over quantity.
+6. Do NOT save a memory about the extraction process itself.`;
+const NATIVE_EXTRACT_DEBOUNCE_MS = 10000;
+const NATIVE_EXTRACT_TIMEOUT_MS = 120000; // hard cap on a single extraction fork (prevents permanent leak on hang)
+const NATIVE_EXTRACT_MAX_CONV_CHARS = 60000;
+const NATIVE_EXTRACT_GRACE_MS = 60000; // keep forkID in the guard after delete — covers the idle-race window
+const nativeIdleTimer = new Map();
+const nativeExtractionSessions = new Set(); // sub-session IDs → skip their idle AND shield from transforms
+const nativeExtractionInFlight = new Set(); // parent sessionIDs with an extraction running → no overlap
+function extractIDFromResponse(response) {
+    const data = response?.data ?? response;
+    const obj = data;
+    const v = obj?.id ?? obj?.sessionID;
+    return typeof v === "string" ? v : null;
+}
+function getNativeExtractAgent() {
+    return process.env.OPENCODE_MEMORY_AGENT || "opencode-memory-extract";
+}
+// Parse OPENCODE_MEMORY_MODEL into the SDK's ModelRef shape (providerID/modelID), same as getRecallModel().
+function getNativeExtractModel() {
+    const raw = process.env.OPENCODE_MEMORY_MODEL;
+    if (!raw)
+        return undefined;
+    const slashIdx = raw.indexOf("/");
+    if (slashIdx <= 0 || slashIdx === raw.length - 1)
+        return undefined;
+    return { providerID: raw.slice(0, slashIdx), modelID: raw.slice(slashIdx + 1) };
+}
+function buildConversationForExtraction(messages) {
+    const lines = [];
+    for (const m of messages) {
+        const role = m?.info?.role;
+        if (!role || !Array.isArray(m?.parts))
+            continue;
+        for (const p of m.parts) {
+            const part = p;
+            if (part.type === "text" && typeof part.text === "string" && !part.synthetic) {
+                lines.push(`### ${role === "user" ? "User" : "Assistant"}\n${part.text}`);
+            }
+            else if (part.type === "tool" && part.tool) {
+                if (part.state?.status === "completed" && typeof part.state?.output === "string") {
+                    const out = part.state.output.length > 300 ? part.state.output.slice(0, 300) + "…" : part.state.output;
+                    lines.push(`_[tool ${part.tool}: ${out}]_`);
+                }
+            }
+        }
+    }
+    let text = lines.join("\n\n");
+    // Keep the TAIL (newest turns carry the new facts worth extracting), drop the oldest head.
+    if (text.length > NATIVE_EXTRACT_MAX_CONV_CHARS) {
+        text = "…[older turns truncated]\n\n" + text.slice(-NATIVE_EXTRACT_MAX_CONV_CHARS);
+    }
+    return text;
+}
+// Security: the extraction fork runs on raw, potentially-untrusted transcript content (fetched web
+// pages, tool output). It MUST be sandboxed to the memory tools only (no bash/edit/write) and capped
+// by a timeout so a hang can't leak the sub-session forever.
+async function runNativeExtraction(client, sessionID, directory) {
+    const c = client;
+    if (!c?.session?.messages || !c.session.create || !c.session.prompt)
+        return;
+    if (nativeExtractionInFlight.has(sessionID))
+        return; // no overlapping runs against the same session
+    nativeExtractionInFlight.add(sessionID);
+    let forkID = null;
+    try {
+        // query.directory is required for correct resolution under multi-directory serve.
+        const resp = await c.session.messages({ path: { id: sessionID }, query: { directory } });
+        const messages = (resp.data ?? []);
+        const convText = buildConversationForExtraction(messages);
+        if (convText.trim().length < 20)
+            return;
+        const created = await c.session.create({
+            body: { parentID: sessionID, title: "opencode-memory extraction" },
+            query: { directory },
+        });
+        forkID = extractIDFromResponse(created);
+        if (!forkID)
+            return;
+        nativeExtractionSessions.add(forkID); // shield the fork from the plugin's own recall/transform hooks
+        const body = {
+            agent: getNativeExtractAgent(),
+            system: EXTRACT_PROMPT, // always pass explicitly — ??= agent registration can miss if the agent already exists
+            tools: { "*": false, memory_save: true, memory_list: true }, // wildcard deny first; findLast → memory allows win
+            parts: [{ type: "text", text: convText }],
+        };
+        const extractModel = getNativeExtractModel();
+        if (extractModel)
+            body.model = extractModel;
+        // Race the prompt against a hard timeout so a hung/permission-gated fork can't leak.
+        let timer;
+        const timeout = new Promise((_, reject) => {
+            timer = setTimeout(() => reject(new Error("native extraction timed out")), NATIVE_EXTRACT_TIMEOUT_MS);
+        });
+        try {
+            await Promise.race([
+                c.session.prompt({ path: { id: forkID }, query: { directory }, body }),
+                timeout,
+            ]);
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+    }
+    catch (e) {
+        console.error("[opencode-claude-memory] native extraction failed:", e?.message ?? e);
+    }
+    finally {
+        if (forkID) {
+            await c.session?.delete?.({ path: { id: forkID }, query: { directory } }).catch(() => { });
+            // Hold the guard past delete: the fork's session.idle can arrive on a separate channel after
+            // the delete HTTP call resolves, and would otherwise re-trigger extraction of the fork itself.
+            const id = forkID;
+            setTimeout(() => nativeExtractionSessions.delete(id), NATIVE_EXTRACT_GRACE_MS);
+        }
+        nativeExtractionInFlight.delete(sessionID);
+    }
+}
+// Native extraction is the bash-wrapper replacement. Default-on for Windows (where the wrapper can't
+// run); opt-in elsewhere. Honors the wrapper's documented OPENCODE_MEMORY_EXTRACT=0 opt-out so a user
+// who disabled extraction gets it disabled here too (not silently re-enabled by the win32 default).
+// OPENCODE_MEMORY_NATIVE_EXTRACT=0/1 force-disables/enables regardless of platform.
+function nativeExtractionEnabled() {
+    if (process.env.OPENCODE_MEMORY_EXTRACT === "0")
+        return false;
+    const flag = process.env.OPENCODE_MEMORY_NATIVE_EXTRACT;
+    if (flag === "0")
+        return false;
+    if (flag === "1")
+        return true;
+    return process.platform === "win32";
+}
 export const MemoryPlugin = async ({ worktree, directory, client }) => {
     directory ??= worktree;
     const memoryRoot = resolveMemoryRoot(worktree, directory);
@@ -248,6 +426,43 @@ export const MemoryPlugin = async ({ worktree, directory, client }) => {
                 hidden: true,
                 prompt: "Select up to 5 relevant memory filenames for the current user query. Return only the requested structured output.",
             };
+            // Dedicated hidden agent for native extraction: its system prompt IS the extraction instruction,
+            // so the fork runs with an explicit system (not the build agent's) and tool-restricted to memory_*.
+            mutable.agent[getNativeExtractAgent()] ??= {
+                mode: "all",
+                hidden: true,
+                prompt: EXTRACT_PROMPT,
+            };
+        },
+        // Native post-session extraction. Enabled by default on Windows (where the
+        // bash wrapper can't run) and via OPENCODE_MEMORY_NATIVE_EXTRACT=1 elsewhere;
+        // =0 force-disables. Hooks `session.idle` (the established idle signal — used
+        // by opencode-mem and others). 10s debounce collapses rapid idle into one
+        // capture; an in-process Set of sub-session IDs prevents recursion. All work
+        // goes through ctx.client — no shell, no fork.
+        event: async (input) => {
+            if (!nativeExtractionEnabled())
+                return;
+            const evt = (input && typeof input === "object" && "event" in input
+                ? input.event
+                : input);
+            if (evt?.type !== "session.idle")
+                return;
+            const sessionID = evt.properties?.sessionID;
+            if (!sessionID)
+                return;
+            if (nativeExtractionSessions.has(sessionID))
+                return; // skip our own extraction sub-sessions
+            if (selectorSessionIDs.has(sessionID))
+                return; // skip recall-selector child sessions (same guard the transforms use)
+            if (nativeIdleTimer.has(sessionID))
+                clearTimeout(nativeIdleTimer.get(sessionID));
+            nativeIdleTimer.set(sessionID, setTimeout(() => {
+                nativeIdleTimer.delete(sessionID);
+                void runNativeExtraction(client, sessionID, directory).catch((e) => {
+                    console.error("[opencode-claude-memory] native extraction failed:", e?.message ?? e);
+                });
+            }, NATIVE_EXTRACT_DEBOUNCE_MS));
         },
         "chat.params": async (input, output) => {
             if (input.agent !== getRecallAgent())
@@ -255,7 +470,6 @@ export const MemoryPlugin = async ({ worktree, directory, client }) => {
             output.temperature = 0;
             output.options = {
                 ...output.options,
-                maxOutputTokens: 256,
             };
         },
         "tool.execute.after": async (input, output) => {
@@ -267,7 +481,7 @@ export const MemoryPlugin = async ({ worktree, directory, client }) => {
         },
         "experimental.chat.messages.transform": async (_input, output) => {
             const { query, sessionID, messageID, messageIndex } = getLastUserQuery(output.messages);
-            if (sessionID && selectorSessionIDs.has(sessionID))
+            if (sessionID && (selectorSessionIDs.has(sessionID) || nativeExtractionSessions.has(sessionID)))
                 return;
             if (sessionID) {
                 const alreadySurfaced = new Set();
@@ -326,7 +540,7 @@ export const MemoryPlugin = async ({ worktree, directory, client }) => {
                     ? _input.sessionID
                     : undefined;
             }
-            if (sessionID && selectorSessionIDs.has(sessionID))
+            if (sessionID && (selectorSessionIDs.has(sessionID) || nativeExtractionSessions.has(sessionID)))
                 return;
             const ctx = sessionID ? turnContextBySession.get(sessionID) : undefined;
             const query = ctx?.query;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-claude-memory",
-  "version": "1.7.2",
+  "version": "1.7.4",
   "type": "module",
   "description": "OpenCode plugin for Claude Code memory: persistent, local-first shared memory with Claude Code-compatible Markdown files, auto extraction, and auto-dream",
   "main": "dist/index.js",