kiln-cli 0.3.1__py3-none-any.whl

kiln/CHANGELOG.md

@@ -0,0 +1,25 @@
+# Nouveautés de kiln
+
+Une entrée par version, la plus récente en tête : `## vX.Y.Z — date`, puis une ligne par
+changement visible (`- …`), cassants en tête. `kiln update` montre les entrées des versions
+qu'un projet passe ; la skill `base:version` rédige celle de la version qu'elle sort, sur la
+branche `release/vX.Y.Z`, avant sa première candidate.
+
+## v0.3.1 — 2026-10-16
+- **Cassant** : le suivi du travail passe en anglais, `docs/a-faire/` devient `docs/backlog/` (tickets `T-NN`, skill `base:backlog` à la place de `base:a-faire`) ; `kiln update` déplace l'ancien dossier.
+- Numérotation comme Claude Code : en 0.x, chaque version monte le correctif, cassante comprise ; la mineure ne monte que pour une étape (`kiln version --minor`). Une version est promue dès que la suivante est prête en candidate, sans délai d'attente.
+- kiln s'installe depuis PyPI : paquet `kiln-cli` (la commande reste `kiln`), publié au tag de chaque version promue ; `kiln doctor` et `maj-kiln` proposent la mise à jour par là.
+- Nouveaux skills : `report-to-kiln` (un défaut de kiln rencontré dans un repo devient une issue ou une PR, publiée seulement avec l'accord de l'utilisateur), `token` (jeton d'un service dans `.<service>/`, collé sans s'afficher), `contribution` (traiter la PR d'un contributeur extérieur).
+- La CI générée lance gitleaks et peut être appelée par d'autres workflows (`workflow_call`).
+- Status line : quatre styles aux couleurs de kiln, en anglais (`kiln set statusline=…`), nom de session, RAM et cœurs occupés.
+- Correctifs : `kiln doctor` propose la mise à jour au tag de la version, colonne du modèle de `kiln status` assez large.
+
+## v0.3.0 — 2026-10-15
+- Première version publiée. Semver en 0.x : une version sort d'abord en candidate (`-rc.N`) pour les postes au canal `interne`, puis est promue quand la suivante est prête et qu'elle a tenu trois jours ; `kiln version` dit où en sont les candidates.
+- Les projets citent les workflows de kiln au tag exact dont ils partent ; `kiln update` le fait avancer et montre les nouveautés de chaque version passée. Le hook de début de session propose l'outil puis le repo à chaque version.
+- `kiln status` dit de quelle version part chaque repo (`f611f82 → v0.3.0`) ; `kiln set canal=interne` (réglage du poste) fait suivre les candidates.
+- Nouvelle interface : four rieur en bannière, écran d'accueil par sections, roue animée et durée pour chaque commande externe, bilan encadré des étapes ; aucune couleur hors terminal, `KILN_VERBOSE=1` pour la sortie complète.
+- `kiln doctor` : diagnostic du poste et du repo, chaque problème avec la commande qui le corrige.
+- `kiln dev` : sorties des serveurs entrelacées, préfixées par service en couleur.
+- `kiln update --all` fusionne directement chaque repo dont les contrôles passent, sans PR.
+- Backend Java (Maven), skill `maj-kiln`, lien `.claude/kiln` vers le plugin, réglages du poste par `kiln set`.

kiln/__init__.py

@@ -0,0 +1 @@
+"""kiln : génère un projet complet et le tient à jour."""

kiln/backlog.py

@@ -0,0 +1,168 @@
+"""Suivi du travail : passage de l'ancien `docs/a-faire/` (en français) à `docs/backlog/`.
+
+`kiln update` l'appelle après Copier : le modèle a posé un `docs/backlog/` vierge, que le suivi
+du repo remplace, converti (titres, champs et états en anglais, `AF-NN` devenu `T-NN`) ; le
+texte des tickets reste tel qu'écrit. Copier a déjà supprimé `docs/a-faire/`, même modifié :
+son contenu se relit dans le dernier commit (`kiln update` part d'un arbre propre).
+"""
+
+import re
+import shutil
+from pathlib import Path
+
+from kiln.shell import KilnError, capture
+
+LEGACY_DIR = Path("docs/a-faire")
+BACKLOG_DIR = Path("docs/backlog")
+
+STATUSES = (
+    ("à faire", "todo"),
+    ("en cours — branche", "in progress — branch"),
+    ("bloqué — attend", "blocked — waiting for"),
+    ("à vérifier", "to verify"),
+)
+SECTIONS = (
+    ("## 🔴 Critique", "## 🔴 Critical"),
+    ("## 🟠 Important", "## 🟠 Important"),
+    ("## 🟡 Normal", "## 🟡 Normal"),
+    ("## ⚪ Fond", "## ⚪ Background — long-running work, debt and ideas"),
+    ("## ✅ Fait", "## ✅ Done"),
+    ("### Journal", "### Log"),
+)
+REJECTED_HEADINGS = (
+    ("# Écarté", "# Rejected"),
+    ("## Exclu pour de bon", "## Ruled out for good"),
+    ("## Refusé pour cette saison", "## Declined for now"),
+    ("## Sans suite", "## Dropped"),
+)
+LEGACY_INTROS = (
+    "Trois catégories, à ne pas confondre.",
+    "Décisions définitives : à ne pas reproposer, même si un audit le recommande.",
+)
+
+
+def migrate_legacy_backlog(root: Path) -> bool:
+    """Convertit `docs/a-faire/` en `docs/backlog/` s'il existe encore ; dit s'il l'a fait."""
+    old_backlog = read_legacy(root, "a-faire.md")
+    if old_backlog is None:
+        return False
+    backlog = root / BACKLOG_DIR
+    backlog.mkdir(parents=True, exist_ok=True)
+    fresh = backlog / "backlog.md"
+    template_text = fresh.read_text() if fresh.exists() else ""
+    dates = opened(root, (LEGACY_DIR / "a-faire.md").as_posix())
+    fresh.write_text(convert_backlog(old_backlog, template_text, dates))
+    if (rejected := read_legacy(root, "ecarte.md")) is not None:
+        (backlog / "rejected.md").write_text(convert_rejected(rejected))
+    if (urgent := read_legacy(root, "urgent.md")) is not None:
+        urgent_path = backlog / "urgent.md"
+        intro = urgent_path.read_text() if urgent_path.exists() else "# Urgent\n"
+        urgent_path.write_text(convert_urgent(urgent, intro))
+    legacy = root / LEGACY_DIR
+    if legacy.exists():
+        for name in ("a-faire.md", "ecarte.md", "urgent.md", "README.md"):
+            (legacy / name).unlink(missing_ok=True)
+        # Comptes rendus d'audit en cours : ils suivent le suivi.
+        for leftover in legacy.iterdir():
+            shutil.move(leftover, backlog / leftover.name)
+        legacy.rmdir()
+    return True
+
+
+def read_legacy(root: Path, name: str) -> str | None:
+    """Un fichier de l'ancien suivi : sur le disque, sinon dans le dernier commit."""
+    path = root / LEGACY_DIR / name
+    if path.exists():
+        return path.read_text()
+    try:
+        return capture(["git", "show", f"HEAD:{(LEGACY_DIR / name).as_posix()}"], root) + "\n"
+    except KilnError:
+        return None
+
+
+def opened(root: Path, path: str) -> dict[str, str]:
+    """Date d'ouverture de chaque ticket : le premier commit où son titre apparaît."""
+    dates: dict[str, str] = {}
+    try:
+        log = capture(["git", "log", "--reverse", "--format=commit %as", "-p", "--", path], root)
+    except KilnError:
+        return dates
+    day = ""
+    for line in log.splitlines():
+        if line.startswith("commit "):
+            day = line.removeprefix("commit ")
+        elif match := re.match(r"\+### AF-(\d+) ·", line):
+            dates.setdefault(match[1], day)
+    return dates
+
+
+def convert_backlog(text: str, template_text: str, dates: dict[str, str]) -> str:
+    """`a-faire.md` en `backlog.md` : en-tête et mode d'emploi du modèle, tickets convertis."""
+    next_free = re.search(r"Prochain libre : AF-(\d+)", text)
+    compass = re.search(r"La boussole est \*\*(.+?)\*\*", text, re.S)
+    started = re.search(r"Créée le\s+\*\*(.+?)\*\*", text)
+    body = text[text.index("## 🔴") :] if "## 🔴" in text else text
+    body = convert_tickets(body, dates)
+    header = template_text[: template_text.index("## 🔴")] if "## 🔴" in template_text else ""
+    if next_free:
+        header = re.sub(r"Next free: T-\d+", f"Next free: T-{next_free[1]}", header)
+    if compass:
+        header = re.sub(r"North star: \*\*.*?\*\*", f"North star: **{compass[1]}**", header)
+    if started:
+        header = re.sub(r"Started on\s+\*\*.*?\*\*", f"Started on\n**{started[1]}**", header)
+    return header + body
+
+
+def convert_tickets(text: str, dates: dict[str, str]) -> str:
+    lines: list[str] = []
+    ticket = ""
+    for line in text.splitlines():
+        for old, new in SECTIONS:
+            if line.startswith(old):
+                line = new
+        if match := re.match(r"### AF-(\d+) ·", line):
+            ticket = match[1]
+        elif line.startswith("- **État** : "):
+            status = line.removeprefix("- **État** : ")
+            for old, new in STATUSES:
+                if status.startswith(old):
+                    status = new + status.removeprefix(old)
+            status = re.sub(r"depuis le ", "since ", status)
+            lines += ["- **Type**: task", f"- **Status**: {status}"]
+            lines.append(f"- **Opened**: {dates.get(ticket) or '—'}")
+            continue
+        line = line.replace("- **Effort** : ", "- **Effort**: ")
+        line = line.replace(" · **Qui** : ", " · **Owner**: ")
+        line = line.replace(" · **Échéance** : ", " · **Due**: ")
+        line = line.replace("- **Origine** : ", "- **Origin**: ")
+        if line.startswith("Une ligne par entrée terminée"):
+            line = "One line per closed ticket, most recent first:"
+        line = line.replace(
+            "`- **AAAA-MM-JJ** · AF-NN · Titre — ce qui a été fait (branche)`.",
+            "`- **YYYY-MM-DD** · T-NN · Title — what was done (branch) · opened YYYY-MM-DD`.",
+        )
+        lines.append(re.sub(r"\bAF-(\d+|NN)\b", r"T-\1", line))
+    return "\n".join(lines) + "\n"
+
+
+def convert_rejected(text: str) -> str:
+    lines = []
+    for line in text.splitlines():
+        for old, new in REJECTED_HEADINGS:
+            if line == old:
+                line = new
+        if line == LEGACY_INTROS[0]:
+            line = "Three kinds, not to be confused."
+        elif line == LEGACY_INTROS[1]:
+            line = "Final decisions: do not propose them again, even if an audit recommends it."
+        lines.append(re.sub(r"\bAF-(\d+)\b", r"T-\1", line))
+    return "\n".join(lines) + "\n"
+
+
+def convert_urgent(text: str, intro: str) -> str:
+    """Les cases d'`urgent.md` sous l'introduction du modèle, en anglais."""
+    lines = text.splitlines()
+    first_box = next((i for i, line in enumerate(lines) if line.startswith("- [")), len(lines))
+    boxes = "\n".join(lines[first_box:]).strip("\n")
+    body = intro.rstrip("\n") + "\n"
+    return body + f"\n{boxes}\n" if boxes else body

kiln/banner.py

@@ -0,0 +1,125 @@
+"""Bannière des commandes longues (`new`, `install`, `update`, `status`) et écran d'accueil.
+
+Un four rieur en pixel art (pierre et feu), dessiné en demi-blocs (deux pixels par caractère),
+à côté de la version de kiln, de la commande lancée, du projet et de son dossier.
+Hors terminal, ou avec `NO_COLOR`, une seule ligne sans dessin : les journaux et les sorties
+capturées restent lisibles.
+"""
+
+from collections.abc import Sequence
+from pathlib import Path
+
+from kiln import ui
+from kiln.shell import KilnError
+from kiln.stack import NO_FRAMEWORK, answers_if_any, load_stack
+from kiln.versions import installed_version
+
+# Un caractère = deux pixels superposés. L pierre éclairée, B pierre, b pierre dans l'ombre,
+# d socle et chapeau de brique, W/K yeux, P joues, R/F/Y flamme (bord, corps, cœur), . vide.
+LOGO = (
+    "..........dd..",
+    "...LLLBBB.bb..",
+    "..LWKBBWKBbb..",
+    ".LLWKBBWKBBbb.",
+    ".LBP.RR..PBbb.",
+    ".LBB.RFR..Bbb.",
+    ".BBB.FYYF.bbb.",
+    "dddddddddddddd",
+)
+LOGO_COLORS = {
+    "L": ui.STONE_LIGHT,
+    "B": ui.STONE,
+    "b": ui.STONE_DARK,
+    "d": ui.BRICK,
+    "W": ui.WHITE,
+    "K": ui.SOOT,
+    "P": ui.CHEEK,
+    "R": ui.EMBER,
+    "F": ui.FIRE,
+    "Y": ui.GLOW,
+}
+EMPTY = "."
+UPPER_HALF, LOWER_HALF, FULL_BLOCK = "▀", "▄", "█"
+LOGO_MARGIN, TEXT_GAP, INDENT = "  ", "   ", "  "
+REPO_URL = "github.com/antoine-tena/kiln"
+
+# Écran d'accueil : sections de commandes (nom, rôle) et exemples.
+CommandGroup = tuple[str, Sequence[tuple[str, str]]]
+
+
+def show_banner(action: str, root: Path | None = None) -> None:
+    """Affiche la bannière ; `root` : le repo concerné, sinon le dossier courant sans projet."""
+    kiln_version = installed_version()
+    details = [action, *([_project_summary(root)] if root is not None else [])]
+    location = _home_relative(root or Path.cwd())
+    if not ui.is_styled():
+        print(" · ".join([f"kiln {kiln_version}", *details, location]), flush=True)
+        return
+    text_lines = [
+        "",
+        f"{ui.paint('kiln', bold=True)} {ui.paint(kiln_version, ui.STONE)}",
+        ui.paint(" · ".join(details), ui.FIRE),
+        ui.paint(location, ui.STONE),
+    ]
+    print()
+    for logo_line, text_line in zip(render_logo(), text_lines, strict=True):
+        print(f"{LOGO_MARGIN}{logo_line}{TEXT_GAP}{text_line}".rstrip())
+    print(flush=True)
+
+
+def show_home(groups: Sequence[CommandGroup], examples: Sequence[str]) -> None:
+    """`kiln` seul ou `kiln --help` : bannière, commandes par section, exemples."""
+    show_banner("atelier de Claude Code")
+    width = max(len(name) for _, commands in groups for name, _ in commands) + 3
+    usage = ui.paint("<commande> [options]", ui.STONE)
+    print(f"{INDENT}{ui.paint('Usage', bold=True)}  kiln {usage}")
+    for title, commands in groups:
+        print(f"\n{INDENT}{ui.paint(title.upper(), ui.FIRE, bold=True)}")
+        for name, role in commands:
+            print(f"{INDENT}  {ui.paint(f'{name:<{width}}', ui.STONE_LIGHT, bold=True)}{role}")
+    print(f"\n{INDENT}{ui.paint('EXEMPLES', ui.FIRE, bold=True)}")
+    for example in examples:
+        print(f"{INDENT}  {ui.paint('$', ui.STONE_DARK)} {example}")
+    print(
+        f"\n{INDENT}{ui.paint('kiln <commande> --help', bold=True)}"
+        f"{ui.paint(f' pour les options · {REPO_URL}', ui.STONE)}\n"
+    )
+
+
+def render_logo() -> list[str]:
+    def cell(top: str, bottom: str) -> str:
+        if top == EMPTY and bottom == EMPTY:
+            return " "
+        if bottom == EMPTY:
+            return f"{ui.foreground(LOGO_COLORS[top])}{UPPER_HALF}{ui.RESET}"
+        if top == EMPTY:
+            return f"{ui.foreground(LOGO_COLORS[bottom])}{LOWER_HALF}{ui.RESET}"
+        if top == bottom:
+            return f"{ui.foreground(LOGO_COLORS[top])}{FULL_BLOCK}{ui.RESET}"
+        colors = ui.foreground(LOGO_COLORS[top]) + ui.background(LOGO_COLORS[bottom])
+        return f"{colors}{UPPER_HALF}{ui.RESET}"
+
+    return [
+        "".join(cell(top, bottom) for top, bottom in zip(top_row, bottom_row, strict=True))
+        for top_row, bottom_row in zip(LOGO[0::2], LOGO[1::2], strict=True)
+    ]
+
+
+def _project_summary(root: Path) -> str:
+    """Nom du projet, envergure et frameworks : `annski · flame · django + nuxt, podman`."""
+    try:
+        answers = answers_if_any(root)
+        stack = load_stack(root)
+    except KilnError, OSError, ValueError:
+        return root.name
+    frameworks = [name for name in (stack.backend, stack.frontend) if name != NO_FRAMEWORK]
+    pile = " + ".join(frameworks) + (", podman" if stack.has_podman else "")
+    parts = [str(answers.get("nom", root.name)), str(answers.get("envergure", "")), pile]
+    return " · ".join(part for part in parts if part)
+
+
+def _home_relative(path: Path) -> str:
+    try:
+        return f"~/{path.relative_to(Path.home())}"
+    except ValueError:
+        return str(path)

kiln/charte/__init__.py

@@ -0,0 +1 @@
+"""Moteur de charte : vérifie un repo contre les règles de son charte.toml."""

kiln/charte/charte.py

@@ -0,0 +1,160 @@
+#!/usr/bin/env python3
+"""charte — vérifie un repo contre les règles de sa charte (CLAUDE.md), décrites dans le
+`charte.toml` de sa racine. Installée avec kiln, à côté de la commande `kiln`.
+
+Une charte que rien n'exécute décrit un projet qui n'existe pas. Deux régimes, parce qu'un
+contrôle qui échoue sur 47 fichiers dès le premier jour finit désactivé :
+
+- **interdiction** (`[interdictions.<nom>]`) : la règle est respectée partout, toute
+  réintroduction échoue ;
+- **cliquet** (`[cliquets.<nom>]`, `budget`) : la règle a un passif, le nombre courant devient
+  un plafond. Le contrôle échoue si le passif augmente, et signale s'il diminue — le budget
+  doit alors être abaissé dans charte.toml, ce qui rend la dette impossible à reprendre.
+  Un **plancher** (`[planchers.<nom>]`, `plancher`) est le cliquet inverse.
+
+Le nom d'une section est celui de la règle (voir interdictions.py et cliquets.py) ; une clé
+`regle` permet d'en déclarer plusieurs du même type. `regles_locales` : modules Python du
+repo, chacun avec une fonction `verifier(depot, params) -> list[str]`, pour ses règles propres.
+
+Usage : charte [verifier]   règles de la charte (défaut)
+        charte types        typage mypy en cliquet ([types])
+        charte couverture   planchers de couverture du backend ([couverture])
+        charte --detail     valeur de chaque cliquet et plancher, sans juger
+Sortie non nulle si une règle est enfreinte.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import subprocess
+import sys
+import tomllib
+from collections.abc import Callable
+from pathlib import Path
+
+from kiln.charte.cliquets import COMPTEURS
+from kiln.charte.interdictions import REGLES
+from kiln.charte.moteur import Depot, Params, echec
+from kiln.charte.outils_python import couverture, types
+
+# Règle propre au repo : `verifier(depot, params)` renvoie ses échecs.
+RegleLocale = Callable[[Depot, Params], list[str]]
+
+FIN_RAPPORT = "Règles de CLAUDE.md non vérifiées"
+
+
+def charger() -> Depot:
+    racine = subprocess.run(
+        ["git", "rev-parse", "--show-toplevel"], capture_output=True, text=True
+    ).stdout.strip()
+    config = Path(racine or ".") / "charte.toml"
+    if not config.exists():
+        sys.exit(f"charte : pas de charte.toml à la racine du repo ({config.parent}).")
+    return Depot(config.parent, tomllib.loads(config.read_text("utf-8")))
+
+
+def _regles_locales(depot: Depot) -> list[RegleLocale]:
+    fonctions: list[RegleLocale] = []
+    for chemin in depot.config.get("regles_locales", []):
+        spec = importlib.util.spec_from_file_location(Path(chemin).stem, depot.racine / chemin)
+        if spec is None or spec.loader is None:
+            raise SystemExit(f"charte : règle locale illisible : {chemin}")
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+        fonctions.append(module.verifier)
+    return fonctions
+
+
+def _regles_non_verifiees(depot: Depot) -> None:
+    fichier = depot.config.get("regles_non_verifiees")
+    if not fichier:
+        return
+    regles = [
+        r
+        for r in (depot.racine / fichier).read_text("utf-8").splitlines()
+        if r and not r.startswith("#")
+    ]
+    print(f"\n{FIN_RAPPORT} par ce script (à appliquer ou à amender) :")
+    print("\n".join(f"  - {r}" for r in regles))
+
+
+def mesures(depot: Depot, section: str) -> list[tuple[str, Params, int, list[str]]]:
+    sortie = []
+    for nom, p in depot.config.get(section, {}).items():
+        valeur, detail = COMPTEURS[p.get("regle", nom)](depot, p)
+        sortie.append((nom, p, valeur, detail))
+    return sortie
+
+
+def verifier(depot: Depot) -> int:
+    problemes: list[str] = []
+    for nom, p in depot.config.get("interdictions", {}).items():
+        problemes.extend(REGLES[p.get("regle", nom)](depot, p))
+    for fonction in _regles_locales(depot):
+        problemes.extend(fonction(depot, {}))
+
+    a_resserrer = []
+    for nom, p, valeur, detail in mesures(depot, "cliquets"):
+        budget = p["budget"]
+        if valeur > budget:
+            message = (
+                f"{p.get('message', nom)} : {valeur} infractions, plafond {budget}. "
+                f"{valeur - budget} de plus qu'au dernier abaissement."
+            )
+            problemes.append(echec(p.get("id", "CLIQUET"), message, detail))
+        elif valeur < budget:
+            a_resserrer.append(
+                f"  {nom} : {valeur} < {budget} — abaisser `budget` de [cliquets.{nom}] "
+                f"à {valeur} (charte.toml)."
+            )
+    for nom, p, valeur, detail in mesures(depot, "planchers"):
+        plancher = p["plancher"]
+        if valeur < plancher:
+            message = (
+                f"{p.get('message', nom)} : {valeur}, plancher {plancher}. La valeur a baissé."
+            )
+            problemes.append(echec(p.get("id", "PLANCHER"), message, detail))
+        elif valeur > plancher:
+            a_resserrer.append(
+                f"  {nom} : {valeur} > {plancher} — relever `plancher` de [planchers.{nom}] "
+                f"à {valeur} (charte.toml)."
+            )
+
+    if a_resserrer:
+        print("Dette réduite, budgets à resserrer (le contrôle reste vert) :")
+        print("\n".join(a_resserrer))
+        print()
+    if problemes:
+        print("Violations de CLAUDE.md :\n")
+        print("\n\n".join(problemes))
+        print("\nLa charte est la norme du dépôt. Corriger, ou l'amender explicitement.")
+        _regles_non_verifiees(depot)
+        return 1
+    print("Règles contrôlées de CLAUDE.md : aucune violation, aucun cliquet dépassé.")
+    _regles_non_verifiees(depot)
+    return 0
+
+
+def detail(depot: Depot) -> int:
+    for section in ("cliquets", "planchers"):
+        for nom, p, valeur, _ in mesures(depot, section):
+            print(f"{section}.{nom} = {valeur} (seuil {p.get('budget', p.get('plancher'))})")
+    return 0
+
+
+def main() -> int:
+    commande = sys.argv[1] if len(sys.argv) > 1 else "verifier"
+    depot = charger()
+    actions = {"verifier": verifier, "types": types, "couverture": couverture, "--detail": detail}
+    if commande not in actions:
+        sys.exit(__doc__)
+    return actions[commande](depot)
+
+
+def lancer() -> None:
+    """Point d'entrée de la commande `charte` installée avec kiln."""
+    sys.exit(main())
+
+
+if __name__ == "__main__":
+    lancer()

kiln/charte/cliquets.py

@@ -0,0 +1,108 @@
+"""Compteurs des cliquets (`[cliquets.<nom>]`, plafond `budget` qui ne fait que baisser) et des
+planchers (`[planchers.<nom>]`, valeur `plancher` qui ne fait que monter).
+
+Chaque compteur reçoit le dépôt et ses paramètres et renvoie (valeur, détail).
+"""
+
+from __future__ import annotations
+
+import ast
+import re
+
+from kiln.charte.moteur import Depot, Params, hors_tests
+
+
+def taille_fichier(depot: Depot, p: Params) -> tuple[int, list[str]]:
+    """`max_lignes` (300) lignes au plus par fichier ; les fichiers engendrés ne comptent pas."""
+    suffixes = set(p.get("suffixes", [".py", ".ts", ".vue", ".css", ".mjs"]))
+    plafond = p.get("max_lignes", 300)
+    fautifs = []
+    for f in depot.suivis(p["fichiers"]):
+        if f.suffix not in suffixes or depot.engendre(f):
+            continue
+        n = len(f.read_text("utf-8").splitlines())
+        if n > plafond:
+            fautifs.append(f"{n:5d}  {depot.rel(f)}")
+    return len(fautifs), sorted(fautifs, reverse=True)
+
+
+def routes_longues(depot: Depot, p: Params) -> tuple[int, list[str]]:
+    """Vues de plus de `max_lignes` (15) lignes, repérées par leur décorateur (`decorateur`,
+    regex ; par défaut celui de django-ninja)."""
+    decorateur = re.compile(p.get("decorateur", r"\s*@(api|router)\.(get|post|put|patch|delete)"))
+    plafond = p.get("max_lignes", 15)
+    fautifs = []
+    for f in depot.suivis(p.get("fichiers", ["backend/*/api/*.py", "backend/*/api.py"])):
+        lignes = f.read_text("utf-8").splitlines()
+        for i, ligne in enumerate(lignes):
+            if not decorateur.match(ligne):
+                continue
+            j = i
+            while j < len(lignes) and not re.match(r"\s*def ", lignes[j]):
+                j += 1
+            if j >= len(lignes):
+                continue
+            retrait = len(lignes[j]) - len(lignes[j].lstrip())
+            k = j + 1
+            while k < len(lignes) and not (
+                lignes[k].strip() and len(lignes[k]) - len(lignes[k].lstrip()) <= retrait
+            ):
+                k += 1
+            if k - j > plafond:
+                fautifs.append(f"{k - j:5d}  {depot.rel(f)}:{j + 1}  {lignes[j].strip()[:60]}")
+    return len(fautifs), sorted(fautifs, reverse=True)
+
+
+def verrous_django(depot: Depot, p: Params) -> tuple[int, list[str]]:
+    """`select_for_update` sans `nowait`/`skip_locked` ni justification « # Verrou bloquant : »
+    dans les 8 lignes au-dessus. Analyse syntaxique : une docstring n'est pas un verrou."""
+    fautifs = []
+    for f in hors_tests(depot.suivis(p.get("fichiers", ["backend/*.py", "backend/**/*.py"]))):
+        texte = f.read_text("utf-8")
+        lignes = texte.splitlines()
+        for n in ast.walk(ast.parse(texte)):
+            if not (isinstance(n, ast.Call) and getattr(n.func, "attr", "") == "select_for_update"):
+                continue
+            garde = any(k.arg in {"nowait", "skip_locked"} for k in n.keywords)
+            au_dessus = "\n".join(lignes[max(0, n.lineno - 9) : n.lineno])
+            if not garde and not re.search(r"#\s*Verrou bloquant\s*:", au_dessus):
+                fautifs.append(f"{depot.rel(f)}:{n.lineno}")
+    return len(fautifs), fautifs
+
+
+def occurrences(depot: Depot, p: Params) -> tuple[int, list[str]]:
+    """Nombre d'occurrences d'un texte (`motif`, littéral) dans des fichiers : par exemple
+    `timezone.now()` dans les tests, où l'horloge doit être figée."""
+    fautifs = []
+    for f in depot.suivis(p["fichiers"]):
+        n = f.read_text("utf-8").count(p["motif"])
+        if n:
+            fautifs.append(f"{n:4d}  {depot.rel(f)}")
+    return sum(int(o.split()[0]) for o in fautifs), sorted(fautifs, reverse=True)
+
+
+def densite_tests(depot: Depot, p: Params) -> tuple[int, list[str]]:
+    """Lignes de test pour mille lignes de code (fichiers engendrés exclus). Les fichiers de
+    test finissent par un des `suffixes_tests`."""
+    suffixes = set(p.get("suffixes", [".ts", ".vue", ".mjs"]))
+    tests_fin = tuple(p.get("suffixes_tests", [".spec.ts", ".nuxt.spec.ts"]))
+    code = tests = 0
+    for f in depot.suivis(p["fichiers"]):
+        if f.suffix not in suffixes or depot.engendre(f):
+            continue
+        n = len(f.read_text("utf-8").splitlines())
+        if f.name.endswith(tests_fin):
+            tests += n
+        else:
+            code += n
+    ratio = round(1000 * tests / code) if code else 0
+    return ratio, [f"{tests} lignes de test pour {code} lignes de code ({ratio}/1000)"]
+
+
+COMPTEURS = {
+    "taille-fichier": taille_fichier,
+    "routes-longues": routes_longues,
+    "verrous-django": verrous_django,
+    "occurrences": occurrences,
+    "densite-tests": densite_tests,
+}