@ghilteras/opencode-agent-memory 0.3.0

package/src/journal.test.ts

@@ -0,0 +1,384 @@
+import { afterEach, describe, expect, mock, test } from "bun:test";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+
+import { createJournalStore, loadConfig } from "./journal";
+
+// Mock the embeddings module to avoid downloading a real model in tests
+mock.module("./embeddings", () => ({
+  generateEmbedding: async (text: string) => {
+    // Deterministic fake embedding based on text content
+    const hash = Array.from(text).reduce(
+      (acc, c) => ((acc << 5) - acc + c.charCodeAt(0)) | 0,
+      0,
+    );
+    return Array.from({ length: 8 }, (_, i) => Math.sin(hash + i));
+  },
+  cosineSimilarity: (a: number[], b: number[]) => {
+    let dot = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < a.length; i++) {
+      const ai = a[i]!;
+      const bi = b[i]!;
+      dot += ai * bi;
+      normA += ai * ai;
+      normB += bi * bi;
+    }
+    const denom = Math.sqrt(normA) * Math.sqrt(normB);
+    return denom === 0 ? 0 : dot / denom;
+  },
+}));
+
+async function mkTmpDir(): Promise<string> {
+  return fs.mkdtemp(path.join("/tmp/", "opencode-journal-"));
+}
+
+describe("loadConfig", () => {
+  test("returns empty config when file does not exist", async () => {
+    const dir = await mkTmpDir();
+    const config = await loadConfig(dir);
+    expect(config).toEqual({});
+  });
+
+  test("returns parsed config when file is valid", async () => {
+    const dir = await mkTmpDir();
+    await fs.writeFile(
+      path.join(dir, "agent-memory.json"),
+      JSON.stringify({ journal: { enabled: true } }),
+    );
+    const config = await loadConfig(dir);
+    expect(config.journal?.enabled).toBe(true);
+  });
+
+  test("returns empty config when file has invalid JSON", async () => {
+    const dir = await mkTmpDir();
+    await fs.writeFile(path.join(dir, "agent-memory.json"), "not json{{{");
+    const config = await loadConfig(dir);
+    expect(config).toEqual({});
+  });
+
+  test("returns custom tags from config", async () => {
+    const dir = await mkTmpDir();
+    await fs.writeFile(
+      path.join(dir, "agent-memory.json"),
+      JSON.stringify({
+        journal: {
+          enabled: true,
+          tags: [
+            { name: "perf", description: "Performance optimization work" },
+            { name: "debug", description: "Debugging sessions" },
+          ],
+        },
+      }),
+    );
+    const config = await loadConfig(dir);
+    expect(config.journal?.tags).toEqual([
+      { name: "perf", description: "Performance optimization work" },
+      { name: "debug", description: "Debugging sessions" },
+    ]);
+  });
+
+  test("returns empty config when schema validation fails", async () => {
+    const dir = await mkTmpDir();
+    await fs.writeFile(
+      path.join(dir, "agent-memory.json"),
+      JSON.stringify({ journal: { enabled: "yes" } }),
+    );
+    const config = await loadConfig(dir);
+    expect(config).toEqual({});
+  });
+});
+
+describe("journal store", () => {
+  let tmpDir: string;
+
+  afterEach(async () => {
+    if (tmpDir) {
+      await fs.rm(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  test("write creates entry file with correct metadata", async () => {
+    tmpDir = await mkTmpDir();
+    const store = createJournalStore(tmpDir);
+
+    const entry = await store.write({
+      title: "Test insight",
+      body: "Discovered an interesting pattern.",
+      project: "/home/user/project",
+      model: "claude-opus-4-6",
+      provider: "anthropic",
+      tags: ["testing"],
+    });
+
+    expect(entry.title).toBe("Test insight");
+    expect(entry.project).toBe("/home/user/project");
+    expect(entry.model).toBe("claude-opus-4-6");
+    expect(entry.provider).toBe("anthropic");
+    expect(entry.tags).toEqual(["testing"]);
+    expect(entry.body).toBe("Discovered an interesting pattern.");
+    expect(entry.id).toMatch(/^\d{8}-\d{6}-\d{3}$/);
+
+    // Verify file exists
+    const raw = await fs.readFile(entry.filePath, "utf-8");
+    expect(raw).toContain("title: Test insight");
+  });
+
+  test("write generates chronological filenames", async () => {
+    tmpDir = await mkTmpDir();
+    const store = createJournalStore(tmpDir);
+
+    const e1 = await store.write({ title: "First", body: "First entry" });
+    // Small delay to ensure different timestamp
+    await new Promise((r) => setTimeout(r, 5));
+    const e2 = await store.write({ title: "Second", body: "Second entry" });
+
+    expect(e2.id > e1.id).toBe(true);
+  });
+
+  test("write saves embedding file alongside entry", async () => {
+    tmpDir = await mkTmpDir();
+    const store = createJournalStore(tmpDir);
+
+    const entry = await store.write({
+      title: "Embedding test",
+      body: "This should get an embedding.",
+    });
+
+    const embeddingFile = entry.filePath.replace(/\.md$/, ".embedding");
+    const raw = await fs.readFile(embeddingFile, "utf-8");
+    const embedding = JSON.parse(raw);
+    expect(Array.isArray(embedding)).toBe(true);
+    expect(embedding.length).toBeGreaterThan(0);
+  });
+
+  test("read returns full entry by id", async () => {
+    tmpDir = await mkTmpDir();
+    const store = createJournalStore(tmpDir);
+
+    const written = await store.write({
+      title: "Read test",
+      body: "Read me back.",
+      tags: ["test", "read"],
+    });
+
+    const read = await store.read(written.id);
+    expect(read.title).toBe("Read test");
+    expect(read.body).toBe("Read me back.");
+    expect(read.tags).toEqual(["test", "read"]);
+  });
+
+  test("read throws for nonexistent id", async () => {
+    tmpDir = await mkTmpDir();
+    const store = createJournalStore(tmpDir);
+
+    expect(store.read("99990101-000000-000")).rejects.toThrow(
+      "Journal entry not found",
+    );
+  });
+
+  test("read rejects path traversal", async () => {
+    tmpDir = await mkTmpDir();
+    const store = createJournalStore(tmpDir);
+
+    expect(store.read("../../../etc/passwd")).rejects.toThrow(
+      "Invalid journal entry ID",
+    );
+  });
+
+  test("search with no filters returns recent entries", async () => {
+    tmpDir = await mkTmpDir();
+    const store = createJournalStore(tmpDir);
+
+    await store.write({ title: "Entry 1", body: "First" });
+    await new Promise((r) => setTimeout(r, 5));
+    await store.write({ title: "Entry 2", body: "Second" });
+    await new Promise((r) => setTimeout(r, 5));
+    await store.write({ title: "Entry 3", body: "Third" });
+
+    const result = await store.search({});
+    expect(result.total).toBe(3);
+    expect(result.entries.length).toBe(3);
+    // Newest first (by recency score)
+    expect(result.entries[0]!.title).toBe("Entry 3");
+    expect(result.entries[2]!.title).toBe("Entry 1");
+  });
+
+  test("search filters by tags", async () => {
+    tmpDir = await mkTmpDir();
+    const store = createJournalStore(tmpDir);
+
+    await store.write({
+      title: "Tagged",
+      body: "...",
+      tags: ["rust", "perf"],
+    });
+    await new Promise((r) => setTimeout(r, 5));
+    await store.write({
+      title: "Other",
+      body: "...",
+      tags: ["python"],
+    });
+
+    const result = await store.search({ tags: ["rust"] });
+    expect(result.total).toBe(1);
+    expect(result.entries[0]!.title).toBe("Tagged");
+  });
+
+  test("search filters by project", async () => {
+    tmpDir = await mkTmpDir();
+    const store = createJournalStore(tmpDir);
+
+    await store.write({ title: "Project A", body: "...", project: "/proj/a" });
+    await new Promise((r) => setTimeout(r, 5));
+    await store.write({ title: "Project B", body: "...", project: "/proj/b" });
+
+    const result = await store.search({ project: "/proj/a" });
+    expect(result.total).toBe(1);
+    expect(result.entries[0]!.title).toBe("Project A");
+  });
+
+  test("search combines filters with AND logic", async () => {
+    tmpDir = await mkTmpDir();
+    const store = createJournalStore(tmpDir);
+
+    await store.write({
+      title: "Match",
+      body: "...",
+      tags: ["rust"],
+      project: "/proj/a",
+    });
+    await new Promise((r) => setTimeout(r, 5));
+    await store.write({
+      title: "Wrong tags",
+      body: "...",
+      tags: ["python"],
+      project: "/proj/a",
+    });
+    await new Promise((r) => setTimeout(r, 5));
+    await store.write({
+      title: "Wrong project",
+      body: "...",
+      tags: ["rust"],
+      project: "/proj/b",
+    });
+
+    const result = await store.search({
+      tags: ["rust"],
+      project: "/proj/a",
+    });
+    expect(result.total).toBe(1);
+    expect(result.entries[0]!.title).toBe("Match");
+  });
+
+  test("search respects limit", async () => {
+    tmpDir = await mkTmpDir();
+    const store = createJournalStore(tmpDir);
+
+    for (let i = 0; i < 5; i++) {
+      await store.write({ title: `Entry ${i}`, body: `Body ${i}` });
+      await new Promise((r) => setTimeout(r, 5));
+    }
+
+    const result = await store.search({ limit: 2 });
+    expect(result.entries.length).toBe(2);
+    expect(result.total).toBe(5);
+  });
+
+  test("search supports offset pagination", async () => {
+    tmpDir = await mkTmpDir();
+    const store = createJournalStore(tmpDir);
+
+    for (let i = 0; i < 5; i++) {
+      await store.write({ title: `Entry ${i}`, body: `Body ${i}` });
+      await new Promise((r) => setTimeout(r, 5));
+    }
+
+    const page1 = await store.search({ limit: 2, offset: 0 });
+    expect(page1.entries.length).toBe(2);
+    expect(page1.total).toBe(5);
+    // Newest first
+    expect(page1.entries[0]!.title).toBe("Entry 4");
+    expect(page1.entries[1]!.title).toBe("Entry 3");
+
+    const page2 = await store.search({ limit: 2, offset: 2 });
+    expect(page2.entries.length).toBe(2);
+    expect(page2.total).toBe(5);
+    expect(page2.entries[0]!.title).toBe("Entry 2");
+    expect(page2.entries[1]!.title).toBe("Entry 1");
+
+    const page3 = await store.search({ limit: 2, offset: 4 });
+    expect(page3.entries.length).toBe(1);
+    expect(page3.entries[0]!.title).toBe("Entry 0");
+
+    // Past the end
+    const page4 = await store.search({ limit: 2, offset: 10 });
+    expect(page4.entries.length).toBe(0);
+    expect(page4.total).toBe(5);
+  });
+
+  test("search handles empty journal directory", async () => {
+    tmpDir = await mkTmpDir();
+    const store = createJournalStore(tmpDir);
+
+    const result = await store.search({});
+    expect(result.entries.length).toBe(0);
+    expect(result.total).toBe(0);
+    expect(result.allTags).toEqual([]);
+  });
+
+  test("search returns allTags from all entries regardless of filters", async () => {
+    tmpDir = await mkTmpDir();
+    const store = createJournalStore(tmpDir);
+
+    await store.write({
+      title: "Rust work",
+      body: "...",
+      tags: ["rust", "perf"],
+    });
+    await new Promise((r) => setTimeout(r, 5));
+    await store.write({
+      title: "Python work",
+      body: "...",
+      tags: ["python", "testing"],
+    });
+
+    // Filter to only rust tag — allTags should still include all tags
+    const result = await store.search({ tags: ["rust"] });
+    expect(result.total).toBe(1);
+    expect(result.allTags).toEqual(["perf", "python", "rust", "testing"]);
+  });
+
+  test("search allTags deduplicates across entries", async () => {
+    tmpDir = await mkTmpDir();
+    const store = createJournalStore(tmpDir);
+
+    await store.write({ title: "A", body: "...", tags: ["rust", "perf"] });
+    await new Promise((r) => setTimeout(r, 5));
+    await store.write({ title: "B", body: "...", tags: ["rust", "debugging"] });
+
+    const result = await store.search({});
+    expect(result.allTags).toEqual(["debugging", "perf", "rust"]);
+  });
+
+  test("search by text uses semantic matching", async () => {
+    tmpDir = await mkTmpDir();
+    const store = createJournalStore(tmpDir);
+
+    await store.write({
+      title: "Rust performance",
+      body: "Optimized the hot loop using SIMD instructions.",
+    });
+    await new Promise((r) => setTimeout(r, 5));
+    await store.write({
+      title: "Python testing",
+      body: "Set up pytest with coverage reporting.",
+    });
+
+    // With mock embeddings, text search falls through to semantic matching
+    const result = await store.search({ text: "Rust performance" });
+    // Should find at least the matching entry
+    expect(result.total).toBeGreaterThan(0);
+  });
+});