@leejungkiin/awkit 1.4.0 → 1.4.3

package/skills/xcode-build-orchestrator/references/recommendation-format.md

@@ -0,0 +1,85 @@
+# Recommendation Format
+
+All optimization skills should report recommendations in a shared structure so the orchestrator can merge and prioritize them cleanly.
+
+## Required Fields
+
+Each recommendation should include:
+
+- `title`
+- `wait_time_impact` -- plain-language statement of expected wall-clock impact, e.g. "Expected to reduce your clean build by ~3s", "Reduces parallel compile work but unlikely to reduce build wait time", or "Impact on wait time is uncertain -- re-benchmark to confirm"
+- `actionability` -- classifies how fixable the issue is from the project (see values below)
+- `category`
+- `observed_evidence`
+- `estimated_impact`
+- `confidence`
+- `approval_required`
+- `benchmark_verification_status`
+
+### Actionability Values
+
+Every recommendation must include an `actionability` classification:
+
+- `repo-local` -- Fix lives entirely in project files, source code, or local configuration. The developer can apply it without side effects outside the repo.
+- `package-manager` -- Requires CocoaPods or SPM configuration changes that may have broad side effects (e.g., linkage mode, dependency restructuring). These should be benchmarked before and after.
+- `xcode-behavior` -- Observed cost is driven by Xcode internals and is not suppressible from the project. Report the finding for awareness but do not promise a fix.
+- `upstream` -- Requires changes in a third-party dependency or external tool. The developer cannot fix it locally.
+
+## Suggested Optional Fields
+
+- `scope`
+- `affected_files`
+- `affected_targets`
+- `affected_packages`
+- `implementation_notes`
+- `risk_level`
+
+## JSON Example
+
+```json
+{
+  "recommendations": [
+    {
+      "title": "Guard a release-only symbol upload script",
+      "wait_time_impact": "Expected to reduce your incremental build by approximately 6 seconds.",
+      "actionability": "repo-local",
+      "category": "project",
+      "observed_evidence": [
+        "Incremental builds spend 6.3 seconds in a run script phase.",
+        "The script runs for Debug builds even though the output is only needed in Release."
+      ],
+      "estimated_impact": "High incremental-build improvement",
+      "confidence": "High",
+      "approval_required": true,
+      "benchmark_verification_status": "Not yet verified",
+      "scope": "Target build phase",
+      "risk_level": "Low"
+    }
+  ]
+}
+```
+
+## Markdown Rendering Guidance
+
+When rendering for human review, preserve the same field order:
+
+1. title
+2. wait-time impact
+3. actionability
+4. observed evidence
+5. estimated impact
+6. confidence
+7. approval required
+8. benchmark verification status
+
+That makes it easier for the developer to approve or reject specific items quickly.
+
+## Verification Status Values
+
+Recommended values:
+
+- `Not yet verified`
+- `Queued for verification`
+- `Verified improvement`
+- `No measurable improvement`
+- `Inconclusive due to benchmark noise`

package/skills/xcode-build-orchestrator/scripts/benchmark_builds.py

@@ -0,0 +1,308 @@
+#!/usr/bin/env python3
+
+import argparse
+import json
+import os
+import platform
+import re
+import shutil
+import statistics
+import subprocess
+import sys
+import tempfile
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Dict, List, Optional
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Benchmark Xcode clean and incremental builds.")
+    group = parser.add_mutually_exclusive_group(required=True)
+    group.add_argument("--workspace", help="Path to the .xcworkspace file")
+    group.add_argument("--project", help="Path to the .xcodeproj file")
+    parser.add_argument("--scheme", required=True, help="Scheme to build")
+    parser.add_argument("--configuration", default="Debug", help="Build configuration")
+    parser.add_argument("--destination", help="xcodebuild destination string")
+    parser.add_argument("--derived-data-path", help="DerivedData path override")
+    parser.add_argument("--output-dir", default=".build-benchmark", help="Output directory for artifacts")
+    parser.add_argument("--repeats", type=int, default=3, help="Measured runs per build type")
+    parser.add_argument("--skip-warmup", action="store_true", help="Skip the validation build")
+    parser.add_argument(
+        "--touch-file",
+        help="Path to a source file to touch before each incremental build. "
+        "When provided, measures a real edit-rebuild loop instead of a zero-change build.",
+    )
+    parser.add_argument(
+        "--no-cached-clean",
+        action="store_true",
+        help="Skip cached clean builds even when COMPILATION_CACHING is detected.",
+    )
+    parser.add_argument(
+        "--extra-arg",
+        action="append",
+        default=[],
+        help="Additional xcodebuild argument to append. Can be passed multiple times.",
+    )
+    return parser.parse_args()
+
+
+def command_base(args: argparse.Namespace) -> List[str]:
+    command = ["xcodebuild"]
+    if args.workspace:
+        command.extend(["-workspace", args.workspace])
+    if args.project:
+        command.extend(["-project", args.project])
+    command.extend(["-scheme", args.scheme, "-configuration", args.configuration])
+    if args.destination:
+        command.extend(["-destination", args.destination])
+    if args.derived_data_path:
+        command.extend(["-derivedDataPath", args.derived_data_path])
+    command.extend(args.extra_arg)
+    return command
+
+
+def shell_join(parts: List[str]) -> str:
+    return " ".join(subprocess.list2cmdline([part]) for part in parts)
+
+
+_TASK_COUNT_RE = re.compile(r"^(.+?)\s*\((\d+)\s+tasks?\)$")
+
+
+def _extract_task_count(name: str) -> tuple[str, Optional[int]]:
+    """Split 'Category (N tasks)' into ('Category', N)."""
+    match = _TASK_COUNT_RE.match(name)
+    if match:
+        return match.group(1).strip(), int(match.group(2))
+    return name, None
+
+
+def parse_timing_summary(output: str) -> List[Dict]:
+    categories: Dict[str, float] = {}
+    task_counts: Dict[str, Optional[int]] = {}
+    for raw_line in output.splitlines():
+        line = raw_line.strip()
+        if not line:
+            continue
+        for suffix in (" seconds", " second", " sec"):
+            if not line.endswith(suffix):
+                continue
+            trimmed = line[: -len(suffix)]
+            if "|" in trimmed:
+                name_part, _, seconds_text = trimmed.rpartition("|")
+            else:
+                name_part, _, seconds_text = trimmed.rpartition(" ")
+            try:
+                seconds = float(seconds_text.strip())
+            except ValueError:
+                continue
+            cleaned_name = name_part.replace("  ", " ").strip(" -:")
+            if len(cleaned_name) < 3:
+                continue
+            base_name, count = _extract_task_count(cleaned_name)
+            categories[base_name] = categories.get(base_name, 0.0) + seconds
+            if count is not None:
+                task_counts[base_name] = (task_counts.get(base_name) or 0) + count
+            break
+    result: List[Dict] = []
+    for name, seconds in sorted(categories.items(), key=lambda item: item[1], reverse=True):
+        entry: Dict = {"name": name, "seconds": round(seconds, 3)}
+        if name in task_counts:
+            entry["task_count"] = task_counts[name]
+        result.append(entry)
+    return result
+
+
+def run_command(command: List[str]) -> subprocess.CompletedProcess:
+    return subprocess.run(command, capture_output=True, text=True)
+
+
+def stats_for(runs: List[Dict[str, object]]) -> Dict[str, float]:
+    durations = [run["duration_seconds"] for run in runs if run.get("success")]
+    if not durations:
+        return {
+            "count": 0,
+            "min_seconds": 0.0,
+            "max_seconds": 0.0,
+            "median_seconds": 0.0,
+            "average_seconds": 0.0,
+        }
+    return {
+        "count": len(durations),
+        "min_seconds": round(min(durations), 3),
+        "max_seconds": round(max(durations), 3),
+        "median_seconds": round(statistics.median(durations), 3),
+        "average_seconds": round(statistics.fmean(durations), 3),
+    }
+
+
+def xcode_version() -> str:
+    result = run_command(["xcodebuild", "-version"])
+    return result.stdout.strip() if result.returncode == 0 else "unknown"
+
+
+def detect_compilation_caching(base_command: List[str]) -> bool:
+    """Check whether COMPILATION_CACHING is enabled in the resolved build settings."""
+    result = run_command([*base_command, "-showBuildSettings"])
+    if result.returncode != 0:
+        return False
+    for line in result.stdout.splitlines():
+        stripped = line.strip()
+        if stripped.startswith("COMPILATION_CACHING") and "=" in stripped:
+            value = stripped.split("=", 1)[1].strip()
+            return value == "YES"
+    return False
+
+
+def measure_build(
+    base_command: List[str],
+    artifact_stem: str,
+    output_dir: Path,
+    build_type: str,
+    run_index: int,
+) -> Dict[str, object]:
+    build_command = [*base_command, "build", "-showBuildTimingSummary"]
+    started = time.perf_counter()
+    result = run_command(build_command)
+    elapsed = round(time.perf_counter() - started, 3)
+    log_path = output_dir / f"{artifact_stem}-{build_type}-{run_index}.log"
+    log_path.write_text(result.stdout + result.stderr)
+    return {
+        "id": f"{build_type}-{run_index}",
+        "build_type": build_type,
+        "duration_seconds": elapsed,
+        "success": result.returncode == 0,
+        "exit_code": result.returncode,
+        "command": shell_join(build_command),
+        "raw_log_path": str(log_path),
+        "timing_summary_categories": parse_timing_summary(result.stdout + result.stderr),
+    }
+
+
+def main() -> int:
+    args = parse_args()
+    output_dir = Path(args.output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    timestamp = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
+    artifact_stem = f"{timestamp}-{args.scheme.replace(' ', '-').lower()}"
+    base_command = command_base(args)
+
+    if not args.skip_warmup:
+        warmup = run_command([*base_command, "build"])
+        if warmup.returncode != 0:
+          sys.stderr.write(warmup.stdout + warmup.stderr)
+          return warmup.returncode
+        warmup_clean = run_command([*base_command, "clean"])
+        if warmup_clean.returncode != 0:
+            sys.stderr.write(warmup_clean.stdout + warmup_clean.stderr)
+            return warmup_clean.returncode
+        warmup_rebuild = run_command([*base_command, "build"])
+        if warmup_rebuild.returncode != 0:
+            sys.stderr.write(warmup_rebuild.stdout + warmup_rebuild.stderr)
+            return warmup_rebuild.returncode
+
+    runs: Dict[str, list] = {"clean": [], "incremental": []}
+
+    for index in range(1, args.repeats + 1):
+        clean_result = run_command([*base_command, "clean"])
+        clean_log_path = output_dir / f"{artifact_stem}-clean-prep-{index}.log"
+        clean_log_path.write_text(clean_result.stdout + clean_result.stderr)
+        if clean_result.returncode != 0:
+            sys.stderr.write(clean_result.stdout + clean_result.stderr)
+            return clean_result.returncode
+        runs["clean"].append(measure_build(base_command, artifact_stem, output_dir, "clean", index))
+
+    # --- Cached clean builds ---------------------------------------------------
+    # When COMPILATION_CACHING is enabled, the compilation cache lives outside
+    # DerivedData and survives product deletion.  We measure "cached clean"
+    # builds by pointing DerivedData at a temp directory, warming the cache with
+    # one build, then deleting the DerivedData directory (but not the cache)
+    # before each measured rebuild.  This captures the realistic scenario:
+    # branch switching, pulling changes, or Clean Build Folder.
+    should_cached_clean = not args.no_cached_clean and detect_compilation_caching(base_command)
+    if should_cached_clean:
+        dd_path = Path(args.derived_data_path) if args.derived_data_path else Path(
+            tempfile.mkdtemp(prefix="xcode-bench-dd-")
+        )
+        cached_cmd = list(base_command)
+        if not args.derived_data_path:
+            cached_cmd.extend(["-derivedDataPath", str(dd_path)])
+
+        cache_warmup = run_command([*cached_cmd, "build"])
+        if cache_warmup.returncode != 0:
+            sys.stderr.write("Warning: cached clean warmup build failed, skipping cached clean benchmarks.\n")
+            sys.stderr.write(cache_warmup.stdout + cache_warmup.stderr)
+            should_cached_clean = False
+
+    if should_cached_clean:
+        runs["cached_clean"] = []
+        for index in range(1, args.repeats + 1):
+            shutil.rmtree(dd_path, ignore_errors=True)
+            runs["cached_clean"].append(
+                measure_build(cached_cmd, artifact_stem, output_dir, "cached-clean", index)
+            )
+        shutil.rmtree(dd_path, ignore_errors=True)
+
+    # --- Incremental / zero-change builds --------------------------------------
+    incremental_label = "incremental"
+    if args.touch_file:
+        touch_path = Path(args.touch_file)
+        if not touch_path.exists():
+            sys.stderr.write(f"--touch-file path does not exist: {touch_path}\n")
+            return 1
+        incremental_label = "incremental"
+    else:
+        incremental_label = "zero-change"
+
+    for index in range(1, args.repeats + 1):
+        if args.touch_file:
+            touch_path.touch()
+        runs["incremental"].append(
+            measure_build(base_command, artifact_stem, output_dir, incremental_label, index)
+        )
+
+    summary: Dict[str, object] = {
+        "clean": stats_for(runs["clean"]),
+        "incremental": stats_for(runs["incremental"]),
+    }
+    if "cached_clean" in runs:
+        summary["cached_clean"] = stats_for(runs["cached_clean"])
+
+    artifact = {
+        "schema_version": "1.2.0" if "cached_clean" in runs else "1.1.0",
+        "created_at": datetime.now(timezone.utc).isoformat(),
+        "build": {
+            "entrypoint": "workspace" if args.workspace else "project",
+            "path": args.workspace or args.project,
+            "scheme": args.scheme,
+            "configuration": args.configuration,
+            "destination": args.destination or "",
+            "derived_data_path": args.derived_data_path or "",
+            "command": shell_join(base_command),
+        },
+        "environment": {
+            "host": platform.node(),
+            "macos_version": platform.platform(),
+            "xcode_version": xcode_version(),
+            "cwd": os.getcwd(),
+        },
+        "runs": runs,
+        "summary": summary,
+        "notes": [f"touch-file: {args.touch_file}"] if args.touch_file else [],
+    }
+
+    artifact_path = output_dir / f"{artifact_stem}.json"
+    artifact_path.write_text(json.dumps(artifact, indent=2) + "\n")
+
+    print(f"Saved benchmark artifact: {artifact_path}")
+    print(f"Clean median: {artifact['summary']['clean']['median_seconds']}s")
+    if "cached_clean" in artifact["summary"]:
+        print(f"Cached clean median: {artifact['summary']['cached_clean']['median_seconds']}s")
+    inc_label = "Incremental" if args.touch_file else "Zero-change"
+    print(f"{inc_label} median: {artifact['summary']['incremental']['median_seconds']}s")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/skills/xcode-build-orchestrator/scripts/diagnose_compilation.py

@@ -0,0 +1,273 @@
+#!/usr/bin/env python3
+
+"""Run a single Xcode build with -Xfrontend diagnostics to find slow type-checking."""
+
+import argparse
+import json
+import re
+import subprocess
+import sys
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Dict, List, Optional
+
+_TYPECHECK_RE = re.compile(
+    r"^(?P<file>.+?):(?P<line>\d+):(?P<col>\d+): warning: "
+    r"(?P<kind>instance method|global function|getter|type-check|expression) "
+    r"'?(?P<name>[^']*?)'?\s+took\s+(?P<ms>\d+)ms\s+to\s+type-check"
+)
+
+_EXPRESSION_RE = re.compile(
+    r"^(?P<file>.+?):(?P<line>\d+):(?P<col>\d+): warning: "
+    r"expression took\s+(?P<ms>\d+)ms\s+to\s+type-check"
+)
+
+_FILE_TIME_RE = re.compile(
+    r"^\s*(?P<seconds>\d+(?:\.\d+)?)\s+seconds\s+.*\s+compiling\s+(?P<file>\S+)"
+)
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Run an Xcode build with -Xfrontend type-checking diagnostics."
+    )
+    group = parser.add_mutually_exclusive_group(required=True)
+    group.add_argument("--workspace", help="Path to the .xcworkspace file")
+    group.add_argument("--project", help="Path to the .xcodeproj file")
+    parser.add_argument("--scheme", required=True, help="Scheme to build")
+    parser.add_argument("--configuration", default="Debug", help="Build configuration")
+    parser.add_argument("--destination", help="xcodebuild destination string")
+    parser.add_argument("--derived-data-path", help="DerivedData path override")
+    parser.add_argument("--output-dir", default=".build-benchmark", help="Output directory")
+    parser.add_argument(
+        "--threshold",
+        type=int,
+        default=100,
+        help="Millisecond threshold for -warn-long-function-bodies and "
+        "-warn-long-expression-type-checking (default: 100)",
+    )
+    parser.add_argument("--skip-clean", action="store_true", help="Skip clean before build")
+    parser.add_argument(
+        "--per-file-timing",
+        action="store_true",
+        help="Add -Xfrontend -debug-time-compilation to report per-file compile times.",
+    )
+    parser.add_argument(
+        "--stats-output",
+        action="store_true",
+        help="Add -Xfrontend -stats-output-dir to collect detailed compiler statistics.",
+    )
+    parser.add_argument(
+        "--extra-arg",
+        action="append",
+        default=[],
+        help="Additional xcodebuild argument. Can be passed multiple times.",
+    )
+    return parser.parse_args()
+
+
+def command_base(args: argparse.Namespace) -> List[str]:
+    command = ["xcodebuild"]
+    if args.workspace:
+        command.extend(["-workspace", args.workspace])
+    if args.project:
+        command.extend(["-project", args.project])
+    command.extend(["-scheme", args.scheme, "-configuration", args.configuration])
+    if args.destination:
+        command.extend(["-destination", args.destination])
+    if args.derived_data_path:
+        command.extend(["-derivedDataPath", args.derived_data_path])
+    command.extend(args.extra_arg)
+    return command
+
+
+def parse_diagnostics(output: str) -> List[Dict]:
+    """Extract type-checking warnings from xcodebuild output."""
+    warnings: List[Dict] = []
+    seen = set()
+    for raw_line in output.splitlines():
+        line = raw_line.strip()
+        match = _TYPECHECK_RE.match(line)
+        if match:
+            key = (match.group("file"), match.group("line"), match.group("col"), "function-body")
+            if key in seen:
+                continue
+            seen.add(key)
+            warnings.append(
+                {
+                    "file": match.group("file"),
+                    "line": int(match.group("line")),
+                    "column": int(match.group("col")),
+                    "duration_ms": int(match.group("ms")),
+                    "kind": "function-body",
+                    "name": match.group("name"),
+                }
+            )
+            continue
+        match = _EXPRESSION_RE.match(line)
+        if match:
+            key = (match.group("file"), match.group("line"), match.group("col"), "expression")
+            if key in seen:
+                continue
+            seen.add(key)
+            warnings.append(
+                {
+                    "file": match.group("file"),
+                    "line": int(match.group("line")),
+                    "column": int(match.group("col")),
+                    "duration_ms": int(match.group("ms")),
+                    "kind": "expression",
+                    "name": "",
+                }
+            )
+    warnings.sort(key=lambda w: w["duration_ms"], reverse=True)
+    return warnings
+
+
+def parse_file_timings(output: str) -> List[Dict]:
+    """Extract per-file compile times from -debug-time-compilation output."""
+    timings: List[Dict] = []
+    seen = set()
+    for raw_line in output.splitlines():
+        match = _FILE_TIME_RE.match(raw_line.strip())
+        if match:
+            filepath = match.group("file")
+            if filepath in seen:
+                continue
+            seen.add(filepath)
+            timings.append(
+                {
+                    "file": filepath,
+                    "duration_seconds": float(match.group("seconds")),
+                }
+            )
+    timings.sort(key=lambda t: t["duration_seconds"], reverse=True)
+    return timings
+
+
+def main() -> int:
+    args = parse_args()
+    output_dir = Path(args.output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    timestamp = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
+    scheme_slug = args.scheme.replace(" ", "-").lower()
+    artifact_stem = f"{timestamp}-{scheme_slug}"
+    base = command_base(args)
+
+    if not args.skip_clean:
+        print("Cleaning build products...")
+        clean = subprocess.run([*base, "clean"], capture_output=True, text=True)
+        if clean.returncode != 0:
+            sys.stderr.write(clean.stdout + clean.stderr)
+            return clean.returncode
+
+    threshold = str(args.threshold)
+    swift_flags = (
+        f"$(inherited) -Xfrontend -warn-long-function-bodies={threshold} "
+        f"-Xfrontend -warn-long-expression-type-checking={threshold}"
+    )
+    if args.per_file_timing:
+        swift_flags += " -Xfrontend -debug-time-compilation"
+
+    stats_dir: Optional[Path] = None
+    if args.stats_output:
+        stats_dir = output_dir / f"{artifact_stem}-stats"
+        stats_dir.mkdir(parents=True, exist_ok=True)
+        swift_flags += f" -Xfrontend -stats-output-dir -Xfrontend {stats_dir}"
+
+    build_command = [
+        *base,
+        "build",
+        "-showBuildTimingSummary",
+        f"OTHER_SWIFT_FLAGS={swift_flags}",
+    ]
+
+    extras = []
+    if args.per_file_timing:
+        extras.append("per-file timing")
+    if args.stats_output:
+        extras.append("stats output")
+    extras_label = f" + {', '.join(extras)}" if extras else ""
+    print(f"Building with type-check threshold {threshold}ms{extras_label}...")
+    started = time.perf_counter()
+    result = subprocess.run(build_command, capture_output=True, text=True)
+    elapsed = round(time.perf_counter() - started, 3)
+
+    combined_output = result.stdout + result.stderr
+    log_path = output_dir / f"{artifact_stem}-diagnostics.log"
+    log_path.write_text(combined_output)
+
+    warnings = parse_diagnostics(combined_output)
+
+    file_timings: Optional[List[Dict]] = None
+    if args.per_file_timing:
+        file_timings = parse_file_timings(combined_output)
+
+    artifact = {
+        "schema_version": "1.0.0",
+        "created_at": datetime.now(timezone.utc).isoformat(),
+        "type": "compilation-diagnostics",
+        "build": {
+            "entrypoint": "workspace" if args.workspace else "project",
+            "path": args.workspace or args.project,
+            "scheme": args.scheme,
+            "configuration": args.configuration,
+            "destination": args.destination or "",
+        },
+        "threshold_ms": args.threshold,
+        "build_duration_seconds": elapsed,
+        "build_success": result.returncode == 0,
+        "raw_log_path": str(log_path),
+        "warnings": warnings,
+        "summary": {
+            "total_warnings": len(warnings),
+            "function_body_warnings": sum(1 for w in warnings if w["kind"] == "function-body"),
+            "expression_warnings": sum(1 for w in warnings if w["kind"] == "expression"),
+            "slowest_ms": warnings[0]["duration_ms"] if warnings else 0,
+        },
+    }
+
+    if file_timings is not None:
+        artifact["per_file_timings"] = file_timings
+    if stats_dir is not None:
+        artifact["stats_dir"] = str(stats_dir)
+
+    artifact_path = output_dir / f"{artifact_stem}-diagnostics.json"
+    artifact_path.write_text(json.dumps(artifact, indent=2) + "\n")
+
+    print(f"\nSaved diagnostics artifact: {artifact_path}")
+    print(f"Build {'succeeded' if result.returncode == 0 else 'failed'} in {elapsed}s")
+    print(f"Found {len(warnings)} type-check warnings above {threshold}ms threshold\n")
+
+    if warnings:
+        print(f"{'Duration':>10}  {'Kind':<15}  {'Location'}")
+        print(f"{'--------':>10}  {'----':<15}  {'--------'}")
+        for w in warnings[:20]:
+            loc = f"{w['file']}:{w['line']}:{w['column']}"
+            label = w["name"] if w["name"] else "(expression)"
+            print(f"{w['duration_ms']:>8}ms  {w['kind']:<15}  {loc}  {label}")
+        if len(warnings) > 20:
+            print(f"\n  ... and {len(warnings) - 20} more (see {artifact_path})")
+    else:
+        print("No type-checking hotspots found above threshold.")
+
+    if file_timings:
+        print(f"\nPer-file compile times (top 20):\n")
+        print(f"{'Duration':>12}  {'File'}")
+        print(f"{'--------':>12}  {'----'}")
+        for t in file_timings[:20]:
+            print(f"{t['duration_seconds']:>10.3f}s  {t['file']}")
+        if len(file_timings) > 20:
+            print(f"\n  ... and {len(file_timings) - 20} more (see {artifact_path})")
+
+    if stats_dir is not None:
+        stat_files = list(stats_dir.glob("*.json"))
+        print(f"\nCompiler statistics: {len(stat_files)} files written to {stats_dir}")
+
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())