codepulse-cli 0.1.0__py3-none-any.whl

codepulse/cli.py

@@ -0,0 +1,250 @@
+"""Command-line entry point for CodePulse.
+
+Two modes:
+
+* **Report** (default) — full HTML health dashboard for a repo.
+* **Risk gate** (``--changed <ref>``) — score only the files changed since a
+  ref, emit JSON or text, and set an exit code so CI can warn or block.
+"""
+
+from __future__ import annotations
+
+import argparse
+import datetime
+import json
+import os
+import sys
+import webbrowser
+from urllib.parse import quote
+
+from . import analyzers
+from .git_data import get_changed_files, get_commits, is_git_repo
+from .report import render
+
+_LEVELS = {"LOW": 0, "MEDIUM": 1, "HIGH": 2}
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="codepulse",
+        description="Reveal a codebase's health from its git history.",
+    )
+    parser.add_argument("repo", nargs="?", default=".", help="path to a git repository (default: current dir)")
+    parser.add_argument("-o", "--output", default="codepulse-report.html", help="HTML report output path")
+    parser.add_argument("--since", help='only commits after this date, e.g. "6 months ago"')
+    parser.add_argument("--max-count", type=int, help="limit to the N most recent commits")
+    parser.add_argument("--top", type=int, default=20, help="rows per table (default: 20)")
+    parser.add_argument("--open", action="store_true", help="open the HTML report in a browser when done")
+    parser.add_argument("--ignore", action="append", metavar="GLOB", default=[],
+                        help="exclude paths matching this glob (repeatable), e.g. '*.sql'")
+    parser.add_argument("--no-default-ignore", action="store_true",
+                        help="don't exclude the built-in generated/data file patterns")
+    parser.add_argument("--who", metavar="PATH",
+                        help="show who knows a file best (from git history) and exit")
+    parser.add_argument("--badge", action="store_true",
+                        help="print a shields.io health-badge snippet and exit")
+
+    gate = parser.add_argument_group("risk gate (CI)")
+    gate.add_argument("--changed", metavar="REF",
+                      help='score files changed since REF (e.g. "origin/main" or "HEAD~10..HEAD")')
+    gate.add_argument("--format", choices=["text", "json", "markdown"], default="text",
+                      help="risk-gate output format (default: text)")
+    gate.add_argument("--fail-on", choices=["LOW", "MEDIUM", "HIGH"],
+                      help="exit with code 1 if release risk reaches this level")
+    return parser
+
+
+def _ignore_patterns(args: argparse.Namespace) -> list[str]:
+    base = [] if args.no_default_ignore else list(analyzers.DEFAULT_IGNORE)
+    return base + list(args.ignore)
+
+
+def _run_report(repo: str, args: argparse.Namespace) -> int:
+    print(f"Reading git history from {repo} ...")
+    commits = get_commits(repo, since=args.since, max_count=args.max_count)
+    if not commits:
+        print("error: no commits found for the given filters.", file=sys.stderr)
+        return 1
+    commits = analyzers.filter_commits(commits, _ignore_patterns(args))
+    print(f"  {len(commits)} commits")
+
+    stats = analyzers.build_file_stats(commits, repo)
+    summary = analyzers.summarize(commits, stats)
+    hot = analyzers.hotspots(stats, limit=args.top)
+    hotspot_paths = {h.path for h in analyzers.hotspots(stats, limit=15)}
+    html = render(
+        repo_name=os.path.basename(repo.rstrip("/\\")) or repo,
+        summary=summary,
+        hotspots=hot,
+        bus_risks=analyzers.bus_factor_risks(stats, limit=args.top),
+        coupling=analyzers.coupling(commits, stats, limit=args.top),
+        trend=analyzers.monthly_trend(commits, hotspot_paths),
+        stale=analyzers.stale_risks(stats, summary.last_timestamp, limit=args.top),
+    )
+
+    out = os.path.abspath(args.output)
+    with open(out, "w", encoding="utf-8") as fh:
+        fh.write(html)
+    print(f"\nReport written to {out}")
+    if args.open:
+        webbrowser.open(f"file://{out}")
+    return 0
+
+
+def _run_gate(repo: str, args: argparse.Namespace) -> int:
+    commits = get_commits(repo, since=args.since, max_count=args.max_count)
+    if not commits:
+        print("error: no commits found to build a risk map.", file=sys.stderr)
+        return 1
+    patterns = _ignore_patterns(args)
+    commits = analyzers.filter_commits(commits, patterns)
+    stats = analyzers.build_file_stats(commits, repo)
+    changed = [p for p in get_changed_files(repo, args.changed) if not analyzers.is_ignored(p, patterns)]
+    risk = analyzers.release_risk(changed, stats)
+    known_count, reviewers = analyzers.suggested_reviewers(changed, stats)
+
+    def _reviewer_label(r):
+        return f"{r.name} ({r.files_known}/{known_count} fichiers)"
+
+    icons = {"HIGH": "🔴", "MEDIUM": "🟠", "LOW": "🟢"}
+
+    if args.format == "json":
+        payload = {
+            "level": risk.level,
+            "score": risk.score,
+            "high_risk_count": risk.high_risk_count,
+            "changed_files": len(risk.files),
+            "files": [
+                {"path": f.path, "risk": f.risk, "commits": f.commits, "loc": f.loc, "reasons": f.reasons}
+                for f in risk.files
+            ],
+            "suggested_reviewers": [
+                {"name": r.name, "files_known": r.files_known, "commits": r.commits} for r in reviewers
+            ],
+        }
+        print(json.dumps(payload, ensure_ascii=False, indent=2))
+    elif args.format == "markdown":
+        # A sticky PR comment. The marker lets a CI step find and update it.
+        lines = [
+            "<!-- codepulse -->",
+            f"## 🩺 CodePulse — Risque : {icons[risk.level]} **{risk.level}** ({risk.score}/100)",
+            "",
+            f"**{len(risk.files)} fichiers modifiés · {risk.high_risk_count} à risque élevé**",
+            "",
+        ]
+        scored = [f for f in risk.files if f.risk > 0]
+        if scored:
+            lines += ["| Risque | Fichier | Pourquoi |", "|---:|---|---|"]
+            for f in scored[:12]:
+                lines.append(f"| {f.risk} | `{f.path}` | {', '.join(f.reasons)} |")
+        else:
+            lines.append("_Aucun fichier à risque touché._ ✅")
+        if reviewers:
+            lines += ["", "**👥 Relecteurs suggérés** (d'après l'historique) : "
+                      + ", ".join(_reviewer_label(r) for r in reviewers)]
+        lines += [
+            "",
+            "<sub>Score basé sur l'historique du dépôt. Risque élevé = touche un hotspot connu ou un fichier à auteur unique.</sub>",
+        ]
+        print("\n".join(lines))
+    else:
+        print(f"{icons[risk.level]} Release risk: {risk.level} ({risk.score}/100)")
+        print(f"   {len(risk.files)} changed files · {risk.high_risk_count} high-risk")
+        for f in risk.files:
+            if f.risk > 0:
+                print(f"   [{f.risk:3}] {f.path}  ({', '.join(f.reasons)})")
+        if reviewers:
+            print("   👥 Relecteurs suggérés: " + ", ".join(_reviewer_label(r) for r in reviewers))
+
+    if args.fail_on and _LEVELS[risk.level] >= _LEVELS[args.fail_on]:
+        print(f"\nRisk level {risk.level} >= threshold {args.fail_on} — failing.", file=sys.stderr)
+        return 1
+    return 0
+
+
+def _load_stats(repo: str, args: argparse.Namespace):
+    commits = get_commits(repo, since=args.since, max_count=args.max_count)
+    if not commits:
+        return None, None
+    commits = analyzers.filter_commits(commits, _ignore_patterns(args))
+    return commits, analyzers.build_file_stats(commits, repo)
+
+
+def _run_who(repo: str, args: argparse.Namespace) -> int:
+    commits, stats = _load_stats(repo, args)
+    if not commits:
+        print("error: no commits found.", file=sys.stderr)
+        return 1
+    matches = analyzers.find_files(stats, args.who)
+    if not matches:
+        print(f"Aucun fichier suivi ne correspond à '{args.who}'.", file=sys.stderr)
+        return 1
+    if len(matches) > 1:
+        print(f"Plusieurs fichiers correspondent à '{args.who}' — précise le chemin :")
+        for m in matches[:20]:
+            print(f"  {m}")
+        return 1
+
+    s = stats[matches[0]]
+    total = sum(s.authors.values())
+    last = datetime.datetime.fromtimestamp(s.last_timestamp).strftime("%Y-%m-%d")
+    print(f"{s.path} — {s.commits} commits, {s.num_authors} auteur(s), dernier changement {last}")
+    for author, n in s.authors.most_common(8):
+        print(f"  {round(n / total * 100):>3}%  {n:>3} commits  {author}")
+    if s.num_authors == 1:
+        print("  ⚠️ Un seul auteur — risque de bus factor.")
+    return 0
+
+
+def _run_badge(repo: str, args: argparse.Namespace) -> int:
+    commits, stats = _load_stats(repo, args)
+    if not commits:
+        print("error: no commits found.", file=sys.stderr)
+        return 1
+    summary = analyzers.summarize(commits, stats)
+    hotspot_paths = {h.path for h in analyzers.hotspots(stats, limit=15)}
+    trend = analyzers.monthly_trend(commits, hotspot_paths)
+    health = analyzers.health_grade(stats, summary, trend)
+
+    message = f"{health.grade} ({health.score})"
+    static = f"https://img.shields.io/badge/{quote('code health')}-{quote(message)}-{health.color}"
+    print(f"Grade: {health.grade} ({health.score}/100)")
+    for r in health.reasons:
+        print(f"  {r}")
+    print("\nMarkdown (copie dans ton README) :")
+    print(f"![code health]({static})")
+    print("\nJSON (endpoint shields.io, si tu héberges ce fichier) :")
+    print(json.dumps({"schemaVersion": 1, "label": "code health", "message": message, "color": health.color},
+                     ensure_ascii=False))
+    return 0
+
+
+def _force_utf8() -> None:
+    # Windows consoles default to cp1252 and choke on emoji/box-drawing output.
+    for stream in (sys.stdout, sys.stderr):
+        try:
+            stream.reconfigure(encoding="utf-8", errors="replace")
+        except (AttributeError, ValueError):
+            pass
+
+
+def main(argv: list[str] | None = None) -> int:
+    _force_utf8()
+    args = build_parser().parse_args(argv)
+    repo = os.path.abspath(args.repo)
+
+    if not is_git_repo(repo):
+        print(f"error: '{repo}' is not a git repository.", file=sys.stderr)
+        return 2
+
+    if args.who:
+        return _run_who(repo, args)
+    if args.badge:
+        return _run_badge(repo, args)
+    if args.changed:
+        return _run_gate(repo, args)
+    return _run_report(repo, args)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

codepulse/complexity.py

@@ -0,0 +1,39 @@
+"""Language-agnostic complexity estimate.
+
+A proper per-language parser is overkill here; what correlates with bug risk is
+the number of *decision points* in a file (McCabe's cyclomatic complexity is
+essentially ``1 + decisions``). We approximate it by counting branch keywords
+and boolean operators that exist across almost every language.
+
+It is a proxy, not a compiler: it may miscount tokens inside strings or
+comments. That's fine — it's applied consistently to every file, so the
+*ranking* it produces is what matters, and it beats raw line count handily.
+"""
+
+from __future__ import annotations
+
+import re
+
+# Branch keywords shared across C/Java/JS/Python/Rust/Go/Ruby/... plus the
+# boolean operators that add a path. Deliberately excludes the lone "?" (Rust's
+# error-propagation operator would wildly inflate the count) and "=>" (arrow
+# functions in JS are not branches).
+_DECISION = re.compile(
+    r"\b(if|elif|else\s+if|for|foreach|while|case|when|match|switch|catch|rescue|except)\b"
+    r"|&&|\|\|",
+)
+
+
+def measure(data: bytes) -> tuple[int, int]:
+    """Return (lines, complexity) for a file's raw bytes.
+
+    Binary files get complexity == lines (a neutral value) so they never look
+    artificially hot or cold.
+    """
+    if not data:
+        return 0, 1
+    lines = data.count(b"\n") + (0 if data.endswith(b"\n") else 1)
+    if b"\x00" in data[:4096]:  # looks binary — has no meaningful complexity
+        return lines, 1
+    text = data.decode("utf-8", "ignore")
+    return lines, 1 + len(_DECISION.findall(text))

codepulse/git_data.py

@@ -0,0 +1,121 @@
+"""Extract commit history from a git repository.
+
+This module shells out to ``git log`` and parses its output into plain
+dataclasses. It has no third-party dependencies on purpose: anyone with git
+and Python can run CodePulse without installing anything.
+"""
+
+from __future__ import annotations
+
+import subprocess
+from dataclasses import dataclass, field
+
+# Delimiters chosen to be extremely unlikely to appear in commit metadata.
+_UNIT = "\x1f"  # separates fields inside a commit header line
+_REC = "--CP--"  # marks the start of a new commit record
+
+
+@dataclass
+class FileChange:
+    """A single file touched by a commit."""
+
+    path: str
+    added: int
+    deleted: int
+
+
+@dataclass
+class Commit:
+    """One commit and the files it changed."""
+
+    hash: str
+    timestamp: int  # unix seconds (author date)
+    author: str
+    files: list[FileChange] = field(default_factory=list)
+
+
+def _run_git(repo: str, args: list[str]) -> str:
+    result = subprocess.run(
+        ["git", "-C", repo, *args],
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        errors="replace",
+    )
+    if result.returncode != 0:
+        raise RuntimeError(f"git {' '.join(args)} failed: {result.stderr.strip()}")
+    return result.stdout
+
+
+def is_git_repo(repo: str) -> bool:
+    try:
+        return _run_git(repo, ["rev-parse", "--is-inside-work-tree"]).strip() == "true"
+    except Exception:
+        return False
+
+
+def normalize_path(path: str) -> str:
+    """Resolve git rename notation to the current path.
+
+    git numstat can emit renames as ``old => new`` or the compact
+    ``dir/{old => new}/file`` form. We keep the *new* path so history
+    accumulates onto the file as it exists today.
+    """
+    if "=>" in path:
+        if "{" in path and "}" in path:
+            prefix, rest = path.split("{", 1)
+            inner, suffix = rest.split("}", 1)
+            new = inner.split("=>", 1)[1].strip()
+            path = f"{prefix}{new}{suffix}".replace("//", "/")
+        else:
+            path = path.split("=>", 1)[1].strip()
+    return path.strip()
+
+
+def get_changed_files(repo: str, ref_range: str) -> list[str]:
+    """Return files changed for a diff spec.
+
+    Accepts either a range ("main..HEAD", "main...HEAD") or a single ref
+    ("origin/main", "HEAD~5"). A single ref is compared against the current
+    working tree, so uncommitted changes count too — which is what a CI job or
+    a pre-commit check usually wants.
+    """
+    out = _run_git(repo, ["diff", "--name-only", ref_range])
+    return [normalize_path(line) for line in out.splitlines() if line.strip()]
+
+
+def get_commits(repo: str, since: str | None = None, max_count: int | None = None) -> list[Commit]:
+    """Return commits (newest first), excluding merges.
+
+    ``since`` is passed straight to ``git --since`` (e.g. "6 months ago").
+    """
+    fmt = f"{_REC}%H{_UNIT}%at{_UNIT}%aN"
+    args = ["log", "--no-merges", "--numstat", f"--pretty=format:{fmt}"]
+    if since:
+        args.append(f"--since={since}")
+    if max_count:
+        args.append(f"--max-count={max_count}")
+
+    out = _run_git(repo, args)
+    commits: list[Commit] = []
+    current: Commit | None = None
+
+    for line in out.splitlines():
+        if line.startswith(_REC):
+            parts = line[len(_REC):].split(_UNIT)
+            if len(parts) == 3:
+                current = Commit(hash=parts[0], timestamp=int(parts[1]), author=parts[2])
+                commits.append(current)
+            continue
+        if not line.strip() or current is None:
+            continue
+        cols = line.split("\t")
+        if len(cols) != 3:
+            continue
+        added_s, deleted_s, path = cols
+        # Binary files report "-" instead of a count.
+        added = int(added_s) if added_s.isdigit() else 0
+        deleted = int(deleted_s) if deleted_s.isdigit() else 0
+        current.files.append(FileChange(path=normalize_path(path), added=added, deleted=deleted))
+
+    return commits

codepulse/report.py

@@ -0,0 +1,275 @@
+"""Render analysis results as a single self-contained HTML dashboard.
+
+No build step, no CDN: the CSS is inlined so the report opens anywhere and
+survives being emailed around. Colours adapt to light/dark via tokens.
+"""
+
+from __future__ import annotations
+
+import datetime as _dt
+import html
+
+from . import charts
+from .analyzers import CouplingPair, FileStat, StaleFile, Summary, Trend
+
+
+def _esc(value: object) -> str:
+    return html.escape(str(value), quote=True)
+
+
+def _date(ts: int) -> str:
+    if not ts:
+        return "—"
+    return _dt.datetime.fromtimestamp(ts).strftime("%Y-%m-%d")
+
+
+def _bar(value: float, maximum: float) -> str:
+    pct = 0 if maximum <= 0 else max(2, round(value / maximum * 100))
+    return f'<span class="bar" style="width:{pct}%"></span>'
+
+
+def _risk_badge(share: float) -> str:
+    if share >= 0.9:
+        cls, label = "high", "élevé"
+    elif share >= 0.7:
+        cls, label = "mid", "moyen"
+    else:
+        cls, label = "low", "faible"
+    return f'<span class="badge {cls}">{label}</span>'
+
+
+def _trend_section(trend: Trend) -> str:
+    if not trend or not trend.buckets:
+        return ""
+    commits = [(b.label, b.commits) for b in trend.buckets]
+    size = [(b.label, b.cum_net) for b in trend.buckets]
+    pressure = [(b.label, b.hotspot_pct) for b in trend.buckets]
+    grid = (
+        charts.bars(f"Commits par {trend.granularity}", commits, "accent", charts.fmt_int)
+        + charts.line("Taille du code (lignes cumulées)", size, "accent", charts.fmt_int)
+        + charts.line("Pression hotspots (% commits)", pressure, "hot", charts.fmt_pct)
+    )
+    return f"""<section>
+    <h2>📈 Tendance</h2>
+    <p class="hint">L'évolution dans le temps — l'activité, la croissance du code, et surtout si les changements se concentrent sur les fichiers à risque.</p>
+    <p class="verdict">{_esc(trend.verdict)}</p>
+    <div class="trend-grid">{grid}</div>
+  </section>"""
+
+
+def _stale_section(stale: list[StaleFile]) -> str:
+    if not stale:
+        return ""
+    rows = "\n".join(
+        f"""<tr>
+          <td class="path">{_esc(s.path)}</td>
+          <td class="num">{s.complexity:,}</td>
+          <td class="num">{s.days_stale} j</td>
+          <td class="owner">{_esc(s.main_owner[0] or '—')}</td>
+        </tr>"""
+        for s in stale
+    )
+    return f"""<section>
+    <h2>🕸️ Code orphelin</h2>
+    <p class="hint">Fichiers complexes que plus personne n'a touchés depuis longtemps — de la logique qui vieillit et que plus grand monde ne comprend.</p>
+    <table>
+      <thead><tr><th>Fichier</th><th class="num">Complexité</th><th class="num">Sans changement</th><th>Dernier auteur</th></tr></thead>
+      <tbody>{rows}</tbody>
+    </table>
+  </section>"""
+
+
+def render(
+    repo_name: str,
+    summary: Summary,
+    hotspots: list[FileStat],
+    bus_risks: list[FileStat],
+    coupling: list[CouplingPair],
+    trend: Trend | None = None,
+    stale: list[StaleFile] | None = None,
+) -> str:
+    generated = _dt.datetime.now().strftime("%Y-%m-%d %H:%M")
+    span = f"{_date(summary.first_timestamp)} → {_date(summary.last_timestamp)}"
+
+    max_hot = max((h.hotspot_score for h in hotspots), default=1)
+    hot_rows = "\n".join(
+        f"""<tr>
+          <td class="rank">{i}</td>
+          <td class="path">{_esc(h.path)}</td>
+          <td class="num">{h.commits}</td>
+          <td class="num">{h.complexity:,}</td>
+          <td class="score">{_bar(h.hotspot_score, max_hot)}<span class="score-val">{h.hotspot_score:,}</span></td>
+        </tr>"""
+        for i, h in enumerate(hotspots, 1)
+    ) or '<tr><td colspan="5" class="empty">Aucun hotspot détecté.</td></tr>'
+
+    bus_rows = "\n".join(
+        f"""<tr>
+          <td class="path">{_esc(s.path)}</td>
+          <td class="owner">{_esc(s.main_owner[0] or '—')}</td>
+          <td class="num">{s.commits}</td>
+          <td>{_risk_badge(s.main_owner[1])}</td>
+        </tr>"""
+        for s in bus_risks
+    ) or '<tr><td colspan="4" class="empty">Aucun risque de bus factor. 🎉</td></tr>'
+
+    coupling_rows = "\n".join(
+        f"""<tr>
+          <td class="path">{_esc(p.a)}</td>
+          <td class="path">{_esc(p.b)}</td>
+          <td class="num">{p.shared}</td>
+          <td class="num">{round(p.degree * 100)}%</td>
+        </tr>"""
+        for p in coupling
+    ) or '<tr><td colspan="4" class="empty">Aucun couplage significatif.</td></tr>'
+
+    max_contrib = max((n for _, n in summary.top_contributors), default=1)
+    contrib_rows = "\n".join(
+        f"""<li><span class="c-name">{_esc(name)}</span>
+          <span class="c-bar">{_bar(n, max_contrib)}</span>
+          <span class="c-num">{n}</span></li>"""
+        for name, n in summary.top_contributors
+    ) or '<li class="empty">—</li>'
+
+    return _TEMPLATE.format(
+        repo_name=_esc(repo_name),
+        generated=generated,
+        span=span,
+        chart_css=charts.CHART_CSS,
+        trend_section=_trend_section(trend),
+        stale_section=_stale_section(stale or []),
+        total_commits=f"{summary.total_commits:,}",
+        active_files=f"{summary.active_files:,}",
+        tracked_files=f"{summary.tracked_files:,}",
+        contributors=summary.contributors,
+        hot_rows=hot_rows,
+        bus_rows=bus_rows,
+        coupling_rows=coupling_rows,
+        contrib_rows=contrib_rows,
+    )
+
+
+_TEMPLATE = """<!doctype html>
+<html lang="fr">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>CodePulse — {repo_name}</title>
+<style>
+:root {{
+  --bg: #f6f7f9; --panel: #ffffff; --ink: #1a1d21; --muted: #6b7280;
+  --line: #e5e7eb; --accent: #2563eb; --hot: #ef4444; --hot-soft: #fee2e2;
+  --high: #dc2626; --mid: #d97706; --low: #16a34a;
+}}
+@media (prefers-color-scheme: dark) {{
+  :root:not([data-theme="light"]) {{
+    --bg: #0d1117; --panel: #161b22; --ink: #e6edf3; --muted: #8b949e;
+    --line: #30363d; --accent: #58a6ff; --hot: #f85149; --hot-soft: #3d1a1a;
+    --high: #f85149; --mid: #e3b341; --low: #3fb950;
+  }}
+}}
+:root[data-theme="dark"] {{
+  --bg: #0d1117; --panel: #161b22; --ink: #e6edf3; --muted: #8b949e;
+  --line: #30363d; --accent: #58a6ff; --hot: #f85149; --hot-soft: #3d1a1a;
+  --high: #f85149; --mid: #e3b341; --low: #3fb950;
+}}
+* {{ box-sizing: border-box; }}
+body {{
+  margin: 0; background: var(--bg); color: var(--ink);
+  font: 15px/1.5 -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+}}
+.wrap {{ max-width: 960px; margin: 0 auto; padding: 32px 16px 64px; }}
+header {{ margin-bottom: 28px; }}
+.logo {{ font-size: 13px; letter-spacing: .14em; text-transform: uppercase; color: var(--accent); font-weight: 700; }}
+h1 {{ margin: 6px 0 4px; font-size: 26px; }}
+.sub {{ color: var(--muted); font-size: 13px; }}
+.cards {{ display: grid; grid-template-columns: repeat(4, 1fr); gap: 12px; margin: 24px 0 36px; }}
+@media (max-width: 640px) {{ .cards {{ grid-template-columns: repeat(2, 1fr); }} }}
+.card {{ background: var(--panel); border: 1px solid var(--line); border-radius: 12px; padding: 16px; }}
+.card .k {{ font-size: 12px; color: var(--muted); text-transform: uppercase; letter-spacing: .05em; }}
+.card .v {{ font-size: 26px; font-weight: 700; margin-top: 4px; }}
+section {{ background: var(--panel); border: 1px solid var(--line); border-radius: 12px; padding: 20px; margin-bottom: 24px; }}
+section h2 {{ margin: 0 0 4px; font-size: 18px; }}
+section .hint {{ color: var(--muted); font-size: 13px; margin: 0 0 16px; }}
+table {{ width: 100%; border-collapse: collapse; font-size: 14px; }}
+th {{ text-align: left; color: var(--muted); font-weight: 600; font-size: 12px; text-transform: uppercase; letter-spacing: .04em; padding: 6px 8px; border-bottom: 1px solid var(--line); }}
+td {{ padding: 8px; border-bottom: 1px solid var(--line); vertical-align: middle; }}
+tr:last-child td {{ border-bottom: none; }}
+.rank {{ color: var(--muted); width: 28px; }}
+.path {{ font-family: ui-monospace, "Cascadia Code", Consolas, monospace; font-size: 13px; word-break: break-all; }}
+.num {{ text-align: right; font-variant-numeric: tabular-nums; white-space: nowrap; }}
+.score {{ position: relative; min-width: 160px; }}
+.bar {{ display: inline-block; height: 8px; border-radius: 4px; background: var(--hot); vertical-align: middle; }}
+.score-val {{ font-variant-numeric: tabular-nums; color: var(--muted); font-size: 12px; margin-left: 8px; }}
+.owner {{ color: var(--ink); }}
+.badge {{ display: inline-block; padding: 2px 10px; border-radius: 999px; font-size: 12px; font-weight: 600; color: #fff; }}
+.badge.high {{ background: var(--high); }}
+.badge.mid {{ background: var(--mid); }}
+.badge.low {{ background: var(--low); }}
+.empty {{ color: var(--muted); text-align: center; padding: 20px; }}
+ul.contrib {{ list-style: none; margin: 0; padding: 0; }}
+ul.contrib li {{ display: grid; grid-template-columns: 180px 1fr 40px; gap: 10px; align-items: center; padding: 5px 0; }}
+ul.contrib .c-name {{ font-size: 14px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }}
+ul.contrib .c-bar .bar {{ background: var(--accent); }}
+ul.contrib .c-num {{ text-align: right; color: var(--muted); font-variant-numeric: tabular-nums; }}
+footer {{ text-align: center; color: var(--muted); font-size: 12px; margin-top: 32px; }}
+footer a {{ color: var(--accent); text-decoration: none; }}
+{chart_css}
+</style>
+</head>
+<body>
+<div class="wrap">
+  <header>
+    <div class="logo">🩺 CodePulse</div>
+    <h1>{repo_name}</h1>
+    <div class="sub">Analyse générée le {generated} · historique {span}</div>
+  </header>
+
+  <div class="cards">
+    <div class="card"><div class="k">Commits</div><div class="v">{total_commits}</div></div>
+    <div class="card"><div class="k">Fichiers actifs</div><div class="v">{active_files}</div></div>
+    <div class="card"><div class="k">Fichiers suivis</div><div class="v">{tracked_files}</div></div>
+    <div class="card"><div class="k">Contributeurs</div><div class="v">{contributors}</div></div>
+  </div>
+
+  {trend_section}
+
+  <section>
+    <h2>🔥 Hotspots</h2>
+    <p class="hint">Fichiers à la fois complexes (beaucoup de chemins de décision) et souvent modifiés — là où les bugs naissent et où refactorer rapporte le plus.</p>
+    <table>
+      <thead><tr><th></th><th>Fichier</th><th class="num">Commits</th><th class="num">Complexité</th><th>Score (commits × complexité)</th></tr></thead>
+      <tbody>{hot_rows}</tbody>
+    </table>
+  </section>
+
+  <section>
+    <h2>👥 Risque de bus factor</h2>
+    <p class="hint">Fichiers activement maintenus par une seule personne. Si elle part, ce savoir part avec elle.</p>
+    <table>
+      <thead><tr><th>Fichier</th><th>Unique auteur</th><th class="num">Commits</th><th>Risque</th></tr></thead>
+      <tbody>{bus_rows}</tbody>
+    </table>
+  </section>
+
+  <section>
+    <h2>🔗 Couplage caché</h2>
+    <p class="hint">Fichiers qui changent presque toujours ensemble — une dépendance que le code ne montre pas.</p>
+    <table>
+      <thead><tr><th>Fichier A</th><th>Fichier B</th><th class="num">Ensemble</th><th class="num">Degré</th></tr></thead>
+      <tbody>{coupling_rows}</tbody>
+    </table>
+  </section>
+
+  {stale_section}
+
+  <section>
+    <h2>🏆 Top contributeurs</h2>
+    <p class="hint">Par nombre de commits sur la période analysée.</p>
+    <ul class="contrib">{contrib_rows}</ul>
+  </section>
+
+  <footer>Généré par <a href="https://github.com/">CodePulse</a> — la santé de votre code, révélée par son historique.</footer>
+</div>
+</body>
+</html>"""