@mingxy/cerebro 1.20.4 → 1.20.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mingxy/cerebro",
-  "version": "1.20.4",
+  "version": "1.20.6",
   "description": "Cerebro persistent memory plugin for OpenCode — auto-recall, auto-capture, 9 memory tools with clustering, project-scoped memory isolation",
   "type": "module",
   "main": "src/index.ts",
@@ -20,7 +20,10 @@
   ],
   "scripts": {
     "build:web": "bash ../../scripts/build-plugin-web.sh",
-    "prepublishOnly": "npm run build:web && npx tsc --noEmit"
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "prepublishOnly": "npm run build:web && npx tsc --noEmit -p tsconfig.publish.json"
   },
   "keywords": [
     "opencode",
@@ -51,6 +54,7 @@
   },
   "devDependencies": {
     "@types/node": "^25.5.0",
-    "typescript": "^5.7.0"
+    "typescript": "^5.7.0",
+    "vitest": "^4.1.7"
   }
 }

package/src/client.test.ts

@@ -0,0 +1,373 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { CerebroClient } from "./client.js";
+
+// sanitizeContent and truncateQuery are not exported, so we test them indirectly
+// through CerebroClient methods. For direct testing we re-implement the logic check
+// via the client's behavior, or we can access the module's internals.
+
+// Actually, sanitizeContent and truncateQuery are module-level (not exported).
+// We test them via CerebroClient methods that use them.
+
+function makeFetchMock(
+  status = 200,
+  body: unknown = {},
+  opts?: { statusText?: string; headers?: Record<string, string> },
+) {
+  return vi.fn().mockResolvedValue(
+    new Response(
+      typeof body === "string" ? body : JSON.stringify(body),
+      {
+        status,
+        statusText: opts?.statusText ?? "OK",
+        headers: opts?.headers,
+      },
+    ),
+  );
+}
+
+describe("sanitizeContent (via createMemory)", () => {
+  let client: CerebroClient;
+  let fetchMock: ReturnType<typeof makeFetchMock>;
+
+  beforeEach(() => {
+    fetchMock = makeFetchMock(200, { id: "1" });
+    vi.stubGlobal("fetch", fetchMock);
+    client = new CerebroClient("http://localhost:8080", "test-key");
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("strips XML tags from content", async () => {
+    await client.createMemory('Hello <thinking>bad</thinking> world');
+    const body = JSON.parse(fetchMock.mock.calls[0][1].body as string);
+    expect(body.content).toBe("Hello world");
+  });
+
+  it("strips self-closing XML tags", async () => {
+    await client.createMemory('Text <br/> more text');
+    const body = JSON.parse(fetchMock.mock.calls[0][1].body as string);
+    expect(body.content).toBe("Text more text");
+  });
+
+  it("collapses whitespace", async () => {
+    await client.createMemory("hello   world\n\nfoo\tbar");
+    const body = JSON.parse(fetchMock.mock.calls[0][1].body as string);
+    expect(body.content).toBe("hello world foo bar");
+  });
+
+  it("truncates content exceeding maxLen with ellipsis marker", async () => {
+    const longContent = "a".repeat(3001);
+    await client.createMemory(longContent);
+    const body = JSON.parse(fetchMock.mock.calls[0][1].body as string);
+    expect(body.content).toBe("a".repeat(3000) + "…[truncated]");
+  });
+
+  it("passes through content under maxLen unchanged", async () => {
+    const shortContent = "hello world";
+    await client.createMemory(shortContent);
+    const body = JSON.parse(fetchMock.mock.calls[0][1].body as string);
+    expect(body.content).toBe(shortContent);
+  });
+
+  it("trims leading/trailing whitespace", async () => {
+    await client.createMemory("  hello  ");
+    const body = JSON.parse(fetchMock.mock.calls[0][1].body as string);
+    expect(body.content).toBe("hello");
+  });
+});
+
+describe("truncateQuery (via searchMemories)", () => {
+  let client: CerebroClient;
+  let fetchMock: ReturnType<typeof makeFetchMock>;
+
+  beforeEach(() => {
+    fetchMock = makeFetchMock(200, { results: [] });
+    vi.stubGlobal("fetch", fetchMock);
+    client = new CerebroClient("http://localhost:8080", "test-key");
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("truncates query exceeding maxLen", async () => {
+    const longQuery = "q".repeat(201);
+    await client.searchMemories(longQuery);
+    const url = fetchMock.mock.calls[0][0] as string;
+    const params = new URL(url).searchParams;
+    expect(params.get("q")).toBe("q".repeat(200));
+  });
+
+  it("passes through query under maxLen unchanged", async () => {
+    const shortQuery = "hello";
+    await client.searchMemories(shortQuery);
+    const url = fetchMock.mock.calls[0][0] as string;
+    const params = new URL(url).searchParams;
+    expect(params.get("q")).toBe(shortQuery);
+  });
+});
+
+describe("CerebroClient constructor", () => {
+  it("removes trailing slashes from baseUrl", () => {
+    const client = new CerebroClient("http://localhost:8080///", "key");
+    // Access internal baseUrl via a fetch call
+    const fetchMock = makeFetchMock(200, {});
+    vi.stubGlobal("fetch", fetchMock);
+    client.getMemory("id");
+    const url = fetchMock.mock.calls[0][0] as string;
+    expect(url).toBe("http://localhost:8080/v1/memories/id");
+    vi.restoreAllMocks();
+  });
+});
+
+describe("CerebroClient HTTP methods", () => {
+  let client: CerebroClient;
+  let fetchMock: ReturnType<typeof makeFetchMock>;
+
+  beforeEach(() => {
+    fetchMock = makeFetchMock(200, { id: "m1", content: "test" });
+    vi.stubGlobal("fetch", fetchMock);
+    client = new CerebroClient("http://localhost:8080", "test-key");
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("createMemory sends POST /v1/memories", async () => {
+    await client.createMemory("test content", ["tag1"], "source", "project", "agent1", "sess1");
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    const [url, init] = fetchMock.mock.calls[0];
+    expect(url).toBe("http://localhost:8080/v1/memories");
+    expect(init.method).toBe("POST");
+    expect(init.headers["X-API-Key"]).toBe("test-key");
+    expect(init.headers["Content-Type"]).toBe("application/json");
+    const body = JSON.parse(init.body as string);
+    expect(body.content).toBe("test content");
+    expect(body.tags).toEqual(["tag1"]);
+    expect(body.source).toBe("source");
+    expect(body.scope).toBe("project");
+    expect(body.agent_id).toBe("agent1");
+    expect(body.session_id).toBe("sess1");
+  });
+
+  it("searchMemories sends GET /v1/memories/search with params", async () => {
+    const results = await client.searchMemories("hello", 5, "project", ["t1"], "/path");
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    const url = fetchMock.mock.calls[0][0] as string;
+    expect(url).toContain("/v1/memories/search?");
+    expect(url).toContain("q=hello");
+    expect(url).toContain("limit=5");
+    expect(url).toContain("scope=project");
+    expect(url).toContain("tags=t1");
+    expect(url).toContain("project_path=%2Fpath");
+    expect(results).toEqual([]);
+  });
+
+  it("getMemory sends GET /v1/memories/:id", async () => {
+    const mem = await client.getMemory("abc-123");
+    const [url, init] = fetchMock.mock.calls[0];
+    expect(url).toBe("http://localhost:8080/v1/memories/abc-123");
+    expect(init.method).toBeUndefined(); // default GET
+    expect(mem).toEqual({ id: "m1", content: "test" });
+  });
+
+  it("getMemory encodes id with special characters", async () => {
+    await client.getMemory("id with spaces");
+    const url = fetchMock.mock.calls[0][0] as string;
+    expect(url).toContain("/v1/memories/id%20with%20spaces");
+  });
+
+  it("updateMemory sends PUT /v1/memories/:id", async () => {
+    await client.updateMemory("m1", "new content", ["t1", "t2"]);
+    const [url, init] = fetchMock.mock.calls[0];
+    expect(url).toBe("http://localhost:8080/v1/memories/m1");
+    expect(init.method).toBe("PUT");
+    const body = JSON.parse(init.body as string);
+    expect(body.content).toBe("new content");
+    expect(body.tags).toEqual(["t1", "t2"]);
+  });
+
+  it("deleteMemory sends DELETE /v1/memories/:id", async () => {
+    fetchMock = vi.fn().mockResolvedValue(new Response(null, { status: 204, statusText: "No Content" }));
+    vi.stubGlobal("fetch", fetchMock);
+    await client.deleteMemory("m1");
+    const [url, init] = fetchMock.mock.calls[0];
+    expect(url).toBe("http://localhost:8080/v1/memories/m1");
+    expect(init.method).toBe("DELETE");
+  });
+
+  it("ingestMessages sends POST /v1/memories with sanitized messages", async () => {
+    await client.ingestMessages(
+      [
+        { role: "user", content: "hello <thinking>hidden</thinking>" },
+        { role: "assistant", content: "world" },
+      ],
+      { mode: "raw", agentId: "a1", sessionId: "s1", tags: ["t1"] },
+    );
+    const [url, init] = fetchMock.mock.calls[0];
+    expect(url).toBe("http://localhost:8080/v1/memories");
+    expect(init.method).toBe("POST");
+    const body = JSON.parse(init.body as string);
+    expect(body.messages).toEqual([
+      { role: "user", content: "hello" },
+      { role: "assistant", content: "world" },
+    ]);
+    expect(body.mode).toBe("raw");
+    expect(body.agent_id).toBe("a1");
+    expect(body.session_id).toBe("s1");
+    expect(body.tags).toEqual(["t1"]);
+  });
+});
+
+describe("CerebroClient error handling", () => {
+  let client: CerebroClient;
+
+  beforeEach(() => {
+    client = new CerebroClient("http://localhost:8080", "test-key");
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("throws on HTTP error response", async () => {
+    const fetchMock = makeFetchMock(500, "internal error", { statusText: "Internal Server Error" });
+    vi.stubGlobal("fetch", fetchMock);
+    await expect(client.getMemory("id")).rejects.toThrow("[cerebro] 500 Internal Server Error: internal error");
+  });
+
+  it("throws on HTTP 4xx response", async () => {
+    const fetchMock = makeFetchMock(403, "forbidden body", { statusText: "Forbidden" });
+    vi.stubGlobal("fetch", fetchMock);
+    await expect(client.getMemory("id")).rejects.toThrow("[cerebro] 403 Forbidden: forbidden body");
+  });
+
+  it("throws on timeout (AbortError)", async () => {
+    const fetchMock = vi.fn().mockImplementation(() => {
+      const err = new DOMException("The operation was aborted", "AbortError");
+      throw err;
+    });
+    vi.stubGlobal("fetch", fetchMock);
+    // Use a client with very short timeout
+    const fastClient = new CerebroClient("http://localhost:8080", "key", {
+      connection: { requestTimeoutMs: 1 },
+    });
+    await expect(fastClient.getMemory("id")).rejects.toThrow("[cerebro] Request timed out (1ms)");
+  });
+
+  it("returns null for 204 No Content", async () => {
+    const fetchMock = vi.fn().mockResolvedValue(new Response(null, { status: 204, statusText: "No Content" }));
+    vi.stubGlobal("fetch", fetchMock);
+    const result = await client.getMemory("id");
+    expect(result).toBeNull();
+  });
+
+  it("throws on malformed JSON response", async () => {
+    const fetchMock = vi.fn().mockResolvedValue(
+      new Response("not valid json{{{", { status: 200, statusText: "OK" }),
+    );
+    vi.stubGlobal("fetch", fetchMock);
+    await expect(client.getMemory("id")).rejects.toThrow();
+  });
+
+  it("strips BOM from response", async () => {
+    const fetchMock = vi.fn().mockResolvedValue(
+      new Response('\uFEFF{"id":"m1","content":"ok"}', { status: 200 }),
+    );
+    vi.stubGlobal("fetch", fetchMock);
+    const result = await client.getMemory("id");
+    expect(result).toEqual({ id: "m1", content: "ok" });
+  });
+
+  it("returns null for empty response body", async () => {
+    const fetchMock = vi.fn().mockResolvedValue(
+      new Response("", { status: 200 }),
+    );
+    vi.stubGlobal("fetch", fetchMock);
+    const result = await client.getMemory("id");
+    expect(result).toBeNull();
+  });
+});
+
+describe("CerebroClient additional methods", () => {
+  let client: CerebroClient;
+  let fetchMock: ReturnType<typeof makeFetchMock>;
+
+  beforeEach(() => {
+    fetchMock = makeFetchMock(200, { preferences: [] });
+    vi.stubGlobal("fetch", fetchMock);
+    client = new CerebroClient("http://localhost:8080", "test-key");
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("getProfile returns empty array when null", async () => {
+    fetchMock = vi.fn().mockResolvedValue(new Response("null", { status: 200 }));
+    vi.stubGlobal("fetch", fetchMock);
+    const result = await client.getProfile();
+    expect(result).toEqual([]);
+  });
+
+  it("getProfile passes project_path", async () => {
+    fetchMock = makeFetchMock(200, []);
+    vi.stubGlobal("fetch", fetchMock);
+    await client.getProfile("/my/project");
+    const url = fetchMock.mock.calls[0][0] as string;
+    expect(url).toContain("project_path=%2Fmy%2Fproject");
+  });
+
+  it("getInjection returns data", async () => {
+    fetchMock = makeFetchMock(200, { content: "injected", preference_count: 3, estimated_tokens: 100 });
+    vi.stubGlobal("fetch", fetchMock);
+    const result = await client.getInjection();
+    expect(result).toEqual({ content: "injected", preference_count: 3, estimated_tokens: 100 });
+  });
+
+  it("listRecent returns memories array", async () => {
+    fetchMock = makeFetchMock(200, { memories: [{ id: "1" }], limit: 20, offset: 0 });
+    vi.stubGlobal("fetch", fetchMock);
+    const result = await client.listRecent(5);
+    const url = fetchMock.mock.calls[0][0] as string;
+    expect(url).toContain("limit=5");
+    expect(result).toEqual([{ id: "1" }]);
+  });
+
+  it("listSpaces returns empty array when null", async () => {
+    fetchMock = vi.fn().mockResolvedValue(new Response("null", { status: 200 }));
+    vi.stubGlobal("fetch", fetchMock);
+    const result = await client.listSpaces();
+    expect(result).toEqual([]);
+  });
+
+  it("createSpace sends POST /v1/spaces", async () => {
+    fetchMock = makeFetchMock(200, { id: "sp1" });
+    vi.stubGlobal("fetch", fetchMock);
+    await client.createSpace("team1", "team", [{ user_id: "u1", role: "admin" }]);
+    const [url, init] = fetchMock.mock.calls[0];
+    expect(url).toBe("http://localhost:8080/v1/spaces");
+    const body = JSON.parse(init.body as string);
+    expect(body.name).toBe("team1");
+    expect(body.space_type).toBe("team");
+    expect(body.members).toEqual([{ user_id: "u1", role: "admin" }]);
+  });
+
+  it("searchMemories returns empty array when response is null", async () => {
+    fetchMock = vi.fn().mockResolvedValue(new Response("null", { status: 200 }));
+    vi.stubGlobal("fetch", fetchMock);
+    const result = await client.searchMemories("test");
+    expect(result).toEqual([]);
+  });
+
+  it("ingestMessages defaults mode to 'smart'", async () => {
+    fetchMock = makeFetchMock(200, {});
+    vi.stubGlobal("fetch", fetchMock);
+    await client.ingestMessages([{ role: "user", content: "hi" }]);
+    const body = JSON.parse(fetchMock.mock.calls[0][1].body as string);
+    expect(body.mode).toBe("smart");
+  });
+});