@polderlabs/bizar 6.2.4 → 6.3.0

package/plugins/bizar/tests/compaction.test.ts

@@ -1,264 +0,0 @@
-/**
- * compaction.test.ts
- *
- * Spec contract for the compaction gate (see src/compaction.mjs):
- *   - `shouldCompact` returns false below 50%, true at and above 50%.
- *   - `shouldCompact` is defensive: null usage, undefined usage.total, and
- *     non-positive maxContext all return false (no false positives).
- *   - `maybeCompactSession` returns `{ compacted: false, reason: "below_threshold" }`
- *     when below the gate.
- *   - `maybeCompactSession` returns `{ compacted: true, sessionId, threshold, … }`
- *     when at/over the gate.
- *   - The default threshold is 0.5.
- *   - `setCompactionThreshold` rejects out-of-range values with a throw;
- *     accepts in-range values silently.
- *   - State leaks between tests are not allowed — every test that mutates
- *     the threshold calls `resetCompactionDefaults()` in its teardown
- *     (bun:test does not have a global afterEach, so we use try/finally).
- *
- * Tests use `bun:test` to match the rest of the plugin suite (see
- * `tests/loop.test.ts`, `tests/options.test.ts`, etc.).
- */
-
-import {
-  describe,
-  test,
-  expect,
-  beforeEach,
-  afterEach,
-} from "bun:test";
-
-import {
-  shouldCompact,
-  maybeCompactSession,
-  getCompactionThreshold,
-  setCompactionThreshold,
-  resetCompactionDefaults,
-} from "../src/compaction.mjs";
-
-/**
- * Bun:test does not expose a global `afterEach`/`beforeEach` reset hook
- * that runs across describe blocks, so we wire per-block setup/teardown
- * via the standard `beforeEach`/`afterEach` imports. We also reset on
- * entry to each test as a belt-and-braces guarantee that no leak from a
- * prior test (run in the same process by `bun test`) can poison state.
- */
-beforeEach(() => {
-  resetCompactionDefaults();
-});
-
-afterEach(() => {
-  resetCompactionDefaults();
-});
-
-describe("shouldCompact", () => {
-  test("does not compact below 50%", () => {
-    expect(shouldCompact({ total: 40000 }, 100000)).toBe(false);
-  });
-
-  test("does not compact at 49.99%", () => {
-    expect(shouldCompact({ total: 49999 }, 100000)).toBe(false);
-  });
-
-  test("compacts at exactly 50%", () => {
-    expect(shouldCompact({ total: 50000 }, 100000)).toBe(true);
-  });
-
-  test("compacts above 50%", () => {
-    expect(shouldCompact({ total: 80000 }, 100000)).toBe(true);
-  });
-
-  test("compacts at 100% (full context)", () => {
-    expect(shouldCompact({ total: 100000 }, 100000)).toBe(true);
-  });
-
-  test("does not compact with null usage", () => {
-    expect(shouldCompact(null, 100000)).toBe(false);
-  });
-
-  test("does not compact with undefined usage", () => {
-    expect(shouldCompact(undefined, 100000)).toBe(false);
-  });
-
-  test("does not compact when usage.total is missing", () => {
-    expect(shouldCompact({}, 100000)).toBe(false);
-  });
-
-  test("does not compact with non-positive maxContext", () => {
-    expect(shouldCompact({ total: 50000 }, 0)).toBe(false);
-    expect(shouldCompact({ total: 50000 }, -1)).toBe(false);
-  });
-
-  test("respects a non-default threshold (0.7)", () => {
-    setCompactionThreshold(0.7);
-    expect(shouldCompact({ total: 60000 }, 100000)).toBe(false);
-    expect(shouldCompact({ total: 70000 }, 100000)).toBe(true);
-    expect(shouldCompact({ total: 80000 }, 100000)).toBe(true);
-  });
-});
-
-describe("getCompactionThreshold / setCompactionThreshold", () => {
-  test("default threshold is 0.5", () => {
-    expect(getCompactionThreshold()).toBe(0.5);
-  });
-
-  test("setCompactionThreshold rejects 0 (below minimum)", () => {
-    expect(() => setCompactionThreshold(0)).toThrow(/Invalid compaction threshold/);
-  });
-
-  test("setCompactionThreshold rejects 0.05 (below minimum 0.1)", () => {
-    expect(() => setCompactionThreshold(0.05)).toThrow(/Invalid compaction threshold/);
-  });
-
-  test("setCompactionThreshold rejects 1.5 (above maximum)", () => {
-    expect(() => setCompactionThreshold(1.5)).toThrow(/Invalid compaction threshold/);
-  });
-
-  test("setCompactionThreshold rejects NaN", () => {
-    expect(() => setCompactionThreshold(Number.NaN)).toThrow(/Invalid compaction threshold/);
-  });
-
-  test("setCompactionThreshold rejects Infinity", () => {
-    expect(() => setCompactionThreshold(Number.POSITIVE_INFINITY)).toThrow(
-      /Invalid compaction threshold/,
-    );
-  });
-
-  test("setCompactionThreshold rejects non-number values", () => {
-    expect(() => setCompactionThreshold("0.5" as unknown as number)).toThrow(
-      /Invalid compaction threshold/,
-    );
-    expect(() => setCompactionThreshold(null as unknown as number)).toThrow(
-      /Invalid compaction threshold/,
-    );
-  });
-
-  test("setCompactionThreshold accepts 0.1 (lower bound)", () => {
-    expect(() => setCompactionThreshold(0.1)).not.toThrow();
-    expect(getCompactionThreshold()).toBe(0.1);
-  });
-
-  test("setCompactionThreshold accepts 1.0 (upper bound)", () => {
-    expect(() => setCompactionThreshold(1.0)).not.toThrow();
-    expect(getCompactionThreshold()).toBe(1.0);
-  });
-
-  test("setCompactionThreshold accepts 0.7 (in-range)", () => {
-    expect(() => setCompactionThreshold(0.7)).not.toThrow();
-    expect(getCompactionThreshold()).toBe(0.7);
-  });
-});
-
-describe("maybeCompactSession", () => {
-  test("returns below_threshold when under limit", async () => {
-    const r = await maybeCompactSession({
-      sessionId: "s1",
-      messageCount: 5,
-      currentUsage: { total: 30000 },
-      maxContext: 100000,
-      summarizer: async (texts) => texts.join(" "),
-    });
-    expect(r.compacted).toBe(false);
-    expect(r.reason).toBe("below_threshold");
-    expect(r.ratio).toBeCloseTo(0.3);
-  });
-
-  test("triggers when over limit", async () => {
-    const r = await maybeCompactSession({
-      sessionId: "s1",
-      messageCount: 100,
-      currentUsage: { total: 60000 },
-      maxContext: 100000,
-      summarizer: async () => "summary",
-    });
-    expect(r.compacted).toBe(true);
-    expect(r.sessionId).toBe("s1");
-    expect(r.atMessages).toBe(100);
-    expect(r.threshold).toBe(0.5);
-    expect(r.preservedRecent).toBe(10);
-    expect(r.ratio).toBeCloseTo(0.6);
-  });
-
-  test("triggers at exactly the threshold (50000/100000 = 0.5)", async () => {
-    const r = await maybeCompactSession({
-      sessionId: "edge",
-      messageCount: 42,
-      currentUsage: { total: 50000 },
-      maxContext: 100000,
-      summarizer: async () => "",
-    });
-    expect(r.compacted).toBe(true);
-    expect(r.atMessages).toBe(42);
-  });
-
-  test("respects a custom preserveRecent override", async () => {
-    const r = await maybeCompactSession({
-      sessionId: "s2",
-      messageCount: 200,
-      currentUsage: { total: 90000 },
-      maxContext: 100000,
-      summarizer: async () => "",
-      preserveRecent: 25,
-    });
-    expect(r.compacted).toBe(true);
-    expect(r.preservedRecent).toBe(25);
-  });
-
-  test("respects a non-default threshold", async () => {
-    setCompactionThreshold(0.8);
-    const r1 = await maybeCompactSession({
-      sessionId: "s3",
-      messageCount: 50,
-      currentUsage: { total: 70000 },
-      maxContext: 100000,
-      summarizer: async () => "",
-    });
-    expect(r1.compacted).toBe(false);
-
-    const r2 = await maybeCompactSession({
-      sessionId: "s3",
-      messageCount: 50,
-      currentUsage: { total: 85000 },
-      maxContext: 100000,
-      summarizer: async () => "",
-    });
-    expect(r2.compacted).toBe(true);
-    expect(r2.threshold).toBe(0.8);
-  });
-
-  test("does not invoke the summarizer when below threshold", async () => {
-    let called = false;
-    await maybeCompactSession({
-      sessionId: "s4",
-      messageCount: 10,
-      currentUsage: { total: 1000 },
-      maxContext: 100000,
-      summarizer: async () => {
-        called = true;
-        return "should-not-run";
-      },
-    });
-    expect(called).toBe(false);
-  });
-
-  test("throws when sessionId is missing", async () => {
-    await expect(
-      maybeCompactSession({
-        sessionId: "",
-        messageCount: 1,
-        currentUsage: { total: 999999 },
-        maxContext: 100000,
-        summarizer: async () => "",
-      }),
-    ).rejects.toThrow(/sessionId is required/);
-  });
-});
-
-describe("resetCompactionDefaults", () => {
-  test("restores the threshold to 0.5 after a custom set", () => {
-    setCompactionThreshold(0.9);
-    expect(getCompactionThreshold()).toBe(0.9);
-    resetCompactionDefaults();
-    expect(getCompactionThreshold()).toBe(0.5);
-  });
-});

package/plugins/bizar/tests/config.test.ts

@@ -1,128 +0,0 @@
-/**
- * config.test.ts — Config drift detection tests (R4 audit).
- *
- * Verifies:
- *   1. Every `bizar_*` tool registered in `plugins/bizar/index.ts`
- *      is also present in `config/cline.json` `tools: { ... }`.
- *   2. No `bizarre_*` (double-r) typos remain in `plugins/bizar/src/`.
- *   3. `plugins/bizar/package.json` version matches the current beta.
- */
-
-import { describe, test, expect } from "bun:test";
-import { readFileSync, readdirSync, statSync, existsSync } from "node:fs";
-import { join } from "node:path";
-
-const BIZAR_PLUGIN_ROOT = join(__dirname, "..");
-const PLUGIN_INDEX = join(BIZAR_PLUGIN_ROOT, "index.ts");
-const CONFIG_CLINE = join(__dirname, "..", "..", "..", "config", "cline.json");
-const PKG_JSON = join(BIZAR_PLUGIN_ROOT, "package.json");
-const SRC_DIR = join(BIZAR_PLUGIN_ROOT, "src");
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-/**
- * Extract `bizar_*` tool registration keys from index.ts.
- * Matches: `bizar_spawn_background: createBgSpawnTool(...)` etc.
- */
-function extractPluginToolKeys(indexContent: string): string[] {
-  const keys: string[] = [];
-  // Matches `bizar_xxx: createXxxTool(` or `bizar_xxx: createBgXxxTool(`
-  const toolKeyRegex = /\bbizar_([a-z_]+)\s*:\s*(?:create(?:Bg)?[A-Z]\w*Tool|createWaitForFeedbackTool)\s*\(/g;
-  let m: RegExpExecArray | null;
-  while ((m = toolKeyRegex.exec(indexContent)) !== null) {
-    keys.push(`bizar_${m[1]}`);
-  }
-  return [...new Set(keys)].sort();
-}
-
-/**
- * Extract `tools: { ... }` keys from config/cline.json.
- */
-function extractConfigToolKeys(configContent: string): string[] {
-  const parsed = JSON.parse(configContent) as { tools?: Record<string, unknown> };
-  if (!parsed.tools) return [];
-  return Object.keys(parsed.tools).sort();
-}
-
-// ---------------------------------------------------------------------------
-// Test cases
-// ---------------------------------------------------------------------------
-
-describe("config drift detection", () => {
-  test("plugin_tool_keys ⊆ config_tools_keys (R4 audit)", () => {
-    if (!existsSync(CONFIG_CLINE)) {
-      // Skip when config/cline.json has not been generated yet.
-      // `bizar install` produces it from `config/cline.json.template`.
-      return;
-    }
-    const indexContent = readFileSync(PLUGIN_INDEX, "utf-8");
-    const configContent = readFileSync(CONFIG_CLINE, "utf-8");
-
-    const pluginKeys = extractPluginToolKeys(indexContent);
-    const configKeys = extractConfigToolKeys(configContent);
-
-    const missingInConfig = pluginKeys.filter((k) => !configKeys.includes(k));
-    expect(missingInConfig, `Plugin tools missing in config: ${JSON.stringify(missingInConfig)}`).toEqual([]);
-  });
-
-  test("no 'bizarre_*' (double-r) typos remain in plugins/bizar/src/", () => {
-    // Walk src/ directory recursively and grep for 'bizarre_'
-    const allSrcFiles = getAllTsFiles(SRC_DIR);
-    const violations: Array<{ file: string; match: string }> = [];
-
-    const doubleRRegex = /\bbizarre_[a-z_]+\b/g;
-
-    for (const file of allSrcFiles) {
-      const content = readFileSync(file, "utf-8");
-      let m: RegExpExecArray | null;
-      while ((m = doubleRRegex.exec(content)) !== null) {
-        violations.push({ file: relativeToSrc(file), match: m[0] });
-      }
-    }
-
-    expect(
-      violations,
-      `Found 'bizarre_*' typos: ${JSON.stringify(violations)}`,
-    ).toEqual([]);
-  });
-
-  test("plugins/bizar/package.json version is current beta", () => {
-    const pkg = JSON.parse(readFileSync(PKG_JSON, "utf-8")) as { version?: string };
-    // v6.0.0 sprint bumped to 5.6.0-beta series; assert the prefix.
-    expect(pkg.version).toMatch(/^\d+\.\d+\.\d+(-beta\.\d+)?$/);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Helper: recursively collect all .ts files under a directory
-// ---------------------------------------------------------------------------
-
-function getAllTsFiles(dir: string): string[] {
-  const results: string[] = [];
-  let entries: string[];
-  try {
-    entries = readdirSync(dir);
-  } catch {
-    return results;
-  }
-  for (const name of entries) {
-    const full = join(dir, name);
-    try {
-      const stat = statSync(full);
-      if (stat.isDirectory()) {
-        results.push(...getAllTsFiles(full));
-      } else if (name.endsWith(".ts") || name.endsWith(".tsx")) {
-        results.push(full);
-      }
-    } catch {
-      // skip inaccessible entries
-    }
-  }
-  return results;
-}
-
-function relativeToSrc(file: string): string {
-  return file.replace(SRC_DIR + "/", "");
-}

package/plugins/bizar/tests/dashboard-client.test.ts

@@ -1,159 +0,0 @@
-/**
- * dashboard-client.test.ts
- *
- * v0.7.0-alpha.1 — Tests for the SDK-backed dashboard publisher.
- *
- * Verifies:
- *   - publish() succeeds when the dashboard is reachable (uses a stub
- *     fetch via `createBizarClient`'s `fetch` injection — but our
- *     publisher doesn't currently expose fetch injection, so we test
- *     via the real `publishV2Event` round-trip from the smoke test
- *     pattern instead).
- *   - publish() drops events when the publisher is not started.
- *   - Graceful degradation: env var override is respected.
- *
- * Network tests (publish to a real dashboard) live in
- * `tests/integration/dashboard-bridge.test.ts` and require a running
- * dashboard server.
- */
-
-import { describe, it, expect } from "bun:test";
-import { createDashboardPublisher, type Logger } from "../src/dashboard-client.js";
-
-// ---------------------------------------------------------------------------
-// Test logger
-// ---------------------------------------------------------------------------
-
-const makeLogger = (): Logger & { lines: string[] } => {
-  const lines: string[] = [];
-  return {
-    lines,
-    debug(m) { lines.push(`debug: ${m}`); },
-    info(m) { lines.push(`info: ${m}`); },
-    warn(m) { lines.push(`warn: ${m}`); },
-    error(m) { lines.push(`error: ${m}`); },
-  };
-};
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe("createDashboardPublisher", () => {
-  it("publish() drops events when not started", async () => {
-    const logger = makeLogger();
-    const pub = createDashboardPublisher({ logger });
-    // Do NOT call start()
-    expect(pub.isReady()).toBe(false);
-
-    await pub.publish({
-      type: "session.created",
-      properties: { sessionId: "ses_1", agent: "mimir" },
-    });
-
-    // Logger should have recorded a debug drop message.
-    expect(logger.lines.some((l) => l.includes("not ready"))).toBe(true);
-  });
-
-  it("start() is a no-op when disabled by config", async () => {
-    const logger = makeLogger();
-    const pub = createDashboardPublisher({ logger, disabled: true });
-    await pub.start();
-    expect(pub.isReady()).toBe(false);
-    expect(logger.lines.some((l) => l.includes("disabled"))).toBe(true);
-  });
-
-  it("start() is a no-op when no password is available", async () => {
-    const logger = makeLogger();
-    // Make sure no env vars or auth files are present in this test.
-    const prevUrl = process.env.BIZAR_DASHBOARD_URL;
-    const prevPort = process.env.BIZAR_DASHBOARD_PORT;
-    const prevPw = process.env.BIZAR_DASHBOARD_PASSWORD;
-    const prevAuthFile = process.env.BIZAR_DASHBOARD_AUTH_FILE;
-    const prevAuthFiles = process.env.BIZAR_DASHBOARD_AUTH_FILES;
-    delete process.env.BIZAR_DASHBOARD_URL;
-    delete process.env.BIZAR_DASHBOARD_PORT;
-    delete process.env.BIZAR_DASHBOARD_PASSWORD;
-    // Point auth-file discovery at a non-existent path.
-    process.env.BIZAR_DASHBOARD_AUTH_FILE = "/tmp/__no_such_auth_file__.json";
-
-    try {
-      const pub = createDashboardPublisher({ logger });
-      await pub.start();
-      expect(pub.isReady()).toBe(false);
-      expect(logger.lines.some((l) => l.includes("not started"))).toBe(true);
-    } finally {
-      if (prevUrl !== undefined) process.env.BIZAR_DASHBOARD_URL = prevUrl;
-      if (prevPort !== undefined) process.env.BIZAR_DASHBOARD_PORT = prevPort;
-      if (prevPw !== undefined) process.env.BIZAR_DASHBOARD_PASSWORD = prevPw;
-      if (prevAuthFile !== undefined) {
-        process.env.BIZAR_DASHBOARD_AUTH_FILE = prevAuthFile;
-      } else {
-        delete process.env.BIZAR_DASHBOARD_AUTH_FILE;
-      }
-      if (prevAuthFiles !== undefined) {
-        process.env.BIZAR_DASHBOARD_AUTH_FILES = prevAuthFiles;
-      } else {
-        delete process.env.BIZAR_DASHBOARD_AUTH_FILES;
-      }
-    }
-  });
-
-  it("start() succeeds when password is provided via env", async () => {
-    const logger = makeLogger();
-    process.env.BIZAR_DASHBOARD_PASSWORD = "test-password-1234567890abcdef";
-
-    try {
-      const pub = createDashboardPublisher({
-        logger,
-        baseUrl: "http://127.0.0.1:1", // port 1 = unreachable, but SDK client constructs fine
-      });
-      await pub.start();
-      expect(pub.isReady()).toBe(true);
-      expect(logger.lines.some((l) => l.includes("publisher started"))).toBe(true);
-      pub.stop();
-    } finally {
-      delete process.env.BIZAR_DASHBOARD_PASSWORD;
-    }
-  });
-
-  it("start() respects BIZAR_DASHBOARD_URL env var", async () => {
-    const logger = makeLogger();
-    process.env.BIZAR_DASHBOARD_URL = "http://127.0.0.1:4099";
-    process.env.BIZAR_DASHBOARD_PASSWORD = "test-password-1234567890abcdef";
-
-    try {
-      const pub = createDashboardPublisher({ logger });
-      await pub.start();
-      expect(pub.isReady()).toBe(true);
-      expect(
-        logger.lines.some((l) => l.includes("url=http://127.0.0.1:4099")),
-      ).toBe(true);
-      pub.stop();
-    } finally {
-      delete process.env.BIZAR_DASHBOARD_URL;
-      delete process.env.BIZAR_DASHBOARD_PASSWORD;
-    }
-  });
-
-  it("stop() clears ready state and drops queue", async () => {
-    const logger = makeLogger();
-    process.env.BIZAR_DASHBOARD_PASSWORD = "test-password-1234567890abcdef";
-
-    try {
-      const pub = createDashboardPublisher({ logger });
-      await pub.start();
-      expect(pub.isReady()).toBe(true);
-      pub.stop();
-      expect(pub.isReady()).toBe(false);
-      // Subsequent publish should be a no-op (drops because not ready).
-      await pub.publish({
-        type: "session.created",
-        properties: { sessionId: "ses_x", agent: "thor" },
-      });
-      // Just verifies it doesn't throw.
-    } finally {
-      delete process.env.BIZAR_DASHBOARD_PASSWORD;
-    }
-  });
-});