Coverage Analysis skill for Claude Code

#!/usr/bin/env python3
"""Coverage triage from LCOV or Cobertura XML, standard library only.

Subcommands:
  diff   Coverage of the lines a unified diff adds (diff coverage), with
         uncovered line ranges per file. Exits 1 if below --fail-under.
  worst  Files ranked by missed lines (where untested code actually is).

Examples:
  git diff -U0 origin/main...HEAD > change.diff
  python3 coverage_report.py diff coverage/lcov.info change.diff --fail-under 80
  python3 coverage_report.py worst coverage.xml --top 15
"""
from __future__ import annotations

import argparse
import re
import sys
import xml.etree.ElementTree as ET
from collections import defaultdict
from pathlib import PurePosixPath


class FileCov:
    def __init__(self) -> None:
        self.lines: dict[int, int] = {}          # line -> hit count
        self.branches: dict[int, list[bool]] = defaultdict(list)  # line -> taken flags

    def add_line(self, n: int, hits: int) -> None:
        self.lines[n] = max(self.lines.get(n, 0), hits)


def norm(path: str) -> str:
    return str(PurePosixPath(path.replace("\\", "/"))).lstrip("./")


def parse_lcov(text: str) -> dict[str, FileCov]:
    files: dict[str, FileCov] = {}
    cur: FileCov | None = None
    for raw in text.splitlines():
        line = raw.strip()
        if line.startswith("SF:"):
            cur = files.setdefault(norm(line[3:]), FileCov())
        elif cur is None:
            continue
        elif line.startswith("DA:"):
            parts = line[3:].split(",")
            cur.add_line(int(parts[0]), int(float(parts[1])))
        elif line.startswith("BRDA:"):
            ln, _blk, _br, taken = line[5:].split(",")
            cur.branches[int(ln)].append(taken not in ("-", "0"))
        elif line == "end_of_record":
            cur = None
    return files


def parse_cobertura(text: str) -> dict[str, FileCov]:
    root = ET.fromstring(text)
    sources = [s.text.strip() for s in root.iter("source") if s.text and s.text.strip()]
    files: dict[str, FileCov] = {}
    for cls in root.iter("class"):
        fname = cls.get("filename", "")
        fc = files.setdefault(norm(fname), FileCov())
        for ln in cls.iter("line"):
            n, hits = int(ln.get("number", 0)), int(float(ln.get("hits", 0)))
            fc.add_line(n, hits)
            cond = ln.get("condition-coverage")  # e.g. "50% (1/2)"
            if ln.get("branch") == "true" and cond:
                m = re.search(r"\((\d+)/(\d+)\)", cond)
                if m:
                    got, tot = int(m.group(1)), int(m.group(2))
                    fc.branches[n] = [True] * got + [False] * (tot - got)
    _ = sources  # paths in Cobertura are relative to <source>; suffix matching covers both
    return files


def load(path: str) -> dict[str, FileCov]:
    with open(path, encoding="utf-8") as fh:
        text = fh.read()
    if text.lstrip().startswith("<"):
        return parse_cobertura(text)
    return parse_lcov(text)


def parse_diff(text: str) -> dict[str, set[int]]:
    added: dict[str, set[int]] = defaultdict(set)
    cur: str | None = None
    new_line = 0
    for line in text.splitlines():
        if line.startswith("+++ "):
            target = line[4:].split("\t")[0]
            cur = None if target == "/dev/null" else norm(re.sub(r"^b/", "", target))
        elif line.startswith("@@"):
            m = re.match(r"@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@", line)
            new_line = int(m.group(1)) if m else 0
        elif cur is None or line.startswith("--- "):
            continue
        elif line.startswith("+"):
            added[cur].add(new_line)
            new_line += 1
        elif line.startswith("-") or line.startswith("\\"):
            continue
        else:
            new_line += 1
    return added


def match(cov: dict[str, FileCov], diff_path: str) -> FileCov | None:
    if diff_path in cov:
        return cov[diff_path]
    hits = [k for k in cov if k.endswith("/" + diff_path) or diff_path.endswith("/" + k)]
    return cov[hits[0]] if len(hits) == 1 else None


def ranges(nums: list[int]) -> str:
    out, start, prev = [], None, None
    for n in sorted(nums):
        if start is None:
            start = prev = n
        elif n == prev + 1:
            prev = n
        else:
            out.append(f"{start}" if start == prev else f"{start}-{prev}")
            start = prev = n
    if start is not None:
        out.append(f"{start}" if start == prev else f"{start}-{prev}")
    return ",".join(out)


def cmd_diff(args: argparse.Namespace) -> int:
    cov = load(args.coverage)
    with open(args.diff, encoding="utf-8") as fh:
        added = parse_diff(fh.read())
    total = covered = 0
    unmatched = []
    rows = []
    for path, lines in sorted(added.items()):
        fc = match(cov, path)
        if fc is None:
            unmatched.append(path)
            continue
        exe = [n for n in lines if n in fc.lines]
        if not exe:
            continue
        miss = [n for n in exe if fc.lines[n] == 0]
        partial = [n for n in exe if n in fc.branches and not all(fc.branches[n]) and fc.lines[n] > 0]
        total += len(exe)
        covered += len(exe) - len(miss)
        rows.append((path, len(exe), len(miss), miss, partial))
    print(f"{'file':60} {'changed':>7} {'missed':>6}  uncovered lines / partial branches")
    for path, n, m, miss, partial in sorted(rows, key=lambda r: -r[2]):
        extra = f"  partial: {ranges(partial)}" if partial else ""
        print(f"{path[-60:]:60} {n:7d} {m:6d}  {ranges(miss) or '-'}{extra}")
    if unmatched:
        print(f"\nnot in coverage report (unmeasured, not 'covered'): {', '.join(unmatched)}")
    if total == 0:
        print("\nno executable changed lines found in the coverage report")
        return 0
    pct = 100.0 * covered / total
    print(f"\ndiff coverage: {covered}/{total} executable changed lines = {pct:.1f}%")
    if args.fail_under is not None and pct < args.fail_under:
        print(f"FAIL: below threshold {args.fail_under:.1f}%")
        return 1
    return 0


def cmd_worst(args: argparse.Namespace) -> int:
    cov = load(args.coverage)
    rows = []
    t_lines = t_hit = t_br = t_br_hit = 0
    for path, fc in cov.items():
        n = len(fc.lines)
        if n == 0:
            continue
        hit = sum(1 for h in fc.lines.values() if h > 0)
        br = sum(len(v) for v in fc.branches.values())
        br_hit = sum(sum(v) for v in fc.branches.values())
        t_lines, t_hit, t_br, t_br_hit = t_lines + n, t_hit + hit, t_br + br, t_br_hit + br_hit
        rows.append((path, n, n - hit, 100.0 * hit / n, (100.0 * br_hit / br) if br else None))
    rows.sort(key=lambda r: (-r[2], r[3]))
    print(f"{'file':60} {'lines':>6} {'missed':>6} {'line%':>6} {'branch%':>7}")
    for path, n, miss, lp, bp in rows[: args.top]:
        bps = f"{bp:6.1f}%" if bp is not None else "     -"
        print(f"{path[-60:]:60} {n:6d} {miss:6d} {lp:5.1f}% {bps}")
    if t_lines:
        bsum = f", branches {100.0 * t_br_hit / t_br:.1f}%" if t_br else ""
        print(f"\ntotal: lines {100.0 * t_hit / t_lines:.1f}% ({t_hit}/{t_lines}){bsum}")
    return 0


def main() -> int:
    p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    sub = p.add_subparsers(dest="cmd", required=True)
    d = sub.add_parser("diff", help="coverage of lines added by a unified diff")
    d.add_argument("coverage", help="lcov.info or Cobertura coverage.xml")
    d.add_argument("diff", help="unified diff file (git diff -U0 base...HEAD)")
    d.add_argument("--fail-under", type=float, default=None)
    d.set_defaults(func=cmd_diff)
    w = sub.add_parser("worst", help="files ranked by missed lines")
    w.add_argument("coverage")
    w.add_argument("--top", type=int, default=20)
    w.set_defaults(func=cmd_worst)
    args = p.parse_args()
    try:
        return args.func(args)
    except (OSError, ET.ParseError, ValueError) as exc:
        print(f"error: {exc}", file=sys.stderr)
        return 2


if __name__ == "__main__":
    sys.exit(main())