@mingxy/cerebro 1.20.4 → 1.20.6

package/src/index.test.ts

@@ -0,0 +1,190 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+// ─── Hoisted mocks ─────────────────────────────────────────────
+
+const { mockReadFileSync, mockWriteFileSync } = vi.hoisted(() => ({
+  mockReadFileSync: vi.fn(),
+  mockWriteFileSync: vi.fn(),
+}));
+
+// ─── Module mocks ──────────────────────────────────────────────
+
+vi.mock("node:fs", () => ({
+  readFileSync: mockReadFileSync,
+  writeFileSync: mockWriteFileSync,
+}));
+
+vi.mock("node:os", () => ({ tmpdir: () => "/test-tmp" }));
+
+vi.mock("node:path", () => ({
+  join: (...args: string[]) => args.join("/"),
+  dirname: (p: string) => p.split("/").slice(0, -1).join("/") || ".",
+}));
+
+vi.mock("node:url", () => ({
+  fileURLToPath: (url: string) => url.replace("file://", "/"),
+}));
+
+vi.mock("@opencode-ai/plugin", () => ({}));
+vi.mock("./client.js", () => ({ CerebroClient: vi.fn() }));
+vi.mock("./hooks.js", () => ({
+  chatMessageRecallHook: vi.fn(),
+  autocontinueHook: vi.fn(),
+  compactingHook: vi.fn(),
+  sessionIdleHook: vi.fn(),
+  sessionMessages: new Map(),
+  firstMessages: new Map(),
+  showToast: vi.fn(),
+}));
+vi.mock("./keywords.js", () => ({
+  detectSaveKeyword: vi.fn(),
+  detectRecallKeyword: vi.fn(),
+  KEYWORD_NUDGE: "",
+  RECALL_NUDGE: "",
+}));
+vi.mock("./tags.js", () => ({
+  getUserTag: vi.fn(() => "user:t"),
+  getProjectTag: vi.fn(() => "project:t"),
+}));
+vi.mock("./tools.js", () => ({ buildTools: vi.fn(() => ({})) }));
+vi.mock("./logger.js", () => ({
+  logInfo: vi.fn(),
+  logDebug: vi.fn(),
+  logError: vi.fn(),
+  setOpencodeClient: vi.fn(),
+}));
+vi.mock("./config.js", () => ({
+  loadPluginConfig: vi.fn(() => ({})),
+  resolveAgentPolicy: vi.fn(),
+}));
+vi.mock("./updater.js", () => ({ checkAndUpdate: vi.fn() }));
+vi.mock("./web-server.js", () => ({
+  startWebServer: vi.fn(),
+  stopWebServer: vi.fn(),
+}));
+
+// ─── Imports ───────────────────────────────────────────────────
+
+import { isAutoStoreEnabled, setAutoStoreEnabled } from "./index.js";
+
+// ─── Helpers ───────────────────────────────────────────────────
+
+function getMap(): Map<string, boolean> {
+  return (globalThis as any).__cerebro_autoStoreMap;
+}
+
+/** Make readFileSync return JSON for a specific sessionId file, throw ENOENT otherwise */
+function stubFileForSession(sessionId: string, data: Record<string, unknown>) {
+  mockReadFileSync.mockImplementation((path: string) => {
+    if (path.includes(`cerebro_autostore_${sessionId}.json`)) {
+      return JSON.stringify(data);
+    }
+    throw new Error("ENOENT");
+  });
+}
+
+// ─── Tests ─────────────────────────────────────────────────────
+
+describe("isAutoStoreEnabled", () => {
+  beforeEach(() => {
+    getMap().clear();
+    mockReadFileSync.mockImplementation(() => { throw new Error("ENOENT"); });
+  });
+
+  it("returns true when sessionId is undefined", () => {
+    expect(isAutoStoreEnabled(undefined)).toBe(true);
+  });
+
+  it("returns cached value from Map (true)", () => {
+    getMap().set("sess-a", true);
+    expect(isAutoStoreEnabled("sess-a")).toBe(true);
+  });
+
+  it("returns cached value from Map (false)", () => {
+    getMap().set("sess-b", false);
+    expect(isAutoStoreEnabled("sess-b")).toBe(false);
+  });
+
+  it("reads from file when Map has no entry (Bug1 fix: restart recovery)", () => {
+    stubFileForSession("sess-file", { enabled: false });
+    expect(isAutoStoreEnabled("sess-file")).toBe(false);
+  });
+
+  it("caches file value back to Map after reading", () => {
+    stubFileForSession("sess-cache", { enabled: false });
+    isAutoStoreEnabled("sess-cache");
+    // Map should now have the value
+    expect(getMap().get("sess-cache")).toBe(false);
+    // Second call uses Map, not file
+    mockReadFileSync.mockImplementation(() => { throw new Error("should not read file again"); });
+    expect(isAutoStoreEnabled("sess-cache")).toBe(false);
+  });
+
+  it("returns true (default) when no Map entry and file does not exist", () => {
+    expect(isAutoStoreEnabled("sess-noexist")).toBe(true);
+  });
+
+  it("handles malformed JSON in file gracefully → returns true", () => {
+    mockReadFileSync.mockImplementation((path: string) => {
+      if (path.includes("cerebro_autostore_sess-bad.json")) return "{invalid";
+      throw new Error("ENOENT");
+    });
+    expect(isAutoStoreEnabled("sess-bad")).toBe(true);
+  });
+
+  it("defaults to true when file has no 'enabled' field", () => {
+    stubFileForSession("sess-nofield", { something: "else" });
+    expect(isAutoStoreEnabled("sess-nofield")).toBe(true);
+  });
+
+  it("reads enabled:true from file correctly", () => {
+    stubFileForSession("sess-on", { enabled: true });
+    expect(isAutoStoreEnabled("sess-on")).toBe(true);
+  });
+});
+
+describe("setAutoStoreEnabled", () => {
+  beforeEach(() => {
+    getMap().clear();
+    mockWriteFileSync.mockImplementation(() => {});
+  });
+
+  it("sets Map entry to true", () => {
+    setAutoStoreEnabled("sess-1", true);
+    expect(getMap().get("sess-1")).toBe(true);
+  });
+
+  it("sets Map entry to false", () => {
+    setAutoStoreEnabled("sess-2", false);
+    expect(getMap().get("sess-2")).toBe(false);
+  });
+
+  it("writes correct JSON { enabled: false } to file", () => {
+    setAutoStoreEnabled("sess-1", false);
+    expect(mockWriteFileSync).toHaveBeenCalledWith(
+      expect.stringContaining("cerebro_autostore_sess-1.json"),
+      JSON.stringify({ enabled: false }),
+    );
+  });
+
+  it("writes correct JSON { enabled: true } to file", () => {
+    setAutoStoreEnabled("sess-2", true);
+    expect(mockWriteFileSync).toHaveBeenCalledWith(
+      expect.stringContaining("cerebro_autostore_sess-2.json"),
+      JSON.stringify({ enabled: true }),
+    );
+  });
+
+  it("handles write error gracefully — Map still updated", () => {
+    mockWriteFileSync.mockImplementation(() => { throw new Error("disk full"); });
+    expect(() => setAutoStoreEnabled("sess-err", true)).not.toThrow();
+    expect(getMap().get("sess-err")).toBe(true);
+  });
+
+  it("round-trip: set then get returns consistent value", () => {
+    setAutoStoreEnabled("sess-rt", false);
+    expect(isAutoStoreEnabled("sess-rt")).toBe(false);
+    setAutoStoreEnabled("sess-rt", true);
+    expect(isAutoStoreEnabled("sess-rt")).toBe(true);
+  });
+});

package/src/index.ts

@@ -33,7 +33,17 @@ function getStateFilePath(sessionId: string): string {
 
 export function isAutoStoreEnabled(sessionId: string | undefined): boolean {
   if (!sessionId) return true;
-  return autoStoreSessions.get(sessionId) ?? true;
+  const cached = autoStoreSessions.get(sessionId);
+  if (cached !== undefined) return cached;
+  // Fallback: read from persisted file (survives restart)
+  try {
+    const data = JSON.parse(readFileSync(getStateFilePath(sessionId), "utf-8"));
+    const enabled = data.enabled ?? true;
+    autoStoreSessions.set(sessionId, enabled); // cache for next time
+    return enabled;
+  } catch {
+    return true; // file doesn't exist → default ON
+  }
 }
 
 export function setAutoStoreEnabled(sessionId: string, enabled: boolean): void {
@@ -204,7 +214,7 @@ const OmemPlugin: Plugin = async (input) => {
     },
     "experimental.session.compacting": compactingHook(cerebroClient, containerTags, tui, config.ingest.ingestMode, isAutoStoreEnabled, () => mainSessionId, client, config, agentId, directory),
     "experimental.compaction.autocontinue": autocontinueHook(cerebroClient, containerTags, tui, config.ingest.ingestMode, isAutoStoreEnabled, () => mainSessionId, client, config, agentId, directory),
-    tool: buildTools(cerebroClient, containerTags, { agentId, getSessionId: () => mainSessionId, getAgentName: () => cachedAgentName || agentId, getProjectPath: () => directory }),
+    tool: buildTools(cerebroClient, containerTags, { agentId, getSessionId: () => mainSessionId, getAgentName: () => cachedAgentName || agentId, getProjectPath: () => directory, config }),
     event: sessionIdleHook(cerebroClient, containerTags, tui, client, config.ingest.ingestMode, config.ingest.autoCaptureThreshold, () => mainSessionId, isAutoStoreEnabled, agentId, config, (name: string) => { cachedAgentName = name; }, directory),
     "shell.env": async (_input: any, output: any) => {
       if (directory) {

package/src/keywords.test.ts

@@ -0,0 +1,283 @@
+import { describe, it, expect } from "vitest";
+import {
+  detectSaveKeyword,
+  detectRecallKeyword,
+  KEYWORD_NUDGE,
+  RECALL_NUDGE,
+} from "./keywords.js";
+
+// ── detectSaveKeyword ──────────────────────────────────────────────
+
+describe("detectSaveKeyword", () => {
+  // English keywords
+  it("detects 'remember'", () => {
+    expect(detectSaveKeyword("please remember this")).toBe(true);
+  });
+
+  it("detects 'save this'", () => {
+    expect(detectSaveKeyword("can you save this for me")).toBe(true);
+  });
+
+  it("detects \"don't forget\"", () => {
+    expect(detectSaveKeyword("don't forget to buy milk")).toBe(true);
+  });
+
+  // Chinese keywords
+  it("detects '记住'", () => {
+    expect(detectSaveKeyword("请记住这个")).toBe(true);
+  });
+
+  it("detects '记一下'", () => {
+    expect(detectSaveKeyword("帮我记一下")).toBe(true);
+  });
+
+  it("detects '保存'", () => {
+    expect(detectSaveKeyword("保存这个设置")).toBe(true);
+  });
+
+  it("detects '记下来'", () => {
+    expect(detectSaveKeyword("把这个记下来")).toBe(true);
+  });
+
+  it("detects '别忘了'", () => {
+    expect(detectSaveKeyword("别忘了明天的会议")).toBe(true);
+  });
+
+  // Tool reference
+  it("detects 'memory_store'", () => {
+    expect(detectSaveKeyword("use memory_store to save")).toBe(true);
+  });
+
+  // Case-insensitive
+  it("is case-insensitive", () => {
+    expect(detectSaveKeyword("REMEMBER this")).toBe(true);
+    expect(detectSaveKeyword("Remember This")).toBe(true);
+    expect(detectSaveKeyword("SAVE THIS please")).toBe(true);
+    expect(detectSaveKeyword("MEMORY_STORE")).toBe(true);
+  });
+
+  // Negative cases
+  it("returns false when no keyword present", () => {
+    expect(detectSaveKeyword("hello world")).toBe(false);
+    expect(detectSaveKeyword("what's the weather?")).toBe(false);
+  });
+
+  it("returns false for partial word that is not a keyword", () => {
+    // "member" is not "remember"
+    expect(detectSaveKeyword("team member")).toBe(false);
+  });
+
+  // Edge: keyword embedded in longer word (still matches because includes)
+  it("matches keyword as substring", () => {
+    // "remember" is in "disremember"
+    expect(detectSaveKeyword("I disremember that")).toBe(true);
+  });
+
+  it("handles empty string", () => {
+    expect(detectSaveKeyword("")).toBe(false);
+  });
+
+  it("handles string with only whitespace", () => {
+    expect(detectSaveKeyword("   ")).toBe(false);
+  });
+
+  it("detects mixed language text", () => {
+    expect(detectSaveKeyword("请 remember 这个设置")).toBe(true);
+  });
+});
+
+// ── detectRecallKeyword ────────────────────────────────────────────
+
+describe("detectRecallKeyword", () => {
+  // English keywords
+  it("detects 'i remember'", () => {
+    expect(detectRecallKeyword("I remember we talked about this")).toBe(true);
+  });
+
+  it("detects 'i recall'", () => {
+    expect(detectRecallKeyword("I recall that discussion")).toBe(true);
+  });
+
+  it("detects 'we discussed'", () => {
+    expect(detectRecallKeyword("We discussed this before")).toBe(true);
+  });
+
+  it("detects 'we talked about'", () => {
+    expect(detectRecallKeyword("We talked about this last week")).toBe(true);
+  });
+
+  it("detects 'last time'", () => {
+    expect(detectRecallKeyword("Last time we met")).toBe(true);
+  });
+
+  it("detects 'look up'", () => {
+    expect(detectRecallKeyword("Can you look up that info")).toBe(true);
+  });
+
+  it("detects 'what did we'", () => {
+    expect(detectRecallKeyword("What did we decide last time")).toBe(true);
+  });
+
+  it("detects 'do you remember'", () => {
+    expect(detectRecallKeyword("Do you remember that project")).toBe(true);
+  });
+
+  it("detects 'as discussed'", () => {
+    expect(detectRecallKeyword("As discussed previously")).toBe(true);
+  });
+
+  // Chinese keywords
+  it("detects '我记得'", () => {
+    expect(detectRecallKeyword("我记得之前说过")).toBe(true);
+  });
+
+  it("detects '之前说过'", () => {
+    expect(detectRecallKeyword("你之前说过这个")).toBe(true);
+  });
+
+  it("detects '之前聊过'", () => {
+    expect(detectRecallKeyword("我们之前聊过")).toBe(true);
+  });
+
+  it("detects '查一下'", () => {
+    expect(detectRecallKeyword("帮我查一下")).toBe(true);
+  });
+
+  it("detects '搜一下'", () => {
+    expect(detectRecallKeyword("帮我搜一下")).toBe(true);
+  });
+
+  it("detects '记得吗'", () => {
+    expect(detectRecallKeyword("你还记得吗")).toBe(true);
+  });
+
+  it("detects '你还记得'", () => {
+    expect(detectRecallKeyword("你还记得那个bug吗")).toBe(true);
+  });
+
+  it("detects '上次那个'", () => {
+    expect(detectRecallKeyword("上次那个方案")).toBe(true);
+  });
+
+  // Tool references
+  it("detects 'memory_search'", () => {
+    expect(detectRecallKeyword("use memory_search")).toBe(true);
+  });
+
+  it("detects 'memory_get'", () => {
+    expect(detectRecallKeyword("use memory_get")).toBe(true);
+  });
+
+  // Case-insensitive
+  it("is case-insensitive", () => {
+    expect(detectRecallKeyword("I REMEMBER that")).toBe(true);
+    expect(detectRecallKeyword("WE DISCUSSED")).toBe(true);
+    expect(detectRecallKeyword("MEMORY_SEARCH")).toBe(true);
+  });
+
+  // Negative cases
+  it("returns false when no keyword present", () => {
+    expect(detectRecallKeyword("hello world")).toBe(false);
+    expect(detectRecallKeyword("the weather is nice")).toBe(false);
+  });
+
+  it("handles empty string", () => {
+    expect(detectRecallKeyword("")).toBe(false);
+  });
+
+  it("handles string with only whitespace", () => {
+    expect(detectRecallKeyword("   \n\t")).toBe(false);
+  });
+
+  it("detects 'previously'", () => {
+    expect(detectRecallKeyword("Previously mentioned")).toBe(true);
+  });
+
+  it("detects 'before we'", () => {
+    expect(detectRecallKeyword("before we proceed")).toBe(true);
+  });
+
+  it("detects 'search for'", () => {
+    expect(detectRecallKeyword("search for that topic")).toBe(true);
+  });
+
+  it("detects 'earlier we'", () => {
+    expect(detectRecallKeyword("earlier we decided")).toBe(true);
+  });
+
+  it("detects 'from our previous'", () => {
+    expect(detectRecallKeyword("from our previous meeting")).toBe(true);
+  });
+
+  it("detects '之前那个'", () => {
+    expect(detectRecallKeyword("之前那个问题")).toBe(true);
+  });
+
+  it("detects '上次讨论'", () => {
+    expect(detectRecallKeyword("上次讨论的方案")).toBe(true);
+  });
+
+  it("detects '上次做的'", () => {
+    expect(detectRecallKeyword("上次做的决定")).toBe(true);
+  });
+
+  it("detects '之前记录'", () => {
+    expect(detectRecallKeyword("之前记录的内容")).toBe(true);
+  });
+
+  it("detects '之前保存'", () => {
+    expect(detectRecallKeyword("之前保存的文件")).toBe(true);
+  });
+
+  it("detects '上次决定'", () => {
+    expect(detectRecallKeyword("上次决定的事情")).toBe(true);
+  });
+
+  it("detects '之前约定'", () => {
+    expect(detectRecallKeyword("之前约定的方案")).toBe(true);
+  });
+
+  it("detects '回忆一下'", () => {
+    expect(detectRecallKeyword("回忆一下当时的场景")).toBe(true);
+  });
+
+  it("detects 'find that'", () => {
+    expect(detectRecallKeyword("find that document")).toBe(true);
+  });
+
+  it("detects 'check what'", () => {
+    expect(detectRecallKeyword("check what we decided")).toBe(true);
+  });
+});
+
+// ── Nudge constants ────────────────────────────────────────────────
+
+describe("KEYWORD_NUDGE", () => {
+  it("is a non-empty string", () => {
+    expect(KEYWORD_NUDGE).toBeTruthy();
+    expect(typeof KEYWORD_NUDGE).toBe("string");
+  });
+
+  it("contains 'memory_store'", () => {
+    expect(KEYWORD_NUDGE).toContain("memory_store");
+  });
+
+  it("contains 'cerebro' prefix", () => {
+    expect(KEYWORD_NUDGE).toContain("[cerebro]");
+  });
+});
+
+describe("RECALL_NUDGE", () => {
+  it("is a non-empty string", () => {
+    expect(RECALL_NUDGE).toBeTruthy();
+    expect(typeof RECALL_NUDGE).toBe("string");
+  });
+
+  it("contains 'memory_search'", () => {
+    expect(RECALL_NUDGE).toContain("memory_search");
+  });
+
+  it("contains 'cerebro' prefix", () => {
+    expect(RECALL_NUDGE).toContain("[cerebro]");
+  });
+});