@ghilteras/opencode-agent-memory 1.2.0 → 2.0.1

package/src/plugin-disabled.test.ts

@@ -1,39 +0,0 @@
-import { expect, mock, test } from "bun:test";
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import * as realEmbeddings from "./embeddings";
-
-if (process.env.HOME === undefined || !process.env.HOME.startsWith("/tmp/")) {
-  throw new Error("plugin tests require HOME pointed at a /tmp fixture directory; run via `bun run test:plugin`");
-}
-
-const configDir = path.join(process.env.HOME, ".config", "opencode");
-
-mock.module("./embeddings", () => ({
-  ...realEmbeddings,
-  generateEmbedding: async () => Array.from({ length: 384 }, (_, i) => Math.sin(i) * 0.5),
-  warmupEmbedder: async () => {},
-}));
-
-import plugin from "./plugin";
-
-test("explicit opt-out registers no tools and emits no warning", async () => {
-  await fs.mkdir(configDir, { recursive: true });
-  await fs.writeFile(path.join(configDir, "agent-memory.json"), JSON.stringify({ journal: { enabled: false } }), "utf-8");
-  const definitions: unknown[] = [];
-  const warn = console.warn;
-  let warnings = 0;
-  console.warn = () => { warnings++; };
-  try {
-    await plugin.setup({
-      location: { directory: "/tmp" },
-      session: { hook: async () => {} },
-      tool: { transform: async (callback: (editor: { add: (tool: unknown) => void; list: () => unknown[] }) => void) => callback({ add: (tool) => definitions.push(tool), list: () => [] }) },
-    } as any);
-    expect(definitions).toEqual([]);
-    expect(warnings).toBe(0);
-  } finally {
-    console.warn = warn;
-    await fs.rm(configDir, { recursive: true, force: true });
-  }
-});

package/src/plugin.test.ts

@@ -1,220 +0,0 @@
-import { afterEach, describe, expect, mock, test } from "bun:test";
-import * as fs from "node:fs/promises";
-import * as os from "node:os";
-import * as path from "node:path";
-import * as realEmbeddings from "./embeddings";
-
-// These tests run in their own bun process (package.json "test:plugin") with
-// HOME pointed at a throwaway fixture directory, so the real loadConfig and
-// createJournalStore exercise real fixture files. Refuse to run against the
-// real home directory. Only the model-loading surface of ./embeddings is
-// stubbed, spreading the real module so other exports keep real values.
-if (process.env.HOME === undefined || !process.env.HOME.startsWith("/tmp/")) {
-  throw new Error("plugin tests require HOME pointed at a /tmp fixture directory; run via `bun run test:plugin`");
-}
-
-const fixtureHome = process.env.HOME;
-const configDir = path.join(fixtureHome, ".config", "opencode");
-const configPath = path.join(configDir, "agent-memory.json");
-const journalDir = path.join(configDir, "journal");
-
-mock.module("./embeddings", () => ({
-  ...realEmbeddings,
-  generateEmbedding: async () => Array.from({ length: 384 }, (_, i) => Math.sin(i) * 0.5),
-  warmupEmbedder: async () => {},
-}));
-
-import plugin from "./plugin";
-
-// value === undefined creates a DIRECTORY at the config path (unreadable);
-// a string is written raw (malformed JSON); an object is JSON-encoded.
-async function writeConfig(value: unknown): Promise<void> {
-  await fs.mkdir(configDir, { recursive: true });
-  if (value === undefined) {
-    await fs.mkdir(configPath, { recursive: true });
-  } else if (typeof value === "string") {
-    await fs.writeFile(configPath, value, "utf-8");
-  } else {
-    await fs.writeFile(configPath, JSON.stringify(value), "utf-8");
-  }
-}
-
-function harness(directory = "/tmp/project") {
-  const definitions = new Map<string, any>();
-  let contextHook: ((event: any) => void) | undefined;
-  let transform: ((editor: { add: (definition: any) => void; list: () => any[] }) => void) | undefined;
-  const context = {
-    location: { directory },
-    session: { hook: async (name: string, callback: (event: any) => void) => { expect(name).toBe("context"); contextHook = callback; } },
-    tool: { transform: async (callback: typeof transform) => { transform = callback; callback!({ add: (definition) => definitions.set(definition.name, definition), list: () => [...definitions.values()] }); } },
-  } as any;
-  return { definitions, contextHook: () => contextHook, replay: () => transform!({ add: (definition) => definitions.set(definition.name, definition), list: () => [...definitions.values()] }), start: () => plugin.setup(context) };
-}
-
-afterEach(async () => {
-  await fs.rm(configDir, { recursive: true, force: true });
-});
-
-describe("v2 plugin registration", () => {
-  test("has a stable id and default-registers exactly the three journal tools", async () => {
-    expect(plugin.id).toBe("opencode-agent-memory");
-    await fs.rm(configDir, { recursive: true, force: true }); // absent config: default-on journal tools
-    const h = harness();
-    await h.start();
-    expect([...h.definitions.keys()].sort()).toEqual(["journal_read", "journal_search", "journal_write"]);
-  });
-
-  test("registered write description suggests configured tag names without their descriptions", async () => {
-    await writeConfig({ journal: { tags: [
-      { name: "owner_approved", description: "Use for a choice made and its rationale." },
-      { name: "incident_followup", description: "Use for investigation notes and findings." },
-    ] } });
-    const h = harness();
-    await h.start();
-    const description = h.definitions.get("journal_write").description as string;
-    expect(description).toContain("Suggested tags: owner_approved, incident_followup.");
-    expect(description).not.toContain("Use for a choice made and its rationale.");
-    expect(description).not.toContain("Use for investigation notes and findings.");
-  });
-
-  test("transform replay does not duplicate tool registration", async () => {
-    const h = harness(); await h.start();
-    h.replay();
-    expect([...h.definitions.keys()].sort()).toEqual(["journal_read", "journal_search", "journal_write"]);
-  });
-
-  test("explicit false opts out without tools", async () => {
-    await writeConfig({ journal: { enabled: false } });
-    const h = harness(); await h.start();
-    expect([...h.definitions.keys()]).toEqual([]);
-  });
-
-  test("invalid journal typo fails closed and warns", async () => {
-    await writeConfig({ journal: { enabled_: false } });
-    const warnings: unknown[][] = [];
-    const originalWarn = console.warn;
-    console.warn = (...args) => warnings.push(args);
-    try {
-      const h = harness(); await h.start();
-      expect([...h.definitions.keys()]).toEqual([]);
-      expect(warnings).toEqual([[`[agent-memory] journal config ${configPath}: schema validation failed; journal tools will NOT be registered`]]);
-    } finally { console.warn = originalWarn; }
-  });
-
-  test("fails closed on unreadable config", async () => {
-    await writeConfig(undefined);
-    const warnings: unknown[][] = [];
-    const originalWarn = console.warn;
-    console.warn = (...args) => warnings.push(args);
-    try {
-      const h = harness(); await h.start();
-      expect([...h.definitions.keys()]).toEqual([]);
-      expect(warnings).toEqual([[`[agent-memory] journal config ${configPath}: read failed (EISDIR); journal tools will NOT be registered`]]);
-    } finally { console.warn = originalWarn; }
-  });
-
-  test("fails closed on malformed config", async () => {
-    await writeConfig("not json{{{");
-    const warnings: unknown[][] = [];
-    const originalWarn = console.warn;
-    console.warn = (...args) => warnings.push(args);
-    try {
-      const h = harness(); await h.start();
-      expect([...h.definitions.keys()]).toEqual([]);
-      expect(warnings).toEqual([[`[agent-memory] journal config ${configPath}: malformed JSON; journal tools will NOT be registered`]]);
-    } finally { console.warn = originalWarn; }
-  });
-
-  test("fails closed on invalid config", async () => {
-    await writeConfig({ journal: { enabled: "yes" } });
-    const warnings: unknown[][] = [];
-    const originalWarn = console.warn;
-    console.warn = (...args) => warnings.push(args);
-    try {
-      const h = harness(); await h.start();
-      expect([...h.definitions.keys()]).toEqual([]);
-      expect(warnings).toEqual([[`[agent-memory] journal config ${configPath}: schema validation failed; journal tools will NOT be registered`]]);
-    } finally { console.warn = originalWarn; }
-  });
-
-  test("default absent config emits no warning", async () => {
-    const warnings: unknown[][] = [];
-    const originalWarn = console.warn;
-    console.warn = (...args) => warnings.push(args);
-    try { const h = harness(); await h.start(); expect(warnings).toEqual([]); }
-    finally { console.warn = originalWarn; }
-  });
-
-  test("captures model/provider per session for interleaved context events", async () => {
-    const h = harness(); await h.start();
-    const hook = h.contextHook()!;
-    hook({ sessionID: "session-a", model: { id: "model-a", providerID: "provider-a" } });
-    hook({ sessionID: "session-b", model: { id: "model-b", providerID: "provider-b" } });
-    hook({ sessionID: "session-a", model: { id: "model-a2", providerID: "provider-a2" } });
-    await h.definitions.get("journal_write").execute({ title: "Title", body: "Body" }, { agent: "agent", sessionID: "session-b" });
-    const files = (await fs.readdir(journalDir)).filter((f) => f.endsWith(".md"));
-    expect(files).toHaveLength(1);
-    const text = await fs.readFile(path.join(journalDir, files[0]!), "utf-8");
-    expect(text).toContain("model: model-b");
-    expect(text).toContain("provider: provider-b");
-    expect(text).toContain("session_id: session-b");
-  });
-});
-
-describe("project journal index injection", () => {
-  const event = () => ({ sessionID: "s", model: { id: "m", providerID: "p" }, system: [] as Array<{ type: "text"; text: string }> });
-  async function project(body?: string) {
-    const directory = await fs.mkdtemp(path.join(os.tmpdir(), "memory-index-"));
-    if (body !== undefined) await fs.writeFile(path.join(directory, "MEMORY.md"), body);
-    return directory;
-  }
-
-  test("injects a byte-stable rendered index at exact word fit", async () => {
-    const directory = await project(Array(330).fill("pointer").join(" "));
-    try {
-      const h = harness(directory); await h.start();
-      const first = event(); const second = event();
-      await h.contextHook()!(first); await h.contextHook()!(second);
-      expect(first.system).toEqual(second.system);
-      expect(first.system).toHaveLength(1);
-      expect(first.system[0]!.text).toBe(`This is the project's journal-pointer index (MEMORY.md at the repository root). Retrieve entries with journal_search/journal_read; older lines remain relevant.\n\n${Array(330).fill("pointer").join(" ")}`);
-    } finally { await fs.rm(directory, { recursive: true, force: true }); }
-  });
-
-  test("331 words injects only the fixed notice", async () => {
-    const directory = await project(Array(331).fill("pointer").join(" "));
-    try { const h = harness(directory); await h.start(); const e = event(); await h.contextHook()!(e); expect(e.system).toEqual([{ type: "text", text: "Project journal index (MEMORY.md) exceeds the injection cap; read the file at the repository root directly for the pointer list." }]); }
-    finally { await fs.rm(directory, { recursive: true, force: true }); }
-  });
-
-  test("empty, missing, and unreadable indexes inject nothing", async () => {
-    const empty = await project("  \n\t");
-    const missing = await project();
-    const unreadable = path.join(os.tmpdir(), `memory-index-file-${Date.now()}`);
-    await fs.writeFile(unreadable, "not a directory");
-    try {
-      for (const directory of [empty, missing, unreadable]) {
-        const h = harness(directory); await h.start(); const e = event(); await h.contextHook()!(e); expect(e.system).toEqual([]);
-      }
-    } finally {
-      await fs.rm(empty, { recursive: true, force: true });
-      await fs.rm(missing, { recursive: true, force: true });
-      await fs.rm(unreadable, { force: true });
-    }
-  });
-
-  test("strips frontmatter; enforces UTF-8 byte cap for long Unicode tokens", async () => {
-    const directory = await project(`---\ntitle: hidden\n---\nvisible pointer`);
-    try { const h = harness(directory); await h.start(); const e = event(); await h.contextHook()!(e); expect(e.system[0]!.text).toContain("\n\nvisible pointer"); expect(e.system[0]!.text).not.toContain("hidden"); }
-    finally { await fs.rm(directory, { recursive: true, force: true }); }
-    const large = await project("界".repeat(8192));
-    try { const h = harness(large); await h.start(); const e = event(); await h.contextHook()!(e); expect(e.system[0]!.text).toBe("Project journal index (MEMORY.md) exceeds the injection cap; read the file at the repository root directly for the pointer list."); }
-    finally { await fs.rm(large, { recursive: true, force: true }); }
-  });
-
-  test("disabled journal registers no hook or injection", async () => {
-    const directory = await project("pointer");
-    try { await writeConfig({ journal: { enabled: false } }); const h = harness(directory); await h.start(); expect(h.contextHook()).toBeUndefined(); }
-    finally { await fs.rm(directory, { recursive: true, force: true }); }
-  });
-});

package/src/test-suite.test.ts

@@ -1,15 +0,0 @@
-import { expect, test } from "bun:test";
-import * as fs from "node:fs/promises";
-
-// Guards the two-process test split in package.json: every test file in
-// src/ must be listed in exactly one group, or it silently never runs.
-const CORE = ["doctor.test.ts", "embeddings.test.ts", "journal.test.ts", "test-suite.test.ts", "tools.test.ts"];
-const PLUGIN = ["plugin-disabled.test.ts", "plugin.test.ts"];
-
-test("every test file is covered by the test:core/test:plugin split", async () => {
-  const files = (await fs.readdir(import.meta.dir))
-    .filter((f) => f.endsWith(".test.ts"))
-    .sort();
-  const covered = [...CORE, ...PLUGIN].sort();
-  expect(files).toEqual(covered);
-});

package/src/tools.test.ts

@@ -1,115 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { JournalRead, JournalSearch, JournalWrite } from "./tools";
-import type { JournalContext } from "./tools";
-import type { JournalEntry, JournalStore } from "./journal";
-
-const context: JournalContext = { directory: "/tmp/project", model: "m", provider: "p" };
-function entry(): JournalEntry {
-  return { id: "20260101-000000-000", title: "Title", project: "/tmp", model: "m", provider: "p", agent: "a", sessionId: "s", created: new Date("2026-01-01T00:00:00.000Z"), tags: ["tag"], body: "Body", filePath: "/tmp/entry.md" };
-}
-const baseStore: JournalStore = {
-  write: async () => entry(),
-  read: async () => entry(),
-  search: async () => ({ entries: [entry()], total: 1, allTags: ["tag"] }),
-};
-
-function valid(schema: any, value: any): boolean {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-  if (schema.additionalProperties === false && Object.keys(value).some((key) => !(key in schema.properties))) return false;
-  if (schema.required?.some((key: string) => !(key in value))) return false;
-  for (const [key, field] of Object.entries<any>(schema.properties)) {
-    if (!(key in value)) continue;
-    const actual = value[key];
-    if (field.type === "string" && typeof actual !== "string") return false;
-    if (field.type === "integer" && (!Number.isInteger(actual) || actual < (field.minimum ?? -Infinity))) return false;
-  }
-  return true;
-}
-
-describe("v2 journal tools", () => {
-  test("preserves the recognizable names and descriptions", () => {
-    expect([JournalWrite(baseStore, context).name, JournalRead(baseStore).name, JournalSearch(baseStore).name]).toEqual(["journal_write", "journal_read", "journal_search"]);
-    expect(JournalWrite(baseStore, context).description).toContain("append-only");
-    expect(JournalRead(baseStore).description).toContain("by its ID");
-    expect(JournalSearch(baseStore).description).toContain("semantic similarity");
-  });
-
-  test("journal_write description preserves its behavioral guidance", () => {
-    const description = JournalWrite(baseStore, context).description;
-    expect(description).toMatch(/insights.*discoveries|discoveries.*decisions/i);
-    expect(description).toMatch(/insights.*technical discoveries.*design decisions.*observations/i);
-    expect(description).toMatch(/never edit old ones/i);
-    expect(description).toMatch(/comma-separated/i);
-    expect(description).not.toMatch(/\d{4}-\d{2}-\d{2}T/);
-    expect(description).not.toContain("Suggested tags:");
-    const tagged = JournalWrite(baseStore, context, [{ name: "focus", description: "private detail" }]).description;
-    expect(tagged).toContain("Suggested tags: focus.");
-    expect(tagged).not.toContain("private detail");
-  });
-
-  test("read and search descriptions retain their distinct contracts", () => {
-    const read = JournalRead(baseStore).description;
-    expect(read).not.toMatch(/append.only|cannot be (edited|modified)/i);
-    expect(read).not.toMatch(/\d{4}-\d{2}-\d{2}T/);
-    const search = JournalSearch(baseStore);
-    expect(search.description).toMatch(/filters are optional/i);
-    expect(search.description).toMatch(/global across all projects/i);
-    expect(search.input.properties).toHaveProperty("project");
-    expect(search.input.properties).toHaveProperty("offset");
-    expect(search.description).toMatch(/paginate/i);
-  });
-
-  test("descriptions are nonempty and do not name sibling tools", () => {
-    const descriptions = [JournalWrite(baseStore, context).description, JournalRead(baseStore).description, JournalSearch(baseStore).description];
-    expect(descriptions.every((description) => description.trim().length > 0)).toBe(true);
-    for (const [index, description] of descriptions.entries()) {
-      for (const [otherIndex, name] of ["journal_write", "journal_read", "journal_search"].entries()) {
-        if (index !== otherIndex) expect(description).not.toContain(name);
-      }
-    }
-  });
-
-  test("uses JSON schemas, rejects malformed and unknown arguments", () => {
-    const write = JournalWrite(baseStore, context).input as any;
-    const read = JournalRead(baseStore).input as any;
-    const search = JournalSearch(baseStore).input as any;
-    expect(write.type).toBe("object");
-    expect(valid(write, { title: "t", body: "b" })).toBe(true);
-    expect(valid(write, { title: 4, body: "b" })).toBe(false);
-    expect(valid(write, { title: "t", body: "b", extra: true })).toBe(false);
-    expect(valid(read, {})).toBe(false);
-    expect(valid(read, { id: "id", extra: 1 })).toBe(false);
-    expect(valid(search, { limit: 0 })).toBe(false);
-    expect(valid(search, { offset: 1.5 })).toBe(false);
-    expect(valid(search, { unexpected: true })).toBe(false);
-    expect(valid(search, { tags: "a,b", limit: 2, offset: 0 })).toBe(true);
-  });
-
-  test("all execute methods return the v2 {content} result", async () => {
-    const writeResult = await JournalWrite(baseStore, context).execute({ title: "t", body: "b" }, { agent: "a", sessionID: "s" });
-    const readResult = await JournalRead(baseStore).execute({ id: "entry" }, {} as any);
-    const searchResult = await JournalSearch(baseStore).execute({}, {} as any);
-    for (const result of [writeResult, readResult, searchResult]) {
-      expect(Object.keys(result)).toEqual(["content"]);
-      expect(typeof result.content).toBe("string");
-    }
-    expect(writeResult.content).toContain("Journal entry created:");
-    expect(readResult.content).toContain("Body");
-    expect(searchResult.content).toContain("Found 1 entries");
-  });
-
-  test("retains bounded tag inventory output formatting", async () => {
-    const populated: JournalStore = { ...baseStore, search: async () => ({ entries: [entry()], total: 1, allTags: ["alpha", "beta"] }) };
-    expect((await JournalSearch(populated).execute({}, {} as any)).content).toContain("Tags in use: alpha, beta");
-    const empty: JournalStore = { ...baseStore, search: async () => ({ entries: [], total: 0, allTags: [] }) };
-    expect((await JournalSearch(empty).execute({}, {} as any)).content).toBe("No journal entries found.");
-    const store: JournalStore = { ...baseStore, search: async () => ({ entries: [], total: 0, allTags: Array.from({ length: 21 }, (_, i) => `tag-${i}`) }) };
-    const result = await JournalSearch(store).execute({}, {} as any);
-    expect(result.content).toBe("No journal entries found.\nTags in use: 21 (filter with tags=...)");
-  });
-
-  test("journal_read formats metadata before the body", async () => {
-    const result = await JournalRead(baseStore).execute({ id: "entry" }, {} as any);
-    expect(result.content).toBe("title: Title\ncreated: 2026-01-01T00:00:00.000Z\nproject: /tmp\nmodel: m\nprovider: p\nagent: a\nsession: s\ntags: tag\n\nBody");
-  });
-});