Skip to content

graff — a fast agentic coding harness in Zig: multi-provider, MCP, workflows, DGM evolution loop, TS/Python SDKs

Python
29.3 KB
Raw Blame
//! CLI flag parsing for `graff`/`harness`, split out of main() (600-line
//! goal, #123 follow-up — the last file over the line goal). `Flags` bundles
//! every CLI-flag local main() used to declare at the top of its body (the
//! ~27 `var foo_flag = ...` locals), plus `positionals` and the two values
//! the old code derived from them right after the parse loop
//! (`is_subcommand`, `oneshot_prompt`).
//!
//! `parse` moves main()'s former ~130-line flag loop VERBATIM: same flag
//! names, same precedence (the `mcp` positional's "everything after this is
//! a raw positional, not a flag" special case included), same
//! `std.process.fatal` messages on a bad/unknown flag or missing value.
//! Locals just became struct-field writes.
//!
//! Back-imports main (as main_mod, the established convention — see
//! mainloop.zig/tools.zig/etc.) for the handful of globals that STAY in
//! main.zig and were only ever *set* (never read) by the parse loop itself:
//! show_timing/show_cost/json_mode/max_tool_calls/max_model_calls/dedupe_tool_calls (`--timing`
//! /`--cost`/`--json`/`--max-tool-calls`/`--max-model-calls`/`--dedupe-tool-calls`) and
//! g_worktree_autocommit (`--no-autocommit`). These are mutable globals, so
//! per the mod-prefix rule they are written through `main_mod.` — never
//! aliased (aliasing a `var` freezes its value at import time).
const std = @import("std");
const Allocator = std.mem.Allocator;

const main_mod = @import("main.zig");
const learning_privacy = @import("learning_privacy.zig");
const no_local_tools = @import("no_local_tools.zig"); // #330: `--no-local-tools` arms the process-global gate (same set-only pattern as the main_mod globals)
const context_limits = @import("context_limits.zig");

/// Every CLI-flag local main() used to declare, plus the resolved
/// positionals/subcommand-detection/one-shot-prompt outputs computed right
/// after the parse loop. One field per former local, same default.
pub const Flags = struct {
    yolo_flag: bool = false,
    safe_flag: bool = false, // --safe: one-shot WITHOUT the implied --yolo (approval-gated, the old -p default)
    no_lean_flag: bool = false, // --no-lean: one-shot WITHOUT the implied --lean (full tool surface + eager MCP, the old -p default)
    lean_flag: bool = false, // --lean: slim catalog + MCP schemas folded behind load_tool_schemas (GRAFF_LEAN=1); does not skip connect
    no_telemetry_flag: bool = false,
    learning_privacy_flag: ?learning_privacy.Mode = null,
    schema_flag: bool = false,
    login_flag: bool = false,
    refresh_flag: bool = false,
    codex_login: bool = false,
    kimi_login: bool = false,
    kimi_region: ?@import("oauth_kimi.zig").Region = null, // `graff login kimi.ai` / `kimi.com`
    xai_login: bool = false,
    zai_login: bool = false,
    chatgpt_login: bool = false,
    anthropic_login: bool = false,
    anthropic_console_login: bool = false,
    claude_agent_login: bool = false,
    help_flag: bool = false,
    version_flag: bool = false,
    print_flag: bool = false,
    stream_json_flag: bool = false, // --output-format stream-json: one-shot lifecycle + result
    update_force: bool = false, // graff update --force
    selftest_spinner_flag: bool = false, // --selftest-spinner: headless spinner render for the PTY anti-stealth test
    selftest_markdown_flag: bool = false, // --selftest-markdown: render the real streaming markdown fixture in a PTY
    update_check: bool = false, // graff update --check
    update_beta: bool = false, // graff update --beta
    model_flag: ?[]const u8 = null,
    subagent_provider_flag: ?[]const u8 = null,
    subagent_model_flag: ?[]const u8 = null,
    allow_cross_provider_subagents_flag: bool = false,
    no_subagent_tier_flag: bool = false, // --no-subagent-tier: opt out of the default worker tier ladder (#291), keep plain inherit-root
    system_prompt_flag: ?[]const u8 = null,
    append_system_flag: ?[]const u8 = null,
    host_flag: []const u8 = "127.0.0.1", // harness serve
    port_flag: u16 = 8787, // harness serve
    token_flag: ?[]const u8 = null, // harness serve
    name_flag: ?[]const u8 = null, // graff remote-control --name: how this machine is listed
    resume_flag: ?[]const u8 = null, // restore this named session
    branch_flag: ?[]const u8 = null, // clone --resume into this independent autosave target
    goal_flag: ?[]const u8 = null, // --goal: standing objective (todos) every turn gets, incl. --json/-p
    eval_cmd_flag: ?[]const u8 = null, // --eval: scoring command for the eval-driven loop
    worktree_flag: ?[]const u8 = null, // --worktree/-w: isolate this session in a git worktree (parallel agents, no file collisions)
    experiment_n: u8 = 0, // --experiment N: #629 pre-mint N child worktrees (279 continuation)
    add_dirs: std.ArrayList([]const u8) = .empty, // --add-dir: extra file-tool roots, max 16
    context_limits: std.ArrayList([]const u8) = .empty, // --context-limit name=N
    eval_target_flag: ?u8 = null, // --until: target score 0-100 for the eval loop
    eval_niche_flag: ?[]const u8 = null, // --niche: fleet niche this eval-driven session optimizes (tags submitted scores)
    output_schema_flag: ?[]const u8 = null, // --output-schema: JSON schema (inline or @file) the final answer must satisfy (#502)
    no_resume_flag: bool = false, // start without auto-loading last.session.json
    new_session_flag: bool = false, // start a fresh autosaved session
    positionals: std.ArrayList([]const u8) = .empty,
    /// True when positionals[0] is a known subcommand (login/key/mcp/serve/
    /// update/title/repl/tui/acp/worktree/sandboxes/cube) — those aren't a one-shot
    /// prompt even with no --print/-p flag.
    is_subcommand: bool = false,
    /// The joined positional args as a one-shot prompt (`harness "say hi"`
    /// or `harness -p "..."`), or null when positionals[0] is a subcommand.
    oneshot_prompt: ?[]const u8 = null,

    /// One-shot is autonomous by default: -p implies --yolo — the typed-out
    /// invocation IS the consent, and a no-stdin approval prompt can only
    /// auto-decline (which stranded unattended coding runs on a policy
    /// artifact). --safe opts back into the old approval-gated -p.
    /// Interactive sessions are untouched: no oneshot prompt, no implied yolo.
    pub fn effectiveYolo(flags: Flags) bool {
        return flags.yolo_flag or (flags.oneshot_prompt != null and !flags.safe_flag);
    }

    /// --lean is the one-shot default (measured: full catalog + eager MCP
    /// roughly doubles a one-shot's per-turn prefix for capability one-shots
    /// rarely exercise); interactive sessions keep the full surface, where
    /// todos/workflow/peer tooling earn their bytes. --no-lean opts back
    /// into the old full-surface -p; explicit --lean always wins.
    pub fn effectiveLean(flags: Flags) bool {
        return flags.lean_flag or (flags.oneshot_prompt != null and !flags.no_lean_flag);
    }
};

/// Parses argv (via init.minimal.args) into a `Flags`. Fatals via
/// std.process.fatal on a bad/unknown flag or a missing required value —
/// identical behavior to main()'s former inline loop.
pub fn parse(init: std.process.Init) !Flags {
    const gpa = init.gpa;
    const arena = init.arena.allocator();
    var flags: Flags = .{};
    {
        var it = try std.process.Args.Iterator.initAllocator(init.minimal.args, gpa);
        defer it.deinit();
        _ = it.next(); // argv[0]
        while (it.next()) |arg| {
            if (flags.positionals.items.len > 0 and
                (std.mem.eql(u8, flags.positionals.items[0], "mcp") or std.mem.eql(u8, flags.positionals.items[0], "computer") or std.mem.eql(u8, flags.positionals.items[0], "learn") or std.mem.eql(u8, flags.positionals.items[0], "peer") or std.mem.eql(u8, flags.positionals.items[0], "keys") or std.mem.eql(u8, flags.positionals.items[0], "harness-tree")))
            {
                try flags.positionals.append(arena, try arena.dupe(u8, arg));
            } else if (std.mem.startsWith(u8, arg, "-")) {
                if (std.mem.eql(u8, arg, "--yolo")) {
                    flags.yolo_flag = true;
                } else if (std.mem.eql(u8, arg, "--safe")) {
                    flags.safe_flag = true;
                } else if (std.mem.eql(u8, arg, "--no-lean")) {
                    flags.no_lean_flag = true;
                } else if (std.mem.eql(u8, arg, "--lean")) {
                    flags.lean_flag = true;
                } else if (std.mem.eql(u8, arg, "--worktree") or std.mem.eql(u8, arg, "-w")) {
                    flags.worktree_flag = it.next() orelse std.process.fatal("--worktree needs a name (e.g. --worktree agent1)", .{});
                } else if (std.mem.eql(u8, arg, "--experiment")) {
                    const ev = it.next() orelse std.process.fatal("--experiment needs N (1-16)", .{});
                    flags.experiment_n = std.fmt.parseInt(u8, ev, 10) catch std.process.fatal("--experiment needs N 1-16, got '{s}'", .{ev});
                    if (flags.experiment_n == 0 or flags.experiment_n > 16) std.process.fatal("--experiment N must be 1-16", .{});
                } else if (std.mem.eql(u8, arg, "--add-dir")) {
                    const dir = it.next() orelse std.process.fatal("--add-dir needs a directory (repeatable, max 16)", .{});
                    flags.add_dirs.append(arena, try arena.dupe(u8, dir)) catch std.process.fatal("--add-dir: out of memory", .{});
                } else if (std.mem.eql(u8, arg, "--context-limit")) {
                    const pair = it.next() orelse std.process.fatal("--context-limit needs name=N (skill_catalog_bytes|mcp_schema_bytes|agents_md_bytes)", .{});
                    context_limits.applyPair(pair) catch std.process.fatal("invalid --context-limit '{s}' (want name=N)", .{pair});
                    flags.context_limits.append(arena, try arena.dupe(u8, pair)) catch {};
                } else if (std.mem.eql(u8, arg, "--goal")) {
                    flags.goal_flag = it.next() orelse std.process.fatal("--goal needs an objective", .{});
                } else if (std.mem.eql(u8, arg, "--eval")) {
                    flags.eval_cmd_flag = it.next() orelse std.process.fatal("--eval needs a scoring command", .{});
                } else if (std.mem.eql(u8, arg, "--until")) {
                    const uv = it.next() orelse std.process.fatal("--until needs a score 0-100", .{});
                    flags.eval_target_flag = std.fmt.parseInt(u8, uv, 10) catch std.process.fatal("--until must be a number 0-100", .{});
                } else if (std.mem.eql(u8, arg, "--niche")) {
                    flags.eval_niche_flag = it.next() orelse std.process.fatal("--niche needs a name (e.g. --niche reviewer)", .{});
                } else if (std.mem.eql(u8, arg, "--output-schema")) {
                    flags.output_schema_flag = it.next() orelse std.process.fatal("--output-schema needs a JSON schema or @file", .{});
                } else if (std.mem.eql(u8, arg, "--no-telemetry")) {
                    flags.no_telemetry_flag = true;
                } else if (std.mem.eql(u8, arg, "--learning-privacy")) {
                    const value = it.next() orelse std.process.fatal("--learning-privacy needs local|aggregate|templates|examples", .{});
                    flags.learning_privacy_flag = learning_privacy.parse(value) orelse std.process.fatal("invalid learning privacy mode '{s}' — use local|aggregate|templates|examples", .{value});
                } else if (std.mem.eql(u8, arg, "--timing")) {
                    main_mod.show_timing = true;
                } else if (std.mem.eql(u8, arg, "--cost")) {
                    main_mod.show_cost = true;
                } else if (std.mem.eql(u8, arg, "--json")) {
                    main_mod.json_mode = true;
                } else if (std.mem.eql(u8, arg, "--output-format")) {
                    const format = it.next() orelse std.process.fatal("--output-format needs text|stream-json", .{});
                    if (!std.mem.eql(u8, format, "text") and !std.mem.eql(u8, format, "stream-json"))
                        std.process.fatal("--output-format needs text|stream-json", .{});
                    flags.stream_json_flag = std.mem.eql(u8, format, "stream-json");
                } else if (std.mem.eql(u8, arg, "--max-tool-calls")) {
                    const mv = it.next() orelse std.process.fatal("--max-tool-calls needs a non-negative integer — graff --help", .{});
                    main_mod.max_tool_calls = std.fmt.parseInt(u64, mv, 10) catch std.process.fatal("--max-tool-calls needs a non-negative integer, got '{s}'", .{mv});
                } else if (std.mem.eql(u8, arg, "--compact-at")) {
                    const mv = it.next() orelse std.process.fatal("--compact-at needs a percent of the context window (10-95)", .{});
                    @import("compact_at.zig").g_cli = @import("compact_at.zig").parse(mv) orelse std.process.fatal("--compact-at needs a percent of the context window (10-95), got '{s}'", .{mv});
                } else if (std.mem.eql(u8, arg, "--max-run-tool-calls")) {
                    const mv = it.next() orelse std.process.fatal("--max-run-tool-calls needs a non-negative integer", .{});
                    @import("run_budget.zig").cli_max_tool_calls = std.fmt.parseInt(u64, mv, 10) catch std.process.fatal("--max-run-tool-calls needs a non-negative integer", .{});
                } else if (std.mem.eql(u8, arg, "--max-model-calls")) {
                    const mv = it.next() orelse std.process.fatal("--max-model-calls needs a non-negative integer — graff --help", .{});
                    main_mod.max_model_calls = std.fmt.parseInt(u64, mv, 10) catch std.process.fatal("--max-model-calls needs a non-negative integer, got '{s}'", .{mv});
                } else if (std.mem.eql(u8, arg, "--dedupe-tool-calls")) {
                    main_mod.dedupe_tool_calls = true;
                } else if (std.mem.eql(u8, arg, "--no-local-tools")) {
                    no_local_tools.enabled = true; // #330: hard-disable the host-touching built-ins for the whole process (also GRAFF_NO_LOCAL_TOOLS=1)
                } else if (std.mem.eql(u8, arg, "--clock-sleep")) {
                    main_mod.g_clock_sleep = true; // #225: opt in to the root-only clock_sleep meta tool (also GRAFF_CLOCK_SLEEP=1)
                } else if (std.mem.eql(u8, arg, "--rlm")) {
                    @import("rlm.zig").setFromCli(true); // ADR 0022: default RLM; last flag wins vs --old
                } else if (std.mem.eql(u8, arg, "--old") or std.mem.eql(u8, arg, "--no-rlm")) {
                    @import("rlm.zig").setFromCli(false); // structured-only catalog (also GRAFF_OLD=1 / GRAFF_RLM=0)
                } else if (std.mem.eql(u8, arg, "--no-autocommit")) {
                    main_mod.g_worktree_autocommit = false;
                } else if (std.mem.eql(u8, arg, "--schema")) {
                    flags.schema_flag = true;
                } else if (std.mem.eql(u8, arg, "--refresh")) {
                    flags.refresh_flag = true;
                } else if (std.mem.eql(u8, arg, "--help") or std.mem.eql(u8, arg, "-h")) {
                    flags.help_flag = true;
                } else if (std.mem.eql(u8, arg, "--version") or std.mem.eql(u8, arg, "-V")) {
                    flags.version_flag = true;
                } else if (std.mem.eql(u8, arg, "--selftest-spinner")) {
                    flags.selftest_spinner_flag = true;
                } else if (std.mem.eql(u8, arg, "--selftest-markdown")) {
                    flags.selftest_markdown_flag = true;
                } else if (std.mem.eql(u8, arg, "--print") or std.mem.eql(u8, arg, "-p")) {
                    flags.print_flag = true;
                } else if (std.mem.eql(u8, arg, "--force")) {
                    flags.update_force = true;
                } else if (std.mem.eql(u8, arg, "--check")) {
                    flags.update_check = true;
                } else if (std.mem.eql(u8, arg, "--beta")) {
                    flags.update_beta = true;
                } else if (std.mem.eql(u8, arg, "--resume")) {
                    const rv = it.next() orelse std.process.fatal("--resume needs a session name — graff --help", .{});
                    flags.resume_flag = try arena.dupe(u8, rv);
                } else if (std.mem.eql(u8, arg, "--branch")) {
                    const bv = it.next() orelse std.process.fatal("--branch needs a destination session name — graff --help", .{});
                    flags.branch_flag = try arena.dupe(u8, bv);
                } else if (std.mem.eql(u8, arg, "--no-resume")) {
                    flags.no_resume_flag = true;
                } else if (std.mem.eql(u8, arg, "--new")) {
                    flags.new_session_flag = true;
                } else if (std.mem.eql(u8, arg, "--model")) {
                    const mv = it.next() orelse std.process.fatal("--model needs a value — graff --help", .{});
                    flags.model_flag = try arena.dupe(u8, mv);
                } else if (std.mem.eql(u8, arg, "--subagent-provider")) {
                    const pv = it.next() orelse std.process.fatal("--subagent-provider needs a value — graff --help", .{});
                    flags.subagent_provider_flag = try arena.dupe(u8, pv);
                } else if (std.mem.eql(u8, arg, "--subagent-model")) {
                    const mv = it.next() orelse std.process.fatal("--subagent-model needs a value — graff --help", .{});
                    flags.subagent_model_flag = try arena.dupe(u8, mv);
                } else if (std.mem.eql(u8, arg, "--allow-cross-provider-subagents")) {
                    flags.allow_cross_provider_subagents_flag = true;
                } else if (std.mem.eql(u8, arg, "--no-subagent-tier")) {
                    flags.no_subagent_tier_flag = true;
                } else if (std.mem.eql(u8, arg, "--system-prompt")) {
                    const sv = it.next() orelse std.process.fatal("--system-prompt needs a value — graff --help", .{});
                    flags.system_prompt_flag = try arena.dupe(u8, sv);
                } else if (std.mem.eql(u8, arg, "--append-system-prompt")) {
                    const av = it.next() orelse std.process.fatal("--append-system-prompt needs a value — graff --help", .{});
                    flags.append_system_flag = try arena.dupe(u8, av);
                } else if (std.mem.eql(u8, arg, "--host")) {
                    const hv = it.next() orelse std.process.fatal("--host needs a value — graff --help", .{});
                    flags.host_flag = try arena.dupe(u8, hv);
                } else if (std.mem.eql(u8, arg, "--port")) {
                    const pv = it.next() orelse std.process.fatal("--port needs a value — graff --help", .{});
                    flags.port_flag = std.fmt.parseInt(u16, pv, 10) catch std.process.fatal("--port needs a number 1-65535, got '{s}'", .{pv});
                } else if (std.mem.eql(u8, arg, "--token")) {
                    const tv = it.next() orelse std.process.fatal("--token needs a value — graff --help", .{});
                    flags.token_flag = try arena.dupe(u8, tv);
                } else if (std.mem.eql(u8, arg, "--name")) {
                    const nv = it.next() orelse std.process.fatal("--name needs a value — graff --help", .{});
                    flags.name_flag = try arena.dupe(u8, nv);
                } else {
                    std.process.fatal("unknown flag '{s}' — graff --help lists them", .{arg});
                }
            } else {
                try flags.positionals.append(arena, try arena.dupe(u8, arg));
            }
        }
        acpLoginIsLogin(&flags.positionals);
        if (flags.positionals.items.len > 0 and std.mem.eql(u8, flags.positionals.items[0], "login")) flags.login_flag = true;
        if (flags.login_flag and flags.positionals.items.len > 1) {
            const name = flags.positionals.items[1];
            const target = loginTarget(name) orelse
                std.process.fatal("unknown login '{s}' — graff login [codegraff|chatgpt|anthropic|claude-agent|kimi|xai|zai]", .{name});
            flags.codex_login = std.mem.eql(u8, target, "codex");
            flags.kimi_login = std.mem.eql(u8, target, "kimi");
            flags.kimi_region = @import("oauth_kimi.zig").regionFromLoginName(name);
            flags.xai_login = std.mem.eql(u8, target, "xai");
            flags.zai_login = std.mem.eql(u8, target, "zai");
            flags.chatgpt_login = std.mem.eql(u8, target, "chatgpt-new");
            flags.anthropic_console_login = std.ascii.eqlIgnoreCase(name, "console");
            flags.anthropic_login = std.mem.eql(u8, target, "anthropic") and !flags.anthropic_console_login;
            flags.claude_agent_login = std.mem.eql(u8, target, "claude-agent");
        }
    }

    // One-shot print mode: `harness -p "prompt"` or a bare positional prompt
    // (`harness "say hi"`). Subcommands (login/key) are not prompts.
    flags.is_subcommand = flags.positionals.items.len > 0 and
        (std.mem.eql(u8, flags.positionals.items[0], "login") or std.mem.eql(u8, flags.positionals.items[0], "computer") or std.mem.eql(u8, flags.positionals.items[0], "logout") or std.mem.eql(u8, flags.positionals.items[0], "key") or std.mem.eql(u8, flags.positionals.items[0], "mcp") or std.mem.eql(u8, flags.positionals.items[0], "learn") or
            std.mem.eql(u8, flags.positionals.items[0], "serve") or std.mem.eql(u8, flags.positionals.items[0], "update") or std.mem.eql(u8, flags.positionals.items[0], "title") or std.mem.eql(u8, flags.positionals.items[0], "repl") or (!flags.print_flag and std.mem.eql(u8, flags.positionals.items[0], "tui")) or
            std.mem.eql(u8, flags.positionals.items[0], "worktree") or std.mem.eql(u8, flags.positionals.items[0], "harness-tree") or std.mem.eql(u8, flags.positionals.items[0], "sandboxes") or std.mem.eql(u8, flags.positionals.items[0], "cube") or std.mem.eql(u8, flags.positionals.items[0], "models") or
            std.mem.eql(u8, flags.positionals.items[0], "remote-control") or std.mem.eql(u8, flags.positionals.items[0], "remote") or @import("acp.zig").isAcpSubcommand(flags.positionals.items[0])); // `acp` also arms ACP's stdout discipline (json_mode) — see acp.isAcpSubcommand
    if (!flags.is_subcommand and flags.positionals.items.len > 0) {
        flags.oneshot_prompt = try std.mem.join(arena, " ", flags.positionals.items);
    }
    if (flags.print_flag and flags.oneshot_prompt == null) std.process.fatal("-p needs a prompt: harness -p \"do something\"", .{});
    if (flags.stream_json_flag) {
        if (flags.oneshot_prompt == null) std.process.fatal("--output-format stream-json needs a one-shot prompt", .{});
        main_mod.json_mode = true;
    }
    if (flags.branch_flag != null and flags.resume_flag == null) std.process.fatal("--branch needs --resume <source>", .{});
    if (flags.branch_flag != null and (flags.new_session_flag or flags.no_resume_flag)) std.process.fatal("--branch cannot be combined with --new or --no-resume", .{});

    // The tool-surface half of lean, set AFTER the one-shot prompt is
    // assembled: on for --lean and for every one-shot without --no-lean (the
    // MCP half reads effectiveLean through session_start.leanMode; env
    // GRAFF_LEAN sets the same global in session_settings.applyEnvKnobs).
    if (flags.effectiveLean()) no_local_tools.lean = true;

    // #502: GRAFF_XAI_WIRE (default responses; =chat opts out) must land before the initial Keys.build
    // (startup.resolveKeys) or the xAI provider is built on the chat wire and
    // the knob silently no-ops; applyEnvKnobs re-parses the same value later.
    if (init.environ_map.get("GRAFF_XAI_WIRE")) |xw|
        @import("provider.zig").g_xai_responses = std.ascii.eqlIgnoreCase(std.mem.trim(u8, xw, " \t"), "responses");
    if (init.environ_map.get("GRAFF_XAI_URL")) |xu| {
        if (xu.len > 0) {
            const provider_mod = @import("provider.zig");
            provider_mod.g_xai_url_override = xu;
        }
    }
    if (init.environ_map.get("GRAFF_ZAI_URL")) |zu| {
        if (zu.len > 0) @import("provider.zig").g_zai_url_override = zu;
    } else if (init.environ_map.get("ZAI_CODING")) |zc| {
        const on = std.mem.eql(u8, zc, "1") or std.ascii.eqlIgnoreCase(zc, "true") or std.ascii.eqlIgnoreCase(zc, "on") or std.ascii.eqlIgnoreCase(zc, "yes");
        if (on) @import("provider.zig").g_zai_url_override = @import("provider.zig").zai_coding_url;
    }
    if (init.environ_map.get("GRAFF_VERCEL_URL")) |vu| {
        if (vu.len > 0) @import("provider.zig").g_vercel_url_override = vu;
    }

    return flags;
}

/// The provider a login name means, for `graff login <name>` and `/login
/// <name>` alike. Every ChatGPT name, codex included, is the plan's sign-in,
/// chatgpt-new: the Codex client's login no longer works (ADR 0229). Null:
/// not a login.
/// ACP Terminal Auth advertises `args: ["login"]`. The v1 schema appends them
/// to the agent command (`graff acp login`); the registry's docs say they
/// replace it (`graff login`). Both must sign in, never start the server.
pub fn acpLoginIsLogin(positionals: *std.ArrayList([]const u8)) void {
    const items = positionals.items;
    if (items.len > 1 and std.mem.eql(u8, items[0], "acp") and std.mem.eql(u8, items[1], "login"))
        _ = positionals.orderedRemove(0);
}

pub fn loginTarget(name: []const u8) ?[]const u8 {
    const aliases = [_][2][]const u8{
        .{ "codex", "chatgpt-new" }, .{ "chatgpt", "chatgpt-new" },       .{ "openai", "chatgpt-new" },  .{ "gpt", "chatgpt-new" },
        .{ "oai", "chatgpt-new" },   .{ "codegraff", "codegraff" },       .{ "graff", "codegraff" },     .{ "kimi", "kimi" },
        .{ "xai", "xai" },           .{ "grok", "xai" },                  .{ "ant", "anthropic" },       .{ "anthropic", "anthropic" },
        .{ "console", "anthropic" }, .{ "claude-agent", "claude-agent" }, .{ "claude", "claude-agent" },
    };
    for (aliases) |pair| if (std.ascii.eqlIgnoreCase(name, pair[0])) return pair[1];
    if (@import("oauth_zai.zig").isLoginName(name)) return "zai";
    if (@import("oauth_kimi.zig").isLoginName(name)) return "kimi";
    if (@import("oauth_chatgpt.zig").isLoginName(name)) return "chatgpt-new";
    return null;
}

test "loginTarget: every ChatGPT name, codex included, is the plan's sign-in; unknown names are not logins" {
    for ([_][]const u8{ "codex", "chatgpt", "ChatGPT", "openai", "gpt", "oai", "chatgpt-new", "chat-gpt-new" }) |name|
        try std.testing.expectEqualStrings("chatgpt-new", loginTarget(name).?);
    try std.testing.expectEqualStrings("codegraff", loginTarget("graff").?);
    try std.testing.expectEqualStrings("xai", loginTarget("grok").?);
    try std.testing.expectEqualStrings("kimi", loginTarget("kimi").?);
    try std.testing.expectEqualStrings("kimi", loginTarget("kimi.ai").?);
    for ([_][]const u8{ "ant", "anthropic", "ANT", "Anthropic", "console", "Console" }) |name|
        try std.testing.expectEqualStrings("anthropic", loginTarget(name).?);
    try std.testing.expectEqualStrings("zai", loginTarget("zai").?);
    try std.testing.expectEqualStrings("claude-agent", loginTarget("claude-agent").?);
    try std.testing.expectEqualStrings("claude-agent", loginTarget("Claude").?);
    try std.testing.expect(loginTarget("chatgptt") == null);
    try std.testing.expect(loginTarget("") == null);
}

test "acp login is login, with or without a target; plain acp stays acp" {
    const gpa = std.testing.allocator;
    for ([_]struct { in: []const []const u8, first: []const u8, len: usize }{
        .{ .in = &.{ "acp", "login" }, .first = "login", .len = 1 },
        .{ .in = &.{ "acp", "login", "chatgpt" }, .first = "login", .len = 2 },
        .{ .in = &.{"acp"}, .first = "acp", .len = 1 },
        .{ .in = &.{ "acp", "--yolo" }, .first = "acp", .len = 2 },
        .{ .in = &.{"login"}, .first = "login", .len = 1 },
    }) |case| {
        var list: std.ArrayList([]const u8) = .empty;
        defer list.deinit(gpa);
        try list.appendSlice(gpa, case.in);
        acpLoginIsLogin(&list);
        try std.testing.expectEqualStrings(case.first, list.items[0]);
        try std.testing.expectEqual(case.len, list.items.len);
    }
}

test "tui is a reserved subcommand, not a one-shot prompt" {
    var tui_pos = std.ArrayList([]const u8).empty;
    defer tui_pos.deinit(std.testing.allocator);
    try tui_pos.append(std.testing.allocator, "tui");
    const tui_flags = Flags{ .positionals = tui_pos, .yolo_flag = true, .is_subcommand = true };
    try std.testing.expect(tui_flags.is_subcommand);
    try std.testing.expect(tui_flags.yolo_flag);
    try std.testing.expect(tui_flags.oneshot_prompt == null);
}

test "effectiveYolo: -p implies yolo, --safe opts out, interactive untouched" {
    try std.testing.expect(Flags.effectiveYolo(.{ .yolo_flag = true }));
    try std.testing.expect(Flags.effectiveYolo(.{ .oneshot_prompt = "fix it" }));
    try std.testing.expect(!Flags.effectiveYolo(.{ .oneshot_prompt = "fix it", .safe_flag = true }));
    try std.testing.expect(!Flags.effectiveYolo(.{}));
    try std.testing.expect(Flags.effectiveYolo(.{ .oneshot_prompt = "fix it", .yolo_flag = true, .safe_flag = true })); // explicit --yolo wins over --safe
}

test "effectiveLean: -p implies lean, --no-lean opts out, interactive keeps the full surface" {
    try std.testing.expect(Flags.effectiveLean(.{ .lean_flag = true }));
    try std.testing.expect(Flags.effectiveLean(.{ .oneshot_prompt = "fix it" }));
    try std.testing.expect(!Flags.effectiveLean(.{ .oneshot_prompt = "fix it", .no_lean_flag = true }));
    try std.testing.expect(!Flags.effectiveLean(.{}));
    try std.testing.expect(Flags.effectiveLean(.{ .oneshot_prompt = "fix it", .lean_flag = true, .no_lean_flag = true })); // explicit --lean wins over --no-lean
}