@polderlabs/bizar 6.2.5 → 6.3.0

package/plugins/bizar/tests/tools/bg-status.test.ts

@@ -1,217 +0,0 @@
-/**
- * bizar_status tool tests.
- *
- * Tests: list all, single instance, filter, no instances,
- * returns documented shape per §7.1. Read-only — any agent can call.
- */
-
-import { describe, it, expect } from "bun:test";
-
-// ---------------------------------------------------------------------------
-// Fake BackgroundState for testing
-// ---------------------------------------------------------------------------
-
-interface BackgroundState {
-  instanceId: string;
-  agent: string;
-  status: "pending" | "running" | "done" | "failed" | "killed" | "timed_out";
-  startedAt: number;
-  completedAt?: number;
-  toolCallCount: number;
-  promptPreview: string;
-  resultPreview?: string;
-  error?: string;
-  parentAgent: string;
-  parentInstanceId?: string;
-  durationMs?: number;
-}
-
-function makeBgState(overrides: Partial<BackgroundState> = {}): BackgroundState {
-  return {
-    instanceId: "bgr_test_01",
-    agent: "mimir",
-    status: "running",
-    startedAt: Date.now() - 60_000,
-    toolCallCount: 12,
-    promptPreview: "Do the research on X",
-    resultPreview: undefined,
-    error: undefined,
-    parentAgent: "odin",
-    parentInstanceId: undefined,
-    durationMs: 60_000,
-    ...overrides,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Fake bizar_status implementation (read-only — any agent can call)
-// ---------------------------------------------------------------------------
-
-function bizar_status(
-  args: { instanceId?: string } | undefined,
-  _ctx: { agent: string },
-  instances: Map<string, BackgroundState>,
-): BackgroundState[] | BackgroundState | { error: string } {
-  if (!args || args.instanceId === undefined) {
-    // Return all
-    return [...instances.values()];
-  }
-
-  const inst = instances.get(args.instanceId);
-  if (!inst) {
-    return { error: `Instance ${args.instanceId} not found` };
-  }
-  return inst;
-}
-
-// ---------------------------------------------------------------------------
-// In-memory instance store for tests
-// ---------------------------------------------------------------------------
-
-const instances = new Map<string, BackgroundState>();
-instances.set("bgr_01", makeBgState({ instanceId: "bgr_01", agent: "mimir", status: "running" }));
-instances.set("bgr_02", makeBgState({ instanceId: "bgr_02", agent: "thor", status: "done", resultPreview: "Done!", completedAt: Date.now() }));
-instances.set("bgr_03", makeBgState({ instanceId: "bgr_03", agent: "tyr", status: "failed", error: "Loop protection: 12 identical calls to read" }));
-
-function makeCompletedState(overrides: Partial<BackgroundState> = {}): BackgroundState {
-  return {
-    instanceId: "bgr_completed",
-    agent: "mimir",
-    status: "done",
-    startedAt: Date.now() - 120_000,
-    toolCallCount: 5,
-    promptPreview: "Quick task",
-    resultPreview: "All done!",
-    error: undefined,
-    parentAgent: "odin",
-    parentInstanceId: undefined,
-    durationMs: 120_000,
-    ...overrides,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// bizarre_status — list all
-// ---------------------------------------------------------------------------
-
-describe("bizar_status — list all", () => {
-  it("returns all instances when called with no args", () => {
-    const result = bizar_status(undefined, { agent: "odin" }, instances);
-    expect(Array.isArray(result)).toBe(true);
-    expect((result as BackgroundState[]).length).toBe(3);
-  });
-
-  it("includes all documented fields per instance (§7.1)", () => {
-    const all = bizar_status(undefined, { agent: "odin" }, instances) as BackgroundState[];
-    const first = all[0];
-    expect(first).toHaveProperty("instanceId");
-    expect(first).toHaveProperty("agent");
-    expect(first).toHaveProperty("status");
-    expect(first).toHaveProperty("startedAt");
-    expect(first).toHaveProperty("toolCallCount");
-    expect(first).toHaveProperty("promptPreview");
-    expect(first).toHaveProperty("resultPreview");
-    expect(first).toHaveProperty("error");
-    expect(first).toHaveProperty("parentAgent");
-  });
-
-  it("returns instances in any order (stable map iteration)", () => {
-    const all = bizar_status(undefined, { agent: "odin" }, instances) as BackgroundState[];
-    const ids = all.map((i) => i.instanceId);
-    expect(ids).toContain("bgr_01");
-    expect(ids).toContain("bgr_02");
-    expect(ids).toContain("bgr_03");
-  });
-
-  it("any agent can call bizar_status (read-only)", () => {
-    for (const agent of ["odin", "vor", "frigg", "mimir", "thor", "tyr", "heimdall"]) {
-      const result = bizar_status(undefined, { agent }, instances);
-      expect(Array.isArray(result)).toBe(true);
-    }
-  });
-});
-
-// ---------------------------------------------------------------------------
-// bizar_status — single instance
-// ---------------------------------------------------------------------------
-
-describe("bizar_status — single instance", () => {
-  it("returns the requested instance", () => {
-    const result = bizar_status({ instanceId: "bgr_02" }, { agent: "odin" }, instances);
-    expect((result as BackgroundState).instanceId).toBe("bgr_02");
-    expect((result as BackgroundState).agent).toBe("thor");
-    expect((result as BackgroundState).status).toBe("done");
-  });
-
-  it("returns error for unknown instanceId", () => {
-    const result = bizar_status({ instanceId: "bgr_unknown" }, { agent: "odin" }, instances);
-    expect(result).toHaveProperty("error");
-    expect((result as { error: string }).error).toContain("not found");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Status values
-// ---------------------------------------------------------------------------
-
-describe("bizar_status — status values", () => {
-  it("running instance shows running status", () => {
-    const result = bizar_status({ instanceId: "bgr_01" }, { agent: "odin" }, instances) as BackgroundState;
-    expect(result.status).toBe("running");
-    expect(result.resultPreview).toBeUndefined();
-  });
-
-  it("done instance shows resultPreview", () => {
-    const result = bizar_status({ instanceId: "bgr_02" }, { agent: "odin" }, instances) as BackgroundState;
-    expect(result.status).toBe("done");
-    expect(result.resultPreview).toBe("Done!");
-  });
-
-  it("failed instance shows error", () => {
-    const result = bizar_status({ instanceId: "bgr_03" }, { agent: "odin" }, instances) as BackgroundState;
-    expect(result.status).toBe("failed");
-    expect(result.error).toContain("Loop protection");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// No instances
-// ---------------------------------------------------------------------------
-
-describe("bizar_status — no instances", () => {
-  it("returns empty array when no instances exist", () => {
-    const emptyMap = new Map<string, BackgroundState>();
-    const result = bizar_status(undefined, { agent: "odin" }, emptyMap);
-    expect(Array.isArray(result)).toBe(true);
-    expect((result as BackgroundState[]).length).toBe(0);
-  });
-
-  it("returns error for unknown instanceId when map is empty", () => {
-    const emptyMap = new Map<string, BackgroundState>();
-    const result = bizar_status({ instanceId: "bgr_anything" }, { agent: "odin" }, emptyMap);
-    expect(result).toHaveProperty("error");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Duration calculation
-// ---------------------------------------------------------------------------
-
-describe("bizar_status — durationMs", () => {
-  it("durationMs is derived from startedAt and now (or completedAt)", () => {
-    // Test the concept: durationMs is computed from startedAt vs now/completedAt
-    // In a real instance, running.durationMs would be Date.now() - startedAt
-    // Here we just verify the field exists and is a number
-    const running = makeBgState({ startedAt: Date.now() - 30_000, status: "running" });
-    expect(typeof running.durationMs).toBe("number");
-    expect(running.durationMs).toBeGreaterThan(0);
-  });
-
-  it("durationMs uses completedAt when instance is done", () => {
-    // completedAt - startedAt gives the actual duration
-    const startedAt = Date.now() - 60_000;
-    const completedAt = Date.now() - 30_000;
-    const expectedDuration = completedAt - startedAt;
-    expect(expectedDuration).toBe(30_000);
-  });
-});

package/plugins/bizar/tests/tools/cline-runner.test.ts

@@ -1,115 +0,0 @@
-/**
- * plugins/bizar/tests/tools/cline-runner.test.ts
- *
- * Unit tests for `buildClineRunArgs` — the pure helper extracted
- * from `plugins/bizar/src/cline-runner.ts` so the argv passed to
- * `Bun.spawn(["cline", "run", ...])` can be asserted without
- * spawning a real process.
- *
- * These tests pin the two regressions that motivated the extraction:
- *
- *   1. Bug 1 (HIGH): the `--agent` flag was missing from the args list,
- *      so `cline run` silently fell back to the cline default
- *      agent and broke session attribution.
- *
- *   2. Bug 2 (HIGH): the OpenRouter model IDs were renamed. Tests assert
- *      the new `minimax/minimax-m3` / `minimax/minimax-m2.7` format so
- *      a stale `openrouter/minimax-m3` reference is caught immediately.
- */
-
-import { describe, it, expect } from "bun:test";
-import {
-  buildClineRunArgs,
-  type SpawnAgentOptions,
-} from "../../src/cline-runner";
-
-function baseOpts(overrides: Partial<SpawnAgentOptions> = {}): SpawnAgentOptions {
-  return {
-    agent: "thor",
-    prompt: "Investigate the auth module",
-    worktree: "/tmp/worktree",
-    logPath: "/tmp/worktree/.bgr/log.log",
-    ...overrides,
-  };
-}
-
-describe("buildClineRunArgs — Bug 1 regression: --agent flag", () => {
-  it("argv contains the --agent flag followed by the agent name", () => {
-    const args = buildClineRunArgs(baseOpts({ agent: "thor" }));
-    const i = args.indexOf("--agent");
-    expect(i).toBeGreaterThanOrEqual(0);
-    expect(args[i + 1]).toBe("thor");
-  });
-
-  it("--agent value matches opts.agent exactly (no default fallback)", () => {
-    for (const agent of ["mimir", "thor", "tyr", "heimdall", "hermod"]) {
-      const args = buildClineRunArgs(baseOpts({ agent }));
-      expect(args[args.indexOf("--agent") + 1]).toBe(agent);
-    }
-  });
-
-  it("throws a clear error when opts.agent is empty", () => {
-    expect(() => buildClineRunArgs(baseOpts({ agent: "" }))).toThrow(
-      /agent is required/,
-    );
-  });
-});
-
-describe("buildClineRunArgs — Bug 2 regression: migrated model ID", () => {
-  it("emits --model with the migrated 'minimax/minimax-m3' ID", () => {
-    const args = buildClineRunArgs(
-      baseOpts({
-        model: { providerID: "minimax", modelID: "minimax-m3" },
-      }),
-    );
-    const i = args.indexOf("--model");
-    expect(i).toBeGreaterThanOrEqual(0);
-    expect(args[i + 1]).toBe("minimax/minimax-m3");
-    // The full flag pair proves the migration target — the OLD ID would
-    // be 'openrouter/minimax-m3'; the NEW ID is 'minimax/minimax-m3'.
-    expect(args[i + 1]).not.toBe("openrouter/minimax-m3");
-  });
-
-  it("emits --model with the migrated 'minimax/minimax-m2.7' ID", () => {
-    const args = buildClineRunArgs(
-      baseOpts({
-        model: { providerID: "minimax", modelID: "minimax-m2.7" },
-      }),
-    );
-    expect(args[args.indexOf("--model") + 1]).toBe("minimax/minimax-m2.7");
-  });
-
-  it("omits --model entirely when opts.model is not provided", () => {
-    const args = buildClineRunArgs(baseOpts({ model: undefined }));
-    expect(args).not.toContain("--model");
-  });
-});
-
-describe("buildClineRunArgs — arg layout", () => {
-  it("starts with 'cline' 'run'", () => {
-    const args = buildClineRunArgs(baseOpts());
-    expect(args[0]).toBe("cline");
-    expect(args[1]).toBe("run");
-  });
-
-  it("appends prompt after the -- separator", () => {
-    const args = buildClineRunArgs(baseOpts({ prompt: "do the thing" }));
-    const sep = args.indexOf("--");
-    expect(sep).toBeGreaterThanOrEqual(0);
-    expect(args[sep + 1]).toBe("do the thing");
-  });
-
-  it("uses opts.title when provided, else defaults to bgr:<agent>:<ts>", () => {
-    const a = buildClineRunArgs(baseOpts({ title: "custom title" }));
-    expect(a[a.indexOf("--title") + 1]).toBe("custom title");
-
-    const b = buildClineRunArgs(baseOpts({ agent: "mimir" }));
-    expect(b[b.indexOf("--title") + 1]).toMatch(/^bgr:mimir:\d+$/);
-  });
-
-  it("wires --dir to opts.worktree and --log-level to INFO", () => {
-    const args = buildClineRunArgs(baseOpts({ worktree: "/srv/repo" }));
-    expect(args[args.indexOf("--dir") + 1]).toBe("/srv/repo");
-    expect(args[args.indexOf("--log-level") + 1]).toBe("INFO");
-  });
-});