opencode-claude-memory 2.0.2 → 2.1.1

package/dist/recall/turn.js

@@ -0,0 +1,49 @@
+// Host-independent text rules for a user turn: the "ignore memory" / "use memory again" phrases and
+// the keys of memories already surfaced in a system prompt. The host adapters apply them to their
+// own message shapes.
+import { RECALLED_MEMORIES_HEADING } from "../prompt/systemPrompt.js";
+// "Ignore memory" handling. Claude Code's semantics are session-scoped: once the user asks to
+// ignore memory, it stays ignored until they explicitly ask for it back.
+export function detectIgnoreMemory(query) {
+    if (!query)
+        return false;
+    const normalized = query.toLowerCase();
+    return (/(ignore|don't use|do not use|without|skip)\s+(the\s+|your\s+)?memory/.test(normalized) ||
+        /memory\s+(should be|must be)?\s*ignored/.test(normalized));
+}
+export function detectResumeMemory(query) {
+    if (!query)
+        return false;
+    const normalized = query.toLowerCase();
+    return (/(use|enable|resume|restore|bring back|turn on)\s+(the\s+|your\s+)?memory(\s+again)?/.test(normalized) ||
+        /memory\s+(back\s+)?on\b/.test(normalized) ||
+        /stop ignoring\s+(the\s+|your\s+)?memory/.test(normalized));
+}
+// Replays user queries in order and returns whether memory is ignored at the end. Used to rebuild
+// session state the coordinator no longer holds (process restart, cache eviction), so an "ignore
+// memory" said earlier in the session keeps applying without the user repeating it.
+export function deriveIgnoredFromQueries(queries) {
+    let ignored = false;
+    for (const query of queries) {
+        if (detectIgnoreMemory(query))
+            ignored = true;
+        else if (ignored && detectResumeMemory(query))
+            ignored = false;
+    }
+    return ignored;
+}
+// Parses "### <name> (<type>)" headers from the ## Recalled Memories section
+// of system prompts. After compaction old system messages disappear, so
+// the returned set naturally shrinks — no manual reset needed.
+export function extractSurfacedMemoryKeys(systemText) {
+    const keys = new Set();
+    const recalledSection = systemText.indexOf(RECALLED_MEMORIES_HEADING);
+    if (recalledSection === -1)
+        return keys;
+    const headerPattern = /^### (.+?) \((\w+)\)/gm;
+    const section = systemText.slice(recalledSection);
+    for (let match = headerPattern.exec(section); match !== null; match = headerPattern.exec(section)) {
+        keys.add(`${match[1]}|${match[2]}`);
+    }
+    return keys;
+}

package/dist/tools.d.ts

@@ -1,9 +1,22 @@
-import { type Hooks } from "@opencode-ai/plugin";
+import { z } from "zod/v4";
+import type { MemoryToolName } from "./agents.js";
 import type { ExtractionCoordinator } from "./extraction/ExtractionCoordinator.js";
 import type { MemoryStore, SaveMemoryResult } from "./store/MemoryStore.js";
 export declare function formatMemorySaveResult(outcome: SaveMemoryResult, savedThisRun?: readonly string[]): string;
 export declare function memorySaveTitle(type: string, name: string): string | undefined;
 export declare function memoryListTitle(count: number): string;
 export declare function memorySearchTitle(query: string, count: number): string;
-export type MemoryTools = NonNullable<Hooks["tool"]>;
-export declare function buildMemoryTools(store: MemoryStore, extraction: Pick<ExtractionCoordinator, "recordSave">): MemoryTools;
+export type MemoryToolResult = {
+    title?: string;
+    output: string;
+};
+export type MemoryToolContext = {
+    sessionID?: string;
+};
+export type MemoryToolSpec = {
+    name: MemoryToolName;
+    description: string;
+    args: z.ZodRawShape;
+    execute(args: Record<string, unknown>, ctx: MemoryToolContext): Promise<MemoryToolResult>;
+};
+export declare function buildMemoryToolSpecs(store: MemoryStore, extraction: Pick<ExtractionCoordinator, "recordSave">): MemoryToolSpec[];

package/dist/tools.js

@@ -1,4 +1,9 @@
-import { tool } from "@opencode-ai/plugin";
+// The five memory tools, defined once. Each host adapter wraps the specs into its own tool format
+// (V1: `Hooks["tool"]`, V2: `ToolEditor.add`); results carry their own titles.
+//
+// Argument schemas use `zod/v4`: both hosts accept them (V1 duck-types Zod v4 schemas, V2 takes any
+// Standard Schema), so the plugin needs no runtime import from either SDK.
+import { z } from "zod/v4";
 import { MEMORY_TYPES } from "./store/frontmatter.js";
 // Tool result for memory_save. Inside an extraction fork, `savedThisRun` (file names already saved
 // by this fork, in order) is appended as an explicit done-signal so the model does not lose track on
@@ -42,9 +47,14 @@ export function memorySearchTitle(query, count) {
     return `"${query}" · ${plural(count, "match", "matches")}`;
 }
 const FILE_NAME_HINT = 'with or without the .md extension; sub-directories are allowed, e.g. "team/conventions"';
-export function buildMemoryTools(store, extraction) {
-    return {
-        memory_save: tool({
+function str(args, key) {
+    const value = args[key];
+    return typeof value === "string" ? value : "";
+}
+export function buildMemoryToolSpecs(store, extraction) {
+    return [
+        {
+            name: "memory_save",
             description: "Save or update a memory for future conversations. " +
                 "Each memory is stored as a markdown file with frontmatter. " +
                 "Use this when the user explicitly asks you to remember something, " +
@@ -52,52 +62,56 @@ export function buildMemoryTools(store, extraction) {
                 "(user preferences, feedback, project context, external references). " +
                 "Check existing memories first with memory_list or memory_search to avoid duplicates.",
             args: {
-                file_name: tool.schema
+                file_name: z
                     .string()
                     .describe('File name for the memory (without .md extension). Use snake_case, e.g. "user_role", "feedback_testing_style", "project_auth_rewrite"; a sub-directory prefix such as "team/conventions" is allowed'),
-                name: tool.schema.string().describe("Human-readable name for this memory"),
-                description: tool.schema
+                name: z.string().describe("Human-readable name for this memory"),
+                description: z
                     .string()
                     .describe("One-line description — used to decide relevance in future conversations, so be specific"),
-                type: tool.schema
+                type: z
                     .enum(MEMORY_TYPES)
                     .describe("Memory type: user (about the person), feedback (guidance on approach), project (ongoing work context), reference (pointers to external systems)"),
-                content: tool.schema
+                content: z
                     .string()
                     .describe("Memory content. For feedback/project types, structure as: rule/fact, then **Why:** and **How to apply:** lines"),
             },
             async execute(args, ctx) {
+                const type = str(args, "type");
                 const outcome = store.save({
-                    fileName: args.file_name,
-                    name: args.name,
-                    description: args.description,
-                    type: args.type,
-                    content: args.content,
+                    fileName: str(args, "file_name"),
+                    name: str(args, "name"),
+                    description: str(args, "description"),
+                    type,
+                    content: str(args, "content"),
                 });
-                const savedThisRun = extraction.recordSave(ctx?.sessionID, outcome.fileName);
+                const savedThisRun = extraction.recordSave(ctx.sessionID, outcome.fileName);
                 return {
-                    title: memorySaveTitle(args.type, args.name),
+                    title: memorySaveTitle(type, str(args, "name")),
                     output: formatMemorySaveResult(outcome, savedThisRun),
                 };
             },
-        }),
-        memory_delete: tool({
+        },
+        {
+            name: "memory_delete",
             description: "Delete a memory that is outdated, wrong, or no longer relevant. Also removes it from the index.",
             args: {
-                file_name: tool.schema.string().describe(`File name of the memory to delete (${FILE_NAME_HINT})`),
+                file_name: z.string().describe(`File name of the memory to delete (${FILE_NAME_HINT})`),
             },
             async execute(args) {
-                const { deleted, trashedTo } = store.delete(args.file_name);
-                let output = `Memory "${args.file_name}" not found.`;
+                const fileName = str(args, "file_name");
+                const { deleted, trashedTo } = store.delete(fileName);
+                let output = `Memory "${fileName}" not found.`;
                 if (deleted) {
                     output = trashedTo
-                        ? `Memory "${args.file_name}" deleted (a copy was kept at ${trashedTo}).`
-                        : `Memory "${args.file_name}" deleted.`;
+                        ? `Memory "${fileName}" deleted (a copy was kept at ${trashedTo}).`
+                        : `Memory "${fileName}" deleted.`;
                 }
-                return { title: args.file_name, output };
+                return { title: fileName, output };
             },
-        }),
-        memory_list: tool({
+        },
+        {
+            name: "memory_list",
             description: "List all saved memories with their names, types, and descriptions. " +
                 "Use this to check what memories exist before saving a new one (to avoid duplicates) " +
                 "or when you need to recall what's been stored.",
@@ -110,36 +124,40 @@ export function buildMemoryTools(store, extraction) {
                 const lines = entries.map((e) => `- **${e.name}** (${e.type}) [${e.filename}]: ${e.description}`);
                 return { title, output: `${entries.length} memories found:\n${lines.join("\n")}` };
             },
-        }),
-        memory_search: tool({
+        },
+        {
+            name: "memory_search",
             description: "Search memories by keyword. Searches across names, descriptions, and content. " +
                 "Use this to find relevant memories before answering questions or when the user references past conversations.",
             args: {
-                query: tool.schema.string().describe("Search query — searches across name, description, and content"),
+                query: z.string().describe("Search query — searches across name, description, and content"),
             },
             async execute(args) {
-                const results = store.search(args.query);
-                const title = memorySearchTitle(args.query, results.length);
+                const query = str(args, "query");
+                const results = store.search(query);
+                const title = memorySearchTitle(query, results.length);
                 if (results.length === 0)
-                    return { title, output: `No memories matching "${args.query}".` };
+                    return { title, output: `No memories matching "${query}".` };
                 const lines = results.map((e) => `- **${e.name}** (${e.type}) [${e.filename}]: ${e.description}\n  Content: ${e.body.slice(0, 200)}${e.body.length > 200 ? "..." : ""}`);
-                return { title, output: `${results.length} matches for "${args.query}":\n${lines.join("\n")}` };
+                return { title, output: `${results.length} matches for "${query}":\n${lines.join("\n")}` };
             },
-        }),
-        memory_read: tool({
+        },
+        {
+            name: "memory_read",
             description: "Read the full content of a specific memory file.",
             args: {
-                file_name: tool.schema.string().describe(`File name of the memory to read (${FILE_NAME_HINT})`),
+                file_name: z.string().describe(`File name of the memory to read (${FILE_NAME_HINT})`),
             },
             async execute(args) {
-                const entry = store.read(args.file_name);
+                const fileName = str(args, "file_name");
+                const entry = store.read(fileName);
                 if (!entry)
-                    return { title: args.file_name, output: `Memory "${args.file_name}" not found.` };
+                    return { title: fileName, output: `Memory "${fileName}" not found.` };
                 return {
-                    title: args.file_name,
+                    title: fileName,
                     output: `# ${entry.name}\n**Type:** ${entry.type}\n**Description:** ${entry.description}\n\n${entry.body}`,
                 };
             },
-        }),
-    };
+        },
+    ];
 }

package/dist/util/log.d.ts

@@ -1,6 +1,4 @@
-import type { OpencodeClient } from "../sdk.js";
 export declare const LOG_SERVICE = "opencode-claude-memory";
 export type LogLevel = "debug" | "info" | "warn" | "error";
 export type Logger = (level: LogLevel, message: string, extra?: Record<string, unknown>) => void;
 export declare function getErrorMessage(error: unknown): string;
-export declare function createLogger(client: OpencodeClient | undefined, directory: string): Logger;

package/dist/util/log.js

@@ -1,3 +1,5 @@
+// Host-independent logging types. Each host adapter supplies its own sink (V1: the OpenCode service
+// log, V2: a file in the plugin state directory); stderr is never used because it ends up in the UI.
 export const LOG_SERVICE = "opencode-claude-memory";
 export function getErrorMessage(error) {
     if (error instanceof Error)
@@ -9,21 +11,3 @@ export function getErrorMessage(error) {
     }
     return String(error);
 }
-// Logging goes through the OpenCode service log only. stderr is rendered into the chat UI, so a
-// failing background task must never write there. Every call is best-effort and never throws.
-export function createLogger(client, directory) {
-    return (level, message, extra) => {
-        const log = client?.app?.log;
-        if (typeof log !== "function")
-            return;
-        try {
-            void Promise.resolve(log.call(client?.app, {
-                body: { service: LOG_SERVICE, level, message, extra },
-                query: { directory },
-            })).catch(() => { });
-        }
-        catch {
-            // best-effort
-        }
-    };
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-claude-memory",
-  "version": "2.0.2",
+  "version": "2.1.1",
   "type": "module",
   "description": "OpenCode plugin for Claude Code memory: persistent, local-first shared memory with Claude Code-compatible Markdown files, LLM recall, in-process auto extraction, and auto-dream consolidation",
   "main": "dist/index.js",
@@ -16,7 +16,7 @@
     "dist"
   ],
   "engines": {
-    "opencode": ">=1.18.0"
+    "opencode": ">=1.18.29"
   },
   "scripts": {
     "build": "tsc -p tsconfig.build.json",
@@ -58,14 +58,26 @@
   ],
   "license": "MIT",
   "peerDependencies": {
-    "@opencode-ai/plugin": ">=1.18.0"
+    "@opencode-ai/plugin": ">=1.18.29",
+    "@opencode/plugin": ">=2.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@opencode-ai/plugin": {
+      "optional": true
+    },
+    "@opencode/plugin": {
+      "optional": true
+    }
   },
   "dependencies": {
-    "zod": "^3.24.0"
+    "zod": "^3.25.0"
   },
   "devDependencies": {
     "@biomejs/biome": "^2",
     "@opencode-ai/plugin": "^1.18.16",
+    "@opencode/client": "2.0.22",
+    "@opencode/plugin": "2.0.22",
+    "@opencode/schema": "2.0.22",
     "bun-types": "^1.3.11",
     "conventional-changelog-conventionalcommits": "^9",
     "typescript": "^6.0.2"

package/dist/hooks/ignore.js

@@ -1,53 +0,0 @@
-// "Ignore memory" handling. Claude Code's semantics are session-scoped: once the user asks to
-// ignore memory, it stays ignored until they explicitly ask for it back.
-import { AUTO_MEMORY_MARKER } from "../prompt/systemPrompt.js";
-import { extractUserQuery, roleOf } from "./messages.js";
-export function detectIgnoreMemory(query) {
-    if (!query)
-        return false;
-    const normalized = query.toLowerCase();
-    return (/(ignore|don't use|do not use|without|skip)\s+(the\s+|your\s+)?memory/.test(normalized) ||
-        /memory\s+(should be|must be)?\s*ignored/.test(normalized));
-}
-export function detectResumeMemory(query) {
-    if (!query)
-        return false;
-    const normalized = query.toLowerCase();
-    return (/(use|enable|resume|restore|bring back|turn on)\s+(the\s+|your\s+)?memory(\s+again)?/.test(normalized) ||
-        /memory\s+(back\s+)?on\b/.test(normalized) ||
-        /stop ignoring\s+(the\s+|your\s+)?memory/.test(normalized));
-}
-// Replays every user message in order and returns whether memory is ignored at the end. Used to
-// rebuild session state that the coordinator no longer holds (process restart, cache eviction), so
-// an "ignore memory" said earlier in the session keeps applying without the user repeating it.
-export function deriveIgnoredFromHistory(messages) {
-    let ignored = false;
-    for (const message of messages) {
-        if (roleOf(message) !== "user")
-            continue;
-        const query = extractUserQuery(message);
-        if (detectIgnoreMemory(query))
-            ignored = true;
-        else if (ignored && detectResumeMemory(query))
-            ignored = false;
-    }
-    return ignored;
-}
-export function isAutoMemoryPart(part) {
-    if (!part || typeof part !== "object")
-        return false;
-    const text = part.text;
-    return typeof text === "string" && text.trimStart().startsWith(AUTO_MEMORY_MARKER);
-}
-// Drops the plugin's own system segment from system-role messages; messages left without parts
-// are removed entirely.
-export function stripAutoMemoryParts(messages) {
-    return messages
-        .map((message) => {
-        if (roleOf(message) !== "system" || !Array.isArray(message.parts))
-            return message;
-        const parts = message.parts.filter((part) => !isAutoMemoryPart(part));
-        return parts.length === message.parts.length ? message : { ...message, parts };
-    })
-        .filter((message) => !Array.isArray(message.parts) || message.parts.length > 0);
-}