opencode-claude-memory 1.7.6 → 1.7.8

package/dist/hooks/ignore.js

@@ -0,0 +1,53 @@
+// "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);
+}

package/dist/hooks/messages.d.ts

@@ -0,0 +1,14 @@
+import type { ChatMessage } from "../sdk.js";
+export type TurnInfo = {
+    sessionID?: string;
+    query?: string;
+    messageID?: string;
+    messageIndex?: number;
+};
+export declare function roleOf(message: ChatMessage): string;
+export declare function extractUserQuery(message: ChatMessage): string | undefined;
+export declare function getLastUserQuery(messages: readonly ChatMessage[]): TurnInfo;
+export declare function buildTurnID(sessionID: string, turn: TurnInfo): string;
+export declare function extractSurfacedMemoryKeys(systemText: string): Set<string>;
+export declare function collectSurfacedMemoryKeys(messages: readonly ChatMessage[]): Set<string>;
+export declare function extractRecentTools(messages: readonly ChatMessage[]): string[];

package/dist/hooks/messages.js

@@ -0,0 +1,96 @@
+// Pure helpers over the SDK message shape passed to `experimental.chat.messages.transform`.
+import { RECALLED_MEMORIES_HEADING } from "../prompt/systemPrompt.js";
+// Older runtimes and tests may hand over messages whose `info` lacks the full SDK shape; only the
+// fields actually used are read, defensively.
+export function roleOf(message) {
+    return String(message.info?.role ?? "");
+}
+function partText(part) {
+    if (!part || typeof part !== "object")
+        return undefined;
+    const text = part.text;
+    return typeof text === "string" ? text : undefined;
+}
+export function extractUserQuery(message) {
+    if (!Array.isArray(message.parts))
+        return undefined;
+    const text = message.parts
+        .filter((part) => part.type === "text")
+        .map((part) => partText(part) ?? "")
+        .filter(Boolean)
+        .join("\n")
+        .trim();
+    return text || undefined;
+}
+export function getLastUserQuery(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const message = messages[i];
+        if (!message || roleOf(message) !== "user")
+            continue;
+        const info = message.info;
+        return {
+            query: extractUserQuery(message),
+            sessionID: typeof info?.sessionID === "string" ? info.sessionID : undefined,
+            messageID: typeof info?.id === "string" ? info.id : undefined,
+            messageIndex: i,
+        };
+    }
+    return {};
+}
+// One user turn may drive several LLM calls (tool loops); they share a turn ID so recall runs once.
+export function buildTurnID(sessionID, turn) {
+    return `${sessionID}:${turn.messageID ?? `${turn.messageIndex ?? -1}:${turn.query ?? ""}`}`;
+}
+// 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;
+}
+export function collectSurfacedMemoryKeys(messages) {
+    const keys = new Set();
+    for (const message of messages) {
+        if (roleOf(message) !== "system" || !Array.isArray(message.parts))
+            continue;
+        for (const part of message.parts) {
+            const text = partText(part);
+            if (!text)
+                continue;
+            for (const key of extractSurfacedMemoryKeys(text))
+                keys.add(key);
+        }
+    }
+    return keys;
+}
+// Only completed tools — matches Claude Code's collectRecentSuccessfulTools().
+export function extractRecentTools(messages) {
+    const tools = [];
+    const seen = new Set();
+    for (const message of messages) {
+        if (!Array.isArray(message.parts))
+            continue;
+        for (const part of message.parts) {
+            if (!part || typeof part !== "object")
+                continue;
+            const p = part;
+            if (p.type !== "tool" || !p.tool)
+                continue;
+            if (p.state?.status !== "completed")
+                continue;
+            if (seen.has(p.tool))
+                continue;
+            seen.add(p.tool);
+            tools.push(p.tool);
+        }
+    }
+    return tools;
+}

package/dist/index.d.ts

@@ -1,2 +1,8 @@
-import type { Plugin } from "@opencode-ai/plugin";
+import type { Plugin, PluginModule } from "@opencode-ai/plugin";
+export declare const PLUGIN_ID = "opencode-claude-memory";
+export declare const createMemoryPlugin: (env?: NodeJS.ProcessEnv, homeDir?: string) => Plugin;
 export declare const MemoryPlugin: Plugin;
+declare const plugin: PluginModule;
+export default plugin;
+export { MEMORY_AGENTS, type MemoryConfig, type MemoryOptions, MemoryOptionsSchema } from "./config.js";
+export { MemoryStore } from "./store/MemoryStore.js";