akm-cli 0.7.0 → 0.7.2

package/dist/tests/agent/agent-config.test.js

@@ -1,221 +0,0 @@
-/**
- * Tests for the `agent.*` config block parser and profile resolver.
- *
- * Acceptance coverage:
- *   • Parser accepts the documented shape.
- *   • Unknown keys are warn-and-ignored (no throw).
- *   • Built-in profiles resolve for opencode, claude, codex, gemini, aider.
- *   • Missing block surfaces a stable ConfigError via requireAgentProfile.
- */
-import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
-const warnings = [];
-// NOTE: `mock.module` in Bun is process-global — once installed it persists
-// across test files run in the same `bun test` invocation. So this mock has
-// to remain a faithful drop-in for the real `src/core/warn` module:
-//
-//   1. Every export that the real module ships must be represented here,
-//      otherwise tests in other files that import a missing export get
-//      `undefined` and silently break (issue #273).
-//   2. `warn()` must also forward to `console.warn` so other test files that
-//      capture stderr (e.g. the noise-gate tests in
-//      tests/workflows/indexer-rejection.test.ts) continue to see the calls.
-//      We push to the local `warnings[]` so this file's own assertions still
-//      work, AND forward to `console.warn` so callers that intercept it
-//      still observe what was emitted.
-let mockedQuiet = false;
-let mockedVerbose = false;
-mock.module("../../src/core/warn", () => ({
-    warn: (...args) => {
-        warnings.push(args.join(" "));
-        if (!mockedQuiet)
-            console.warn(...args);
-    },
-    warnVerbose: (...args) => {
-        if (!mockedVerbose)
-            return;
-        warnings.push(args.join(" "));
-        if (!mockedQuiet)
-            console.warn(...args);
-    },
-    setQuiet: (value) => {
-        mockedQuiet = value;
-    },
-    resetQuiet: () => {
-        mockedQuiet = false;
-    },
-    isQuiet: () => mockedQuiet,
-    setVerbose: (value) => {
-        mockedVerbose = value;
-    },
-    resetVerbose: () => {
-        mockedVerbose = false;
-    },
-    isVerbose: () => {
-        const env = process.env.AKM_VERBOSE?.trim().toLowerCase();
-        if (env === "1" || env === "true" || env === "yes" || env === "on")
-            return true;
-        if (env === "0" || env === "false" || env === "no" || env === "off")
-            return false;
-        return mockedVerbose;
-    },
-}));
-beforeEach(() => {
-    warnings.length = 0;
-});
-afterEach(() => {
-    warnings.length = 0;
-});
-describe("parseAgentConfig", () => {
-    test("returns undefined when block is absent", async () => {
-        const { parseAgentConfig } = await import("../../src/integrations/agent/config");
-        expect(parseAgentConfig(undefined)).toBeUndefined();
-        expect(warnings).toHaveLength(0);
-    });
-    test("warns and returns undefined for non-object root", async () => {
-        const { parseAgentConfig } = await import("../../src/integrations/agent/config");
-        expect(parseAgentConfig("oops")).toBeUndefined();
-        expect(warnings.some((w) => w.includes('"agent"'))).toBe(true);
-    });
-    test("accepts the documented shape", async () => {
-        const { parseAgentConfig } = await import("../../src/integrations/agent/config");
-        const parsed = parseAgentConfig({
-            default: "opencode",
-            timeoutMs: 30000,
-            profiles: {
-                opencode: { bin: "opencode", args: ["--non-interactive"], stdio: "captured" },
-            },
-        });
-        expect(parsed?.default).toBe("opencode");
-        expect(parsed?.timeoutMs).toBe(30000);
-        expect(parsed?.profiles?.opencode).toEqual({
-            bin: "opencode",
-            args: ["--non-interactive"],
-            stdio: "captured",
-        });
-    });
-    test("warn-and-ignore unknown top-level keys (no throw)", async () => {
-        const { parseAgentConfig } = await import("../../src/integrations/agent/config");
-        const parsed = parseAgentConfig({
-            default: "claude",
-            moonRoutingTable: { foo: "bar" }, // unknown
-        });
-        expect(parsed?.default).toBe("claude");
-        expect(warnings.some((w) => w.includes("moonRoutingTable"))).toBe(true);
-    });
-    test("warn-and-ignore unknown per-profile keys", async () => {
-        const { parseAgentConfig } = await import("../../src/integrations/agent/config");
-        const parsed = parseAgentConfig({
-            profiles: {
-                custom: { bin: "ok", quirks: "nope" },
-            },
-        });
-        expect(parsed?.profiles?.custom?.bin).toBe("ok");
-        expect(warnings.some((w) => w.includes("quirks"))).toBe(true);
-    });
-    test("warn-and-ignore malformed timeoutMs", async () => {
-        const { parseAgentConfig } = await import("../../src/integrations/agent/config");
-        const parsed = parseAgentConfig({ timeoutMs: "60s" });
-        expect(parsed?.timeoutMs).toBeUndefined();
-        expect(warnings.some((w) => w.includes("timeoutMs"))).toBe(true);
-    });
-    test("rejects non-string args entries", async () => {
-        const { parseAgentConfig } = await import("../../src/integrations/agent/config");
-        const parsed = parseAgentConfig({
-            profiles: { opencode: { args: ["--ok", 5, "--also-ok"] } },
-        });
-        expect(parsed?.profiles?.opencode?.args).toEqual(["--ok", "--also-ok"]);
-        expect(warnings.some((w) => w.includes("args"))).toBe(true);
-    });
-    test("rejects bad stdio mode", async () => {
-        const { parseAgentConfig } = await import("../../src/integrations/agent/config");
-        const parsed = parseAgentConfig({
-            profiles: { opencode: { stdio: "weird" } },
-        });
-        expect(parsed?.profiles?.opencode?.stdio).toBeUndefined();
-        expect(warnings.some((w) => w.includes("stdio"))).toBe(true);
-    });
-});
-describe("built-in profile resolution", () => {
-    test("resolves opencode, claude, codex, gemini, aider out of the box", async () => {
-        const { BUILTIN_AGENT_PROFILE_NAMES, getBuiltinAgentProfile } = await import("../../src/integrations/agent/profiles");
-        expect(BUILTIN_AGENT_PROFILE_NAMES).toEqual(["aider", "claude", "codex", "gemini", "opencode"]);
-        for (const name of ["opencode", "claude", "codex", "gemini", "aider"]) {
-            const profile = getBuiltinAgentProfile(name);
-            expect(profile).toBeDefined();
-            expect(profile?.bin).toBeTruthy();
-            expect(profile?.envPassthrough).toContain("PATH");
-        }
-    });
-    test("user override merges on top of built-in", async () => {
-        const { resolveAgentProfile } = await import("../../src/integrations/agent/config");
-        const merged = resolveAgentProfile("opencode", { args: ["--scripted"], stdio: "captured" });
-        expect(merged?.bin).toBe("opencode"); // built-in default
-        expect(merged?.args).toEqual(["--scripted"]); // override
-        expect(merged?.stdio).toBe("captured"); // override
-        expect(merged?.envPassthrough).toContain("PATH"); // built-in retained
-    });
-    test("user-defined profile (no built-in) requires bin", async () => {
-        const { resolveAgentProfile } = await import("../../src/integrations/agent/config");
-        expect(resolveAgentProfile("rover", undefined)).toBeUndefined();
-        expect(resolveAgentProfile("rover", {})).toBeUndefined();
-        const ok = resolveAgentProfile("rover", { bin: "rover-cli", args: ["--silent"] });
-        expect(ok?.bin).toBe("rover-cli");
-        expect(ok?.args).toEqual(["--silent"]);
-        expect(ok?.stdio).toBe("captured");
-    });
-    test("envPassthrough merges base + override", async () => {
-        const { resolveAgentProfile } = await import("../../src/integrations/agent/config");
-        const merged = resolveAgentProfile("opencode", { envPassthrough: ["MY_TOKEN"] });
-        expect(merged?.envPassthrough).toContain("PATH"); // from built-in
-        expect(merged?.envPassthrough).toContain("MY_TOKEN"); // from override
-    });
-    test("listAgentProfileNames includes built-ins plus user-defined", async () => {
-        const { listAgentProfileNames } = await import("../../src/integrations/agent/config");
-        const names = listAgentProfileNames({ profiles: { rover: { bin: "rover" } } });
-        expect(names).toContain("rover");
-        expect(names).toContain("opencode");
-        expect(names).toContain("claude");
-    });
-});
-describe("requireAgentProfile", () => {
-    test("throws ConfigError when the agent block is missing", async () => {
-        const { requireAgentProfile } = await import("../../src/integrations/agent/config");
-        const { ConfigError } = await import("../../src/core/errors");
-        let caught;
-        try {
-            requireAgentProfile(undefined);
-        }
-        catch (err) {
-            caught = err;
-        }
-        expect(caught).toBeInstanceOf(ConfigError);
-        expect(caught.message).toContain("agent commands are disabled");
-        const hint = caught.hint();
-        expect(hint).toBeTruthy();
-        expect(hint).toContain("akm setup");
-    });
-    test("throws when no default and no requested name", async () => {
-        const { requireAgentProfile } = await import("../../src/integrations/agent/config");
-        const { ConfigError } = await import("../../src/core/errors");
-        let caught;
-        try {
-            requireAgentProfile({});
-        }
-        catch (err) {
-            caught = err;
-        }
-        expect(caught).toBeInstanceOf(ConfigError);
-        expect(caught.message).toContain("require a profile");
-    });
-    test("resolves the requested profile when valid", async () => {
-        const { requireAgentProfile } = await import("../../src/integrations/agent/config");
-        const profile = requireAgentProfile({ default: "claude" });
-        expect(profile.name).toBe("claude");
-        expect(profile.bin).toBe("claude");
-    });
-    test("explicit requested name beats config default", async () => {
-        const { requireAgentProfile } = await import("../../src/integrations/agent/config");
-        const profile = requireAgentProfile({ default: "claude" }, "codex");
-        expect(profile.name).toBe("codex");
-    });
-});

package/dist/tests/agent/agent-detect.test.js

@@ -1,100 +0,0 @@
-/**
- * Tests for setup-time agent CLI detection.
- *
- * Acceptance coverage:
- *   • Detects every built-in profile bin via the injected `which` probe.
- *   • Picks the first available profile as the default.
- *   • Honours an existing `agent.default` when that profile is still
- *     available (round-trip stability).
- *   • Returns `undefined` when nothing is installed.
- *   • `stepAgentCliDetection` produces a config-shaped result the wizard
- *     can `apply()`.
- */
-import { describe, expect, test } from "bun:test";
-import { detectAgentCliProfiles, pickDefaultAgentProfile } from "../../src/integrations/agent/detect";
-function whichOnly(installed) {
-    const set = new Set(installed);
-    return (bin) => (set.has(bin) ? `/usr/local/bin/${bin}` : undefined);
-}
-describe("detectAgentCliProfiles", () => {
-    test("reports every built-in profile, available iff bin found", () => {
-        const results = detectAgentCliProfiles(undefined, whichOnly(["claude", "codex"]));
-        const names = results.map((r) => r.name).sort();
-        expect(names).toEqual(["aider", "claude", "codex", "gemini", "opencode"]);
-        expect(results.find((r) => r.name === "claude")?.available).toBe(true);
-        expect(results.find((r) => r.name === "codex")?.available).toBe(true);
-        expect(results.find((r) => r.name === "gemini")?.available).toBe(false);
-    });
-    test("includes user-defined profiles via the resolver", () => {
-        const results = detectAgentCliProfiles({ profiles: { rover: { bin: "rover-cli" } } }, whichOnly(["rover-cli"]));
-        const rover = results.find((r) => r.name === "rover");
-        expect(rover?.available).toBe(true);
-        expect(rover?.resolvedPath).toContain("rover-cli");
-    });
-    test("returns nothing-installed when the probe always says no", () => {
-        const results = detectAgentCliProfiles(undefined, whichOnly([]));
-        expect(results.every((r) => !r.available)).toBe(true);
-    });
-});
-describe("pickDefaultAgentProfile", () => {
-    test("picks the first available result when no existing default", () => {
-        const picked = pickDefaultAgentProfile([
-            { name: "aider", bin: "aider", available: false },
-            { name: "claude", bin: "claude", available: true },
-            { name: "codex", bin: "codex", available: true },
-        ]);
-        expect(picked).toBe("claude");
-    });
-    test("keeps an existing available default", () => {
-        const picked = pickDefaultAgentProfile([
-            { name: "claude", bin: "claude", available: true },
-            { name: "codex", bin: "codex", available: true },
-        ], "codex");
-        expect(picked).toBe("codex");
-    });
-    test("falls back when the existing default is no longer available", () => {
-        const picked = pickDefaultAgentProfile([
-            { name: "claude", bin: "claude", available: true },
-            { name: "codex", bin: "codex", available: false },
-        ], "codex");
-        expect(picked).toBe("claude");
-    });
-    test("returns undefined when nothing is available", () => {
-        const picked = pickDefaultAgentProfile([
-            { name: "claude", bin: "claude", available: false },
-            { name: "codex", bin: "codex", available: false },
-        ]);
-        expect(picked).toBeUndefined();
-    });
-});
-describe("stepAgentCliDetection (setup wizard)", () => {
-    test("persists default + leaves block absent when nothing detected & no prior config", async () => {
-        const { stepAgentCliDetection } = await import("../../src/setup/setup");
-        const result = stepAgentCliDetection({ semanticSearchMode: "auto" }, () => [
-            { name: "claude", bin: "claude", available: false },
-            { name: "codex", bin: "codex", available: false },
-        ]);
-        expect(result.agent).toBeUndefined();
-        expect(result.detections).toHaveLength(2);
-    });
-    test("writes agent.default to the first detected profile", async () => {
-        const { stepAgentCliDetection } = await import("../../src/setup/setup");
-        const result = stepAgentCliDetection({ semanticSearchMode: "auto" }, () => [
-            { name: "claude", bin: "claude", available: false },
-            { name: "codex", bin: "codex", available: true },
-        ]);
-        expect(result.agent?.default).toBe("codex");
-    });
-    test("preserves user-overridden default when still available", async () => {
-        const { stepAgentCliDetection } = await import("../../src/setup/setup");
-        const result = stepAgentCliDetection({
-            semanticSearchMode: "auto",
-            agent: { default: "aider", profiles: { aider: { args: ["--no-auto-commits"] } } },
-        }, () => [
-            { name: "claude", bin: "claude", available: true },
-            { name: "aider", bin: "aider", available: true },
-        ]);
-        expect(result.agent?.default).toBe("aider");
-        expect(result.agent?.profiles?.aider?.args).toEqual(["--no-auto-commits"]);
-    });
-});

package/dist/tests/agent/agent-spawn.test.js

@@ -1,234 +0,0 @@
-/**
- * Tests for the agent CLI spawn wrapper (`runAgent`).
- *
- * Acceptance coverage:
- *   • Captured stdio collects stdout/stderr.
- *   • Hard timeout maps to `reason: "timeout"`.
- *   • Non-zero exit maps to `reason: "non_zero_exit"`.
- *   • Synchronous spawn failure maps to `reason: "spawn_failed"`.
- *   • Malformed JSON output (when `parseOutput: "json"`) maps to
- *     `reason: "parse_error"`.
- *   • Successful run returns `ok: true`, captured `stdout`, parsed JSON.
- *
- * The wrapper takes a `spawn` injection point so we never touch real
- * binaries here. Where we do touch a real subprocess (one fast `bun -e`
- * timeout test) we keep the timeout small and deterministic.
- */
-import { describe, expect, test } from "bun:test";
-import { runAgent } from "../../src/integrations/agent/spawn";
-function makeProfile(overrides = {}) {
-    return {
-        name: "test-agent",
-        bin: "test-agent",
-        args: [],
-        stdio: "captured",
-        envPassthrough: ["PATH"],
-        parseOutput: "text",
-        ...overrides,
-    };
-}
-function asReadableStream(text) {
-    const bytes = new TextEncoder().encode(text);
-    return new ReadableStream({
-        start(controller) {
-            controller.enqueue(bytes);
-            controller.close();
-        },
-    });
-}
-function fakeSpawnFn(config) {
-    const state = { kills: 0 };
-    const spawn = () => {
-        if (config.throwSync)
-            throw config.throwSync;
-        let resolveExit = () => { };
-        const exited = new Promise((resolve, reject) => {
-            resolveExit = resolve;
-            if (config.rejectExit) {
-                reject(config.rejectExit);
-            }
-            else if (!config.hangsUntilKilled) {
-                resolve(config.exitCode);
-            }
-        });
-        const proc = {
-            exitCode: config.hangsUntilKilled ? null : config.exitCode,
-            exited,
-            stdout: asReadableStream(config.stdout ?? ""),
-            stderr: asReadableStream(config.stderr ?? ""),
-            stdin: null,
-            kill() {
-                state.kills += 1;
-                // Simulate process exit on signal.
-                resolveExit(143);
-            },
-        };
-        return proc;
-    };
-    return { spawn, kills: 0 };
-}
-describe("runAgent — captured stdio", () => {
-    test("returns ok:true with stdout/stderr on exit 0", async () => {
-        const { spawn } = fakeSpawnFn({ exitCode: 0, stdout: "hello\n", stderr: "" });
-        const result = await runAgent(makeProfile(), "go", { spawn });
-        expect(result.ok).toBe(true);
-        expect(result.exitCode).toBe(0);
-        expect(result.stdout).toBe("hello\n");
-        expect(result.reason).toBeUndefined();
-        expect(typeof result.durationMs).toBe("number");
-    });
-    test("non-zero exit yields structured `non_zero_exit`", async () => {
-        const { spawn } = fakeSpawnFn({ exitCode: 7, stderr: "boom" });
-        const result = await runAgent(makeProfile(), "go", { spawn });
-        expect(result.ok).toBe(false);
-        expect(result.reason).toBe("non_zero_exit");
-        expect(result.exitCode).toBe(7);
-        expect(result.stderr).toBe("boom");
-        expect(result.error).toContain("exited with code 7");
-    });
-    test("synchronous spawn failure yields `spawn_failed`", async () => {
-        const { spawn } = fakeSpawnFn({ exitCode: 0, throwSync: new Error("ENOENT: command not found") });
-        const result = await runAgent(makeProfile(), "go", { spawn });
-        expect(result.ok).toBe(false);
-        expect(result.reason).toBe("spawn_failed");
-        expect(result.error).toContain("ENOENT");
-        expect(result.exitCode).toBeNull();
-    });
-    test("rejected proc.exited yields `spawn_failed`", async () => {
-        const { spawn } = fakeSpawnFn({ exitCode: 0, rejectExit: new Error("kernel ate it") });
-        const result = await runAgent(makeProfile(), "go", { spawn });
-        expect(result.ok).toBe(false);
-        expect(result.reason).toBe("spawn_failed");
-    });
-});
-describe("runAgent — timeout", () => {
-    test("kills the subprocess and reports `timeout`", async () => {
-        // Drive the timer manually so the assertion is deterministic.
-        let timerCallback;
-        const fakeSet = ((cb) => {
-            timerCallback = cb;
-            return 1;
-        });
-        const fakeClear = (() => { });
-        const { spawn } = fakeSpawnFn({ exitCode: 0, hangsUntilKilled: true });
-        const promise = runAgent(makeProfile(), "go", {
-            spawn,
-            setTimeoutFn: fakeSet,
-            clearTimeoutFn: fakeClear,
-            timeoutMs: 100,
-        });
-        // Kick the deadline.
-        expect(timerCallback).toBeDefined();
-        timerCallback?.();
-        const result = await promise;
-        expect(result.ok).toBe(false);
-        expect(result.reason).toBe("timeout");
-        expect(result.error).toContain("100ms");
-    });
-    test("real timeout against `bun -e` sleeping past the deadline (deterministic & fast)", async () => {
-        const profile = makeProfile({ bin: "bun", args: ["-e", "await new Promise(r => setTimeout(r, 5000))"] });
-        const start = Date.now();
-        const result = await runAgent(profile, undefined, { timeoutMs: 250 });
-        const elapsed = Date.now() - start;
-        expect(result.ok).toBe(false);
-        expect(result.reason).toBe("timeout");
-        // Should bail well before the 5-second sleep would complete.
-        expect(elapsed).toBeLessThan(2000);
-    });
-});
-describe("runAgent — JSON parse mode", () => {
-    test("parses JSON stdout and surfaces it via `parsed`", async () => {
-        const { spawn } = fakeSpawnFn({ exitCode: 0, stdout: '{"role":"agent"}' });
-        const result = await runAgent(makeProfile({ parseOutput: "json" }), "go", { spawn });
-        expect(result.ok).toBe(true);
-        expect(result.parsed).toEqual({ role: "agent" });
-    });
-    test("malformed JSON yields `parse_error`", async () => {
-        const { spawn } = fakeSpawnFn({ exitCode: 0, stdout: "not json {" });
-        const result = await runAgent(makeProfile({ parseOutput: "json" }), "go", { spawn });
-        expect(result.ok).toBe(false);
-        expect(result.reason).toBe("parse_error");
-        expect(result.error).toBeTruthy();
-    });
-    // ── #284 GAP-HIGH 10: parseOutput=json + non-zero exit + non-JSON stderr ──
-    test("parseOutput=json + non-zero exit: non_zero_exit precedence (parse_error suppressed)", async () => {
-        // Non-zero exit must surface as `non_zero_exit`, not `parse_error`, even
-        // when the stdout/stderr payload is malformed JSON. The exit code is the
-        // primary failure signal; parse failures are downstream of a successful run.
-        const { spawn } = fakeSpawnFn({
-            exitCode: 5,
-            stdout: "not json {",
-            stderr: "agent panic: kernel ate my JSON",
-        });
-        const result = await runAgent(makeProfile({ parseOutput: "json" }), "go", { spawn });
-        expect(result.ok).toBe(false);
-        expect(result.reason).toBe("non_zero_exit");
-        expect(result.exitCode).toBe(5);
-        expect(result.stderr).toBe("agent panic: kernel ate my JSON");
-        expect(result.parsed).toBeUndefined();
-    });
-});
-// ── #284 GAP-HIGH 11: timeoutMs precedence ────────────────────────────────
-describe("runAgent — timeoutMs precedence", () => {
-    test("options.timeoutMs overrides profile.timeoutMs", async () => {
-        // Both profile and options carry a timeoutMs. Options must win.
-        let timerCallback;
-        let observedDeadlineMs;
-        const fakeSet = ((cb, ms) => {
-            timerCallback = cb;
-            observedDeadlineMs = ms;
-            return 1;
-        });
-        const fakeClear = (() => { });
-        const { spawn } = fakeSpawnFn({ exitCode: 0, hangsUntilKilled: true });
-        const profile = makeProfile({ timeoutMs: 999_999 });
-        const promise = runAgent(profile, "go", {
-            spawn,
-            setTimeoutFn: fakeSet,
-            clearTimeoutFn: fakeClear,
-            timeoutMs: 250,
-        });
-        expect(observedDeadlineMs).toBe(250); // override won
-        timerCallback?.();
-        const result = await promise;
-        expect(result.reason).toBe("timeout");
-    });
-});
-describe("runAgent — argument and env construction", () => {
-    test("appends prompt after profile.args and options.args", async () => {
-        let capturedCmd;
-        const spawn = (cmd) => {
-            capturedCmd = cmd;
-            return {
-                exitCode: 0,
-                exited: Promise.resolve(0),
-                stdout: asReadableStream(""),
-                stderr: asReadableStream(""),
-                stdin: null,
-                kill() { },
-            };
-        };
-        await runAgent(makeProfile({ args: ["--profile-arg"] }), "the-prompt", { spawn, args: ["--call-arg"] });
-        expect(capturedCmd).toEqual(["test-agent", "--profile-arg", "--call-arg", "the-prompt"]);
-    });
-    test("env is filtered by envPassthrough plus profile/options env", async () => {
-        let capturedEnv;
-        const spawn = (_cmd, opts) => {
-            capturedEnv = opts.env;
-            return {
-                exitCode: 0,
-                exited: Promise.resolve(0),
-                stdout: asReadableStream(""),
-                stderr: asReadableStream(""),
-                stdin: null,
-                kill() { },
-            };
-        };
-        await runAgent(makeProfile({ envPassthrough: ["KEEP_ME"], env: { PROFILE_VAR: "1" } }), undefined, {
-            spawn,
-            env: { CALL_VAR: "2" },
-            envSource: { KEEP_ME: "yes", DROP_ME: "no" },
-        });
-        expect(capturedEnv).toEqual({ KEEP_ME: "yes", PROFILE_VAR: "1", CALL_VAR: "2" });
-    });
-});