@mingxy/cerebro 1.20.5 → 1.20.6

package/src/config.test.ts

@@ -0,0 +1,405 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { loadPluginConfig, resolveAgentPolicy, DEFAULTS } from "./config.js";
+import type { CerebroPluginConfig } from "./config.js";
+import * as fs from "node:fs";
+
+vi.mock("node:fs", () => ({
+  readFileSync: vi.fn(() => {
+    throw new Error("no config file");
+  }),
+  appendFileSync: vi.fn(),
+  mkdirSync: vi.fn(),
+}));
+
+vi.mock("node:os", () => ({
+  homedir: vi.fn(() => "/mock/home"),
+}));
+
+describe("DEFAULTS", () => {
+  it("has connection defaults", () => {
+    expect(DEFAULTS.connection).toBeDefined();
+    expect(DEFAULTS.connection.apiUrl).toBe("https://www.mengxy.cc");
+    expect(DEFAULTS.connection.apiKey).toBe("");
+    expect(DEFAULTS.connection.requestTimeoutMs).toBe(15000);
+  });
+
+  it("has content defaults", () => {
+    expect(DEFAULTS.content).toBeDefined();
+    expect(DEFAULTS.content.maxQueryLength).toBe(200);
+    expect(DEFAULTS.content.maxContentChars).toBe(30000);
+    expect(DEFAULTS.content.maxContentLength).toBe(3000);
+  });
+
+  it("has injection defaults", () => {
+    expect(DEFAULTS.injection).toBeDefined();
+    expect(DEFAULTS.injection.recentCount).toBe(5);
+    expect(DEFAULTS.injection.searchCount).toBe(10);
+    expect(DEFAULTS.injection.recentTruncateChars).toBe(0);
+    expect(DEFAULTS.injection.searchTruncateChars).toBe(0);
+  });
+
+  it("has ingest defaults", () => {
+    expect(DEFAULTS.ingest).toBeDefined();
+    expect(DEFAULTS.ingest.autoCaptureThreshold).toBe(5);
+    expect(DEFAULTS.ingest.ingestMode).toBe("smart");
+  });
+
+  it("has logging defaults", () => {
+    expect(DEFAULTS.logging).toBeDefined();
+    expect(DEFAULTS.logging.logEnabled).toBe(true);
+    expect(DEFAULTS.logging.logLevel).toBe("INFO");
+    expect(DEFAULTS.logging.logDir).toContain(".config/cerebro");
+  });
+
+  it("has ui defaults", () => {
+    expect(DEFAULTS.ui).toBeDefined();
+    expect(DEFAULTS.ui.toastDelayMs).toBe(7000);
+  });
+
+  it("has web defaults", () => {
+    expect(DEFAULTS.web).toBeDefined();
+    expect(DEFAULTS.web!.enabled).toBe(true);
+  });
+
+  it("has autoUpdate default as false", () => {
+    expect(DEFAULTS.autoUpdate).toBe(false);
+  });
+});
+
+// ── loadPluginConfig ───────────────────────────────────────────────
+
+describe("loadPluginConfig", () => {
+  const mockReadFileSync = vi.mocked(fs.readFileSync);
+
+  beforeEach(() => {
+    vi.unstubAllEnvs();
+    mockReadFileSync.mockImplementation(() => {
+      throw new Error("no config file");
+    });
+  });
+
+  afterEach(() => {
+    vi.unstubAllEnvs();
+    mockReadFileSync.mockRestore();
+  });
+
+  it("returns defaults when no config file and no overrides", () => {
+    const config = loadPluginConfig();
+    expect(config.connection.apiUrl).toBe("https://www.mengxy.cc");
+    expect(config.connection.apiKey).toBe("");
+    expect(config.connection.requestTimeoutMs).toBe(15000);
+    expect(config.ingest.ingestMode).toBe("smart");
+    expect(config.ingest.autoCaptureThreshold).toBe(5);
+  });
+
+  it("deep merges overrides correctly", () => {
+    const config = loadPluginConfig({
+      connection: { apiUrl: "http://custom:3000", apiKey: "key123" },
+      ingest: { ingestMode: "raw" },
+    });
+    expect(config.connection.apiUrl).toBe("http://custom:3000");
+    expect(config.connection.apiKey).toBe("key123");
+    // requestTimeoutMs should keep default since not overridden
+    expect(config.connection.requestTimeoutMs).toBe(15000);
+    expect(config.ingest.ingestMode).toBe("raw");
+    // autoCaptureThreshold should keep default
+    expect(config.ingest.autoCaptureThreshold).toBe(5);
+  });
+
+  it("loads nested config from file", () => {
+    mockReadFileSync.mockReturnValue(
+      JSON.stringify({
+        connection: { apiUrl: "http://file-url:9999" },
+        ingest: { autoCaptureThreshold: 10 },
+      })
+    );
+    const config = loadPluginConfig();
+    expect(config.connection.apiUrl).toBe("http://file-url:9999");
+    expect(config.ingest.autoCaptureThreshold).toBe(10);
+    // Non-overridden fields keep defaults
+    expect(config.connection.requestTimeoutMs).toBe(15000);
+  });
+
+  it("migrates flat config (apiUrl at top level)", () => {
+    mockReadFileSync.mockReturnValue(
+      JSON.stringify({
+        apiUrl: "http://flat-url:8080",
+        apiKey: "flat-key",
+        requestTimeoutMs: 5000,
+        maxQueryLength: 500,
+        autoCaptureThreshold: 3,
+        ingestMode: "raw",
+        toastDelayMs: 3000,
+        logEnabled: false,
+        logLevel: "DEBUG",
+      })
+    );
+    const config = loadPluginConfig();
+    expect(config.connection.apiUrl).toBe("http://flat-url:8080");
+    expect(config.connection.apiKey).toBe("flat-key");
+    expect(config.connection.requestTimeoutMs).toBe(5000);
+    expect(config.content.maxQueryLength).toBe(500);
+    expect(config.ingest.autoCaptureThreshold).toBe(3);
+    expect(config.ingest.ingestMode).toBe("raw");
+    expect(config.ui.toastDelayMs).toBe(3000);
+    expect(config.logging.logEnabled).toBe(false);
+    expect(config.logging.logLevel).toBe("DEBUG");
+  });
+
+  it("does NOT migrate when connection field exists", () => {
+    mockReadFileSync.mockReturnValue(
+      JSON.stringify({
+        apiUrl: "http://should-not-migrate",
+        connection: { apiUrl: "http://nested-url" },
+      })
+    );
+    const config = loadPluginConfig();
+    // Should use nested connection.apiUrl, not top-level apiUrl
+    expect(config.connection.apiUrl).toBe("http://nested-url");
+  });
+
+  // ── Environment variable overrides ──
+
+  it("OMEM_API_URL overrides apiUrl", () => {
+    vi.stubEnv("OMEM_API_URL", "http://env-url:7777");
+    const config = loadPluginConfig();
+    expect(config.connection.apiUrl).toBe("http://env-url:7777");
+  });
+
+  it("OMEM_API_KEY overrides apiKey", () => {
+    vi.stubEnv("OMEM_API_KEY", "env-api-key-123");
+    const config = loadPluginConfig();
+    expect(config.connection.apiKey).toBe("env-api-key-123");
+  });
+
+  it("OMEM_REQUEST_TIMEOUT_MS overrides timeout", () => {
+    vi.stubEnv("OMEM_REQUEST_TIMEOUT_MS", "30000");
+    const config = loadPluginConfig();
+    expect(config.connection.requestTimeoutMs).toBe(30000);
+  });
+
+  it("OMEM_REQUEST_TIMEOUT_MS falls back to default on invalid value", () => {
+    vi.stubEnv("OMEM_REQUEST_TIMEOUT_MS", "not-a-number");
+    const config = loadPluginConfig();
+    expect(config.connection.requestTimeoutMs).toBe(15000);
+  });
+
+  it("OMEM_AUTO_CAPTURE_THRESHOLD overrides threshold", () => {
+    vi.stubEnv("OMEM_AUTO_CAPTURE_THRESHOLD", "15");
+    const config = loadPluginConfig();
+    expect(config.ingest.autoCaptureThreshold).toBe(15);
+  });
+
+  it("OMEM_AUTO_CAPTURE_THRESHOLD falls back to default on invalid", () => {
+    vi.stubEnv("OMEM_AUTO_CAPTURE_THRESHOLD", "abc");
+    const config = loadPluginConfig();
+    expect(config.ingest.autoCaptureThreshold).toBe(5);
+  });
+
+  it("OMEM_INGEST_MODE=raw overrides ingestMode", () => {
+    vi.stubEnv("OMEM_INGEST_MODE", "raw");
+    const config = loadPluginConfig();
+    expect(config.ingest.ingestMode).toBe("raw");
+  });
+
+  it("OMEM_INGEST_MODE=smart overrides ingestMode", () => {
+    vi.stubEnv("OMEM_INGEST_MODE", "smart");
+    const config = loadPluginConfig();
+    expect(config.ingest.ingestMode).toBe("smart");
+  });
+
+  it("OMEM_INGEST_MODE with invalid value is ignored", () => {
+    vi.stubEnv("OMEM_INGEST_MODE", "invalid");
+    const config = loadPluginConfig();
+    expect(config.ingest.ingestMode).toBe("smart"); // default
+  });
+
+  it("OMEM_WEB_ENABLED=false disables web", () => {
+    vi.stubEnv("OMEM_WEB_ENABLED", "false");
+    const config = loadPluginConfig();
+    expect(config.web!.enabled).toBe(false);
+  });
+
+  it("OMEM_WEB_ENABLED=0 disables web", () => {
+    vi.stubEnv("OMEM_WEB_ENABLED", "0");
+    const config = loadPluginConfig();
+    expect(config.web!.enabled).toBe(false);
+  });
+
+  it("OMEM_WEB_ENABLED=true does not disable web", () => {
+    vi.stubEnv("OMEM_WEB_ENABLED", "true");
+    const config = loadPluginConfig();
+    expect(config.web!.enabled).toBe(true);
+  });
+
+  it("OMEM_LOCAL_PORT sets web port", () => {
+    vi.stubEnv("OMEM_LOCAL_PORT", "3456");
+    const config = loadPluginConfig();
+    expect(config.web!.port).toBe(3456);
+  });
+
+  it("OMEM_LOCAL_PORT with invalid value falls back to default port", () => {
+    vi.stubEnv("OMEM_LOCAL_PORT", "not-a-number");
+    const config = loadPluginConfig();
+    // DEFAULTS.web!.port is undefined, so fallback is undefined
+    expect(config.web!.port).toBeUndefined();
+  });
+
+  it("env vars have highest priority over file config and overrides", () => {
+    mockReadFileSync.mockReturnValue(
+      JSON.stringify({
+        connection: { apiUrl: "http://file-url", apiKey: "file-key" },
+      })
+    );
+    vi.stubEnv("OMEM_API_URL", "http://env-url");
+    vi.stubEnv("OMEM_API_KEY", "env-key");
+    const config = loadPluginConfig({
+      connection: { apiUrl: "http://override-url" },
+    });
+    expect(config.connection.apiUrl).toBe("http://env-url");
+    expect(config.connection.apiKey).toBe("env-key");
+  });
+
+  // ── ~ expansion in logDir ──
+
+  it("expands ~ in logDir to homedir", () => {
+    mockReadFileSync.mockReturnValue(
+      JSON.stringify({
+        logging: { logDir: "~/custom-logs" },
+      })
+    );
+    const config = loadPluginConfig();
+    expect(config.logging.logDir).toBe("/mock/home/custom-logs");
+  });
+
+  it("does not expand logDir without ~ prefix", () => {
+    mockReadFileSync.mockReturnValue(
+      JSON.stringify({
+        logging: { logDir: "/absolute/path/logs" },
+      })
+    );
+    const config = loadPluginConfig();
+    expect(config.logging.logDir).toBe("/absolute/path/logs");
+  });
+
+  // ── Edge cases ──
+
+  it("handles malformed JSON in config file gracefully", () => {
+    mockReadFileSync.mockReturnValue("{ invalid json");
+    const config = loadPluginConfig();
+    // Should fall back to defaults
+    expect(config.connection.apiUrl).toBe("https://www.mengxy.cc");
+  });
+
+  it("handles empty overrides object", () => {
+    const config = loadPluginConfig({});
+    expect(config.connection.apiUrl).toBe("https://www.mengxy.cc");
+  });
+
+  it("preserves overrides not present in env vars", () => {
+    const config = loadPluginConfig({
+      content: { maxQueryLength: 999, maxContentChars: 9999, maxContentLength: 999 },
+    });
+    expect(config.content.maxQueryLength).toBe(999);
+    expect(config.content.maxContentChars).toBe(9999);
+    expect(config.content.maxContentLength).toBe(999);
+  });
+
+  it("applies agentMemoryPolicy from overrides", () => {
+    const config = loadPluginConfig({
+      agentMemoryPolicy: { oracle: "readonly", builder: "none" },
+    });
+    expect(config.agentMemoryPolicy).toEqual({ oracle: "readonly", builder: "none" });
+  });
+
+  it("applies defaultPolicy from overrides", () => {
+    const config = loadPluginConfig({
+      defaultPolicy: "readonly",
+    });
+    expect(config.defaultPolicy).toBe("readonly");
+  });
+
+  it("applies autoUpdate from overrides", () => {
+    const config = loadPluginConfig({ autoUpdate: true });
+    expect(config.autoUpdate).toBe(true);
+  });
+
+  it("returns independent copies (no shared mutation)", () => {
+    const config1 = loadPluginConfig();
+    const config2 = loadPluginConfig();
+    config1.connection.apiUrl = "mutated";
+    expect(config2.connection.apiUrl).toBe("https://www.mengxy.cc");
+  });
+});
+
+// ── resolveAgentPolicy ─────────────────────────────────────────────
+
+describe("resolveAgentPolicy", () => {
+  it("returns exact match from agentMemoryPolicy", () => {
+    const config = {
+      agentMemoryPolicy: { oracle: "readonly" as const, builder: "none" as const },
+    };
+    expect(resolveAgentPolicy("oracle", config)).toBe("readonly");
+    expect(resolveAgentPolicy("builder", config)).toBe("none");
+  });
+
+  it("uses prefix matching (case-insensitive) when no exact match", () => {
+    const config = {
+      agentMemoryPolicy: { build: "readwrite" as const },
+    };
+    // "builder" starts with "build"
+    expect(resolveAgentPolicy("builder", config)).toBe("readwrite");
+  });
+
+  it("matches agentName prefix against policy key (case-insensitive)", () => {
+    const config = {
+      agentMemoryPolicy: { Build: "none" as const },
+    };
+    // "build" starts with "Build" (case-insensitive)
+    expect(resolveAgentPolicy("build", config)).toBe("none");
+  });
+
+  it("falls back to defaultPolicy when no policy match", () => {
+    const config = {
+      agentMemoryPolicy: { oracle: "readonly" as const },
+      defaultPolicy: "readonly" as const,
+    };
+    expect(resolveAgentPolicy("unknown-agent", config)).toBe("readonly");
+  });
+
+  it("falls back to 'readwrite' when no policy and no defaultPolicy", () => {
+    const config = {};
+    expect(resolveAgentPolicy("unknown-agent", config)).toBe("readwrite");
+  });
+
+  it("falls back to 'readwrite' when agentMemoryPolicy is undefined", () => {
+    const config = { defaultPolicy: undefined };
+    expect(resolveAgentPolicy("any-agent", config)).toBe("readwrite");
+  });
+
+  it("handles empty agentMemoryPolicy", () => {
+    const config = {
+      agentMemoryPolicy: {},
+      defaultPolicy: "none" as const,
+    };
+    expect(resolveAgentPolicy("any-agent", config)).toBe("none");
+  });
+
+  it("exact match takes priority over prefix match", () => {
+    const config = {
+      agentMemoryPolicy: {
+        build: "none" as const,
+        builder: "readwrite" as const,
+      },
+    };
+    expect(resolveAgentPolicy("builder", config)).toBe("readwrite");
+  });
+
+  it("is case-insensitive for exact matching", () => {
+    const config = {
+      agentMemoryPolicy: { Oracle: "readonly" as const },
+    };
+    expect(resolveAgentPolicy("oracle", config)).toBe("readonly");
+    expect(resolveAgentPolicy("ORACLE", config)).toBe("readonly");
+  });
+});

package/src/hooks-tier1.test.ts

@@ -0,0 +1,220 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { showToast, createToast, createCerebroCompactionPrompt } from "./hooks.js";
+import type { SearchResult } from "./client.js";
+
+describe("showToast", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("calls tui.showToast with correct args after delay", () => {
+    const tui = { showToast: vi.fn() };
+    showToast(tui, "Title", "Hello", "info", 100);
+
+    // Not called immediately
+    expect(tui.showToast).not.toHaveBeenCalled();
+
+    // Called after delay
+    vi.advanceTimersByTime(100);
+    expect(tui.showToast).toHaveBeenCalledWith({
+      body: { title: "Title", message: "Hello", variant: "info", duration: 5000 },
+    });
+  });
+
+  it("uses default delay when delayMs is not provided", () => {
+    const tui = { showToast: vi.fn() };
+    showToast(tui, "Title", "Hello");
+
+    // DEFAULTS.ui.toastDelayMs = 7000
+    vi.advanceTimersByTime(6999);
+    expect(tui.showToast).not.toHaveBeenCalled();
+
+    vi.advanceTimersByTime(1);
+    expect(tui.showToast).toHaveBeenCalledWith({
+      body: { title: "Title", message: "Hello", variant: "info", duration: 5000 },
+    });
+  });
+
+  it("does nothing when tui is null", () => {
+    showToast(null, "Title", "Hello", "info", 100);
+    vi.advanceTimersByTime(200);
+    // No error thrown, no crash
+  });
+
+  it("does nothing when tui is undefined", () => {
+    showToast(undefined as any, "Title", "Hello", "info", 100);
+    vi.advanceTimersByTime(200);
+  });
+
+  it("catches errors from tui.showToast gracefully", () => {
+    const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+    const tui = {
+      showToast: vi.fn(() => {
+        throw new Error("toast boom");
+      }),
+    };
+    showToast(tui, "Title", "Hello", "info", 50);
+    vi.advanceTimersByTime(50);
+
+    // Should not throw, just log
+    expect(tui.showToast).toHaveBeenCalled();
+    errorSpy.mockRestore();
+  });
+
+  it("passes custom variant to tui.showToast", () => {
+    const tui = { showToast: vi.fn() };
+    showToast(tui, "Warn", "Something", "warning", 0);
+    vi.advanceTimersByTime(0);
+    expect(tui.showToast).toHaveBeenCalledWith({
+      body: { title: "Warn", message: "Something", variant: "warning", duration: 5000 },
+    });
+  });
+});
+
+describe("createToast", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("returns a function that calls showToast with default delay from config", () => {
+    const tui = { showToast: vi.fn() };
+    const config = { ui: { toastDelayMs: 3000 } };
+    const toastFn = createToast(config);
+
+    toastFn(tui, "Title", "Msg");
+    vi.advanceTimersByTime(3000);
+    expect(tui.showToast).toHaveBeenCalledWith({
+      body: { title: "Title", message: "Msg", variant: "info", duration: 5000 },
+    });
+  });
+
+  it("uses global DEFAULTS when config has no ui.toastDelayMs", () => {
+    const tui = { showToast: vi.fn() };
+    const toastFn = createToast({});
+
+    toastFn(tui, "Title", "Msg");
+    vi.advanceTimersByTime(7000);
+    expect(tui.showToast).toHaveBeenCalled();
+  });
+
+  it("allows overriding delay via delayMs parameter", () => {
+    const tui = { showToast: vi.fn() };
+    const toastFn = createToast({ ui: { toastDelayMs: 3000 } });
+
+    toastFn(tui, "Title", "Msg", "info", 100);
+    vi.advanceTimersByTime(100);
+    expect(tui.showToast).toHaveBeenCalled();
+  });
+
+  it("prefers explicit delayMs over config default", () => {
+    const tui = { showToast: vi.fn() };
+    const toastFn = createToast({ ui: { toastDelayMs: 5000 } });
+
+    toastFn(tui, "Title", "Msg", "info", 50);
+    vi.advanceTimersByTime(50);
+    expect(tui.showToast).toHaveBeenCalledTimes(1);
+  });
+});
+
+function makeSearchResult(content: string, category?: string): SearchResult {
+  return {
+    memory: {
+      id: "mem-1",
+      content,
+      category: category ?? null,
+      tags: [],
+      tier: "work",
+      visibility: "global",
+      created_at: new Date().toISOString(),
+      updated_at: new Date().toISOString(),
+      score: 0.9,
+      space_id: "space-1",
+      tenant_id: "tenant-1",
+    },
+    score: 0.9,
+  };
+}
+
+describe("createCerebroCompactionPrompt", () => {
+  it("contains all required section headers", () => {
+    const result = createCerebroCompactionPrompt([], []);
+    expect(result).toContain("[Cerebro Compaction Context]");
+    expect(result).toContain("## 1. User's Original Request");
+    expect(result).toContain("## 2. Final Goal");
+    expect(result).toContain("## 3. Work Completed");
+    expect(result).toContain("## 4. Remaining Tasks");
+    expect(result).toContain("## 5. Prohibited Actions");
+    expect(result).toContain("## 6. Existing Project Knowledge");
+    expect(result).toContain("IMPORTANT: Output must preserve the user's original language");
+  });
+
+  it("shows 'No project memories' when projectMemories is empty", () => {
+    const result = createCerebroCompactionPrompt([], []);
+    expect(result).toContain("(No project memories retrieved)");
+  });
+
+  it("includes project memories when provided", () => {
+    const memories = [
+      makeSearchResult("Built auth module", "cases"),
+      makeSearchResult("Prefers dark mode", "preferences"),
+    ];
+    const result = createCerebroCompactionPrompt([], memories);
+    expect(result).toContain("[cases] Built auth module");
+    expect(result).toContain("[preferences] Prefers dark mode");
+  });
+
+  it("truncates long memory content to 200 chars", () => {
+    const longContent = "A".repeat(300);
+    const memories = [makeSearchResult(longContent)];
+    const result = createCerebroCompactionPrompt([], memories);
+    expect(result).toContain("A".repeat(200) + "...");
+    expect(result).not.toContain("A".repeat(300));
+  });
+
+  it("limits to 10 project memories", () => {
+    const memories = Array.from({ length: 15 }, (_, i) =>
+      makeSearchResult(`Memory ${i}`, "general"),
+    );
+    const result = createCerebroCompactionPrompt([], memories);
+    // Should contain Memory 0 through Memory 9, not Memory 10+
+    expect(result).toContain("Memory 0");
+    expect(result).toContain("Memory 9");
+    expect(result).not.toContain("Memory 10");
+  });
+
+  it("handles memories with null category as 'general'", () => {
+    const memories = [makeSearchResult("Some content", null as any)];
+    const result = createCerebroCompactionPrompt([], memories);
+    expect(result).toContain("[general] Some content");
+  });
+
+  it("includes additional context when context array is non-empty", () => {
+    const result = createCerebroCompactionPrompt(
+      ["User prefers TypeScript", "Last task: fix auth bug"],
+      [],
+    );
+    expect(result).toContain("### Additional Context");
+    expect(result).toContain("User prefers TypeScript");
+    expect(result).toContain("Last task: fix auth bug");
+  });
+
+  it("does not include Additional Context section when context is empty", () => {
+    const result = createCerebroCompactionPrompt([], []);
+    expect(result).not.toContain("### Additional Context");
+  });
+
+  it("handles empty messages/context gracefully", () => {
+    const result = createCerebroCompactionPrompt([], []);
+    expect(result).toBeTruthy();
+    expect(typeof result).toBe("string");
+    expect(result.length).toBeGreaterThan(0);
+  });
+});