@ghilteras/opencode-agent-memory 0.4.2 → 0.4.3

package/README.md

@@ -1,13 +1,6 @@
 # opencode-agent-memory
 
-> **Fork notice**: This is the maintained fork `@ghilteras/opencode-agent-memory` v0.4.2 of
-> [opencode-agent-memory](https://github.com/joshuadavidthomas/opencode-agent-memory)
-> (joshuadavidthomas, MIT). v0.4.2 adds a title-anchor floor so title queries are not diluted by long bodies. This release adopts the "proper timestamps without cache
-> busting" design (per-block `modified_at` frontmatter, remove the volatile
-> `memory_metadata` block, append memory XML at the end of the system prompt) derived
-> from the Annakan/draxxris fork plan. Upstream PR #20 (freeze metadata timestamps) is
-> superseded by the stronger per-block design and remains open upstream. v0.4.0 swaps
-> the embedding model to a multilingual one and adds a versioned embedding format. v0.4.1 makes journal search fast (in-memory per-store index, embedding-model warmup at init) and fixes the js-yaml import for ESM runtimes.
+**agent-memory for OpenCode — maintained by Ghilteras.** Originally based on [opencode-agent-memory](https://github.com/joshuadavidthomas/opencode-agent-memory) by Josh Thomas (MIT).
 
 [Letta](https://letta.com)-style editable [memory blocks](https://docs.letta.com/guides/agents/memory-blocks/) for [OpenCode](https://opencode.ai).
 
@@ -19,6 +12,12 @@ Think of it as AGENTS.md with a harness. OpenCode supports [rules](https://openc
 
 For background on the memory concept, see Letta's docs on [memory](https://docs.letta.com/guides/agents/memory/) and [memory blocks](https://docs.letta.com/guides/agents/memory-blocks/).
 
+## Maintenance & contributions
+
+This repository (`Ghilteras/opencode-agent-memory`, npm `@ghilteras/opencode-agent-memory`) is the **maintained home** of this plugin and its sole upstream. Issues and pull requests belong here.
+
+The historical origin (`joshuadavidthomas/opencode-agent-memory`) is reference-only: it is not a contribution target — do not open PRs, issues, or comments there, including courtesy closings.
+
 ## Features
 
 - **Persistent memory** - Information survives across sessions and context compaction

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ghilteras/opencode-agent-memory",
-  "version": "0.4.2",
+  "version": "0.4.3",
   "description": "Letta-style editable memory blocks + journal for OpenCode (maintained fork of opencode-agent-memory).",
   "author": "Angelo Pantano <ghilteras@protonmail.com>",
   "license": "MIT",

package/src/frontmatter.ts

@@ -1,8 +1,23 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
+import { randomUUID } from "node:crypto";
 
 import * as yaml from "js-yaml";
 
+const fileLocks = new Map<string, Promise<unknown>>();
+
+export function withFileLock<T>(filePath: string, fn: () => Promise<T>): Promise<T> {
+  const key = path.resolve(filePath);
+  const prior = fileLocks.get(key) ?? Promise.resolve();
+  const result = prior.then(fn, fn);           // run fn whatever the prior outcome was
+  const settled = result.then(() => undefined, () => undefined);  // never rejects
+  fileLocks.set(key, settled);
+  settled.then(() => {
+    if (fileLocks.get(key) === settled) fileLocks.delete(key);
+  });
+  return result;
+}
+
 export function splitFrontmatter(text: string): {
   frontmatterText: string | undefined;
   body: string;
@@ -40,8 +55,13 @@ export async function atomicWriteFile(
 ): Promise<void> {
   const tempPath = path.join(
     path.dirname(filePath),
-    `.${path.basename(filePath)}.tmp`,
+    `.${path.basename(filePath)}.${process.pid}.${randomUUID()}.tmp`,
   );
-  await fs.writeFile(tempPath, content, "utf-8");
-  await fs.rename(tempPath, filePath);
+  try {
+    await fs.writeFile(tempPath, content, "utf-8");
+    await fs.rename(tempPath, filePath);
+  } catch (err) {
+    await fs.rm(tempPath, { force: true }).catch(() => {});
+    throw err;
+  }
 }

package/src/memory.concurrency.test.ts

@@ -0,0 +1,57 @@
+import { describe, expect, test } from "bun:test";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { tmpdir } from "node:os";
+
+import { createMemoryStore } from "./memory";
+
+async function mkTmpDir(): Promise<string> {
+  return fs.mkdtemp(path.join(tmpdir(), "mem-race-"));
+}
+
+describe("concurrent block edits", () => {
+  test("two concurrent replaceInBlock calls both survive", async () => {
+    const dir = await mkTmpDir();
+    const store = createMemoryStore(dir);
+    await store.ensureSeed();
+    await store.setBlock("project", "project", "AAA bbb CCC ddd", { limit: 5000 });
+
+    await Promise.all([
+      store.replaceInBlock("project", "project", "AAA", "111"),
+      store.replaceInBlock("project", "project", "CCC", "333"),
+    ]);
+
+    const block = await store.getBlock("project", "project");
+    expect(block.value).toContain("111");
+    expect(block.value).toContain("333");
+    expect(block.value).toContain("bbb");
+    expect(block.value).toContain("ddd");
+
+    // No leftover temp files
+    const memDir = path.join(dir, ".opencode", "memory");
+    const files = await fs.readdir(memDir);
+    const tmpFiles = files.filter((f) => f.includes(".tmp"));
+    expect(tmpFiles).toEqual([]);
+  });
+
+  test("10 concurrent setBlock calls produce valid frontmatter", async () => {
+    const dir = await mkTmpDir();
+    const store = createMemoryStore(dir);
+    await store.ensureSeed();
+
+    const ops = Array.from({ length: 10 }, (_, i) =>
+      store.setBlock("project", `project`, `iteration ${i} ${"x".repeat(50)}`, { limit: 5000 }),
+    );
+    await Promise.all(ops);
+
+    // File must parse as valid frontmatter
+    const block = await store.getBlock("project", "project");
+    expect(block.value).toMatch(/iteration \d+/);
+
+    // No leftover temp files
+    const memDir = path.join(dir, ".opencode", "memory");
+    const files = await fs.readdir(memDir);
+    const tmpFiles = files.filter((f) => f.includes(".tmp"));
+    expect(tmpFiles).toEqual([]);
+  });
+});

package/src/memory.ts

@@ -5,7 +5,7 @@ import * as path from "node:path";
 import * as yaml from "js-yaml";
 import { z } from "zod";
 
-import { atomicWriteFile, buildFrontmatterDocument, splitFrontmatter } from "./frontmatter";
+import { atomicWriteFile, buildFrontmatterDocument, splitFrontmatter, withFileLock } from "./frontmatter";
 import { getDefaultDescription } from "./letta";
 
 export type MemoryScope = "global" | "project";
@@ -247,53 +247,61 @@ export function createMemoryStore(projectDirectory: string): MemoryStore {
       await fs.mkdir(dir, { recursive: true });
 
       const filePath = path.join(dir, `${safeLabel}.md`);
-      const existing = (await exists(filePath)) ? await readBlockFile(scope, filePath) : undefined;
 
-      if (existing?.readOnly) {
-        throw new Error(`Memory block is read-only: ${scope}:${safeLabel}`);
-      }
+      return withFileLock(filePath, async () => {
+        const existing = (await exists(filePath)) ? await readBlockFile(scope, filePath) : undefined;
+
+        if (existing?.readOnly) {
+          throw new Error(`Memory block is read-only: ${scope}:${safeLabel}`);
+        }
 
-      const description = (opts?.description ?? existing?.description ?? "").trim();
-      const limit = opts?.limit ?? existing?.limit ?? 5000;
+        const description = (opts?.description ?? existing?.description ?? "").trim();
+        const limit = opts?.limit ?? existing?.limit ?? 5000;
 
-      if (value.length > limit) {
-        throw new Error(
-          `Value too large for ${scope}:${safeLabel} (chars=${value.length}, limit=${limit}).`,
-        );
-      }
+        if (value.length > limit) {
+          throw new Error(
+            `Value too large for ${scope}:${safeLabel} (chars=${value.length}, limit=${limit}).`,
+          );
+        }
 
-      return writeBlockFile(filePath, {
-        label: safeLabel,
-        description,
-        limit,
-        readOnly: existing?.readOnly ?? false,
-        value,
+        return writeBlockFile(filePath, {
+          label: safeLabel,
+          description,
+          limit,
+          readOnly: existing?.readOnly ?? false,
+          value,
+        });
       });
     },
 
     async replaceInBlock(scope, label, oldText, newText) {
-      const block = await this.getBlock(scope, label);
-      if (block.readOnly) {
-        throw new Error(`Memory block is read-only: ${scope}:${block.label}`);
-      }
+      const safeLabel = validateLabel(label);
+      const filePath = path.join(scopeDir(projectDirectory, scope), `${safeLabel}.md`);
 
-      if (!block.value.includes(oldText)) {
-        throw new Error(`Old text not found in ${scope}:${block.label}.`);
-      }
+      return withFileLock(filePath, async () => {
+        const block = await this.getBlock(scope, label);
+        if (block.readOnly) {
+          throw new Error(`Memory block is read-only: ${scope}:${block.label}`);
+        }
 
-      const next = block.value.replace(oldText, newText);
-      if (next.length > block.limit) {
-        throw new Error(
-          `Value too large for ${scope}:${block.label} after replace (chars=${next.length}, limit=${block.limit}).`,
-        );
-      }
+        if (!block.value.includes(oldText)) {
+          throw new Error(`Old text not found in ${scope}:${block.label}.`);
+        }
 
-      return writeBlockFile(block.filePath, {
-        label: block.label,
-        description: block.description,
-        limit: block.limit,
-        readOnly: block.readOnly,
-        value: next,
+        const next = block.value.replace(oldText, newText);
+        if (next.length > block.limit) {
+          throw new Error(
+            `Value too large for ${scope}:${block.label} after replace (chars=${next.length}, limit=${block.limit}).`,
+          );
+        }
+
+        return writeBlockFile(block.filePath, {
+          label: block.label,
+          description: block.description,
+          limit: block.limit,
+          readOnly: block.readOnly,
+          value: next,
+        });
       });
     },
   };

package/src/plugin.ts

@@ -1,5 +1,7 @@
 import type { Plugin, ToolDefinition } from "@opencode-ai/plugin";
 
+import { existsSync } from "node:fs";
+
 import {
   buildJournalSystemNote,
   createJournalStore,
@@ -20,7 +22,12 @@ import { warmupEmbedder } from "./embeddings";
 
 export const MemoryPlugin: Plugin = async ({ directory }) => {
   const store = createMemoryStore(directory);
-  await store.ensureSeed();
+  // Only seed into a directory that still exists. OpenCode walks a persisted instance list
+  // at startup and bootstraps every entry; because ensureSeed() creates
+  // <directory>/.opencode/memory recursively, a stale entry made this plugin re-create
+  // directories the operator had deliberately deleted. A missing directory means the
+  // instance is gone, not new, so there is nothing to seed.
+  if (existsSync(directory)) await store.ensureSeed();
 
   // Journal: opt-in via ~/.config/opencode/agent-memory.json
   const config = await loadConfig();