zexus 1.6.8 → 1.7.2

package/src/zexus/blockchain/loadtest.py

@@ -0,0 +1,721 @@
+"""
+Zexus Blockchain — Load Testing Framework
+==========================================
+
+A self-contained load testing tool that simulates realistic blockchain
+workloads and validates throughput targets (e.g. 1 800 TPS).
+
+The framework measures:
+* **Throughput** — sustained transactions per second (TPS)
+* **Latency** — per-transaction percentiles (p50, p95, p99, max)
+* **Resource usage** — CPU, memory, GC pauses
+* **Chain integrity** — all blocks are valid after the run
+
+Usage
+-----
+::
+
+    from zexus.blockchain.loadtest import LoadTestRunner, LoadProfile
+
+    profile = LoadProfile(
+        target_tps=1800,
+        duration_seconds=30,
+        contract_count=8,
+        actions_per_contract=5,
+    )
+    runner = LoadTestRunner(profile)
+    report = runner.run()
+    report.print_summary()
+
+CLI shortcut::
+
+    python -m zexus.blockchain.loadtest --tps 1800 --duration 30
+"""
+
+from __future__ import annotations
+
+import gc
+import hashlib
+import json
+import logging
+import math
+import os
+import random
+import statistics
+import sys
+import threading
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional, Tuple
+
+logger = logging.getLogger("zexus.blockchain.loadtest")
+
+
+# =====================================================================
+# Load profile — describes the workload
+# =====================================================================
+
+@dataclass
+class LoadProfile:
+    """Configuration for a load test run."""
+
+    # ── Throughput target ────────────────────────────────────────
+    target_tps: int = 1_800
+    """Target transactions per second to *attempt*."""
+
+    duration_seconds: int = 30
+    """How long to sustain the load (seconds)."""
+
+    # ── Workload shape ───────────────────────────────────────────
+    contract_count: int = 8
+    """Number of distinct contracts (parallelism factor)."""
+
+    actions_per_contract: int = 5
+    """Number of unique action names per contract."""
+
+    batch_size: int = 200
+    """Transactions submitted per batch call."""
+
+    # ── Transaction complexity ───────────────────────────────────
+    payload_bytes: int = 256
+    """Average extra data per transaction (simulates calldata)."""
+
+    gas_limit: int = 100_000
+    """Max gas per transaction."""
+
+    # ── Concurrency ──────────────────────────────────────────────
+    sender_count: int = 50
+    """Number of distinct sender addresses (simulates wallets)."""
+
+    workers: int = 0
+    """Thread-pool size for batch submission (0 = auto)."""
+
+    # ── Rust / accelerator settings ──────────────────────────────
+    use_rust: bool = True
+    """Enable the Rust execution core if available."""
+
+    # ── Warm-up ──────────────────────────────────────────────────
+    warmup_seconds: int = 3
+    """Warm-up period before measurements begin."""
+
+    # ── Seed ─────────────────────────────────────────────────────
+    seed: int = 42
+    """Random seed for reproducible workloads."""
+
+
+# =====================================================================
+# Transaction generator
+# =====================================================================
+
+class TransactionGenerator:
+    """Generates realistic-looking synthetic transactions."""
+
+    def __init__(self, profile: LoadProfile):
+        self._profile = profile
+        self._rng = random.Random(profile.seed)
+
+        # Pre-generate contract addresses
+        self._contracts = [
+            f"0x{hashlib.sha256(f'contract-{i}'.encode()).hexdigest()[:40]}"
+            for i in range(profile.contract_count)
+        ]
+        # Pre-generate sender addresses
+        self._senders = [
+            f"0x{hashlib.sha256(f'sender-{i}'.encode()).hexdigest()[:40]}"
+            for i in range(profile.sender_count)
+        ]
+        # Pre-generate action names per contract
+        self._actions: Dict[str, List[str]] = {}
+        for c in self._contracts:
+            self._actions[c] = [
+                f"action_{j}" for j in range(profile.actions_per_contract)
+            ]
+
+    def generate_batch(self, size: int) -> List[Dict[str, Any]]:
+        """Return *size* random transactions."""
+        txs: List[Dict[str, Any]] = []
+        for _ in range(size):
+            contract = self._rng.choice(self._contracts)
+            action = self._rng.choice(self._actions[contract])
+            sender = self._rng.choice(self._senders)
+            payload = os.urandom(self._profile.payload_bytes).hex()
+            txs.append({
+                "contract": contract,
+                "action": action,
+                "args": {
+                    "value": self._rng.randint(0, 1_000_000),
+                    "data": payload,
+                    "nonce": self._rng.randint(0, 2**32),
+                },
+                "caller": sender,
+                "gas_limit": self._profile.gas_limit,
+            })
+        return txs
+
+    @property
+    def contracts(self) -> List[str]:
+        return list(self._contracts)
+
+
+# =====================================================================
+# Lightweight mock VM for load testing
+# =====================================================================
+
+class _MockContractVM:
+    """Minimal VM that executes transactions at maximum speed.
+
+    Instead of running real contract bytecode, this mock performs
+    the same overhead that a real VM would (hashing, state lookup,
+    gas deduction) so that the measured TPS reflects genuine
+    system throughput for the *infrastructure* layer.
+    """
+
+    def execute_action(
+        self,
+        contract: str,
+        action: str,
+        args: Dict[str, Any],
+        caller: str,
+        gas_limit: int = 100_000,
+    ) -> Dict[str, Any]:
+        start = time.perf_counter()
+        # Simulate minimal hashing work (like a real state-transition
+        # that computes the new state hash)
+        data = f"{contract}:{action}:{caller}:{json.dumps(args, sort_keys=True)}"
+        result_hash = hashlib.sha256(data.encode()).hexdigest()
+        gas_used = max(21_000, len(data) * 8)  # gas proportional to size
+        elapsed = time.perf_counter() - start
+        return {
+            "success": True,
+            "result": result_hash[:16],
+            "gas_used": min(gas_used, gas_limit),
+            "elapsed": elapsed,
+        }
+
+
+# =====================================================================
+# Resource sampler
+# =====================================================================
+
+class _ResourceSampler:
+    """Background thread that periodically samples CPU & memory."""
+
+    def __init__(self, interval: float = 0.5):
+        self._interval = interval
+        self._samples: List[Dict[str, Any]] = []
+        self._stop = threading.Event()
+        self._thread: Optional[threading.Thread] = None
+
+    def start(self) -> None:
+        self._stop.clear()
+        self._thread = threading.Thread(target=self._loop, daemon=True)
+        self._thread.start()
+
+    def stop(self) -> List[Dict[str, Any]]:
+        self._stop.set()
+        if self._thread:
+            self._thread.join(timeout=2.0)
+        return list(self._samples)
+
+    def _loop(self) -> None:
+        try:
+            import resource as _resource
+        except ImportError:
+            _resource = None  # type: ignore[assignment]
+
+        while not self._stop.is_set():
+            sample: Dict[str, Any] = {"ts": time.time()}
+            # Memory (RSS) from /proc/self/status (Linux) or resource module
+            try:
+                with open("/proc/self/status") as f:
+                    for line in f:
+                        if line.startswith("VmRSS:"):
+                            sample["rss_kb"] = int(line.split()[1])
+                            break
+            except Exception:
+                if _resource:
+                    usage = _resource.getrusage(_resource.RUSAGE_SELF)
+                    sample["rss_kb"] = usage.ru_maxrss
+
+            # GC stats
+            gc_stats = gc.get_stats()
+            sample["gc_collections"] = sum(s.get("collections", 0) for s in gc_stats)
+
+            self._samples.append(sample)
+            self._stop.wait(self._interval)
+
+
+# =====================================================================
+# Test report
+# =====================================================================
+
+@dataclass
+class LoadTestReport:
+    """Results of a load test run."""
+
+    profile: LoadProfile
+    total_transactions: int = 0
+    succeeded: int = 0
+    failed: int = 0
+    elapsed_seconds: float = 0.0
+    warmup_transactions: int = 0
+
+    # Throughput
+    sustained_tps: float = 0.0
+    peak_tps: float = 0.0
+
+    # Latency (seconds)
+    latency_p50: float = 0.0
+    latency_p95: float = 0.0
+    latency_p99: float = 0.0
+    latency_max: float = 0.0
+    latency_avg: float = 0.0
+
+    # Batch latencies
+    batch_latency_p50: float = 0.0
+    batch_latency_p95: float = 0.0
+    batch_latency_avg: float = 0.0
+
+    # Resource usage
+    peak_rss_mb: float = 0.0
+    avg_rss_mb: float = 0.0
+    gc_collections: int = 0
+
+    # Status
+    target_met: bool = False
+    rust_core_used: bool = False
+    error_rate: float = 0.0
+
+    # Raw data for post-analysis
+    per_second_tps: List[float] = field(default_factory=list)
+    resource_samples: List[Dict[str, Any]] = field(default_factory=list)
+
+    def print_summary(self) -> None:
+        """Print a human-readable summary to stdout."""
+        line = "=" * 62
+        print(f"\n{line}")
+        print(f"  ZEXUS LOAD TEST REPORT")
+        print(f"{line}")
+        print(f"  Target TPS       : {self.profile.target_tps:,}")
+        print(f"  Duration          : {self.elapsed_seconds:.1f}s "
+              f"(+ {self.profile.warmup_seconds}s warm-up)")
+        print(f"  Contracts         : {self.profile.contract_count}")
+        print(f"  Batch size        : {self.profile.batch_size}")
+        print(f"  Rust core         : {'YES' if self.rust_core_used else 'no (fallback)'}")
+        print(f"{line}")
+        print()
+
+        # Throughput
+        result = "PASS" if self.target_met else "FAIL"
+        print(f"  Throughput")
+        print(f"    Sustained TPS   : {self.sustained_tps:,.0f}  [{result}]")
+        print(f"    Peak TPS        : {self.peak_tps:,.0f}")
+        print(f"    Total txns      : {self.total_transactions:,}")
+        print(f"    Succeeded       : {self.succeeded:,}")
+        print(f"    Failed          : {self.failed:,}")
+        print(f"    Error rate      : {self.error_rate:.2%}")
+        print()
+
+        # Latency
+        print(f"  Latency (per transaction)")
+        print(f"    p50             : {self.latency_p50 * 1000:.2f} ms")
+        print(f"    p95             : {self.latency_p95 * 1000:.2f} ms")
+        print(f"    p99             : {self.latency_p99 * 1000:.2f} ms")
+        print(f"    max             : {self.latency_max * 1000:.2f} ms")
+        print(f"    avg             : {self.latency_avg * 1000:.2f} ms")
+        print()
+
+        # Batch latency
+        print(f"  Latency (per batch of {self.profile.batch_size})")
+        print(f"    p50             : {self.batch_latency_p50 * 1000:.1f} ms")
+        print(f"    p95             : {self.batch_latency_p95 * 1000:.1f} ms")
+        print(f"    avg             : {self.batch_latency_avg * 1000:.1f} ms")
+        print()
+
+        # Resources
+        print(f"  Resources")
+        print(f"    Peak RSS        : {self.peak_rss_mb:.1f} MB")
+        print(f"    Avg RSS         : {self.avg_rss_mb:.1f} MB")
+        print(f"    GC collections  : {self.gc_collections}")
+        print()
+
+        # Per-second TPS histogram (text sparkline)
+        if self.per_second_tps:
+            _max = max(self.per_second_tps) or 1
+            bars = ""
+            for tps in self.per_second_tps:
+                level = int(tps / _max * 7)
+                bars += " ▁▂▃▄▅▆▇"[min(level, 7)]
+            print(f"  TPS sparkline     : [{bars}]")
+            print()
+
+        print(f"{line}")
+        if self.target_met:
+            print(f"  RESULT: TARGET MET — {self.sustained_tps:,.0f} >= "
+                  f"{self.profile.target_tps:,} TPS")
+        else:
+            print(f"  RESULT: TARGET NOT MET — {self.sustained_tps:,.0f} < "
+                  f"{self.profile.target_tps:,} TPS")
+        print(f"{line}\n")
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Serialize to a JSON-friendly dict."""
+        return {
+            "target_tps": self.profile.target_tps,
+            "sustained_tps": round(self.sustained_tps, 1),
+            "peak_tps": round(self.peak_tps, 1),
+            "total_transactions": self.total_transactions,
+            "succeeded": self.succeeded,
+            "failed": self.failed,
+            "elapsed_seconds": round(self.elapsed_seconds, 2),
+            "target_met": self.target_met,
+            "rust_core_used": self.rust_core_used,
+            "error_rate": round(self.error_rate, 4),
+            "latency_ms": {
+                "p50": round(self.latency_p50 * 1000, 3),
+                "p95": round(self.latency_p95 * 1000, 3),
+                "p99": round(self.latency_p99 * 1000, 3),
+                "max": round(self.latency_max * 1000, 3),
+                "avg": round(self.latency_avg * 1000, 3),
+            },
+            "batch_latency_ms": {
+                "p50": round(self.batch_latency_p50 * 1000, 2),
+                "p95": round(self.batch_latency_p95 * 1000, 2),
+                "avg": round(self.batch_latency_avg * 1000, 2),
+            },
+            "resources": {
+                "peak_rss_mb": round(self.peak_rss_mb, 1),
+                "avg_rss_mb": round(self.avg_rss_mb, 1),
+                "gc_collections": self.gc_collections,
+            },
+            "per_second_tps": [round(t, 1) for t in self.per_second_tps],
+        }
+
+
+# =====================================================================
+# Load test runner
+# =====================================================================
+
+class LoadTestRunner:
+    """Executes a load test against the Zexus blockchain stack.
+
+    The runner simulates a steady stream of transactions at the
+    configured ``target_tps``, dispatching them in batches via the
+    ``ExecutionAccelerator`` (which in turn uses the Rust core if it's
+    compiled).  It collects per-transaction latencies, per-second TPS
+    counters, and resource samples, then produces a
+    :class:`LoadTestReport`.
+    """
+
+    def __init__(
+        self,
+        profile: Optional[LoadProfile] = None,
+        contract_vm: Any = None,
+    ):
+        self.profile = profile or LoadProfile()
+        self._vm = contract_vm or _MockContractVM()
+        self._tx_gen = TransactionGenerator(self.profile)
+
+    def run(self) -> LoadTestReport:
+        """Execute the full load test and return a report."""
+        p = self.profile
+        report = LoadTestReport(profile=p)
+        workers = p.workers or min(32, max(4, p.contract_count))
+
+        # ── Check Rust core ───────────────────────────────────────
+        try:
+            from .rust_bridge import rust_core_available
+            report.rust_core_used = p.use_rust and rust_core_available()
+        except ImportError:
+            report.rust_core_used = False
+
+        # ── Build the accelerator ─────────────────────────────────
+        try:
+            from .accelerator import ExecutionAccelerator
+            accel = ExecutionAccelerator(
+                contract_vm=self._vm,
+                rust_core=p.use_rust,
+                batch_workers=workers,
+            )
+        except ImportError:
+            accel = None  # type: ignore[assignment]
+
+        logger.info(
+            "Starting load test: target=%d TPS, duration=%ds, "
+            "contracts=%d, batch=%d, rust=%s",
+            p.target_tps, p.duration_seconds, p.contract_count,
+            p.batch_size, report.rust_core_used,
+        )
+
+        # ── Resource sampler ──────────────────────────────────────
+        sampler = _ResourceSampler(interval=0.5)
+        sampler.start()
+
+        # ── Timing ────────────────────────────────────────────────
+        tx_latencies: List[float] = []
+        batch_latencies: List[float] = []
+        per_second_counts: Dict[int, int] = {}
+        total_sent = 0
+        total_ok = 0
+        total_fail = 0
+
+        # Token-bucket rate limiter: track cumulative "debt" to
+        # compensate for sleep() granularity and processing time.
+        batches_per_sec = max(1, p.target_tps / p.batch_size)
+        inter_batch_delay = 1.0 / batches_per_sec
+
+        run_start = time.time()
+        warmup_end = run_start + p.warmup_seconds
+        test_end = warmup_end + p.duration_seconds
+        is_warmup = True
+        next_batch_time = time.perf_counter()  # token-bucket deadline
+
+        try:
+            while True:
+                now = time.time()
+                if now >= test_end:
+                    break
+                if is_warmup and now >= warmup_end:
+                    is_warmup = False
+                    # Reset counters after warm-up
+                    tx_latencies.clear()
+                    batch_latencies.clear()
+                    per_second_counts.clear()
+                    total_sent = 0
+                    total_ok = 0
+                    total_fail = 0
+                    logger.info("Warm-up complete, measuring...")
+
+                # Generate & submit a batch
+                batch = self._tx_gen.generate_batch(p.batch_size)
+                batch_start = time.perf_counter()
+
+                if accel:
+                    result = accel.execute_batch(batch)
+                    batch_elapsed_inner = time.perf_counter() - batch_start
+                    # Extract per-tx latencies from receipts, or derive
+                    # from batch time when Rust doesn't report them
+                    found_latency = False
+                    for r in (result.receipts if hasattr(result, 'receipts') else []):
+                        if isinstance(r, dict) and r.get("elapsed", 0.0) > 0:
+                            tx_latencies.append(r["elapsed"])
+                            found_latency = True
+                    if not found_latency and hasattr(result, 'receipts') and result.receipts:
+                        # Derive per-tx latency from batch wall time
+                        per_tx = batch_elapsed_inner / max(len(result.receipts), 1)
+                        tx_latencies.extend([per_tx] * len(result.receipts))
+                    ok = result.succeeded if hasattr(result, 'succeeded') else 0
+                    fail = result.failed if hasattr(result, 'failed') else 0
+                else:
+                    # Direct VM fallback
+                    ok = 0
+                    fail = 0
+                    for tx in batch:
+                        t0 = time.perf_counter()
+                        try:
+                            res = self._vm.execute_action(
+                                contract=tx["contract"],
+                                action=tx["action"],
+                                args=tx["args"],
+                                caller=tx["caller"],
+                                gas_limit=tx.get("gas_limit", 100_000),
+                            )
+                            lat = time.perf_counter() - t0
+                            tx_latencies.append(lat)
+                            if res.get("success"):
+                                ok += 1
+                            else:
+                                fail += 1
+                        except Exception:
+                            fail += 1
+
+                batch_elapsed = time.perf_counter() - batch_start
+                batch_latencies.append(batch_elapsed)
+
+                if not is_warmup:
+                    total_sent += len(batch)
+                    total_ok += ok
+                    total_fail += fail
+                    # Track per-second TPS
+                    sec = int(time.time() - warmup_end)
+                    per_second_counts[sec] = per_second_counts.get(sec, 0) + len(batch)
+
+                # Token-bucket throttle: sleep only until next_batch_time
+                next_batch_time += inter_batch_delay
+                sleep_time = next_batch_time - time.perf_counter()
+                if sleep_time > 0.0001:
+                    time.sleep(sleep_time)
+
+        except KeyboardInterrupt:
+            logger.warning("Load test interrupted")
+
+        # ── Stop resource sampler ─────────────────────────────────
+        resource_data = sampler.stop()
+
+        # ── Compute report ────────────────────────────────────────
+        run_end = time.time()
+        elapsed = max(0.001, run_end - warmup_end - max(0, run_end - test_end))
+        report.elapsed_seconds = elapsed
+        report.total_transactions = total_sent
+        report.succeeded = total_ok
+        report.failed = total_fail
+        report.error_rate = total_fail / max(total_sent, 1)
+
+        # Throughput
+        report.sustained_tps = total_sent / elapsed
+        if per_second_counts:
+            report.per_second_tps = [
+                per_second_counts.get(s, 0)
+                for s in range(max(per_second_counts.keys()) + 1)
+            ]
+            report.peak_tps = max(report.per_second_tps) if report.per_second_tps else 0
+
+        # Latency percentiles
+        if tx_latencies:
+            tx_latencies.sort()
+            report.latency_avg = statistics.mean(tx_latencies)
+            report.latency_p50 = _percentile(tx_latencies, 50)
+            report.latency_p95 = _percentile(tx_latencies, 95)
+            report.latency_p99 = _percentile(tx_latencies, 99)
+            report.latency_max = tx_latencies[-1]
+
+        if batch_latencies:
+            batch_latencies.sort()
+            report.batch_latency_avg = statistics.mean(batch_latencies)
+            report.batch_latency_p50 = _percentile(batch_latencies, 50)
+            report.batch_latency_p95 = _percentile(batch_latencies, 95)
+
+        # Resources
+        rss_values = [s.get("rss_kb", 0) for s in resource_data if s.get("rss_kb")]
+        if rss_values:
+            report.peak_rss_mb = max(rss_values) / 1024.0
+            report.avg_rss_mb = statistics.mean(rss_values) / 1024.0
+        gc_vals = [s.get("gc_collections", 0) for s in resource_data]
+        if gc_vals:
+            report.gc_collections = max(gc_vals) - min(gc_vals)
+
+        report.resource_samples = resource_data
+        report.target_met = report.sustained_tps >= p.target_tps
+
+        logger.info(
+            "Load test complete: %d txns in %.1fs = %.0f TPS (%s)",
+            total_sent, elapsed, report.sustained_tps,
+            "PASS" if report.target_met else "FAIL",
+        )
+
+        return report
+
+
+# =====================================================================
+# Helpers
+# =====================================================================
+
+def _percentile(sorted_data: List[float], pct: float) -> float:
+    """Compute the *pct*-th percentile from pre-sorted data."""
+    if not sorted_data:
+        return 0.0
+    k = (len(sorted_data) - 1) * pct / 100.0
+    f = math.floor(k)
+    c = math.ceil(k)
+    if f == c:
+        return sorted_data[int(k)]
+    return sorted_data[f] * (c - k) + sorted_data[c] * (k - f)
+
+
+# =====================================================================
+# Convenience: quick benchmark
+# =====================================================================
+
+def quick_benchmark(
+    target_tps: int = 1_800,
+    duration: int = 10,
+    contracts: int = 8,
+    use_rust: bool = True,
+) -> LoadTestReport:
+    """Run a quick benchmark with sensible defaults.
+
+    ::
+
+        from zexus.blockchain.loadtest import quick_benchmark
+        report = quick_benchmark()
+        report.print_summary()
+    """
+    profile = LoadProfile(
+        target_tps=target_tps,
+        duration_seconds=duration,
+        contract_count=contracts,
+        use_rust=use_rust,
+        warmup_seconds=2,
+    )
+    runner = LoadTestRunner(profile)
+    return runner.run()
+
+
+# =====================================================================
+# CLI entry-point
+# =====================================================================
+
+def _cli_main() -> None:
+    """Simple CLI for running load tests."""
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        description="Zexus Blockchain Load Tester",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=(
+            "Examples:\n"
+            "  python -m zexus.blockchain.loadtest --tps 1800 --duration 30\n"
+            "  python -m zexus.blockchain.loadtest --tps 5000 --contracts 16 --batch 500\n"
+            "  python -m zexus.blockchain.loadtest --no-rust  # Pure Python baseline\n"
+        ),
+    )
+    parser.add_argument("--tps", type=int, default=1_800,
+                        help="Target TPS (default: 1800)")
+    parser.add_argument("--duration", type=int, default=30,
+                        help="Test duration in seconds (default: 30)")
+    parser.add_argument("--contracts", type=int, default=8,
+                        help="Number of contracts (default: 8)")
+    parser.add_argument("--batch", type=int, default=200,
+                        help="Batch size (default: 200)")
+    parser.add_argument("--workers", type=int, default=0,
+                        help="Worker threads (0=auto)")
+    parser.add_argument("--warmup", type=int, default=3,
+                        help="Warm-up seconds (default: 3)")
+    parser.add_argument("--senders", type=int, default=50,
+                        help="Distinct sender addresses (default: 50)")
+    parser.add_argument("--no-rust", action="store_true",
+                        help="Disable Rust core (pure-Python baseline)")
+    parser.add_argument("--json", type=str, default=None,
+                        help="Write JSON report to file")
+    parser.add_argument("-v", "--verbose", action="store_true",
+                        help="Enable debug logging")
+
+    args = parser.parse_args()
+
+    level = logging.DEBUG if args.verbose else logging.INFO
+    logging.basicConfig(level=level, format="%(levelname)s %(name)s: %(message)s")
+
+    profile = LoadProfile(
+        target_tps=args.tps,
+        duration_seconds=args.duration,
+        contract_count=args.contracts,
+        batch_size=args.batch,
+        workers=args.workers,
+        warmup_seconds=args.warmup,
+        sender_count=args.senders,
+        use_rust=not args.no_rust,
+    )
+
+    runner = LoadTestRunner(profile)
+    report = runner.run()
+    report.print_summary()
+
+    if args.json:
+        with open(args.json, "w") as f:
+            json.dump(report.to_dict(), f, indent=2)
+        print(f"JSON report written to {args.json}")
+
+
+if __name__ == "__main__":
+    _cli_main()