@polderlabs/bizar 3.23.1 → 4.2.0

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

@@ -0,0 +1,217 @@
+/**
+ * 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/opencode-runner.test.ts

@@ -0,0 +1,115 @@
+/**
+ * plugins/bizar/tests/tools/opencode-runner.test.ts
+ *
+ * Unit tests for `buildOpencodeRunArgs` — the pure helper extracted
+ * from `plugins/bizar/src/opencode-runner.ts` so the argv passed to
+ * `Bun.spawn(["opencode", "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 `opencode run` silently fell back to the opencode 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 {
+  buildOpencodeRunArgs,
+  type SpawnAgentOptions,
+} from "../../src/opencode-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("buildOpencodeRunArgs — Bug 1 regression: --agent flag", () => {
+  it("argv contains the --agent flag followed by the agent name", () => {
+    const args = buildOpencodeRunArgs(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 = buildOpencodeRunArgs(baseOpts({ agent }));
+      expect(args[args.indexOf("--agent") + 1]).toBe(agent);
+    }
+  });
+
+  it("throws a clear error when opts.agent is empty", () => {
+    expect(() => buildOpencodeRunArgs(baseOpts({ agent: "" }))).toThrow(
+      /agent is required/,
+    );
+  });
+});
+
+describe("buildOpencodeRunArgs — Bug 2 regression: migrated model ID", () => {
+  it("emits --model with the migrated 'minimax/minimax-m3' ID", () => {
+    const args = buildOpencodeRunArgs(
+      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 = buildOpencodeRunArgs(
+      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 = buildOpencodeRunArgs(baseOpts({ model: undefined }));
+    expect(args).not.toContain("--model");
+  });
+});
+
+describe("buildOpencodeRunArgs — arg layout", () => {
+  it("starts with 'opencode' 'run'", () => {
+    const args = buildOpencodeRunArgs(baseOpts());
+    expect(args[0]).toBe("opencode");
+    expect(args[1]).toBe("run");
+  });
+
+  it("appends prompt after the -- separator", () => {
+    const args = buildOpencodeRunArgs(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 = buildOpencodeRunArgs(baseOpts({ title: "custom title" }));
+    expect(a[a.indexOf("--title") + 1]).toBe("custom title");
+
+    const b = buildOpencodeRunArgs(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 = buildOpencodeRunArgs(baseOpts({ worktree: "/srv/repo" }));
+    expect(args[args.indexOf("--dir") + 1]).toBe("/srv/repo");
+    expect(args[args.indexOf("--log-level") + 1]).toBe("INFO");
+  });
+});