@event4u/agent-config 6.0.0 → 7.0.0

package/src/scripts/snapshot_agent_outputs.py

@@ -1,144 +0,0 @@
-#!/usr/bin/env python3
-"""Snapshot the agent-config build outputs for byte-identity verification.
-
-Used by monorepo Phase 4 (physical layout move) to assert that the
-pre-move and post-move `task sync` + `task build-discovery` outputs
-match byte-for-byte except for `artefacts[].path` values.
-
-Captures sha256 of every file under:
-  - dist/agent-src/
-  - .augment/
-  - dist/discovery/discovery-manifest.json (also stores parsed copy
-    with paths stripped so the post-move diff is path-only)
-
-CLI:
-  --out PATH    write JSON to this path (default: dist/migration/pre-move-snapshot.json)
-"""
-from __future__ import annotations
-
-import argparse
-import hashlib
-import json
-import sys
-from pathlib import Path
-from typing import Any
-
-ROOT = Path(__file__).resolve().parents[2]
-DEFAULT_OUT = ROOT / "dist" / "migration" / "pre-move-snapshot.json"
-
-TARGETS = (
-    ROOT / "dist/agent-src",
-    ROOT / ".augment",
-)
-MANIFEST = ROOT / "dist" / "discovery" / "discovery-manifest.json"
-
-
-def _sha256(path: Path) -> str:
-    h = hashlib.sha256()
-    with path.open("rb") as f:
-        for chunk in iter(lambda: f.read(65536), b""):
-            h.update(chunk)
-    return h.hexdigest()
-
-
-# Runtime artefacts that never participate in byte-identity verification.
-# Eval last-run.json + pytest caches are gitignored; including them just
-# adds noise when the worktree is clean.
-_SKIP_NAMES = frozenset({"last-run.json"})
-_SKIP_DIRS = frozenset({".pytest_cache", "__pycache__", ".mypy_cache",
-                         ".ruff_cache", "node_modules", ".DS_Store"})
-
-
-def _hash_tree(root: Path) -> dict[str, str]:
-    if not root.exists():
-        return {}
-    hashes: dict[str, str] = {}
-    for p in sorted(root.rglob("*")):
-        if not p.is_file():
-            continue
-        if p.name in _SKIP_NAMES:
-            continue
-        if any(part in _SKIP_DIRS for part in p.parts):
-            continue
-        hashes[p.relative_to(ROOT).as_posix()] = _sha256(p)
-    return hashes
-
-
-def _logical_path(rel: str) -> str:
-    """Strip any source-root prefix (legacy or packages/*) so the diff
-    compares the artefact's logical identity, not its physical location.
-    Non-source paths are returned unchanged.
-    """
-    posix = rel.replace("\\", "/")
-    if posix.startswith(".agent-src.uncondensed/"):
-        return posix[len(".agent-src.uncondensed/"):]
-    if posix.startswith("packages/"):
-        marker = "/.agent-src.uncondensed/"
-        idx = posix.find(marker)
-        if idx != -1:
-            return posix[idx + len(marker):]
-    return posix
-
-
-def _manifest_path_stripped(manifest_path: Path) -> dict[str, Any] | None:
-    if not manifest_path.exists():
-        return None
-    data = json.loads(manifest_path.read_text(encoding="utf-8"))
-    # Strip `path` from every artefact so the diff is path-only, then
-    # re-sort by (category, checksum) so the list order is content-stable
-    # — the original sort is path-based, which shifts when files move
-    # between roots even though no artefact body changed.
-    artefacts = data.get("artefacts", []) or []
-    for a in artefacts:
-        a.pop("path", None)
-    artefacts.sort(key=lambda a: (a.get("category", ""), a.get("checksum", "")))
-    data["artefacts"] = artefacts
-    # Normalise unassigned / documented_unassigned to logical paths and
-    # re-sort so the post-move diff is content-only.
-    for key in ("unassigned", "documented_unassigned"):
-        entries = data.get(key) or []
-        for e in entries:
-            if isinstance(e, dict) and "path" in e:
-                e["path"] = _logical_path(e["path"])
-        entries.sort(key=lambda e: (e.get("path", ""), e.get("category", "")))
-        data[key] = entries
-    # Drop volatile fields: timestamp, the manifest's own checksum (which
-    # covers everything above and changes with any path text), and the
-    # scanner_version (sha of the build script — moves with code edits).
-    data.pop("generated_at", None)
-    data.pop("checksum", None)
-    data.pop("scanner_version", None)
-    return data
-
-
-def _build_snapshot() -> dict[str, Any]:
-    snap: dict[str, Any] = {"schema_version": "1", "trees": {}}
-    for tgt in TARGETS:
-        key = tgt.relative_to(ROOT).as_posix()
-        snap["trees"][key] = _hash_tree(tgt)
-    snap["manifest_sha256"] = _sha256(MANIFEST) if MANIFEST.exists() else None
-    snap["manifest_path_stripped"] = _manifest_path_stripped(MANIFEST)
-    return snap
-
-
-def main() -> int:
-    ap = argparse.ArgumentParser(description=__doc__)
-    ap.add_argument("--out", type=Path, default=DEFAULT_OUT)
-    args = ap.parse_args()
-
-    snap = _build_snapshot()
-    args.out.parent.mkdir(parents=True, exist_ok=True)
-    args.out.write_text(
-        json.dumps(snap, indent=2, sort_keys=True, ensure_ascii=False) + "\n",
-        encoding="utf-8",
-    )
-    n_files = sum(len(t) for t in snap["trees"].values())
-    print(f"Snapshot: {args.out.relative_to(ROOT)}")
-    print(f"  files hashed     : {n_files}")
-    print(f"  trees            : {list(snap['trees'])}")
-    print(f"  manifest sha256  : {snap['manifest_sha256'][:16] if snap['manifest_sha256'] else 'MISSING'}")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

package/src/scripts/spotcheck_thin_root.py

@@ -1,134 +0,0 @@
-#!/usr/bin/env python3
-"""Phase 6.6 platform spot-check via AI council.
-
-Sends the refactored package-root AGENTS.md and the consumer template
-to Sonnet 4.5 + gpt-4o, asks each member to answer five questions
-that simulate a fresh agent landing on the file. Records qualitative
-verdicts in agents/runtime/reports/thin-root-platform-spotcheck.md.
-"""
-from __future__ import annotations
-
-import json
-import sys
-from pathlib import Path
-
-ROOT = Path(__file__).resolve().parent.parent.parent
-sys.path.insert(0, str(ROOT / "src"))
-
-from scripts.ai_council.clients import (  # noqa: E402
-    AnthropicClient,
-    OpenAIClient,
-    load_anthropic_key,
-    load_openai_key,
-)
-from scripts.ai_council.orchestrator import (  # noqa: E402
-    CostBudget,
-    CouncilQuestion,
-    consult,
-)
-from scripts.ai_council.pricing import load_prices  # noqa: E402
-
-QUESTIONS = """
-You are evaluating whether the AGENTS.md file below is a sufficient
-entry point for an AI coding agent landing on this repository for
-the first time. You see only the AGENTS.md content; you do NOT have
-file-system access. Answer the following five questions in JSON
-shape `{"q1": {...}, ..., "q5": {...}}` where each value is
-`{"answer": <string>, "confidence": "high"|"medium"|"low",
-"pointer_used": <one of the linked paths from AGENTS.md, or null>}`.
-
-Q1. Where do I edit content in this repo / project? (a path)
-Q2. What command do I run to verify everything is green before opening a PR?
-Q3. Where would I find the always-active behavioural rules?
-Q4. If only this file is reachable, what five things must I assume to be true to act safely? (cite the emergency-triage block)
-Q5. What outboard target document would I open to learn the package-self-orientation / the consumer-fill-out guide? (a path)
-
-After the JSON, add a short prose verdict (≤ 5 sentences) on:
-- Whether the pointer-following worked (could you cite a path for Q1, Q3, Q5?)
-- Whether the emergency-triage block answered Q4 unambiguously.
-- One concrete improvement you'd make to the AGENTS.md.
-
-Do not invent file paths. If a question cannot be answered from the
-file alone, set `"pointer_used": null` and lower confidence.
-""".strip()
-
-
-def main() -> int:
-    package_root = (ROOT / "AGENTS.md").read_text(encoding="utf-8")
-    consumer_template = (
-        ROOT / ".agent-src.uncondensed" / "templates" / "AGENTS.md"
-    ).read_text(encoding="utf-8")
-
-    artefact = (
-        "## Artefact A — package-root AGENTS.md\n\n"
-        f"```markdown\n{package_root}\n```\n\n"
-        "## Artefact B — consumer-template AGENTS.md\n\n"
-        f"```markdown\n{consumer_template}\n```\n\n"
-        f"{QUESTIONS}\n"
-    )
-
-    members = [
-        AnthropicClient(model="claude-sonnet-4-5", api_key=load_anthropic_key()),
-        OpenAIClient(model="gpt-4o", api_key=load_openai_key()),
-    ]
-
-    question = CouncilQuestion(
-        mode="files",
-        user_prompt=artefact,
-        max_tokens=1500,
-    )
-    budget = CostBudget(max_total_usd=2.00, max_calls=4)
-    table = load_prices()
-
-    print("Running spot-check council …", file=sys.stderr)
-    responses = consult(members, question, budget, table=table, rounds=1)
-
-    out_dir = ROOT / "agents" / "reports"
-    out_dir.mkdir(parents=True, exist_ok=True)
-    md_path = out_dir / "thin-root-platform-spotcheck.md"
-    json_path = out_dir / "thin-root-platform-spotcheck.json"
-
-    md_lines = [
-        "# Thin-Root platform spot-check (Phase 6.6)",
-        "",
-        "> AI-council proxy for the manual platform spot-check. Two",
-        "> external reviewers (Sonnet 4.5, gpt-4o) simulate a fresh",
-        "> agent landing on the refactored AGENTS.md and answer five",
-        "> orientation questions from the file alone.",
-        "",
-        "## Verdicts",
-        "",
-    ]
-
-    raw = []
-    for r in responses:
-        body = r.text or f"<error: {r.error}>"
-        raw.append({
-            "provider": r.provider,
-            "model": r.model,
-            "tokens_in": r.input_tokens,
-            "tokens_out": r.output_tokens,
-            "latency_ms": r.latency_ms,
-            "error": r.error,
-            "text": body,
-        })
-        md_lines.append(f"### {r.provider} ({r.model})")
-        md_lines.append("")
-        md_lines.append(f"- tokens in: {r.input_tokens} · out: {r.output_tokens} · latency: {r.latency_ms}ms")
-        if r.error:
-            md_lines.append(f"- error: `{r.error}`")
-        md_lines.append("")
-        md_lines.append("```")
-        md_lines.append(body[:8000])
-        md_lines.append("```")
-        md_lines.append("")
-
-    md_path.write_text("\n".join(md_lines), encoding="utf-8")
-    json_path.write_text(json.dumps(raw, indent=2), encoding="utf-8")
-    print(f"✅  Wrote {md_path}", file=sys.stderr)
-    print(f"✅  Wrote {json_path}", file=sys.stderr)
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/src/scripts/sync_agent_settings.py

@@ -1,180 +0,0 @@
-#!/usr/bin/env python3
-"""Sync `.agent-settings.yml` against the template + profile (additive merge).
-
-Applies the section-aware merge rules documented in
-`docs/guidelines/agent-infra/layered-settings.md`:
-
-- **User lines are preserved verbatim** — comments, quoting, and key order
-  survive every sync. Existing values, custom inline comments, and
-  user-chosen ordering are never modified.
-- Missing template keys are inserted (leaf into existing parent section,
-  full subtree at EOF for entirely missing top-level sections).
-- Top-level user-only sections (no home in the template) are moved to a
-  single-level `_user:` block at the end of the file.
-- The `_user:` block is single-level only — legacy multi-prefix
-  corruption (`_user._user.foo`) heals to `foo` on the next sync.
-- Template comment changes on already-existing user keys do **not**
-  propagate (existing line untouched is the deal).
-
-Idempotent — writing a file that is already in sync is a no-op.
-
-Usage:
-    python3 scripts/sync_agent_settings.py                       # write (default)
-    python3 scripts/sync_agent_settings.py --dry-run             # show diff, no write
-    python3 scripts/sync_agent_settings.py --check               # exit 2 on drift (for CI)
-    python3 scripts/sync_agent_settings.py --profile balanced    # use a specific profile
-    python3 scripts/sync_agent_settings.py --path path/to/.agent-settings.yml
-
-Exit codes:
-    0 — already in sync, or changes applied (or --dry-run ran cleanly)
-    2 — drift detected under --check, or invalid arguments / missing files
-"""
-
-from __future__ import annotations
-
-import argparse
-import difflib
-import sys
-from pathlib import Path
-
-sys.path.insert(0, str(Path(__file__).resolve().parent))
-import install as _install  # noqa: E402 — profile parsing + template rendering
-import sync_yaml_rt as _rt  # noqa: E402 — additive round-trip merge
-
-try:
-    import yaml  # type: ignore
-except ImportError:
-    print("error: PyYAML not installed (pip install pyyaml)", file=sys.stderr)
-    sys.exit(2)
-
-DEFAULT_SETTINGS = ".agent-settings.yml"
-DEFAULT_TEMPLATE = Path(__file__).resolve().parent.parent.parent / "src" / "config" / "agent-settings.template.yml"
-DEFAULT_PROFILE_DIR = Path(__file__).resolve().parent.parent.parent / "src" / "config" / "profiles"
-
-
-def load_profile(profile_dir: Path, profile: str) -> dict[str, str]:
-    profile_source = profile_dir / f"{profile}.ini"
-    if not profile_source.is_file():
-        raise FileNotFoundError(f"profile not found: {profile_source}")
-    return _install._parse_profile_ini(profile_source)
-
-
-def load_template(path: Path, profile_values: dict[str, str]) -> str:
-    if not path.is_file():
-        raise FileNotFoundError(f"template not found: {path}")
-    return _install._render_template(path.read_text(encoding="utf-8"), profile_values)
-
-
-def load_user(path: Path) -> dict:
-    if not path.is_file():
-        return {}
-    data = yaml.safe_load(path.read_text(encoding="utf-8")) or {}
-    if not isinstance(data, dict):
-        return {}
-    return data
-
-
-def render_diff(old_text: str, new_text: str, path: str) -> str:
-    return "".join(difflib.unified_diff(
-        old_text.splitlines(keepends=True),
-        new_text.splitlines(keepends=True),
-        fromfile=path, tofile=path, n=3,
-    ))
-
-
-
-def main(argv: list[str] | None = None) -> int:
-    ap = argparse.ArgumentParser(description=__doc__)
-    ap.add_argument("--path", default=None,
-                    help="target settings file (default: canonical "
-                         "agents/settings/.agent-settings.yml, falling back to "
-                         "a legacy repo-root .agent-settings.yml — ADR-038)")
-    ap.add_argument("--template", default=str(DEFAULT_TEMPLATE),
-                    help="path to the settings template")
-    ap.add_argument("--profile", default=None,
-                    help="rule_loading_tier preset (minimal|balanced|full). "
-                         "Default: inferred from target, else 'minimal'")
-    ap.add_argument("--profile-dir", default=str(DEFAULT_PROFILE_DIR),
-                    help="directory containing profile .ini files")
-    ap.add_argument("--dry-run", action="store_true",
-                    help="print diff; do not modify the file")
-    ap.add_argument("--check", action="store_true",
-                    help="exit 2 if the target is out of sync (no writes)")
-    ap.add_argument("--quiet", action="store_true",
-                    help="suppress summary on success")
-    args = ap.parse_args(argv)
-
-    target = (
-        Path(args.path) if args.path is not None
-        else _install._resolve_settings_read(Path.cwd())
-    )
-    template_path = Path(args.template)
-    profile_dir = Path(args.profile_dir)
-
-    try:
-        user_data = load_user(target)
-        profile = args.profile or str(
-            user_data.get("rule_loading_tier") or user_data.get("cost_profile") or "minimal"
-        )
-        if profile not in _install.SUPPORTED_PROFILES:
-            print(f"error: unsupported profile {profile!r}", file=sys.stderr)
-            return 2
-        profile_values = load_profile(profile_dir, profile)
-        # Preserve existing user_type (step-9 axis) so the template's
-        # __USER_TYPE__ placeholder renders without forcing the user to
-        # re-pass --user-type on every sync. Empty string = no filter.
-        personal = user_data.get("personal") if isinstance(user_data.get("personal"), dict) else {}
-        existing_user_type = str(personal.get("user_type") or "") if personal else ""
-        profile_values["user_type"] = existing_user_type
-        template_body = load_template(template_path, profile_values)
-    except FileNotFoundError as exc:
-        print(f"error: {exc}", file=sys.stderr)
-        return 2
-    except yaml.YAMLError as exc:
-        print(f"error: cannot parse {target}: {exc}", file=sys.stderr)
-        return 2
-
-    existing_text = target.read_text(encoding="utf-8") if target.is_file() else ""
-
-    if existing_text:
-        # Additive merge — preserves user lines verbatim, inserts only
-        # the template keys the user is missing.
-        try:
-            new_text = _rt.sync(existing_text, template_body)
-        except ValueError as exc:
-            print(
-                f"error: cannot parse {target}: {exc}",
-                file=sys.stderr,
-            )
-            return 2
-    else:
-        # First-run / file absent — write the rendered template as-is.
-        new_text = template_body
-
-    if new_text == existing_text:
-        if not args.quiet:
-            print(f"✅  {target}: already in sync (profile={profile})")
-        return 0
-
-    if args.check:
-        diff = render_diff(existing_text, new_text, str(target))
-        sys.stdout.write(diff)
-        print(f"\n❌  {target}: drift detected (profile={profile})", file=sys.stderr)
-        return 2
-
-    if args.dry_run:
-        diff = render_diff(existing_text, new_text, str(target))
-        sys.stdout.write(diff)
-        if not args.quiet:
-            print(f"\n(dry-run) would update {target} (profile={profile})", file=sys.stderr)
-        return 0
-
-    target.parent.mkdir(parents=True, exist_ok=True)
-    target.write_text(new_text, encoding="utf-8")
-    if not args.quiet:
-        print(f"✅  {target}: updated (profile={profile})")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

package/src/scripts/sync_github_metadata.py

@@ -1,147 +0,0 @@
-#!/usr/bin/env python3
-"""Sync `.github/topics.yml` + `.github/about.yml` to the GitHub repo.
-
-Reads two on-disk manifests and pushes them via the REST API:
-  * `PUT  /repos/{owner}/{repo}/topics`   \u2014 topics list
-  * `PATCH /repos/{owner}/{repo}`         \u2014 description + homepage
-
-Default mode is `--dry-run`: fetches remote state, prints a unified
-diff (remote \u2192 desired), exits 0 (or 2 if drift exists when
-`--strict` is passed). `--apply` is required to mutate; it also
-appends an audit row to `agents/evidence/notes/visibility-sync-audit.md`.
-
-Auth: `GITHUB_TOKEN` env var. The repo slug is taken from
-`package.json` `repository.url` (parsed) or `--repo owner/name`.
-
-Stdlib only \u2014 `urllib.request` matches the convention in
-`scripts/_lib/update_check.py`.
-
-Roadmap: agents/roadmaps/strategic-visibility-mcp-topics-positioning.md Phase 1.
-"""
-from __future__ import annotations
-
-import argparse
-import datetime as _dt
-import difflib
-import json
-import os
-import re
-import sys
-import urllib.error
-import urllib.request
-from pathlib import Path
-
-import yaml
-
-ROOT = Path(__file__).resolve().parents[2]
-TOPICS_FILE = ROOT / ".github" / "topics.yml"
-ABOUT_FILE = ROOT / ".github" / "about.yml"
-AUDIT_FILE = ROOT / "agents" / "notes" / "visibility-sync-audit.md"
-API = "https://api.github.com"
-
-
-def _load_yaml(path: Path) -> dict:
-    return yaml.safe_load(path.read_text(encoding="utf-8")) or {}
-
-
-def _resolve_repo(explicit: str | None) -> str:
-    if explicit:
-        return explicit
-    pkg = json.loads((ROOT / "package.json").read_text(encoding="utf-8"))
-    url = (pkg.get("repository") or {}).get("url") or ""
-    m = re.search(r"github\.com[:/]+([^/]+/[^/.]+)", url)
-    if not m:
-        sys.exit("ERROR: cannot resolve owner/repo from package.json; pass --repo")
-    return m.group(1)
-
-
-def _request(method: str, url: str, token: str, body: dict | None = None) -> dict:
-    data = json.dumps(body).encode("utf-8") if body is not None else None
-    req = urllib.request.Request(url, data=data, method=method)
-    req.add_header("Authorization", f"Bearer {token}")
-    req.add_header("Accept", "application/vnd.github+json")
-    req.add_header("X-GitHub-Api-Version", "2022-11-28")
-    req.add_header("User-Agent", "event4u-agent-config-sync")
-    if body is not None:
-        req.add_header("Content-Type", "application/json")
-    try:
-        with urllib.request.urlopen(req, timeout=20) as resp:  # noqa: S310
-            return json.loads(resp.read() or b"{}")
-    except urllib.error.HTTPError as e:
-        sys.exit(f"ERROR: {method} {url} \u2192 HTTP {e.code}: {e.read().decode('utf-8', 'replace')[:300]}")
-    except urllib.error.URLError as e:
-        sys.exit(f"ERROR: {method} {url} \u2192 {e.reason}")
-
-
-def _diff(label: str, remote, desired) -> list[str]:
-    a = json.dumps(remote, indent=2, sort_keys=True).splitlines()
-    b = json.dumps(desired, indent=2, sort_keys=True).splitlines()
-    return list(difflib.unified_diff(a, b, fromfile=f"remote/{label}", tofile=f"desired/{label}", lineterm=""))
-
-
-def _audit(repo: str, mutations: list[str]) -> None:
-    AUDIT_FILE.parent.mkdir(parents=True, exist_ok=True)
-    if not AUDIT_FILE.exists():
-        AUDIT_FILE.write_text("# Visibility sync audit log\n\nAppend-only. Every `--apply` run logs one block.\n", encoding="utf-8")
-    ts = _dt.datetime.now(_dt.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
-    block = [f"\n## {ts} \u2014 {repo}\n"]
-    block.extend(f"- {m}\n" for m in mutations)
-    with AUDIT_FILE.open("a", encoding="utf-8") as f:
-        f.writelines(block)
-
-
-def main() -> int:
-    ap = argparse.ArgumentParser(description=__doc__.splitlines()[0])
-    ap.add_argument("--apply", action="store_true", help="actually mutate the remote (default: dry-run)")
-    ap.add_argument("--strict", action="store_true", help="exit 2 if drift exists (dry-run only)")
-    ap.add_argument("--quiet", action="store_true")
-    ap.add_argument("--repo", help="owner/name (default: parsed from package.json)")
-    args = ap.parse_args()
-
-    repo = _resolve_repo(args.repo)
-    token = os.environ.get("GITHUB_TOKEN")
-    if not token:
-        sys.exit("ERROR: GITHUB_TOKEN not set")
-
-    topics_doc = _load_yaml(TOPICS_FILE)
-    about_doc = _load_yaml(ABOUT_FILE)
-    desired_topics = sorted(topics_doc.get("topics") or [])
-    desired_about = {"description": about_doc.get("description", ""), "homepage": about_doc.get("homepage", "")}
-
-    remote_topics = sorted((_request("GET", f"{API}/repos/{repo}/topics", token).get("names") or []))
-    repo_payload = _request("GET", f"{API}/repos/{repo}", token)
-    remote_about = {"description": repo_payload.get("description") or "", "homepage": repo_payload.get("homepage") or ""}
-
-    topic_diff = _diff("topics", remote_topics, desired_topics)
-    about_diff = _diff("about", remote_about, desired_about)
-    has_drift = bool(topic_diff or about_diff)
-
-    if not args.quiet:
-        if topic_diff:
-            print("\n".join(topic_diff))
-        if about_diff:
-            print("\n".join(about_diff))
-        if not has_drift:
-            print(f"\u2705  {repo}: topics + about already in sync")
-
-    if not args.apply:
-        return 2 if (has_drift and args.strict) else 0
-
-    mutations: list[str] = []
-    if topic_diff:
-        _request("PUT", f"{API}/repos/{repo}/topics", token, {"names": desired_topics})
-        mutations.append(f"topics \u2192 {desired_topics}")
-    if about_diff:
-        _request("PATCH", f"{API}/repos/{repo}", token, desired_about)
-        mutations.append(f"about \u2192 {desired_about}")
-    if mutations:
-        _audit(repo, mutations)
-        if not args.quiet:
-            print(f"\u2705  {repo}: applied {len(mutations)} mutation(s); audit appended")
-    elif not args.quiet:
-        print(f"\u2705  {repo}: nothing to apply")
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())