@event4u/agent-config 6.1.0 → 7.0.0

package/src/scripts/_cli/cmd_prune.py

@@ -1,322 +0,0 @@
-"""``agent-config prune`` — remove orphaned project bridge markers.
-
-Sibling to ``uninstall``: where ``uninstall`` removes bridges for an
-explicit tool list, ``prune`` removes every bridge marker present on
-disk that is **not** declared in ``agents/installed-tools.lock``. Mirrors
-the ``npm prune`` / ``cargo prune`` convention — the lockfile is the
-source of truth; anything else is drift.
-
-Scope: project only. Global pruning would touch user anchor dirs
-(``~/.claude/``, ``~/.cursor/``…) that may contain unrelated user
-content; the safer surface there is ``uninstall --global --purge``.
-
-Hard Floor: refuses to operate without a lockfile (would otherwise
-delete every bridge it finds). Pass ``--all-missing-lock`` to opt into
-that behaviour explicitly.
-
-Schema v2 (P2.1): when the manifest carries per-tool ``files[]``
-inventories, prune enumerates them in addition to the legacy
-``PROJECT_BRIDGE_MARKERS`` disk scan. Files whose owning tool has
-``status: uninstalling`` (forward-compat for P2.2 two-phase uninstall)
-are surfaced as orphans even when the tool entry still exists. Manifests
-without ``files[]`` fall back to the v1 disk-scan path unchanged.
-
-Drift detection (P2.3): orphaned files with a recorded ``sha256`` are
-hashed before deletion. A mismatch flags the file as **modified** —
-prune surfaces the path and skips removal so user / neighbour-tool
-edits to deployed content survive the prune sweep. Files without a
-recorded hash (bridges) skip the check and prune normally.
-
-Resume-uninstall (P2.2): ``--resume-uninstall`` narrows prune to the
-crash-recovery scope — only files belonging to tools with
-``status: uninstalling`` are surfaced. The legacy disk scan is skipped
-and healthy tools / unmanaged drift are untouched. Intended for
-re-running after an uninstall crashed mid-flight; no-op when no tool
-is in the ``uninstalling`` state.
-"""
-from __future__ import annotations
-
-import argparse
-import hashlib
-import json
-import sys
-from pathlib import Path
-
-from scripts._lib import installed_tools
-from scripts._lib.agent_settings import resolve_project_root
-from scripts.install import PROJECT_BRIDGE_MARKERS
-
-
-def _resolve_project_root(arg: str | None) -> Path:
-    """Resolve the project root using the shared Phase-3 helper.
-
-    Drops the origin tag — ``prune`` does not surface it in output but
-    still honors ``AGENT_CONFIG_PROJECT_ROOT`` and the anchor walk.
-    """
-    root, _ = resolve_project_root(arg)
-    return root
-
-
-def _load_manifest(project_root: Path, *, force_empty: bool
-                   ) -> tuple[dict | None, set[str] | None]:
-    """Return ``(manifest, declared)``.
-
-    ``declared`` is the set of project-scope tool names whose entry is
-    healthy (``status`` absent or ``installed``). When the manifest is
-    missing, returns ``(None, set())`` if ``force_empty`` else
-    ``(None, None)``.
-    """
-    manifest_path = installed_tools.manifest_path(project_root)
-    manifest = installed_tools.read_manifest(manifest_path)
-    if manifest is None:
-        if force_empty:
-            return None, set()
-        return None, None
-    tools = manifest.get("tools") or []
-    declared = {
-        str(e.get("name", ""))
-        for e in tools
-        if e.get("name")
-        and e.get("scope") == "project"
-        and e.get("status", "installed") == "installed"
-    }
-    return manifest, declared
-
-
-def _resolve_path(project_root: Path, raw: str) -> Path:
-    """Expand a manifest path (repo-relative or absolute / ``~``-prefixed)."""
-    p = Path(raw).expanduser()
-    if not p.is_absolute():
-        p = project_root / p
-    return p
-
-
-def _sha256(path: Path) -> str | None:
-    """Hex SHA-256 of ``path`` content, or ``None`` if unreadable.
-
-    Mirrors :func:`scripts.install._sha256_of_file` without taking the
-    import dependency on the installer module beyond what already
-    exists. Drift detection (P2.3) calls this for every orphan with a
-    recorded hash.
-    """
-    try:
-        return hashlib.sha256(path.read_bytes()).hexdigest()
-    except OSError:
-        return None
-
-
-def _orphaned(project_root: Path, manifest: dict | None, declared: set[str],
-              *, resume_uninstall: bool = False,
-              ) -> list[tuple[str, Path, str | None, str | None]]:
-    """Return ``[(tool_id, target_path, kind, expected_sha256), …]``.
-
-    ``kind`` is ``"bridge"`` / ``"marker"`` / ``"deployed"`` for v2
-    entries, ``None`` for the legacy disk scan (which has no manifest
-    context). ``expected_sha256`` is the hash recorded at install time
-    and is used by the drift detector (P2.3); ``None`` skips the check.
-
-    Two sources:
-
-    1. Disk scan via ``PROJECT_BRIDGE_MARKERS`` — catches legacy / v1
-       installs and unmanaged drift not recorded in ``files[]``.
-    2. Manifest-driven scan via per-tool ``files[]`` (v2 only) —
-       surfaces files whose owning tool has ``status: uninstalling``
-       (P2.2 crash recovery) or whose ``kind`` is ``bridge`` /
-       ``marker`` / ``deployed`` and the tool is no longer declared.
-
-    Paths already collected by the disk scan are deduplicated so the
-    same orphan never appears twice.
-
-    ``resume_uninstall=True`` skips the legacy disk scan and the
-    healthy-tool branch entirely — only tools with
-    ``status == "uninstalling"`` contribute candidates. Used by
-    ``--resume-uninstall`` to scope crash recovery to half-removed
-    tools without touching unmanaged drift.
-    """
-    out: list[tuple[str, Path, str | None, str | None]] = []
-    seen: set[Path] = set()
-
-    if not resume_uninstall:
-        for tool_id, rel in PROJECT_BRIDGE_MARKERS.items():
-            if tool_id in declared:
-                continue
-            target = project_root / rel
-            if not target.exists():
-                continue
-            out.append((tool_id, target, None, None))
-            seen.add(target.resolve())
-
-    if manifest is None:
-        return out
-
-    for tool in manifest.get("tools") or []:
-        if tool.get("scope") != "project":
-            continue
-        files = tool.get("files") or []
-        if not files:
-            continue
-        tool_id = str(tool.get("name", ""))
-        status = tool.get("status", "installed")
-        if resume_uninstall:
-            if status != "uninstalling":
-                continue
-        elif status == "installed" and tool_id in declared:
-            continue
-        for entry in files:
-            kind = entry.get("kind")
-            if kind not in ("bridge", "marker", "deployed"):
-                continue
-            raw = entry.get("path") or ""
-            if not raw:
-                continue
-            target = _resolve_path(project_root, raw)
-            try:
-                resolved = target.resolve()
-            except OSError:
-                resolved = target
-            if resolved in seen or not target.exists():
-                continue
-            out.append((tool_id, target, kind, entry.get("sha256")))
-            seen.add(resolved)
-    return out
-
-
-def _classify(target: Path, expected_sha: str | None
-              ) -> tuple[str, str | None]:
-    """Return ``(state, actual_sha)`` for a prune candidate.
-
-    States:
-
-    * ``"orphan"`` — safe to delete (hash matches or no hash recorded).
-    * ``"modified"`` — recorded hash differs from disk; skip deletion.
-
-    A missing recorded hash short-circuits to ``"orphan"`` because
-    bridges are content-less by design and would otherwise spuriously
-    flag as modified after every install.
-    """
-    if expected_sha is None:
-        return "orphan", None
-    actual = _sha256(target)
-    if actual is None or actual != expected_sha:
-        return "modified", actual
-    return "orphan", actual
-
-
-def _remove(target: Path, *, dry_run: bool) -> tuple[bool, str]:
-    if dry_run:
-        return True, "would remove"
-    try:
-        target.unlink()
-        return True, "removed"
-    except IsADirectoryError:
-        return False, "❌ is a directory (refusing — use uninstall --purge)"
-    except OSError as exc:
-        return False, f"❌ failed ({exc})"
-
-
-def _parse(argv: list[str]) -> argparse.Namespace:
-    parser = argparse.ArgumentParser(
-        prog="agent-config prune",
-        description=(
-            "Remove project bridge markers not declared in "
-            "agents/installed-tools.lock. Mirrors `npm prune`."
-        ),
-    )
-    parser.add_argument("--project", default=None, help="project root (default: cwd)")
-    parser.add_argument("--dry-run", action="store_true",
-                        help="show what would be removed; make no changes")
-    parser.add_argument("--json", action="store_true",
-                        help="emit a JSON report instead of human text")
-    parser.add_argument("--all-missing-lock", action="store_true",
-                        help="treat a missing lockfile as 'no tools declared' "
-                             "and prune every known marker (destructive)")
-    parser.add_argument("--resume-uninstall", action="store_true",
-                        help="only sweep files of tools left in "
-                             "status='uninstalling' (P2.2 crash recovery); "
-                             "skips the legacy disk scan and healthy tools")
-    return parser.parse_args(argv)
-
-
-def _emit_text(
-    project_root: Path,
-    candidates: list,
-    results: list[tuple[str, Path, str, bool, str]],
-    *,
-    dry_run: bool,
-) -> None:
-    prefix = "[dry-run] " if dry_run else ""
-    if not candidates:
-        print(f"✅  {prefix}no orphaned bridges in {project_root}")
-        return
-    modified = [r for r in results if r[2] == "modified"]
-    orphans = [r for r in results if r[2] == "orphan"]
-    print(
-        f"{prefix}{len(orphans)} orphaned, {len(modified)} modified "
-        f"bridge(s) under {project_root}:"
-    )
-    for tool_id, target, state, ok, msg in results:
-        rel = target.relative_to(project_root) if target.is_absolute() else target
-        if state == "modified":
-            print(f"  ⚠  {tool_id}: modified — skipped {rel}")
-            continue
-        mark = "·" if ok else "!"
-        print(f"  {mark} {tool_id}: {msg} {rel}")
-
-
-def _emit_json(
-    project_root: Path,
-    results: list[tuple[str, Path, str, bool, str]],
-    *,
-    dry_run: bool,
-) -> None:
-    payload = {
-        "project_root": str(project_root),
-        "dry_run": dry_run,
-        "orphans": [
-            {
-                "tool": tool_id,
-                "path": str(target.relative_to(project_root)
-                            if target.is_absolute() else target),
-                "state": state,
-                "ok": ok,
-                "status": msg,
-            }
-            for tool_id, target, state, ok, msg in results
-        ],
-    }
-    print(json.dumps(payload, indent=2))
-
-
-def main(argv: list[str] | None = None) -> int:
-    opts = _parse(list(argv) if argv is not None else sys.argv[1:])
-    project_root = _resolve_project_root(opts.project)
-    manifest, declared = _load_manifest(project_root, force_empty=opts.all_missing_lock)
-    if declared is None:
-        manifest_path = installed_tools.manifest_path(project_root)
-        print(f"❌  no project lockfile at {manifest_path}", file=sys.stderr)
-        print("    pass --all-missing-lock to prune every known marker (destructive)",
-              file=sys.stderr)
-        return 1
-    candidates = _orphaned(
-        project_root, manifest, declared,
-        resume_uninstall=opts.resume_uninstall,
-    )
-    results: list[tuple[str, Path, str, bool, str]] = []
-    for tool_id, target, _kind, expected_sha in candidates:
-        state, _actual = _classify(target, expected_sha)
-        if state == "modified":
-            # Drift — leave the file alone, surface in output.
-            results.append((tool_id, target, state, True, "skipped (modified)"))
-            continue
-        ok, msg = _remove(target, dry_run=opts.dry_run)
-        results.append((tool_id, target, state, ok, msg))
-    if opts.json:
-        _emit_json(project_root, results, dry_run=opts.dry_run)
-    else:
-        _emit_text(project_root, candidates, results, dry_run=opts.dry_run)
-    failed = [r for r in results if not r[2]]
-    return 1 if failed else 0
-
-
-if __name__ == "__main__":  # pragma: no cover
-    raise SystemExit(main())

package/src/scripts/_cli/cmd_refresh.py

@@ -1,179 +0,0 @@
-"""``agent-config refresh`` — idempotent re-install, no version change.
-
-The same-version counterpart to ``agent-config upgrade`` (which fetches
-the latest). Two scopes, exactly one required:
-
-* ``--global`` — re-run the global install (``scripts/install --global``)
-  so the global root + Claude plugin hooks are rewritten from the
-  currently-installed package. Idempotent: a second run is a no-op diff.
-* ``--project`` — refresh the **minimal** project surface ADR-020 permits
-  for a consumer: the ``agents/.event4u-bridge.yml`` marker, an
-  ``agents/overrides/`` scaffold, and the managed ``agents/`` block in
-  ``.gitignore``. Writes **no** distributed content (no ``.augment/`` /
-  ``.claude/`` / skills / hooks). No wizard.
-
-Bare ``agent-config refresh`` (no scope flag) errors — never a silent
-global default (council 2026-05-30).
-
-Exit codes: ``0`` success · ``1`` a step failed / bad invocation.
-"""
-from __future__ import annotations
-
-import argparse
-import subprocess
-import sys
-from pathlib import Path
-from typing import Callable, Optional
-
-PACKAGE_ROOT = Path(__file__).resolve().parents[3]
-
-Runner = Callable[[list[str]], int]
-
-
-def _default_runner(cmd: list[str]) -> int:
-    try:
-        return subprocess.run(cmd, check=False).returncode
-    except OSError as exc:
-        sys.stderr.write(f"agent-config refresh: cannot run {cmd[0]}: {exc}\n")
-        return 1
-
-
-def _refresh_global(runner: Runner, out, err) -> int:
-    install_sh = PACKAGE_ROOT / "src" / "scripts" / "install"
-    if not install_sh.is_file():
-        print(f"❌  agent-config refresh: installer not found at {install_sh}",
-              file=err)
-        return 1
-    print("→ refreshing global install (scripts/install --global)", file=out)
-    rc = runner(["bash", str(install_sh), "--global"])
-    if rc != 0:
-        print(f"❌  agent-config refresh --global: install failed (exit {rc})",
-              file=err)
-        return 1
-    print("✅  global install refreshed.", file=out)
-    return 0
-
-
-def _is_source_repo(project_root: Path) -> bool:
-    """True when project_root is the agent-config package itself.
-
-    ``_write_consumer_bridge_marker`` only guards on a root-level
-    ``.agent-src.uncondensed/``, which the monorepo keeps under
-    ``packages/*/`` instead — so the narrow guard misses here and would
-    write a consumer marker into the maintainer tree. This broader check
-    (condensed output, packaged source, or the package's own
-    ``package.json`` name) makes ``refresh --project`` a no-op in any
-    agent-config checkout. Consumers use dev-mode, not refresh.
-    """
-    if (project_root / "dist/agent-src").is_dir():
-        return True
-    if any((project_root / "packages").glob("*/.agent-src.uncondensed")):
-        return True
-    pkg = project_root / "package.json"
-    if pkg.is_file():
-        try:
-            import json
-            if json.loads(pkg.read_text(encoding="utf-8")).get("name") == \
-                    "@event4u/agent-config":
-                return True
-        except (OSError, ValueError):
-            pass
-    return False
-
-
-def _refresh_project(project_root: Path, out, err) -> int:
-    # Imported lazily: scripts.install is large and only needed for --project.
-    from scripts import install as installer
-    from scripts._lib import cli_wrapper, installed_lock
-
-    if _is_source_repo(project_root):
-        print("ℹ️  refresh --project skipped: this is the agent-config package "
-              "itself (or a checkout of it). Maintainers use "
-              "AGENT_CONFIG_DEV_MODE=1, not a consumer refresh.", file=out)
-        return 0
-
-    version = installed_lock.current_package_version() or "0.0.0"
-    marker = installer._write_consumer_bridge_marker(project_root, version)
-    if marker is None:
-        print("ℹ️  refresh --project skipped the bridge marker: this is the "
-              "agent-config source repo (or AGENT_CONFIG_DEV_MODE=1). Nothing "
-              "to scaffold in a maintainer checkout.", file=out)
-        return 0
-
-    print(f"✅  bridge marker: {marker}", file=out)
-
-    overrides = project_root / "agents" / "overrides"
-    overrides.mkdir(parents=True, exist_ok=True)
-    keep = overrides / "README.md"
-    if not keep.exists():
-        keep.write_text(
-            "# Project overrides\n\n"
-            "Project-local overrides/extensions of shared skills, rules, and "
-            "commands. The only project-side agent surface ADR-020 permits "
-            "besides the bridge marker. See the `override-management` skill.\n",
-            encoding="utf-8")
-    print(f"✅  overrides scaffold: {overrides}", file=out)
-
-    # Re-stamp the ``./agent-config`` wrapper from the canonical template so
-    # an older, fallback-less wrapper cannot linger and break the hooks.
-    wrapper = cli_wrapper.install_cli_wrapper(project_root)
-    if wrapper is not None:
-        print(f"✅  ./agent-config wrapper refreshed: {wrapper}", file=out)
-
-    rc = _sync_gitignore(project_root, out, err)
-    if rc != 0:
-        return rc
-    print("✅  refresh --project complete.", file=out)
-    return 0
-
-
-def _sync_gitignore(project_root: Path, out, err) -> int:
-    try:
-        from scripts import sync_gitignore
-    except ImportError as exc:
-        print(f"⚠️  refresh --project: gitignore sync unavailable ({exc})",
-              file=err)
-        return 0  # advisory — do not fail the refresh on a missing helper
-    rc = sync_gitignore.main(["--path", str(project_root / ".gitignore")])
-    if rc not in (0, None):
-        print(f"⚠️  refresh --project: gitignore sync returned {rc}", file=err)
-    else:
-        print("✅  .gitignore agents/ block synced.", file=out)
-    return 0
-
-
-def main(
-    argv: Optional[list[str]] = None,
-    *,
-    runner: Runner = _default_runner,
-    project_root: Optional[Path] = None,
-    out=sys.stdout,
-    err=sys.stderr,
-) -> int:
-    parser = argparse.ArgumentParser(
-        prog="agent-config refresh",
-        description="Idempotent re-install (no version change). Requires a scope.",
-    )
-    parser.add_argument("--global", dest="is_global", action="store_true",
-                        help="Re-run the global install (root + Claude plugin).")
-    parser.add_argument("--project", dest="is_project", action="store_true",
-                        help="Refresh the minimal project surface (bridge "
-                             "marker, overrides scaffold, .gitignore).")
-    args = parser.parse_args(argv)
-
-    if not args.is_global and not args.is_project:
-        print("❌  agent-config refresh: specify a scope — --global "
-              "and/or --project (never a silent default).", file=err)
-        return 1
-
-    root = project_root or Path.cwd()
-    rc = 0
-    if args.is_global:
-        rc = _refresh_global(runner, out, err) or rc
-    if args.is_project and rc == 0:
-        rc = _refresh_project(root, out, err) or rc
-    return rc
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/src/scripts/_cli/cmd_settings_check.py

@@ -1,171 +0,0 @@
-"""``agent-config settings:check`` — validate ``.agent-settings.yml`` against the supported YAML subset.
-
-Read-only. Implements P3.2 of road-to-proof-not-features.md. The contract
-this checks against is pinned in
-``docs/contracts/settings-sync-yaml-subset.md``; out-of-subset constructs
-cause :class:`sync_yaml_rt` to raise ``ValueError`` during a sync. This
-CLI surfaces the same findings *before* a sync runs, so users can fix
-their file without watching the merge fail.
-
-Output line format::
-
-    line:N  <kind>  <verdict>  <fix hint>
-
-Exit codes:
-
-* ``0`` — file is inside the supported subset (or absent and ``--allow-missing``).
-* ``1`` — one or more findings (verdict ``not supported``).
-* ``2`` — file absent (without ``--allow-missing``) or unreadable.
-"""
-from __future__ import annotations
-
-import argparse
-import re
-import sys
-from pathlib import Path
-
-# Imported lazily inside ``main`` so a missing engine cannot break ``--help``.
-
-DEFAULT_PATH = ".agent-settings.yml"
-
-# Out-of-subset patterns detected by a line-level pre-scan. Each rule is
-# (label, regex, fix hint). The regex is applied to the *stripped* body
-# of each non-comment line so leading indent does not affect matching.
-_PRESCAN_RULES: tuple[tuple[str, re.Pattern[str], str], ...] = (
-    (
-        "multi-doc separator",
-        re.compile(r"^(---|\.\.\.)\s*(#.*)?$"),
-        "remove the separator — one YAML document per file only.",
-    ),
-    (
-        "complex key",
-        re.compile(r"^\?\s"),
-        "rewrite as a plain ``key: value`` mapping line.",
-    ),
-    (
-        "block-scalar indicator",
-        re.compile(r":\s*[|>][+-]?\s*(#.*)?$"),
-        "inline the value as a single-line quoted scalar.",
-    ),
-    (
-        "tagged scalar",
-        re.compile(r":\s*!!?[A-Za-z_]"),
-        "remove the ``!tag``; the parser does not honour it.",
-    ),
-    (
-        "anchor / alias",
-        re.compile(r":\s*[&*][A-Za-z_]"),
-        "expand the anchor inline — anchors / aliases are not supported.",
-    ),
-    (
-        "nested flow-mapping",
-        re.compile(r":\s*\{[^}]*:[^}]*\}"),
-        "rewrite as a block-style nested mapping (indented child keys).",
-    ),
-)
-
-
-def _scan_line(stripped: str) -> tuple[str, str] | None:
-    if not stripped or stripped.startswith("#"):
-        return None
-    for label, pattern, hint in _PRESCAN_RULES:
-        if pattern.search(stripped):
-            return label, hint
-    return None
-
-
-def _scan_text(text: str) -> list[dict]:
-    findings: list[dict] = []
-    for lineno, raw in enumerate(text.splitlines(), 1):
-        stripped = raw.strip()
-        if "\t" in raw[: len(raw) - len(raw.lstrip(" \t"))]:
-            findings.append({
-                "line": lineno,
-                "kind": "tab in indent",
-                "verdict": "not supported",
-                "hint": "replace leading tabs with 2 or 4 spaces.",
-            })
-            continue
-        hit = _scan_line(stripped)
-        if hit is not None:
-            label, hint = hit
-            findings.append({
-                "line": lineno,
-                "kind": label,
-                "verdict": "not supported",
-                "hint": hint,
-            })
-    return findings
-
-
-def _format(finding: dict) -> str:
-    return (
-        f"  ❌  line:{finding['line']:<4}  "
-        f"{finding['kind']:<22}  {finding['verdict']:<14}  {finding['hint']}"
-    )
-
-
-def _parse(argv: list[str]) -> argparse.Namespace:
-    parser = argparse.ArgumentParser(
-        prog="agent-config settings:check",
-        description=(
-            "Validate .agent-settings.yml against the supported YAML subset "
-            "(docs/contracts/settings-sync-yaml-subset.md). Read-only."
-        ),
-    )
-    parser.add_argument("--path", default=DEFAULT_PATH,
-                        help=f"target settings file (default: ./{DEFAULT_PATH})")
-    parser.add_argument("--allow-missing", action="store_true",
-                        help="exit 0 when the file is absent (CI-friendly)")
-    parser.add_argument("--quiet", action="store_true",
-                        help="suppress non-essential output")
-    return parser.parse_args(argv)
-
-
-def main(argv: list[str]) -> int:
-    opts = _parse(argv)
-    target = Path(opts.path)
-    if not target.is_file():
-        if opts.allow_missing:
-            if not opts.quiet:
-                print(f"✅  {target}: file absent (allow-missing).")
-            return 0
-        print(f"❌  {target}: file not found.", file=sys.stderr)
-        print("    Run `./agent-config sync-agent-settings` to create it.", file=sys.stderr)
-        return 2
-    try:
-        text = target.read_text(encoding="utf-8")
-    except OSError as exc:
-        print(f"❌  {target}: cannot read: {exc}", file=sys.stderr)
-        return 2
-
-    findings = _scan_text(text)
-    if not findings:
-        # Final gate: run the round-trip parser to catch anything the
-        # pre-scan missed (mismatched indent, malformed mapping lines).
-        from scripts import sync_yaml_rt as _rt  # noqa: PLC0415
-        try:
-            _rt.parse(text)
-        except ValueError as exc:
-            findings.append({
-                "line": 0, "kind": "parser",
-                "verdict": "not supported", "hint": str(exc),
-            })
-
-    if not findings:
-        if not opts.quiet:
-            print(f"✅  {target}: inside the supported subset "
-                  "(docs/contracts/settings-sync-yaml-subset.md).")
-        return 0
-    print(f"❌  {target}: {len(findings)} finding(s) outside the supported subset.",
-          file=sys.stderr)
-    for finding in findings:
-        print(_format(finding), file=sys.stderr)
-    print("", file=sys.stderr)
-    print("    Contract: docs/contracts/settings-sync-yaml-subset.md",
-          file=sys.stderr)
-    return 1
-
-
-if __name__ == "__main__":
-    sys.exit(main(sys.argv[1:]))