@polderlabs/bizar 6.2.5 → 6.3.0

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

@@ -1,125 +0,0 @@
-/**
- * plugins/bizar/tests/odin.test.ts
- *
- * Unit tests for the Odin orchestrator decomposition logic.
- *
- * Odin takes a user prompt, decomposes it into subtasks, and assigns
- * roles based on keyword analysis. v1 uses heuristic sentence splitting
- * + role templates (no LLM in the loop). These tests verify that
- * decomposition produces sensible outputs for representative inputs.
- */
-import { describe, test, expect } from "bun:test";
-
-import { decomposeTask, buildOdinPrompt, type OdinDecomposition } from "../src/odin";
-
-describe("decomposeTask — single-sentence fallback", () => {
-  test("returns 2-step research+implement default", () => {
-    const out = decomposeTask("Build a CLI todo app");
-    expect(out.subtasks).toHaveLength(2);
-    expect(out.subtasks[0].role).toBe("mimir");
-    expect(out.subtasks[1].role).toBe("thor");
-    expect(out.subtasks[0].blocking).toBe(true);
-    expect(out.estimatedAgents).toBe(3);
-    expect(out.rationale).toContain("defaulted");
-  });
-
-  test("empty task → empty decomposition", () => {
-    const out = decomposeTask("");
-    expect(out.subtasks).toEqual([]);
-    expect(out.estimatedAgents).toBe(0);
-  });
-
-  test("whitespace-only task → empty decomposition", () => {
-    const out = decomposeTask("   \n\t  ");
-    expect(out.subtasks).toEqual([]);
-  });
-});
-
-describe("decomposeTask — sentence splitting", () => {
-  test("splits on period + space", () => {
-    const out = decomposeTask("Research the auth library. Implement the OAuth flow. Test the integration.");
-    expect(out.subtasks.length).toBeGreaterThanOrEqual(2);
-    expect(out.subtasks[0].role).toBe("mimir"); // research
-    expect(out.subtasks[1].role).toBe("thor"); // implement
-    expect(out.subtasks[2].role).toBe("forseti"); // test
-  });
-
-  test("splits on ' and ' when no periods", () => {
-    const out = decomposeTask("Research auth libraries and implement the OAuth flow");
-    expect(out.subtasks).toHaveLength(2);
-  });
-
-  test("caps at maxSubtasks (default 4)", () => {
-    const out = decomposeTask(
-      "Step A. Step B. Step C. Step D. Step E. Step F. Step G.",
-    );
-    expect(out.subtasks.length).toBeLessThanOrEqual(4);
-  });
-
-  test("merges adjacent same-role sentences when overflowing", () => {
-    // 7 sentences that all map to "thor" — should merge down to ≤4.
-    const out = decomposeTask(
-      "Build a function. Build another function. Build a class. " +
-      "Build a service. Build an API. Build a CLI. Test the result.",
-    );
-    expect(out.subtasks.length).toBeLessThanOrEqual(4);
-    // First subtask should still be thor (build keyword).
-    expect(out.subtasks[0].role).toBe("thor");
-  });
-});
-
-describe("decomposeTask — role assignment", () => {
-  test("UI-related → baldr", () => {
-    const out = decomposeTask("Design a new UI for the dashboard. Animate the buttons.");
-    const roles = out.subtasks.map((s) => s.role);
-    expect(roles.some((r) => r === "baldr")).toBe(true);
-  });
-
-  test("testing-related → forseti", () => {
-    const out = decomposeTask("Add unit tests for the parser and verify coverage.");
-    const roles = out.subtasks.map((s) => s.role);
-    expect(roles.some((r) => r === "forseti")).toBe(true);
-  });
-
-  test("research-related → mimir", () => {
-    const out = decomposeTask("Investigate the docs. Survey the codebase. Analyze patterns.");
-    const roles = out.subtasks.map((s) => s.role);
-    expect(roles.some((r) => r === "mimir")).toBe(true);
-  });
-
-  test("debug-related → tyr", () => {
-    const out = decomposeTask("Debug the bug. Investigate the root cause.");
-    const roles = out.subtasks.map((s) => s.role);
-    expect(roles.some((r) => r === "tyr")).toBe(true);
-  });
-});
-
-describe("buildOdinPrompt", () => {
-  test("includes mission, subtasks, and rationale", () => {
-    const decomp = decomposeTask("Build a CLI todo app");
-    const prompt = buildOdinPrompt("Build a CLI todo app", decomp);
-    expect(prompt).toContain("You are Odin");
-    expect(prompt).toContain("## Mission");
-    expect(prompt).toContain("Build a CLI todo app");
-    expect(prompt).toContain("## Subtasks");
-    expect(prompt).toContain("## Coordination");
-    expect(prompt).toContain("## Rationale");
-  });
-
-  test("marks blocking subtasks explicitly", () => {
-    const decomp: OdinDecomposition = {
-      subtasks: [
-        { title: "Research", prompt: "do research", role: "mimir", blocking: true },
-        { title: "Implement", prompt: "implement", role: "thor" },
-      ],
-      estimatedAgents: 3,
-      rationale: "test",
-    };
-    const prompt = buildOdinPrompt("x", decomp);
-    expect(prompt).toContain("blocking");
-    // The non-blocking entry should not have "blocking" appended.
-    const implMatch = prompt.match(/2\.\s+\*\*Implement\*\*/);
-    expect(implMatch).toBeTruthy();
-    expect(prompt.indexOf("(thor, blocking)")).toBeLessThan(prompt.indexOf("(thor)"));
-  });
-});

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

@@ -1,329 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import os from "node:os";
-import path from "node:path";
-import {
-  DEFAULT_OPTIONS,
-  expandHome,
-  findOffendingPath,
-  findSecretDirMatch,
-  normalizeOptions,
-  readEnvFlags,
-  type NormalizedOptions,
-} from "../src/options";
-
-const D = DEFAULT_OPTIONS;
-
-// ── expandHome ────────────────────────────────────────────────────────────────
-
-test("expandHome converts ~ to homedir", () => {
-  const home = process.env.HOME ?? "/home/test";
-  expect(expandHome("~")).toBe(home);
-});
-
-test("expandHome converts ~-prefixed paths", () => {
-  const home = process.env.HOME ?? "/home/test";
-  expect(expandHome("~/foo/bar")).toBe(`${home}/foo/bar`);
-});
-
-test("expandHome leaves absolute paths alone", () => {
-  expect(expandHome("/absolute/path")).toBe("/absolute/path");
-});
-
-// ── normalizeOptions ──────────────────────────────────────────────────────────
-
-describe("normalizeOptions", () => {
-  test("returns DEFAULT_OPTIONS when passed undefined", () => {
-    const { options, notes } = normalizeOptions(undefined);
-    expect(options.loopThresholdWarn).toBe(D.loopThresholdWarn);
-    expect(options.loopThresholdEscalate).toBe(D.loopThresholdEscalate);
-    expect(options.loopThresholdBlock).toBe(D.loopThresholdBlock);
-    expect(options.loopWindowSize).toBe(D.loopWindowSize);
-    expect(options.logDir).toBe(D.logDir);
-    expect(options.stateDir).toBe(D.stateDir);
-    expect(options.logRotationBytes).toBe(D.logRotationBytes);
-    expect(notes).toContain(`loopThresholdWarn defaulted to ${D.loopThresholdWarn}`);
-  });
-
-  test("returns DEFAULT_OPTIONS when passed empty object", () => {
-    const { options, notes } = normalizeOptions({});
-    expect(options.loopThresholdWarn).toBe(D.loopThresholdWarn);
-    expect(notes).toContain(`loopThresholdWarn defaulted to ${D.loopThresholdWarn}`);
-  });
-
-  test("negative loopThresholdWarn is clamped to 1", () => {
-    const { options, notes } = normalizeOptions({ loopThresholdWarn: -5 });
-    expect(options.loopThresholdWarn).toBe(1);
-    expect(notes).toContain("loopThresholdWarn -5 clamped to 1");
-  });
-
-  test("zero loopThresholdWarn is clamped to 1", () => {
-    const { options } = normalizeOptions({ loopThresholdWarn: 0 });
-    expect(options.loopThresholdWarn).toBe(1);
-  });
-
-  test("loopThresholdWarn of 3 is preserved", () => {
-    const { options } = normalizeOptions({ loopThresholdWarn: 3 });
-    expect(options.loopThresholdWarn).toBe(3);
-  });
-
-  test("warn >= escalate → escalate bumped above warn", () => {
-    // warn=5, escalate=5  → escalate becomes 6
-    const { options, notes } = normalizeOptions({ loopThresholdWarn: 5, loopThresholdEscalate: 5 });
-    expect(options.loopThresholdWarn).toBe(5);
-    expect(options.loopThresholdEscalate).toBe(6);
-    expect(notes.some((n) => n.includes("adjusted from 5 to 6"))).toBe(true);
-  });
-
-  test("escalate >= block → block bumped above escalate", () => {
-    // escalate=8, block=8  → block becomes 9
-    const { options, notes } = normalizeOptions({ loopThresholdEscalate: 8, loopThresholdBlock: 8 });
-    expect(options.loopThresholdEscalate).toBe(8);
-    expect(options.loopThresholdBlock).toBe(9);
-    expect(notes.some((n) => n.includes("adjusted from 8 to 9"))).toBe(true);
-  });
-
-  test("loopWindowSize below 3 is clamped to 3", () => {
-    const { options, notes } = normalizeOptions({ loopWindowSize: 1 });
-    expect(options.loopWindowSize).toBe(3);
-    expect(notes).toContain("loopWindowSize 1 clamped to 3 (minimum)");
-  });
-
-  test("loopWindowSize above 50 is clamped to 50", () => {
-    const { options, notes } = normalizeOptions({ loopWindowSize: 200 });
-    expect(options.loopWindowSize).toBe(50);
-    expect(notes).toContain("loopWindowSize 200 clamped to 50 (maximum)");
-  });
-
-  test("loopWindowSize within [3,50] is preserved", () => {
-    const { options } = normalizeOptions({ loopWindowSize: 25 });
-    expect(options.loopWindowSize).toBe(25);
-  });
-
-  test("block > window + 2 → block clamped down", () => {
-    // block=50, window=10 → block must be ≤ 12
-    const { options, notes } = normalizeOptions({ loopThresholdBlock: 50, loopWindowSize: 10 });
-    expect(options.loopThresholdBlock).toBe(12);
-    expect(notes.some((n) => n.includes("adjusted to 12"))).toBe(true);
-  });
-
-  test("NaN threshold → uses default", () => {
-    const { options } = normalizeOptions({ loopThresholdWarn: NaN });
-    expect(options.loopThresholdWarn).toBe(D.loopThresholdWarn);
-  });
-
-  test("string threshold value is parsed", () => {
-    const { options } = normalizeOptions({ loopThresholdWarn: "7" });
-    expect(options.loopThresholdWarn).toBe(7);
-  });
-
-  test("non-numeric string threshold → uses default", () => {
-    const { options } = normalizeOptions({ loopThresholdWarn: "not-a-number" });
-    expect(options.loopThresholdWarn).toBe(D.loopThresholdWarn);
-  });
-
-  test("logRotationBytes below 1024 is clamped to 1024", () => {
-    const { options, notes } = normalizeOptions({ logRotationBytes: 500 });
-    expect(options.logRotationBytes).toBe(1024);
-    expect(notes).toContain("logRotationBytes 500 clamped to 1024 (minimum)");
-  });
-
-  test("custom logDir and stateDir are preserved", () => {
-    const { options } = normalizeOptions({ logDir: path.join(os.tmpdir(), "my-logs"), stateDir: path.join(os.tmpdir(), "my-state") });
-    expect(options.logDir).toBe(path.join(os.tmpdir(), "my-logs"));
-    expect(options.stateDir).toBe(path.join(os.tmpdir(), "my-state"));
-  });
-});
-
-// ── findSecretDirMatch ───────────────────────────────────────────────────────
-
-describe("findSecretDirMatch", () => {
-  const home = process.env.HOME ?? "/home/test";
-
-  test("returns null for safe paths", () => {
-    expect(findSecretDirMatch(path.join(os.tmpdir(), "foo"))).toBeNull();
-    expect(findSecretDirMatch("/home/user/project")).toBeNull();
-  });
-
-  test("returns null for paths that are prefix siblings", () => {
-    // ~/.ssh-foo is NOT ~/.ssh
-    expect(findSecretDirMatch(`${home}/.ssh-foo`)).toBeNull();
-    expect(findSecretDirMatch(`${home}/.ssh-foo/bar`)).toBeNull();
-  });
-
-  test("returns the secret kind for exact secret dir", () => {
-    expect(findSecretDirMatch(`${home}/.ssh`)).toBe("~/.ssh");
-    expect(findSecretDirMatch(`${home}/.gnupg`)).toBe("~/.gnupg");
-    expect(findSecretDirMatch(`${home}/.aws`)).toBe("~/.aws");
-    expect(findSecretDirMatch(`${home}/.kube`)).toBe("~/.kube");
-  });
-
-  test("returns the secret kind for descendant paths", () => {
-    expect(findSecretDirMatch(`${home}/.ssh/keys`)).toBe("~/.ssh");
-    expect(findSecretDirMatch(`${home}/.ssh/keys/id_rsa`)).toBe("~/.ssh");
-    expect(findSecretDirMatch(`${home}/.gnupg/private`)).toBe("~/.gnupg");
-    expect(findSecretDirMatch(`${home}/.aws/credentials`)).toBe("~/.aws");
-    expect(findSecretDirMatch(`${home}/.kube/config`)).toBe("~/.kube");
-  });
-
-  test("tilde paths are expanded before comparison", () => {
-    expect(findSecretDirMatch("~/.ssh")).toBe("~/.ssh");
-    expect(findSecretDirMatch("~/.ssh/id_rsa")).toBe("~/.ssh");
-    expect(findSecretDirMatch("~/some-other-dir")).toBeNull();
-  });
-
-  test("refuses paths inside secret dir", () => {
-    expect(findSecretDirMatch(`${home}/.ssh/../ssh`)).toBeNull(); // resolves outside
-    expect(findSecretDirMatch(`${home}/.ssh/../.ssh/legit`)).toBe("~/.ssh"); // resolves to ~/.ssh
-  });
-});
-
-// ── findOffendingPath ────────────────────────────────────────────────────────
-
-describe("findOffendingPath", () => {
-  test("returns null when both paths are safe", () => {
-    const opts: NormalizedOptions = {
-      ...D,
-      logDir: path.join(os.tmpdir(), "bizar-logs"),
-      stateDir: path.join(os.tmpdir(), "bizar-state"),
-    };
-    expect(findOffendingPath(opts)).toBeNull();
-  });
-
-  test("returns offending logDir when it is inside a secret dir", () => {
-    const home = process.env.HOME ?? "/home/test";
-    const opts: NormalizedOptions = {
-      ...D,
-      logDir: `${home}/.ssh/evil`,
-      stateDir: path.join(os.tmpdir(), "bizar-state"),
-    };
-    const result = findOffendingPath(opts);
-    expect(result).not.toBeNull();
-    expect(result!.kind).toBe("~/.ssh");
-    expect(result!.path).toContain(".ssh");
-  });
-
-  test("returns offending stateDir when it is inside a secret dir", () => {
-    const home = process.env.HOME ?? "/home/test";
-    const opts: NormalizedOptions = {
-      ...D,
-      logDir: path.join(os.tmpdir(), "bizar-logs"),
-      stateDir: `${home}/.aws/creds`,
-    };
-    const result = findOffendingPath(opts);
-    expect(result).not.toBeNull();
-    expect(result!.kind).toBe("~/.aws");
-  });
-
-  test("logDir takes priority over stateDir in error message", () => {
-    const home = process.env.HOME ?? "/home/test";
-    const opts: NormalizedOptions = {
-      ...D,
-      logDir: `${home}/.ssh/evil`,
-      stateDir: `${home}/.gnupg/evil`,
-    };
-    const result = findOffendingPath(opts);
-    // logDir is checked first
-    expect(result!.kind).toBe("~/.ssh");
-  });
-});
-
-// ── readEnvFlags ─────────────────────────────────────────────────────────────
-
-describe("readEnvFlags", () => {
-  test("returns all false when env vars are not set", () => {
-    delete process.env.BIZAR_DISABLE;
-    delete process.env.BIZAR_DISABLE_LOOP;
-    delete process.env.BIZAR_DISABLE_LOG;
-    const flags = readEnvFlags();
-    expect(flags.disable).toBe(false);
-    expect(flags.disableLoop).toBe(false);
-    expect(flags.disableLog).toBe(false);
-  });
-
-  test("BIZAR_DISABLE=1 sets disable=true", () => {
-    process.env.BIZAR_DISABLE = "1";
-    const flags = readEnvFlags();
-    expect(flags.disable).toBe(true);
-    delete process.env.BIZAR_DISABLE;
-  });
-
-  test("BIZAR_DISABLE_LOOP=1 sets disableLoop=true", () => {
-    process.env.BIZAR_DISABLE_LOOP = "1";
-    const flags = readEnvFlags();
-    expect(flags.disableLoop).toBe(true);
-    delete process.env.BIZAR_DISABLE_LOOP;
-  });
-
-  test("BIZAR_DISABLE_LOG=1 sets disableLog=true", () => {
-    process.env.BIZAR_DISABLE_LOG = "1";
-    const flags = readEnvFlags();
-    expect(flags.disableLog).toBe(true);
-    delete process.env.BIZAR_DISABLE_LOG;
-  });
-
-  test("non-1 values are treated as false", () => {
-    process.env.BIZAR_DISABLE = "true";
-    process.env.BIZAR_DISABLE_LOOP = "yes";
-    process.env.BIZAR_DISABLE_LOG = "0";
-    const flags = readEnvFlags();
-    expect(flags.disable).toBe(false);
-    expect(flags.disableLoop).toBe(false);
-    expect(flags.disableLog).toBe(false);
-    delete process.env.BIZAR_DISABLE;
-    delete process.env.BIZAR_DISABLE_LOOP;
-    delete process.env.BIZAR_DISABLE_LOG;
-  });
-});
-
-// ── clineruntimeMaxConsecutiveMistakes ───────────────────────────────────────
-
-describe("clineruntimeMaxConsecutiveMistakes (v0.3.1)", () => {
-  test("default is 10 when neither raw nor env is provided (v6.2.4)", () => {
-    delete process.env.BIZAR_MAX_CONSECUTIVE_MISTAKES;
-    const { options } = normalizeOptions({});
-    expect(options.clineruntimeMaxConsecutiveMistakes).toBe(10);
-  });
-
-  test("raw value is honored when in range", () => {
-    delete process.env.BIZAR_MAX_CONSECUTIVE_MISTAKES;
-    const { options, notes } = normalizeOptions({ clineruntimeMaxConsecutiveMistakes: 15 });
-    expect(options.clineruntimeMaxConsecutiveMistakes).toBe(15);
-    expect(notes.some((n) => n.includes("clineruntimeMaxConsecutiveMistakes"))).toBe(false);
-  });
-
-  test("below-range raw value is clamped to 3 (minimum)", () => {
-    delete process.env.BIZAR_MAX_CONSECUTIVE_MISTAKES;
-    const { options, notes } = normalizeOptions({ clineruntimeMaxConsecutiveMistakes: 1 });
-    expect(options.clineruntimeMaxConsecutiveMistakes).toBe(3);
-    expect(notes.some((n) => n.includes("clamped to 3"))).toBe(true);
-  });
-
-  test("above-range raw value is clamped to 20 (maximum)", () => {
-    delete process.env.BIZAR_MAX_CONSECUTIVE_MISTAKES;
-    const { options, notes } = normalizeOptions({ clineruntimeMaxConsecutiveMistakes: 100 });
-    expect(options.clineruntimeMaxConsecutiveMistakes).toBe(20);
-    expect(notes.some((n) => n.includes("clamped to 20"))).toBe(true);
-  });
-
-  test("raw option takes precedence over env (raw wins when both set)", () => {
-    process.env.BIZAR_MAX_CONSECUTIVE_MISTAKES = "8";
-    const { options, notes } = normalizeOptions({ clineruntimeMaxConsecutiveMistakes: 12 });
-    expect(options.clineruntimeMaxConsecutiveMistakes).toBe(12);
-    expect(notes.some((n) => n.includes("(env)"))).toBe(false);
-    delete process.env.BIZAR_MAX_CONSECUTIVE_MISTAKES;
-  });
-
-  test("env var clamps when out of range", () => {
-    process.env.BIZAR_MAX_CONSECUTIVE_MISTAKES = "999";
-    const { options, notes } = normalizeOptions({});
-    expect(options.clineruntimeMaxConsecutiveMistakes).toBe(20);
-    expect(notes.some((n) => n.includes("(env) clamped"))).toBe(true);
-    delete process.env.BIZAR_MAX_CONSECUTIVE_MISTAKES;
-  });
-
-  test("non-numeric raw falls back to default (10)", () => {
-    delete process.env.BIZAR_MAX_CONSECUTIVE_MISTAKES;
-    const { options } = normalizeOptions({ clineruntimeMaxConsecutiveMistakes: "not-a-number" });
-    expect(options.clineruntimeMaxConsecutiveMistakes).toBe(10);
-  });
-});