Przejdź do treści
Biblioteka skilli
Programowanie · Analiza

coverage-diff-reporter

/coverage-diff-reporter

Buduje raport różnic pokrycia na PR z par wyników LCOV, Cobertura lub JSON: tabela per plik z deltą linii i gałęzi, nowe pliki, ukryte spadki i jednowierszowe podsumowanie komentarza.

Repozytorium
qa ↗
Licencja
MIT
Ostatnia zmiana repozytorium
20.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
2
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 20.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Buduje raport różnic pokrycia na PR z par wyników LCOV, Cobertura lub JSON: tabela per plik z deltą linii i gałęzi, nowe pliki, ukryte spadki i jednowierszowe podsumowanie komentarza.

Oryginalny opis (EN)

Builds a per-PR coverage delta report from any pair of LCOV / Cobertura / JSON coverage outputs (current run + baseline from the merge target) - emits a per-file table with line% / branch% deltas, called-out new files, hidden drops (overall +0.1pp but one file -8pp), and a single-line PR-comment summary. Use when the team has coverage in CI but needs human-readable PR feedback that points at the specific file the reviewer should focus on, not just an aggregate number.

Jak działa

  1. Overview
  2. When to use
  3. Step 1 - Pick the parser
  4. Step 2 - Get the baseline
  5. Step 3 - Compute the per-file delta
  6. Step 4 - Sort and classify
  7. Step 5 - Render the report
  8. Step 6 - One-line summary for the PR top
  9. Step 7 - Post to the PR
  10. Anti-patterns
Sekcje z nagłówków SKILL.md, w oryginale · 256 linii, 1 350 słów
Podgląd SKILL.md
---
name: coverage-diff-reporter
description: "Builds a per-PR coverage delta report from any pair of LCOV / Cobertura / JSON coverage outputs (current run + baseline from the merge target) - emits a per-file table with line% / branch% deltas, called-out new files, hidden drops (overall +0.1pp but one file -8pp), and a single-line PR-comment summary. Use when the team has coverage in CI but needs human-readable PR feedback that points at the specific file the reviewer should focus on, not just an aggregate number."
---

# coverage-diff-reporter

## Overview

A whole-repo coverage gate is necessary but not sufficient. A drop
of 0.4pp overall might hide a 12pp drop in one critical file. A
new file at 35% line coverage might pass an aggregate gate but
leave a regression-risk hot spot.

This skill **builds a coverage diff report** that solves the
"reviewer can see what to look at" problem:

1. Parse the current run's coverage (LCOV / Cobertura).
2. Parse a baseline from the merge target.
3. Emit a per-file delta table sorted by absolute drop.
4. Highlight new files below threshold, files with disproportionate
   drops, and files that gained coverage (positive feedback).
5. Post a single-line summary as the PR top-of-comment, with
   click-through to the full table.

## When to use

- A PR is missing reviewer signal about which file's coverage
  changed.
- The repo has coverage but no PR-time visualization (the data is in
  the artifacts but nobody opens them).
- A coverage SaaS isn't an option (compliance, cost) and the team
  wants a self-hosted equivalent.

This skill **does not** decide pass/fail - that's the gate's job
(see `lcov-analysis` or
`lcov-analysis` references/cobertura.md). This
skill just makes the diff legible.

## Step 1 - Pick the parser

Match the existing CI's reporter:

| Existing reporter           | Use                                                      |
|-----------------------------|----------------------------------------------------------|
| LCOV `.info`                | `lcov-analysis` parser      |
| Cobertura XML               | `lcov-analysis` (references/cobertura.md) parser |
| Jest JSON / V8 coverage     | Convert to LCOV first (`jest --coverageReporters=lcov`)  |
| JaCoCo XML                  | Use `jacoco-analysis`, or convert to Cobertura |
| coverage.py                 | `coverage xml` → Cobertura, OR `py2lcov` → LCOV          |

The reporter writes to `current.json` (parsed). The same parser
runs against the baseline → `baseline.json`.

## Step 2 - Get the baseline

Two patterns:

### Pattern A - cached artifact (recommended)

The main branch's last successful CI run uploaded its coverage as
an artifact. PR jobs download it.

```yaml
- name: Restore baseline
  uses: dawidd6/action-download-artifact@v3
  with:
    workflow: coverage.yml
    branch: main
    name: coverage-baseline
    path: baseline/

- name: Parse current
  run: python scripts/parse_lcov.py coverage/lcov.info > current.json

- name: Parse baseline
  run: python scripts/parse_lcov.py baseline/lcov.info > baseline.json

- name: Generate diff
  run: python scripts/coverage_diff.py current.json baseline.json > diff.md
```

### Pattern B - recompute the baseline in the PR job

The PR job checks out main, runs tests + coverage, then checks out
the PR head. Slower (~2x runtime) but always-fresh.

```yaml
- name: Checkout main
  run: git fetch origin main && git checkout origin/main

- name: Run tests on main
  run: npm test -- --coverage && cp coverage/lcov.info baseline.lcov

- name: Checkout PR head
  run: git checkout ${{ github.event.pull_request.head.sha }}

- name: Run tests on PR head
  run: npm test -- --coverage
```

Pattern A is the default. Pattern B is the fallback when artifact
retention has expired or main coverage is non-deterministic.

## Step 3 - Compute the per-file delta

```python
# scripts/coverage_diff.py
def compute_diff(current, baseline):
    base_idx = {f['path']: f for f in baseline}
    rows = []
    for f in current:
        b = base_idx.get(f['path'])
        line_now    = pct(f.get('lh', 0), f.get('lf', 0))
        branch_now  = pct(f.get('brh', 0), f.get('brf', 0))
        line_then   = pct(b.get('lh', 0), b.get('lf', 0)) if b else None
        branch_then = pct(b.get('brh', 0), b.get('brf', 0)) if b else None
        rows.append({
            'path': f['path'],
            'is_new': b is None,
            'line_now': line_now,    'line_delta':   delta(line_now, line_then),
            'branch_now': branch_now,'branch_delta': delta(branch_now, branch_then),
        })
    # Also catch deletions - files in baseline but not current.
    for path, b in base_idx.items():
        if path not in {f['path'] for f in current}:
            rows.append({'path': path, 'is_deleted': True, 'line_now': None, 'line_then': pct(b.get('lh', 0), b.get('lf', 0))})
    return rows
```

## Step 4 - Sort and classify

Reviewers care most about big drops. Sort by `line_delta` ascending
(most-negative first), with new sub-threshold files at the top:

```python
def classify(row):
    if row.get('is_deleted'):                      return 'deleted'
    if row.get('is_new') and row['line_now'] < 80: return 'new_below_threshold'
    if row.get('is_new'):                          return 'new_ok'
    if row['line_delta'] is not None and row['line_delta'] <= -5:   return 'regressed'
    if row['line_delta'] is not None and row['line_delta'] <  0:    return 'declined'
    if row['line_delta'] is not None and row['line_delta'] >  0:    return 'improved'
    return 'unchanged'
```

The thresholds (80% for new files, -5pp for regression) are tunable
per repo.

## Step 5 - Render the report

```markdown
## Coverage diff - `<sha>` vs `main` `<base-sha>`

**Overall:** line 84.2% (-0.3pp) | branch 71.5% (-0.1pp)
**Files changed:** 7 (3 regressed, 1 new, 2 improved, 1 deleted)

### ⚠ Regressions (4)

| File                                  | Line%       | Branch%     |
|---------------------------------------|-------------|-------------|
| `src/checkout/cart.ts`                | 65.4 (-12.8 ⬇) | 50.0 (-25.0 ⬇) |
| `src/checkout/promo.ts`               | 78.0 (-8.5 ⬇)  | 60.0 (-15.0 ⬇) |

### 🆕 New files (1)

| File                                  | Line%       | Branch%     |
|---------------------------------------|-------------|-------------|
| `src/checkout/discount-stack.ts`      | 35.0 (NEW, below 80% threshold) | 25.0 |

### ✅ Improvements (2)

| File                                  | Line%       | Branch%     |
|---------------------------------------|-------------|-------------|
| `src/orders/list.ts`                  | 92.0 (+4.5 ⬆) | 85.0 (+10.0 ⬆) |

### 🗑 Deleted (1)

| File                                  | Was line%   |
|---------------------------------------|-------------|
| `src/legacy/old-checkout.ts`          | 22.0        |
```

The four-section split (Regressions / New / Improvements / Deleted)
matches reviewer attention budget. Improvements get airtime - 
positive feedback prevents the gate from feeling adversarial.

## Step 6 - One-line summary for the PR top

PR comment APIs render long markdown by default; the summary line
sits at the top so the reviewer doesn't have to scroll:

```
📉 Coverage 84.2% (-0.3pp) - 3 files regressed, 1 new file below threshold. See full report below.
```

Or if all-clear:

```
✅ Coverage 84.5% (+0.2pp) - no regressions, 2 files improved.
```

## Step 7 - Post to the PR

```yaml
- name: Generate diff report
  run: python scripts/coverage_diff.py current.json baseline.json > diff.md

- name: Post / update PR comment
  uses: marocchino/sticky-pull-request-comment@v2
  with:
    header: coverage-diff
    path: diff.md
```

`sticky-pull-request-comment` uses the `header` to update the same
comment across pushes - the reviewer doesn't see N copies of the
report as the PR evolves.

## Anti-patterns

| Anti-pattern                                                      | Why it fails                                                                  | Fix |
|-------------------------------------------------------------------|-------------------------------------------------------------------------------|-----|
| Posting only the aggregate (overall ± Xpp)                        | Hides which file regressed; reviewer can't act.                              | Per-file table sorted by drop (Step 4 - 5). |
| One thread per push (new comment per commit)                      | PR conversation drowns in coverage churn; nobody reads.                      | Sticky comment updated in place (Step 7). |
| Showing every unchanged file                                       | 500-row tables; the 3 regressions are buried.                                | Filter to only changed files; one summary line for unchanged count. |
| Adversarial framing ("FAIL: coverage dropped")                    | Reviewer associates coverage tool with friction; team disables.              | Show improvements too (Step 5). Gate failures are the gate's job; this report is informational. |
| Using PR's merge-base coverage (re-runs main coverage)            | Doubles CI cost; flake risk on the main re-run.                              | Cache main coverage as artifact (Step 2 Pattern A). |
| Hiding new files because they "don't have a baseline"             | New files are exactly where regressions enter the codebase.                   | Always show new files; flag the sub-threshold ones explicitly (Step 4). |
| Ignoring deleted files                                              | Coverage went up because high-coverage code was deleted; aggregate misleads.  | Show deletions (Step 3); explain in summary if they cause aggregate movement. |

## Limitations

- **Per-line uncovered detail isn't shown.** This skill is the
  file-level summary; for per-line drilldown, generate the
  language-native HTML report (Allure / genhtml / `coverage html`).
- **No semantic awareness.** A 50% drop because the file got 2x
  bigger (more code, same number of tests) reads the same as a
  drop because tests were deleted. The reviewer still has to look.
- **Sub-1pp deltas are noise.** Coverage tools have measurement
  jitter from non-deterministic test ordering; show only deltas
  above a threshold (typical: ±0.5pp).
- **Baseline staleness.** Pattern A assumes main's last coverage
  artifact is recent. If main is stale, surface the baseline age
  in the report header.

## References

- `lcov-analysis` - LCOV parser this
  skill consumes.
- `lcov-analysis` - LCOV + Cobertura
  parser this skill consumes.
- `jacoco-analysis`,
  `coverage-py-analysis`, and
  `js-unit-tests` (qa-unit-tests-js) for Jest/Vitest - 
  language-specific parsers; convert to LCOV / Cobertura before
  feeding this skill.
- `test-coverage-targeter` - downstream skill that reads the same data to suggest which
  uncovered branches to target next.
Pliki w paczce (2)
  • SKILL.md 11 KB
  • .tessl-plugin/plugin.json 1 KB

Wersje

RepozytoriumWynikLicencja
Ta strona · testland/qa100MIT
testland/qa-skills100MIT

Migawka bazy z 13.11.2026 · wersja paczki 5c20044827af (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100lcov-analysis
    Parsuje raporty pokrycia kodu w formatach LCOV .info i Cobertura XML, wydobywając metryki linii, funkcji i gałęzi dla każdego pliku z wyników gcov, llvm-cov, JaCoCo, Jest i innych narzędzi.
  • 84audit-coverage
    Odczytuje gotowe raporty pokrycia (lcov, Cobertura, coverage.py JSON, profil Go) i podaje pokrycie linii oraz wskaźnik CRAP dla plików i funkcji.
  • 100coverage-py-analysis
    Konfiguruje coverage.py w projektach Pythona: coverage run, pokrycie gałęzi, plik .coverage i combine dla równoległych przebiegów pytest-xdist, .coveragerc z source, omit i fail_under oraz formaty raportów.
  • 100verifying-change-coverage
    Sprawdza, czy linie i gałęzie zmienione w PR są wykonywane przez testy, używając diff coverage z LCOV lub Cobertura zamiast procentu dla całego repozytorium, i eskaluje nieprzetestowane zmiany wysokiego ryzyka.
  • 100dart-collect-coverage
    Mierzy pokrycie kodu testami w Dart, generuje raporty LCOV lub HTML i filtruje pliki pokrycia.
  • 92dart-collect-coverage
    Zbiera pokrycie testami pakietem coverage i generuje raport LCOV dla projektów Dart.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.