@caddis/cli 0.4.34 → 0.4.36

package/bundles/antigravity-plugin/scripts/caddis_lanes.py

@@ -28,6 +28,8 @@ except ModuleNotFoundError as exc:
     sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "claude-harness" / "scripts"))
     import caddis_exit
 
+import caddis_routing
+
 if hasattr(sys.stdout, "reconfigure"):
     sys.stdout.reconfigure(encoding="utf-8", errors="replace")
     sys.stderr.reconfigure(encoding="utf-8", errors="replace")
@@ -69,7 +71,17 @@ DEFAULT_CHAINS = {
     "docs": ("agy", "glm", "claude"),
 }
 BUDGET_PATTERNS: dict[str, tuple[str, ...]] = {
-    "claude": (),
+    # Claude Code 2.1.283 CLI bundle (limit-message builder and its prefix list).
+    "claude": (
+        r"You[’']ve hit your (?:session|weekly|Opus|Sonnet|Fable|usage credit) limit\b",
+        r"You[’']ve hit your (?:channel's )?monthly spend limit\b",
+        r"You[’']ve hit your team's shared budget\b",
+        r"You[’']ve reached your Fable limit\b",
+        r"You[’']re out of (?:usage credits|extra usage)\b",
+        r"Your org is out of usage\b",
+        r"Your usage allocation has been disabled by your admin\b",
+        r"Your group's usage limit is set to \$0\b",
+    ),
     # https://docs.z.ai/api-reference/api-code
     "glm": (
         r"API Error: 429.*\"type\"\s*:\s*\"(?:1113|1308|1309|1310|1316|1317)\"",
@@ -943,6 +955,216 @@ def classify_exit(
     return RESULT_LANE_FAILED
 
 
+CLAUDE_FAMILY = frozenset({"opus", "sonnet", "claude"})
+
+
+def next_lane(
+    role: str,
+    after: str,
+    *,
+    home: Path,
+    repo: Path,
+    which=shutil.which,
+) -> str | None:
+    """Find the next available model, sharing one budget across Claude models."""
+    routing = caddis_routing.resolve(home, repo, which=which)
+    chain = routing[role]
+    if role != "coding" and after not in chain and after not in CLAUDE_FAMILY:
+        # `after` came from the coding fallback (a Claude model ran out first): carry on down
+        # the coding chain, and never hand the exhausted Claude budget back.
+        coding = routing["coding"]
+        if after not in coding:
+            return None
+        rest = [model for model in coding[coding.index(after) + 1:] if model not in CLAUDE_FAMILY]
+        return rest[0] if rest else None
+    candidates = chain[chain.index(after) + 1:] if after in chain else chain
+    if after in CLAUDE_FAMILY:
+        candidates = [model for model in candidates if model not in CLAUDE_FAMILY]
+        if not candidates and role != "coding":
+            # Fall to coding models this role has not already tried. The coding chain ran before
+            # its own Claude fallback, and a role that lists agy or codex ran them before Claude;
+            # restarting either would loop.
+            candidates = [
+                model for model in routing["coding"]
+                if model not in CLAUDE_FAMILY and model not in chain
+            ]
+    return candidates[0] if candidates else None
+
+
+def _ci_watch_block(output: str) -> dict[str, str] | None:
+    """Read the last complete watch report, ignoring an echoed prompt template."""
+    fields: dict[str, str] = {}
+    reports: list[dict[str, str]] = []
+    for line in output.splitlines():
+        match = re.match(
+            r"^\s*(?:[`*]+\s*)?(RESULT|CHECKS|MERGE_STATE|FAILING)[`*]*\s*:\s*[`*]*\s*(.*?)\s*[`*]*\s*$",
+            line, re.I,
+        )
+        if not match:
+            continue
+        key, value = match.group(1).upper(), match.group(2).strip().strip("`* ")
+        if key == "RESULT":
+            if fields:
+                reports.append(fields)
+            fields = {}
+        if fields or key == "RESULT":
+            fields[key] = value
+    if fields:
+        reports.append(fields)
+    if not reports:
+        return None
+    last = reports[-1]
+    if set(last) != {"RESULT", "CHECKS", "MERGE_STATE", "FAILING"}:
+        return None
+    if last["RESULT"].lower() not in {"pass", "fail", "timeout"}:
+        return None
+    return last
+
+
+def _print_ci_watch(result: str, checks: str, merge_state: str, failing: str, watcher: str) -> None:
+    print(f"RESULT: {result}")
+    print(f"CHECKS: {checks}")
+    print(f"MERGE_STATE: {merge_state}")
+    print(f"FAILING: {failing}")
+    print(f"WATCHER: {watcher}")
+
+
+def ci_watch(
+    target_kind: str,
+    target_id: int,
+    repo_slug: str | None,
+    timeout_s: int,
+    *,
+    home: Path,
+    repo: Path,
+    which=shutil.which,
+    run_agy=run_lane,
+    run_gh=subprocess.run,
+    clock=time.monotonic,
+) -> int:
+    """Wait for CI with the resolved watcher, using one shared time budget."""
+    if target_kind not in {"pr", "run"} or target_id <= 0 or timeout_s <= 0:
+        print("[caddis-lanes] ci-watch: target and timeout must be positive", file=sys.stderr)
+        _print_ci_watch("timeout", "n/a", "n/a", "none", "gh")
+        return EXIT_CONFIG
+    if repo_slug is not None and not re.fullmatch(r"[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+", repo_slug):
+        print("[caddis-lanes] ci-watch: --repo must be OWNER/NAME", file=sys.stderr)
+        _print_ci_watch("timeout", "n/a", "n/a", "none", "gh")
+        return EXIT_CONFIG
+
+    started = clock()
+    try:
+        watchers = caddis_routing.resolve(home, repo, which=which)["ci-watch"]
+    except caddis_routing.RoutingConfigError as exc:
+        print(f"[caddis-lanes] {exc}", file=sys.stderr)
+        _print_ci_watch("timeout", "n/a", "n/a", "none", "gh")
+        return EXIT_CONFIG
+
+    repo_opt = f" --repo {repo_slug}" if repo_slug else ""
+    if target_kind == "pr":
+        poll = f"gh pr checks {target_id}{repo_opt}"
+        state = f"gh pr view {target_id} --json mergeStateStatus,headRefOid{repo_opt}"
+    else:
+        poll = f"gh run view {target_id}{repo_opt}"
+        state = "n/a"
+    prompt = (
+        "Read-only CI watch. Poll with " + poll + " until every check has finished or the time runs out. "
+        + (f"For the PR, also poll {state}. " if target_kind == "pr" else "")
+        + "Never merge, push, comment, re-run, approve, close or edit anything. "
+        + "Then print exactly this block as the last thing you output, with actual values:\n"
+        "RESULT: pass|fail|timeout\n"
+        "CHECKS: <n passed>/<n total>\n"
+        "MERGE_STATE: <mergeStateStatus or n/a>\n"
+        "FAILING: <comma-separated failing check names, or none>"
+    )
+
+    for watcher in watchers:
+        if watcher == "claude":
+            break
+        if watcher != "agy":
+            print(f"[caddis-lanes] ci-watch: unsupported watcher {watcher}; skipping", file=sys.stderr)
+            continue
+        agy_path = which("agy")
+        if agy_path is None:
+            break
+        remaining = timeout_s - (clock() - started)
+        if remaining <= 0:
+            _print_ci_watch("timeout", "n/a", "n/a", "none", "agy")
+            return EXIT_CONFIG
+        try:
+            model = resolve_models(load_lanes_config(repo))["agy"]
+            effort = DEFAULT_EFFORT["agy"]
+        except LaneConfigError as exc:
+            print(f"[caddis-lanes] {exc}", file=sys.stderr)
+            _print_ci_watch("timeout", "n/a", "n/a", "none", "agy")
+            return EXIT_CONFIG
+        agy_argv = [
+            agy_path, "--model", f"{model}-{effort}",
+            "--dangerously-skip-permissions", "--output-format", "text", "--print",
+        ]
+        try:
+            run = run_agy(agy_argv, repo, prompt, False, remaining, child_env(os.environ, "agy", model))
+        except OSError as exc:
+            print(f"[caddis-lanes] ci-watch: agy could not start ({exc}); watching with gh", file=sys.stderr)
+            break
+        outcome = classify_exit("agy", run.returncode, run.output, run.timed_out)
+        if run.timed_out:
+            _print_ci_watch("timeout", "n/a", "n/a", "none", "agy")
+            return EXIT_CONFIG
+        if outcome in {RESULT_OUT_OF_BUDGET, RESULT_CONFIG_ERROR}:
+            reason = "out of budget" if outcome == RESULT_OUT_OF_BUDGET else "configuration error"
+            print(f"[caddis-lanes] ci-watch: agy {reason}; watching with gh", file=sys.stderr)
+            break
+        report = _ci_watch_block(run.output)
+        if report is not None:
+            result = report["RESULT"].lower()
+            _print_ci_watch(result, report["CHECKS"], report["MERGE_STATE"], report["FAILING"], "agy")
+            return {"pass": EXIT_OK, "fail": EXIT_FAIL, "timeout": EXIT_CONFIG}[result]
+        break
+
+    remaining = timeout_s - (clock() - started)
+    if remaining <= 0:
+        print("[caddis-lanes] ci-watch: time budget expired before gh", file=sys.stderr)
+        _print_ci_watch("timeout", "n/a", "n/a", "none", "gh")
+        return EXIT_CONFIG
+    gh_path = which("gh")
+    if gh_path is None:
+        print("[caddis-lanes] ci-watch: gh not found on PATH", file=sys.stderr)
+        _print_ci_watch("timeout", "n/a", "n/a", "none", "gh")
+        return EXIT_CONFIG
+    command = (
+        [gh_path, "pr", "checks", str(target_id), "--watch"]
+        if target_kind == "pr" else [gh_path, "run", "watch", str(target_id), "--exit-status"]
+    )
+    if repo_slug:
+        command.extend(["--repo", repo_slug])
+    try:
+        completed = run_gh(
+            command, cwd=repo, capture_output=True, text=True,
+            encoding="utf-8", errors="replace", timeout=remaining,
+        )
+    except subprocess.TimeoutExpired:
+        print("[caddis-lanes] ci-watch: gh timed out", file=sys.stderr)
+        _print_ci_watch("timeout", "n/a", "n/a", "none", "gh")
+        return EXIT_CONFIG
+    except OSError as exc:
+        print(f"[caddis-lanes] ci-watch: gh could not start ({exc})", file=sys.stderr)
+        _print_ci_watch("timeout", "n/a", "n/a", "none", "gh")
+        return EXIT_CONFIG
+    output = "\n".join(part for part in (completed.stdout, completed.stderr) if part)
+    if output:
+        print("\n".join(output.splitlines()[-40:]), file=sys.stderr)
+    no_checks = "no checks reported" in output.lower()
+    code = EXIT_OK if completed.returncode == 0 else (
+        EXIT_FAIL if completed.returncode == 1 and not no_checks else EXIT_CONFIG
+    )
+    _print_ci_watch(
+        "pass" if code == EXIT_OK else "fail" if code == EXIT_FAIL else "timeout",
+        "n/a", "n/a", "see gh output" if code == EXIT_FAIL else "none", "gh",
+    )
+    return code
+
+
 def load_wording_findings(text: str) -> list[str]:
     findings = []
     seen = set()
@@ -1595,6 +1817,17 @@ def main(argv: list[str] | None = None) -> int:
     show_chain.add_argument("--lane")
     show_chain.add_argument("--repo", type=Path)
 
+    next_model = subparsers.add_parser("next-lane")
+    next_model.add_argument("--role", required=True, choices=tuple(caddis_routing.DEFAULT_ROUTING))
+    next_model.add_argument("--after", required=True)
+
+    watch = subparsers.add_parser("ci-watch")
+    watch_target = watch.add_mutually_exclusive_group(required=True)
+    watch_target.add_argument("--pr", type=int)
+    watch_target.add_argument("--run", type=int)
+    watch.add_argument("--repo")
+    watch.add_argument("--timeout", type=int, default=DEFAULT_TIMEOUT_S)
+
     run = subparsers.add_parser("run")
     _add_phase_arguments(run)
     run.add_argument("--type", required=True)
@@ -1618,6 +1851,34 @@ def main(argv: list[str] | None = None) -> int:
     args = parser.parse_args(argv)
 
     try:
+        if args.command == "next-lane":
+            if args.after not in caddis_routing.KNOWN_MODELS:
+                print(f"[caddis-lanes] next-lane: unknown model {args.after!r}", file=sys.stderr)
+                return EXIT_CONFIG
+            try:
+                candidate = next_lane(
+                    args.role, args.after, home=Path.home(), repo=Path.cwd(), which=shutil.which
+                )
+            except caddis_routing.RoutingConfigError as exc:
+                print(f"[caddis-lanes] next-lane: {exc}", file=sys.stderr)
+                return EXIT_CONFIG
+            if candidate is None:
+                print(
+                    f"[caddis-lanes] next-lane: no lane left for {args.role} after {args.after}",
+                    file=sys.stderr,
+                )
+                return EXIT_CONFIG
+            print(candidate)
+            return EXIT_OK
+        if args.command == "ci-watch":
+            return ci_watch(
+                "pr" if args.pr is not None else "run",
+                args.pr if args.pr is not None else args.run,
+                args.repo,
+                args.timeout,
+                home=Path.home(),
+                repo=Path.cwd(),
+            )
         if args.command == "show-chain":
             cfg = load_lanes_config(args.repo if args.repo is not None else Path.cwd())
             chain = resolve_chain(args.type, cfg, first_lane=args.lane)

package/bundles/antigravity-plugin/scripts/caddis_relay_git.py

@@ -0,0 +1,159 @@
+"""Transfer one workstream relay through an isolated, leased Git ref."""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+try:
+    from caddis_workstreams import _name, _validate_relay, read_relay, write_relay
+    import secret_filter
+except ModuleNotFoundError as exc:
+    if exc.name not in {"caddis_workstreams", "secret_filter"}:
+        raise
+    sys.path.insert(0, str(Path(__file__).resolve().parent))
+    sys.path.insert(0, str(Path(__file__).resolve().parents[1] / ".github" / "tools"))
+    from caddis_workstreams import _name, _validate_relay, read_relay, write_relay
+    import secret_filter
+
+
+MAX_NOTE_CHARS = 4000
+
+
+def _git(repo: Path, *args: str, input_data: bytes | None = None,
+         env: dict[str, str] | None = None) -> bytes:
+    result = subprocess.run(["git", *args], cwd=repo, env=env, input=input_data,
+                            stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=False)
+    if result.returncode:
+        # Name the subcommand, not a leading "-c key=value" option.
+        command = next((arg for i, arg in enumerate(args) if not arg.startswith("-") and (i == 0 or args[i - 1] != "-c")), "?")
+        raise RuntimeError(f"git {command} failed: {result.stderr.decode('utf-8', 'replace').strip()}")
+    return result.stdout
+
+
+def _ref(workstream: str) -> str:
+    return "refs/caddis/relay/" + _name(workstream)
+
+
+def _check_note(workstream: str, note: str) -> None:
+    if len(note) > MAX_NOTE_CHARS:
+        raise ValueError("relay exceeds 4,000 characters")
+    _validate_relay(workstream, note)
+
+
+def _pre_send(note: str) -> None:
+    # A synthetic new-file diff makes the existing filter scan every line, not
+    # only lines changed since a prior relay. No user-configured allowlist is
+    # accepted for this outbound note.
+    lines = note.splitlines()
+    diff = ("diff --git a/relay.md b/relay.md\nnew file mode 100644\n"
+            "--- /dev/null\n+++ b/relay.md\n"
+            f"@@ -0,0 +1,{len(lines)} @@\n" +
+            "".join("+" + line + "\n" for line in lines))
+    result = secret_filter.filter_diff(diff, list(secret_filter.DEFAULT_DENY_GLOBS), [])
+    if result.hits or result.dropped_paths or not result.kept_diff:
+        raise ValueError("relay refused by pre-send filter")
+
+
+def push_relay(repo: Path, workstream: str, *, confirmed: bool, interactive: bool) -> int:
+    """Return 0 on a leased push, 1 on refusal or conflict.
+
+    A Git or network failure before the push (for example an unreachable remote in
+    ``ls-remote``) raises RuntimeError, so the caller reports it instead of a refusal.
+
+    The caller must obtain this invocation's interactive decision. This API
+    never reads an ambient confirmation variable or prompts by itself.
+    """
+    if not confirmed or not interactive:
+        return 1
+    repo = Path(repo)
+    ref = _ref(workstream)
+    note, digest = read_relay(repo, workstream)
+    if digest is None:
+        return 1
+    _check_note(workstream, note)
+    _pre_send(note)
+    with tempfile.TemporaryDirectory(prefix="caddis-relay-index-") as temp:
+        index = Path(temp) / "index"
+        env = os.environ.copy()
+        env["GIT_INDEX_FILE"] = str(index)
+        _git(repo, "read-tree", "--empty", env=env)
+        blob = _git(repo, "hash-object", "-w", "--stdin", input_data=note.encode("utf-8"), env=env).decode().strip()
+        _git(repo, "update-index", "--add", "--cacheinfo", "100644", blob, "relay.md", env=env)
+        tree = _git(repo, "write-tree", env=env).decode().strip()
+        commit = _git(repo, "-c", "user.name=Caddis Relay", "-c", "user.email=relay@localhost",
+                      "commit-tree", tree, input_data=b"Relay note\n", env=env).decode().strip()
+        old = _git(repo, "ls-remote", "origin", ref, env=env).decode().strip()
+        expected = old.split("\t", 1)[0] if old else ""
+        try:
+            _git(repo, "push", f"--force-with-lease={ref}:{expected}", "origin",
+                 f"{commit}:{ref}", env=env)
+        except RuntimeError:
+            return 1
+    return 0
+
+
+def fetch_relay(repo: Path, workstream: str, *, replace: bool = False) -> str:
+    """Fetch one explicit ref, validate its one-file tree, then store by local CAS.
+
+    A local relay that differs from the fetched one is never replaced unless the caller
+    passes ``replace=True``: it may hold newer, never-pushed work.
+    """
+    repo = Path(repo)
+    ref = _ref(workstream)
+    local, expected_hash = read_relay(repo, workstream)
+    _git(repo, "fetch", "--no-tags", "origin", ref)
+    fetched = _git(repo, "rev-parse", "FETCH_HEAD").decode().strip()
+    entries = _git(repo, "ls-tree", "-z", fetched).split(b"\0")
+    if len(entries) != 2 or not entries[0].startswith(b"100644 blob ") or not entries[0].endswith(b"\trelay.md"):
+        raise ValueError("remote relay tree must contain only an ordinary relay.md")
+    size = int(_git(repo, "cat-file", "-s", f"{fetched}:relay.md").decode().strip())
+    if size > MAX_NOTE_CHARS * 4:  # UTF-8 upper bound; read nothing larger into memory
+        raise ValueError("remote relay exceeds 4,000 characters")
+    note = _git(repo, "show", f"{fetched}:relay.md").decode("utf-8")
+    _check_note(workstream, note)
+    if expected_hash is not None and local != note and not replace:
+        raise ValueError("local relay differs from the fetched one; pass replace=True to overwrite it")
+    result = write_relay(repo, workstream, note, expected_hash)
+    if result.status != "written":
+        raise RuntimeError("local relay changed during fetch")
+    return note
+
+
+def _headless() -> bool:
+    """No human is watching: the caddis launchers and the docket runner set these."""
+    return any(os.environ.get(name) for name in ("CADDIS_HEADLESS", "DOCKET_PLAN", "DOCKET_BRANCH"))
+
+
+def main(argv: list[str] | None = None) -> int:
+    import argparse
+    parser = argparse.ArgumentParser(description="Move one workstream relay between machines")
+    common = argparse.ArgumentParser(add_help=False)
+    common.add_argument("--repo", type=Path, default=Path("."))
+    sub = parser.add_subparsers(dest="command", required=True)
+    push_p = sub.add_parser("push", parents=[common], help="publish .caddis/relay/<name>.md to refs/caddis/relay/<name>")
+    push_p.add_argument("name")
+    push_p.add_argument("--user-said-yes", action="store_true",
+                        help="pass only after the user answered y to the push question in this session")
+    fetch_p = sub.add_parser("fetch", parents=[common], help="fetch refs/caddis/relay/<name> into .caddis/relay/<name>.md")
+    fetch_p.add_argument("name")
+    fetch_p.add_argument("--replace", action="store_true",
+                         help="overwrite a different local relay (it may hold never-pushed work)")
+    args = parser.parse_args(argv)
+    try:
+        if args.command == "push":
+            code = push_relay(args.repo, args.name, confirmed=args.user_said_yes, interactive=not _headless())
+            print("relay pushed" if code == 0 else "relay not pushed (no consent, headless, missing relay, or remote conflict)")
+            return code
+        print(fetch_relay(args.repo, args.name, replace=args.replace), end="")
+        return 0
+    except (RuntimeError, ValueError, OSError) as exc:
+        print(f"caddis-relay: {exc}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/bundles/antigravity-plugin/scripts/caddis_routing.py

@@ -0,0 +1,103 @@
+#!/usr/bin/env python3
+"""Resolve the local model order for each caddis role."""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import shutil
+import sys
+import tomllib
+from pathlib import Path
+from typing import Callable, Mapping
+
+import oss_model
+
+
+DEFAULT_ROUTING: dict[str, list[str]] = {
+    "critical": ["opus"],
+    "light": ["sonnet"],
+    "coding": ["agy", "codex"],
+    "review": ["glm", "deepseek"],
+    "consult": ["agy", "glm", "codex"],
+    "ci-watch": ["agy"],
+}
+KNOWN_MODELS = frozenset({"opus", "sonnet", "agy", "codex", "glm", "deepseek", "claude"})
+
+
+class RoutingConfigError(Exception):
+    """A routing file has an invalid value or cannot be parsed."""
+
+
+def _routing_from(path: Path) -> dict[str, list[str]]:
+    if not path.is_file():
+        return {}
+    try:
+        with path.open("rb") as file:
+            config = tomllib.load(file)
+    except (OSError, tomllib.TOMLDecodeError) as exc:
+        raise RoutingConfigError(f"{path}: {exc}") from exc
+
+    routing = config.get("routing", {})
+    if not isinstance(routing, dict):
+        raise RoutingConfigError(f"{path}: [routing] must be a table")
+    for role, models in routing.items():
+        if role not in DEFAULT_ROUTING:
+            raise RoutingConfigError(f"{path}: unknown routing role {role!r}")
+        if not isinstance(models, list):
+            raise RoutingConfigError(f"{path}: routing.{role} must be a list")
+        for model in models:
+            if not isinstance(model, str) or model not in KNOWN_MODELS:
+                raise RoutingConfigError(f"{path}: unknown model {model!r} in routing.{role}")
+    return routing
+
+
+def resolve(
+    home: Path,
+    repo: Path,
+    which: Callable[[str], str | None] = shutil.which,
+    env: Mapping[str, str] | None = None,
+) -> dict[str, list[str]]:
+    """Apply user and repo overrides, then keep only locally available models."""
+    env = os.environ if env is None else env
+    configured = dict(DEFAULT_ROUTING)
+    configured.update(_routing_from(Path(home) / ".caddis" / "config.toml"))
+    configured.update(_routing_from(Path(repo) / ".caddis" / "config.toml"))
+
+    providers = set(oss_model.configured_providers(dict(env)))
+    available = {"opus", "sonnet", "claude"} | (providers & {"glm", "deepseek"})
+    for tool in ("agy", "codex"):
+        if which(tool):
+            available.add(tool)
+
+    resolved = {}
+    for role, models in configured.items():
+        resolved[role] = list(dict.fromkeys(
+            model for model in models if model != "claude" and model in available
+        )) + ["claude"]
+    return resolved
+
+
+def main(argv: list[str] | None = None, env: Mapping[str, str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    commands = parser.add_subparsers(dest="command", required=True)
+    show = commands.add_parser("show", help="print the resolved routing table")
+    show.add_argument("--json", action="store_true", help="print JSON")
+    show.add_argument("--repo", type=Path, default=Path.cwd(), help="repository path")
+    args = parser.parse_args(argv)
+
+    try:
+        routing = resolve(Path.home(), args.repo, env=env)
+    except RoutingConfigError as exc:
+        print(exc, file=sys.stderr)
+        return 3
+    if args.json:
+        print(json.dumps(routing))
+    else:
+        for role, models in routing.items():
+            print(f"{role}: {', '.join(models)}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())