opencode-claude-memory 2.1.1 → 2.1.2

package/README.md

@@ -144,7 +144,7 @@ The V2 plugin API exposes less than V1, so a few behaviours differ:
 | Memory directory | `~/.claude/projects/<sanitized canonical git root>/memory/` | identical (`sanitizePath`, worktree → main repo resolution ported byte for byte) |
 | File format | Markdown + `name` / `description` / `type` frontmatter | identical; frontmatter parsed only within the first 30 lines, as in Claude Code |
 | Taxonomy | `user`, `feedback`, `project`, `reference` | identical |
-| `MEMORY.md` | one-line pointers, hand-organisable | read with the same truncation rules; written with minimal line-level edits |
+| `MEMORY.md` | one-line pointers, hand-organisable | read with the same truncation rules; written with minimal line-level edits, hand-written pointer lines are never replaced |
 | Sub-directories | `team/x.md` etc. | scanned, recalled and addressable from every tool |
 | System prompt | memory instructions + index + recalled memories | ported sections (`memoryTypes.ts`, `memdir.ts`) |
 | Recall | LLM side query | LLM side query (`findRelevantMemories.ts` port): a hidden child session on 1.x, a `generate.text` call on 2.x |

package/dist/store/MemoryStore.d.ts

@@ -43,5 +43,4 @@ export declare class MemoryStore {
     search(query: string): MemoryEntry[];
     readIndex(): string;
     private writeIndex;
-    private isUnchanged;
 }

package/dist/store/MemoryStore.js

@@ -2,7 +2,7 @@ import { cpSync, lstatSync, mkdirSync, readFileSync, realpathSync, statSync, unl
 import { dirname, join } from "node:path";
 import { writeFileAtomicSync } from "../util/exclusiveFile.js";
 import { buildFrontmatter, editFrontmatter, FRONTMATTER_MAX_LINES, frontmatterKeys, ORIGIN, parseFrontmatter, parseMemoryType, } from "./frontmatter.js";
-import { buildIndexPointer, indexHasPointer, readIndexFile, removeIndexLine, upsertIndexLine } from "./indexFile.js";
+import { buildIndexPointer, findIndexPointerLine, readIndexFile, removeIndexLine, upsertIndexLine, } from "./indexFile.js";
 import { ENTRYPOINT_NAME, findCanonicalGitRoot, findGitRoot, MAX_MEMORY_FILE_BYTES, resolveMemoryFilePath, sanitizePath, } from "./paths.js";
 import { formatMemoryManifest, nameFromFilename, readMemoryEntry, scanMemoryFiles, } from "./scan.js";
 // Owns the resolved memory paths for one project. Path resolution (git root, worktree canonical
@@ -65,9 +65,14 @@ export class MemoryStore {
         }
         const existing = readTextFile(filePath);
         const parsed = existing === null ? null : parseFrontmatter(existing);
-        const pointer = buildIndexPointer(relativePath, input.name, input.description);
-        if (parsed !== null && this.isUnchanged(parsed, relativePath, input, pointer)) {
-            return { filePath, fileName: relativePath, unchanged: true };
+        const index = this.readIndex();
+        const nextIndex = indexAfterSave(index, relativePath, input, parsed);
+        if (parsed !== null && isUnchanged(parsed, relativePath, input)) {
+            // The same memory: at most a missing index pointer is added, the file itself is not rewritten.
+            if (nextIndex === index)
+                return { filePath, fileName: relativePath, unchanged: true };
+            this.writeIndex(nextIndex);
+            return { filePath, fileName: relativePath, unchanged: false };
         }
         const modified = this.now().toISOString();
         const fileContent = existing === null || parsed === null
@@ -83,7 +88,8 @@ export class MemoryStore {
             throw new Error(`Memory "${relativePath}" frontmatter would exceed ${FRONTMATTER_MAX_LINES} lines; trim its frontmatter first`);
         }
         writeFileAtomicSync(filePath, fileContent);
-        this.writeIndex(upsertIndexLine(this.readIndex(), relativePath, pointer));
+        if (nextIndex !== index)
+            this.writeIndex(nextIndex);
         return { filePath, fileName: relativePath, unchanged: false };
     }
     // Deleting a memory that is not purely this plugin's (Claude Code's, dsh's, a hand-written one, or
@@ -123,19 +129,41 @@ export class MemoryStore {
     writeIndex(content) {
         writeFileAtomicSync(this.entrypoint, content);
     }
-    // Unchanged means the same name, description, type and body, whatever else the frontmatter
-    // holds, so an identical re-save neither bumps `modified` nor stamps provenance.
-    isUnchanged(parsed, relativePath, input, pointer) {
-        const { frontmatter, body, hasFrontmatter } = parsed;
-        if (!hasFrontmatter)
-            return false;
-        // Missing fields compare as the defaults the scanner (and `read()`) reports for them.
-        const same = (frontmatter.name ?? nameFromFilename(relativePath)) === input.name &&
-            (frontmatter.description ?? "") === input.description &&
-            (parseMemoryType(frontmatter.type) ?? "user") === input.type &&
-            body.replace(/\r\n/g, "\n") === input.content.trim().replace(/\r\n/g, "\n");
-        return same && indexHasPointer(this.readIndex(), pointer);
-    }
+}
+// A memory's name and description as the scanner (and `read()`) reports them: missing fields
+// count as their defaults.
+function previousFields(parsed, relativePath) {
+    return {
+        name: parsed.frontmatter.name ?? nameFromFilename(relativePath),
+        description: parsed.frontmatter.description ?? "",
+    };
+}
+// Unchanged means the same name, description, type and body, whatever else the frontmatter holds,
+// so an identical re-save neither bumps `modified` nor stamps provenance.
+function isUnchanged(parsed, relativePath, input) {
+    if (!parsed.hasFrontmatter)
+        return false;
+    const before = previousFields(parsed, relativePath);
+    return (before.name === input.name &&
+        before.description === input.description &&
+        (parseMemoryType(parsed.frontmatter.type) ?? "user") === input.type &&
+        parsed.body.replace(/\r\n/g, "\n") === input.content.trim().replace(/\r\n/g, "\n"));
+}
+// MEMORY.md after a save. Index lines are often hand-written (Claude Code's format is
+// `- [Title](file.md) — one-line hook`, and neither part has to repeat the frontmatter), so an
+// existing pointer is kept unless it is still exactly the line this plugin generates from the
+// memory's previous name and description: only such a line follows a new name or description. A
+// memory without a pointer gains one. No other line is touched.
+function indexAfterSave(raw, relativePath, input, parsed) {
+    const pointer = buildIndexPointer(relativePath, input.name, input.description);
+    const current = findIndexPointerLine(raw, relativePath);
+    if (current === undefined)
+        return upsertIndexLine(raw, relativePath, pointer);
+    if (current === pointer || parsed === null)
+        return raw;
+    const before = previousFields(parsed, relativePath);
+    const generatedBefore = buildIndexPointer(relativePath, before.name, before.description);
+    return current === generatedBefore ? upsertIndexLine(raw, relativePath, pointer) : raw;
 }
 // The frontmatter keys of a memory this plugin creates (buildFrontmatter), each on one line; its own
 // later saves keep exactly this set.

package/dist/store/indexFile.d.ts

@@ -2,6 +2,7 @@ export declare const POINTER_RE: RegExp;
 export declare function readIndexFile(entrypoint: string): string;
 export declare function buildIndexPointer(fileName: string, name: string, description: string): string;
 export declare function indexHasPointer(raw: string, pointer: string): boolean;
+export declare function findIndexPointerLine(raw: string, fileName: string): string | undefined;
 export declare function pointerTarget(line: string): string | undefined;
 export declare function upsertIndexLine(raw: string, fileName: string, pointer: string): string;
 export declare function removeIndexLine(raw: string, fileName: string): string;

package/dist/store/indexFile.js

@@ -20,6 +20,14 @@ export function buildIndexPointer(fileName, name, description) {
 export function indexHasPointer(raw, pointer) {
     return raw.split(/\r?\n/).some((line) => line.trimEnd() === pointer);
 }
+// The first pointer line for `fileName` without its indentation and trailing whitespace, or
+// undefined when the index has none.
+export function findIndexPointerLine(raw, fileName) {
+    return raw
+        .split(/\r?\n/)
+        .find((line) => pointerTarget(line) === fileName)
+        ?.trim();
+}
 function detectEol(raw) {
     return raw.includes("\r\n") ? "\r\n" : "\n";
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-claude-memory",
-  "version": "2.1.1",
+  "version": "2.1.2",
   "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",