codereview-loop 0.13.0__py3-none-any.whl

codereview/setup_wizard.py

@@ -0,0 +1,355 @@
+#!/usr/bin/env python3
+"""codereview first-run setup wizard (OpenClaw-style).
+
+Run on first open — interactively by the review entry point
+when nothing is configured, or any time via `codereview
+setup`. The user, not the product, chooses the models:
+
+  0. discovery (Epic K1): the wizard first scans PATH for the
+     agent CLIs discovery.py knows and offers the found ones
+     as seats — they review on the user's existing CLI logins,
+     no API key needed. Discovery proposes; only a confirmed
+     pick becomes a spec, indistinguishable from a hand-typed
+     agent seat from then on;
+  1. pick providers (registry presets, custom specs, agent
+     seats, local model servers) — the registry's default
+     models are shown as SUGGESTIONS to confirm or replace,
+     never as decisions. Local presets (Epic L5: ollama,
+     lmstudio, or any local:<name>:<base-url>|<model>
+     endpoint) are listed as their own section with the
+     short recipe for each; they are keyless, so step 2
+     never prompts for a key for them — there is none;
+  2. keys: for each API seat the wizard names the environment
+     variable that must hold the user's key and reports whether
+     it is currently set. The wizard never asks for a key value,
+     never echoes one, and never writes one anywhere — the
+     saved config references env var names only;
+  3. assign a model per role (correctness, operations,
+     verifier, tech-lead, solver): each prompt shows the
+     candidate specs; the user confirms one, types another
+     spec, or leaves the role to the panel;
+  4. save to the user config (userconfig) as the defaults.
+
+input/print are injectable so the whole flow is testable with
+scripted answers; EOF at any prompt aborts WITHOUT saving.
+"""
+
+from __future__ import annotations
+
+import os
+
+from . import discovery, registry, userconfig
+from .providers import (ProviderError, _parse_agent_spec,
+                        describe_spec)
+
+
+# Bound on provider-entry attempts in the wizard: without it
+# the provider loop re-asked forever on persistently invalid
+# input (review finding a509b806fda6). Exhausting the bound
+# aborts through the same EOF channel as an EOF at any prompt —
+# nothing is saved and the caller exits cleanly.
+MAX_PROVIDER_ATTEMPTS = 3
+
+
+def _ask(input_fn, print_fn, prompt):
+    try:
+        return input_fn(prompt).strip()
+    except EOFError:
+        print_fn("setup aborted — nothing saved.")
+        raise
+
+
+def _panel_families(providers):
+    """Distinct VENDOR families a confirmed panel covers, for
+    the discovery family warning. API seats read their family
+    from the spec; agent seats resolve their vendor through the
+    discovery table by seat name (agent:claude:* is Anthropic's
+    CLI) — an agent seat the table does not know contributes no
+    family, the same conservative reading the gate's derivation
+    makes (its family tag is 'agent', never a guessed vendor)."""
+    families = set()
+    for spec in providers:
+        family = None
+        if spec.startswith("agent:"):
+            try:
+                name, _opts, _cmd = _parse_agent_spec(spec)
+            except ProviderError:
+                continue
+            family = discovery.family_for_seat_name(name)
+        else:
+            try:
+                family = describe_spec(spec)["family"]
+            except ProviderError:
+                continue
+        if family and family not in ("agent", "unknown"):
+            families.add(family)
+    return families
+
+
+def _discovery_step(input_fn, print_fn, environ, discover_fn):
+    """Epic K1: offer the agent CLIs found on PATH as seats.
+
+    Returns the list of agent specs the user confirmed (empty
+    when nothing was found or everything was declined). Found
+    CLIs without a verified seat command are reported — with
+    their resolved path and probe outcome — but never offered:
+    the wizard pre-fills no invocation this repository has not
+    verified. EOF at the pick prompt aborts via _ask, like
+    every other wizard prompt."""
+    found = (discover_fn() if discover_fn is not None
+             else discovery.discover_clis(environ.get("PATH")))
+    if not found:
+        print_fn("No supported agent CLIs found on PATH — "
+                 "continuing with API providers.")
+        return []
+    print_fn("Agent CLIs found on this machine — they review "
+             "using your existing CLI logins, no API key "
+             "needed:")
+    offerable = []
+    for entry in found:
+        if entry["probe_ok"]:
+            probe_txt = "version probe ok"
+            if entry["probe_detail"]:
+                probe_txt += f" ({entry['probe_detail']})"
+        else:
+            probe_txt = ("version probe FAILED "
+                         f"({entry['probe_detail']})")
+        if entry["command"]:
+            offerable.append(entry)
+            print_fn(f"  {len(offerable)}. {entry['display']} "
+                     f"— {entry['path']} ({probe_txt}) — can "
+                     "be added as a seat")
+        else:
+            print_fn(f"  - {entry['display']} — {entry['path']} "
+                     f"({probe_txt}) — found, but CodeReview "
+                     "has no verified seat command for it "
+                     "yet; to seat it, enter "
+                     f"agent:{entry['name']}:<your command> "
+                     "in the provider step below")
+    if not offerable:
+        return []
+    raw = _ask(input_fn, print_fn,
+               "Add any as seats? Numbers or names, "
+               "comma-separated (Enter for none): ")
+    chosen = []
+    for token in (t.strip() for t in raw.split(",")):
+        if not token:
+            continue
+        entry = None
+        if token.isdigit():
+            idx = int(token) - 1
+            if 0 <= idx < len(offerable):
+                entry = offerable[idx]
+        else:
+            entry = next(
+                (e for e in offerable
+                 if e["name"] == token.lower()), None)
+        if entry is None:
+            print_fn(f"  ! {token!r} is not one of the "
+                     "choices — ignored.")
+        elif entry not in chosen:
+            chosen.append(entry)
+    picked = []
+    for entry in chosen:
+        picked.append(discovery.seat_spec(entry))
+        print_fn(f"  + {entry['display']} added as an agent "
+                 "seat.")
+    if picked:
+        print_fn("You can add API providers below too, or "
+                 "press Enter at the provider prompt to keep "
+                 "just the discovered seats.")
+    return picked
+
+
+def run_wizard(input_fn=input, print_fn=print, environ=None,
+               probe_fn=None, discover_fn=None):
+    """Drive the wizard; returns the saved config dict
+    ({"providers", "roles", "path"}), or None when aborted.
+    `probe_fn(providers_dict) -> doctor-result` is optional;
+    when given, the user is offered a live seat probe before
+    saving (the CLI wires core.run_doctor). `discover_fn()` ->
+    found-CLI list is the Epic K1 seam: None runs real PATH
+    discovery against `environ`'s PATH (discovery.discover_
+    clis); tests inject a fake machine."""
+    environ = os.environ if environ is None else environ
+    print_fn("CodeReview setup — you choose the models; nothing "
+             "is pre-picked.")
+    print_fn("CodeReview is a multi-model review gate for "
+             "AI-written code: a panel of models from different "
+             "providers reviews every change, cross-checks each "
+             "other's findings, and issues a recorded pass/block "
+             "verdict — so the model that wrote the code is never "
+             "the only one that checked it.")
+    picked = _discovery_step(input_fn, print_fn, environ,
+                             discover_fn)
+    print_fn("Providers (preset[:model], a custom "
+             "name|type|base|model|KEY_ENV spec, or "
+             "agent:<name>:<command>):")
+    for name, preset in registry.PRESETS.items():
+        if preset.get("family") == registry.LOCAL_FAMILY:
+            continue  # local presets get their own section
+        print_fn(f"  {name:<12} suggested model: "
+                 f"{preset['model']}   key env: "
+                 f"{preset['key_env']}")
+    print_fn("Local model servers — they run on your own "
+             "machine: no API key, and the review never "
+             "leaves the machine (no network):")
+    for name, preset in registry.local_presets().items():
+        print_fn(f"  {name:<12} endpoint: "
+                 f"{preset['base_url']}   suggested model: "
+                 f"{preset['model']}")
+        print_fn(f"  {'':<12} recipe: {preset['recipe']}")
+    print_fn("  any other local server: "
+             "local:<name>:<base-url>|<model> (e.g. "
+             "local:box:http://localhost:8080/v1|my-model) — "
+             "start the server, pick the spec, then probe "
+             "with `codereview doctor`")
+    providers = []
+    attempts = 0
+    while not providers:
+        raw = _ask(input_fn, print_fn,
+                   "Providers, comma-separated: ")
+        attempts += 1
+        candidates = [s.strip() for s in raw.split(",")
+                      if s.strip()]
+        if not candidates and picked:
+            # Enter at the provider prompt keeps the seats the
+            # discovery step confirmed — only reachable when
+            # discovery contributed, so a hand-typed flow sees
+            # today's behaviour byte-for-byte.
+            providers = list(picked)
+            break
+        bad = []
+        for spec in candidates:
+            try:
+                describe_spec(spec)
+            except ProviderError as exc:
+                bad.append(str(exc))
+        if not candidates:
+            bad.append("no providers entered")
+        if bad:
+            for msg in bad:
+                print_fn(f"  ! {msg}")
+            if attempts >= MAX_PROVIDER_ATTEMPTS:
+                print_fn("setup aborted — too many invalid "
+                         "provider entries; nothing saved.")
+                raise EOFError
+            continue
+        # An exact repeat of a discovery pick (the user pasted
+        # the same agent spec by hand) would seat the identical
+        # command twice under two names — one model wearing
+        # two seat hats. Drop exact duplicates of a pick, with
+        # a note; anything else the user typed stands as typed.
+        for spec in candidates:
+            if spec in picked:
+                print_fn(f"  ! {spec} is already in the panel "
+                         "from discovery — duplicate skipped.")
+        providers = picked + [s for s in candidates
+                              if s not in picked]
+    if picked:
+        # Family-diversity guard (Epic K1): discovery makes it
+        # easy to build a one-family panel without noticing.
+        # Warn in plain words and offer one API spec as the
+        # second family; never block saving — the gate's
+        # degraded-panel rules govern what a one-family panel
+        # may conclude.
+        families = _panel_families(providers)
+        if len(families) < 2:
+            fam_txt = (f" ({', '.join(sorted(families))})"
+                       if families else "")
+            print_fn("Panel check: the seats above cover a "
+                     f"single vendor family{fam_txt}. Reviews "
+                     "still run, but the verification round "
+                     "needs two distinct families to clear a "
+                     "disputed finding — a one-family panel's "
+                     "PASS can be held to INCONCLUSIVE.")
+            extra = _ask(
+                input_fn, print_fn,
+                "Add an API provider from another family? "
+                "Enter a provider spec (Enter to continue "
+                "with this panel): ")
+            if extra:
+                try:
+                    describe_spec(extra)
+                except ProviderError as exc:
+                    print_fn(f"  ! {exc} — continuing with "
+                             "the current panel.")
+                else:
+                    if extra in providers:
+                        print_fn(f"  ! {extra} is already in "
+                                 "the panel — duplicate "
+                                 "skipped.")
+                    else:
+                        providers.append(extra)
+    for spec in providers:
+        desc = describe_spec(spec)
+        if desc["kind"] == "agent":
+            print_fn(f"  seat {desc['seat']}: agent seat — it "
+                     "authenticates as itself, no key env.")
+        elif desc["family"] == registry.LOCAL_FAMILY:
+                print_fn(f"  seat {desc['seat']}: local model "
+                     f"server at {desc['base_url']} — no API "
+                     "key; it runs on your machine, so the "
+                     "review never leaves it (no network).")
+        elif desc["key_env"]:
+            state = ("set" if environ.get(desc["key_env"])
+                     else "NOT set")
+            print_fn(f"  seat {desc['seat']}: key env "
+                     f"{desc['key_env']} is {state}. Export it "
+                     "before running reviews; the key itself is "
+                     "never stored.")
+    print_fn("Assign a model per role. Enter accepts the "
+             "suggestion, type any provider spec to override, "
+             "'-' leaves the role to the panel.")
+    roles = {}
+    # The wizard assigns the serving roles; tech-lead-shadow is
+    # an opt-in evaluation seat assigned via --role or the saved
+    # config, not part of the first-run flow.
+    wizard_roles = [r for r in registry.ROLES
+                    if r != "tech-lead-shadow"]
+    for i, role in enumerate(wizard_roles):
+        suggestion = providers[i % len(providers)]
+        answer = _ask(
+            input_fn, print_fn,
+            f"  {role} [{suggestion}]: ")
+        if answer == "-":
+            continue
+        spec = answer or suggestion
+        try:
+            describe_spec(spec)
+        except ProviderError as exc:
+            print_fn(f"  ! {exc} — role left to the panel.")
+            continue
+        roles[role] = spec
+    if probe_fn is not None:
+        answer = _ask(input_fn, print_fn,
+                      "Probe the seats now? [y/N]: ")
+        if answer.lower().startswith("y"):
+            from .providers import build_providers
+            try:
+                result = probe_fn(build_providers(providers))
+                for seat in result.get("seats") or []:
+                    print_fn(f"  probe {seat.get('name')}: "
+                             f"{'ok' if seat.get('ok') else 'FAILED'}")
+            except Exception as exc:  # noqa: BLE001
+                print_fn(f"  probe failed: {exc}")
+    # P6-06: persist the seat metadata the wizard derived
+    # for the confirmed panel (each spec's family, agent
+    # seats included — describe_spec resolves an agent seat
+    # to its CLI's vendor family). Runs apply the saved table
+    # over the derived baseline, so the families a saved
+    # panel is judged by are the ones setup computed.
+    seat_meta = {}
+    for spec in providers:
+        try:
+            desc = describe_spec(spec)
+        except ProviderError:
+            continue
+        seat_meta[desc["seat"]] = desc["family"]
+    path = userconfig.save_user_config(
+        providers, roles, environ=environ, seat_meta=seat_meta)
+    print_fn(f"Saved your setup to {path} — providers: "
+             f"{', '.join(providers)}; roles: "
+             f"{len(roles)} assigned.")
+    return {"providers": providers, "roles": roles,
+            "seat_meta": seat_meta, "path": path}

codereview/support.py

@@ -0,0 +1,328 @@
+"""Support bundle — release-gate row L18.
+
+`codereview support-bundle` writes ONE zip a user can read and
+attach to a bug report. It is built to be safe to read first and
+safe to send:
+
+  * every text file passes through the same `redact_secrets` the
+    run records use;
+  * environment variables appear by NAME only (a fixed list of the
+    variables the product reads) and as set / not set — never a
+    value;
+  * nothing is sent anywhere by this module;
+  * a file over the per-file cap, or one that would push the zip
+    over the total cap, is left out and named in MANIFEST.txt —
+    never silently truncated;
+  * any step that fails (no records, a missing config, a doctor
+    that crashes) is recorded in MANIFEST.txt and the bundle is
+    still produced.
+
+Run records hold excerpts of the code that was reviewed. Redaction
+cannot recognise private code, so the bundle says so on screen and
+offers --no-records.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import datetime
+import glob
+import io
+import json
+import os
+import platform
+import sys
+import zipfile
+
+from .core import VERSION, redact_secrets
+
+SCHEMA = "codereview.support-bundle/1"
+MAX_FILE_BYTES = 2 * 1024 * 1024
+MAX_TOTAL_BYTES = 8 * 1024 * 1024
+
+WARNING = ("Read the bundle before you send it. Redaction removes "
+           "secret-shaped text, but run records contain excerpts of "
+           "the code you reviewed and redaction cannot recognise "
+           "private code. Use --no-records to leave records out. "
+           "Nothing is sent automatically.")
+
+# Variables the product reads. Names only, ever.
+_ENV_NAMES = (
+    "OPENAI_API_KEY", "ANTHROPIC_API_KEY", "GEMINI_API_KEY",
+    "DEEPSEEK_API_KEY", "MINIMAX_API_KEY", "MOONSHOT_API_KEY",
+    "NVIDIA_API_KEY", "XAI_API_KEY", "MISTRAL_API_KEY",
+    "OPENROUTER_API_KEY", "GITHUB_TOKEN")
+_ENV_PREFIXES = ("CODEREVIEW_", "REVIEWLOOP_")
+_SECRET_ENV_NAME_WORDS = ("KEY", "TOKEN", "SECRET", "PASSWORD")
+
+
+class _Bundle:
+    def __init__(self):
+        self.files = []     # (arcname, bytes, reason)
+        self.skipped = []   # (name, reason)
+        self.notes = []
+        self._total = 0
+
+    def add_text(self, arcname, text, reason, redact=True):
+        if redact:
+            try:
+                text = redact_secrets(text)
+            except Exception as exc:  # noqa: BLE001
+                self.skipped.append(
+                    (arcname, f"redaction failed ({type(exc).__name__});"
+                              " file left out"))
+                return
+        data = text.encode("utf-8", "replace")
+        if len(data) > MAX_FILE_BYTES:
+            self.skipped.append(
+                (arcname, f"{len(data)} bytes exceeds the "
+                          f"{MAX_FILE_BYTES}-byte per-file cap"))
+            return
+        if self._total + len(data) > MAX_TOTAL_BYTES:
+            self.skipped.append(
+                (arcname, f"would exceed the {MAX_TOTAL_BYTES}-byte "
+                          "bundle cap"))
+            return
+        self._total += len(data)
+        self.files.append((arcname, data, reason))
+
+    def add_file(self, arcname, path, reason):
+        try:
+            with open(path, encoding="utf-8", errors="replace") as fh:
+                text = fh.read(MAX_FILE_BYTES + 1)
+        except OSError as exc:
+            self.skipped.append((arcname, f"unreadable: {exc}"))
+            return
+        self.add_text(arcname, text, reason)
+
+
+def _env_report(environ):
+    lines = []
+    for name in sorted(set(_ENV_NAMES) | {
+            k for k in environ if k.startswith(_ENV_PREFIXES)}):
+        is_set = bool(str(environ.get(name, "")).strip())
+        lines.append(f"{name}: {'set' if is_set else 'not set'}")
+    return "\n".join(lines) + "\n"
+
+
+def _packages():
+    try:
+        from importlib import metadata
+        rows = sorted(
+            f"{d.metadata['Name']}=={d.version}"
+            for d in metadata.distributions()
+            if d.metadata and d.metadata["Name"])
+        return "\n".join(rows) + "\n"
+    except Exception as exc:  # noqa: BLE001
+        return f"(package list unavailable: {type(exc).__name__})\n"
+
+
+def _find_records(records_dir):
+    dirs = []
+    if records_dir:
+        dirs.append(records_dir)
+    else:
+        dirs.extend(["codereview-out", "."])
+    for directory in dirs:
+        if not os.path.isdir(directory):
+            continue
+        found = [p for p in glob.glob(
+            os.path.join(directory, "codereview-*.json"))
+            if "crash" not in os.path.basename(p)
+            and not p.endswith(".sidecar.json")]
+        if found:
+            found.sort(key=lambda p: os.path.getmtime(p))
+            return directory, found[-1]
+    return None, None
+
+
+def _find_crash_notes(directories):
+    seen, notes = set(), []
+    for directory in directories:
+        if not directory:
+            continue
+        for p in glob.glob(os.path.join(
+                directory, "codereview-crash-*.json")):
+            rp = os.path.realpath(p)
+            if rp not in seen:
+                seen.add(rp)
+                notes.append(p)
+    notes.sort(key=lambda p: os.path.getmtime(p))
+    return notes[-3:]
+
+
+def _run_doctor(bundle):
+    from . import cli
+    out, err = io.StringIO(), io.StringIO()
+    try:
+        with contextlib.redirect_stdout(out), \
+                contextlib.redirect_stderr(err):
+            rc = cli._doctor_main([])
+        bundle.add_text("doctor.txt",
+                        f"exit code: {rc}\n{out.getvalue()}\n"
+                        f"{err.getvalue()}",
+                        "output of 'codereview doctor'")
+    except BaseException as exc:  # noqa: BLE001 — recorded, not raised
+        bundle.add_text("doctor.txt",
+                        f"doctor did not complete: "
+                        f"{type(exc).__name__}: {exc}\n"
+                        f"{out.getvalue()}{err.getvalue()}",
+                        "doctor output (it failed)")
+        bundle.notes.append(
+            "doctor failed; its failure is recorded in doctor.txt")
+
+
+def build_bundle(path, records_dir=None, include_records=True,
+                 message="", environ=None, with_doctor=False):
+    """Write the zip at `path` and return its manifest dict."""
+    environ = os.environ if environ is None else environ
+    bundle = _Bundle()
+    now = datetime.datetime.now(datetime.timezone.utc) \
+        .strftime("%Y-%m-%dT%H:%M:%SZ")
+    from .crash import build_identity
+    identity = {"schema": SCHEMA, "created_at": now,
+                **build_identity(),
+                "python": platform.python_version(),
+                "platform": platform.platform(),
+                "machine": platform.machine()}
+    bundle.add_text("identity.json",
+                    json.dumps(identity, indent=2, sort_keys=True),
+                    "build, Python and OS identity")
+    bundle.add_text("packages.txt", _packages(),
+                    "installed Python packages", redact=False)
+    bundle.add_text("environment-names.txt", _env_report(environ),
+                    "which variables the product reads are set "
+                    "(names only, never values)", redact=False)
+    if message.strip():
+        bundle.add_text("MESSAGE.txt", message,
+                        "your description of the problem")
+    # user config and project policy
+    from . import userconfig
+    cfg = userconfig.config_path(environ)
+    if os.path.isfile(cfg):
+        bundle.add_file("user-config.toml", cfg,
+                        "your saved provider setup (redacted)")
+    else:
+        bundle.notes.append("no saved user config found")
+    policy_path = ".codereview.toml"
+    if os.path.isfile(policy_path):
+        bundle.add_file("policy.toml", policy_path,
+                        "project policy (redacted)")
+    else:
+        bundle.notes.append("no .codereview.toml in the current "
+                            "directory")
+    # records and crash notes
+    rec_dir = None
+    if include_records:
+        rec_dir, record = _find_records(records_dir)
+        if record:
+            bundle.add_file(os.path.join("records",
+                                         os.path.basename(record)),
+                            record, "latest run record (JSON)")
+            md = os.path.splitext(record)[0] + ".md"
+            if os.path.isfile(md):
+                bundle.add_file(
+                    os.path.join("records", os.path.basename(md)),
+                    md, "latest run record (report)")
+        else:
+            bundle.notes.append("no run record found")
+    else:
+        bundle.notes.append("run records left out (--no-records)")
+    for note in _find_crash_notes([rec_dir or records_dir, "."]):
+        bundle.add_file(os.path.join("crash", os.path.basename(note)),
+                        note, "crash note (redacted)")
+    if with_doctor:
+        _run_doctor(bundle)
+    else:
+        bundle.notes.append(
+            "doctor not run (it calls your providers); add "
+            "--with-doctor to include it")
+    manifest = {
+        "entries": [{"name": n, "size": len(d), "reason": r}
+                    for n, d, r in bundle.files],
+        "skipped": [{"name": n, "reason": r}
+                    for n, r in bundle.skipped],
+        "notes": list(bundle.notes),
+    }
+    lines = [f"CodeReview support bundle ({SCHEMA})", f"created {now}",
+             "", "Files:"]
+    for e in manifest["entries"]:
+        lines.append(f"  {e['name']}  ({e['size']} bytes) — "
+                     f"{e['reason']}")
+    lines.append("  MANIFEST.txt — this list")
+    if manifest["skipped"]:
+        lines += ["", "Left out:"]
+        lines += [f"  {s['name']} — {s['reason']}"
+                  for s in manifest["skipped"]]
+    if manifest["notes"]:
+        lines += ["", "Notes:"] + [f"  {n}" for n in manifest["notes"]]
+    lines += ["", WARNING, ""]
+    manifest_text = "\n".join(lines)
+    fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
+    with os.fdopen(fd, "wb") as raw:
+        with zipfile.ZipFile(raw, "w", zipfile.ZIP_DEFLATED) as zf:
+            zf.writestr("MANIFEST.txt", manifest_text)
+            for name, data, _reason in bundle.files:
+                zf.writestr(name, data)
+    manifest["text"] = manifest_text
+    return manifest
+
+
+def describe(manifest, show=False, path=None):
+    parts = [manifest["text"].rstrip()]
+    if show and path:
+        with zipfile.ZipFile(path) as zf:
+            for name in zf.namelist():
+                if name == "MANIFEST.txt":
+                    continue
+                parts.append(f"\n===== {name} =====")
+                parts.append(zf.read(name).decode("utf-8", "replace"))
+    return "\n".join(parts)
+
+
+def _unique_path(base):
+    if not os.path.exists(base):
+        return base
+    stem, ext = os.path.splitext(base)
+    n = 2
+    while os.path.exists(f"{stem}-{n}{ext}"):
+        n += 1
+    return f"{stem}-{n}{ext}"
+
+
+def support_main(argv, environ=None):
+    import argparse
+    ap = argparse.ArgumentParser(
+        prog="codereview support-bundle",
+        description="Write one redacted zip to attach to a bug "
+                    "report. Nothing is sent.")
+    ap.add_argument("--out", default=None,
+                    help="zip path (default: "
+                         "codereview-support-<time>.zip here)")
+    ap.add_argument("--records", default=None,
+                    help="directory holding the run records "
+                         "(default: ./codereview-out, then .)")
+    ap.add_argument("--no-records", action="store_true",
+                    help="leave run records out of the bundle")
+    ap.add_argument("--with-doctor", action="store_true",
+                    help="also run 'codereview doctor' (calls your "
+                         "providers)")
+    ap.add_argument("--message", default="",
+                    help="what went wrong, in your words")
+    args = ap.parse_args(argv)
+    stamp = datetime.datetime.now(datetime.timezone.utc) \
+        .strftime("%Y%m%d-%H%M%S")
+    path = _unique_path(args.out or f"codereview-support-{stamp}.zip")
+    try:
+        manifest = build_bundle(
+            path, records_dir=args.records,
+            include_records=not args.no_records,
+            message=args.message, environ=environ,
+            with_doctor=args.with_doctor)
+    except Exception as exc:  # noqa: BLE001
+        print(f"codereview support-bundle: could not write the "
+              f"bundle: {type(exc).__name__}: {exc}", file=sys.stderr)
+        return 2
+    print(describe(manifest))
+    print(f"\nbundle written: {path}")
+    return 0