cli(workflows): générer le HTML automatiquement (Phase 4.5 chantier post-rewrite)

Avant : les commandes ``picarones diagnose``/``economics``/``edition``
écrivaient un JSON mais l'utilisateur devait relancer manuellement
``picarones report --results foo.json`` pour obtenir le rapport HTML —
alors que les docstrings vendent justement les vues HTML correspondantes
(« Diagnostic approfondi », « Coût et performance », « Taxonomie avancée »).
Symptôme classique d'UX post-rewrite : la pipeline JSON était portée mais
le HTML automatique avait été oublié.

Modifications :
- ``_run_workflow`` accepte ``generate_html: bool = True`` et ``html_lang``.
Après écriture du JSON, instancie ``ReportGenerator`` directement sur le
``BenchmarkResult`` in-memory et écrit le HTML à côté
(``results.json`` → ``results.html`` via ``_html_path_from_json``).
- Échec HTML → warning stderr, pas exit code 1 : le JSON est déjà écrit
et l'utilisateur peut retenter avec ``picarones report``.
- Nouvelles options ``--no-html`` (CI/scripts) et ``--html-lang fr|en``
sur ``diagnose``, ``economics``, ``edition``.

Tests : ``TestCliWorkflows.test_command_exposes_html_options`` (paramétré
sur les 3 commandes) + ``test_run_workflow_generates_html_by_default``
(vérification statique du default ``generate_html=True``).

https://claude.ai/code/session_01ArfZ8kcgv7Cyda7VbJVmpn

picarones/interfaces/cli/_workflows.py

@@ -205,6 +205,20 @@ def run_cmd(
 # L'option ``--profile`` reste disponible mais le défaut change pour
 # chaque commande.
 
+def _html_path_from_json(json_path: str) -> str:
+    """Convertit un chemin ``results.json`` en chemin ``results.html``.
+
+    Utilisé par les workflows pour générer automatiquement le rapport
+    HTML à côté du JSON (Phase 4.5 du chantier post-rewrite — auparavant
+    chaque workflow imprimait juste le chemin JSON et l'utilisateur
+    devait relancer ``picarones report --results …`` manuellement,
+    contre-intuitif vu que le workflow vendait un livrable HTML).
+    """
+    from pathlib import Path
+    p = Path(json_path)
+    return str(p.with_suffix(".html"))
+
+
 def _run_workflow(
     *,
     corpus: str,
@@ -216,14 +230,25 @@ def _run_workflow(
     verbose: bool,
     profile: str,
     workflow_label: str,
+    generate_html: bool = True,
+    html_lang: str = "fr",
 ) -> None:
     """Implémentation commune des commandes ``run``, ``diagnose``,
     ``economics`` et ``edition``.
 
     Les 4 commandes partagent le squelette : chargement corpus →
     instanciation moteurs → ``run_benchmark_via_service(profile=...)`` → affichage
-    classement.  Seul le profil par défaut et le message d'en-tête
-    diffèrent.
+    classement → génération automatique du rapport HTML.  Seul le profil
+    par défaut et le message d'en-tête diffèrent.
+
+    Phase 4.5 du chantier post-rewrite : ``generate_html=True`` par
+    défaut.  Auparavant les workflows ne produisaient que du JSON, ce
+    qui forçait l'utilisateur à ré-exécuter ``picarones report``
+    manuellement — contre-intuitif (les docstrings vendaient une vue
+    HTML "Diagnostic", "Coût et performance", "Taxonomie avancée"
+    qui n'était jamais générée).  Passer ``generate_html=False``
+    permet de désactiver pour les usages CI/scripts qui ne veulent
+    que le JSON.
     """
     _setup_logging(verbose)
 
@@ -281,7 +306,25 @@ def _run_workflow(
             f"CER={cer_pct:<8} WER={wer_pct}{failed_str}"
         )
 
-    click.echo(f"\nRésultats écrits dans : {output}")
+    click.echo(f"\nRésultats JSON écrits dans : {output}")
+
+    if generate_html:
+        html_output = _html_path_from_json(output)
+        try:
+            from picarones.reports.html.generator import ReportGenerator
+            gen = ReportGenerator(result, lang=html_lang)
+            gen.generate(html_output)
+            click.echo(f"Rapport HTML généré    : {html_output}")
+        except Exception as exc:  # noqa: BLE001
+            # Le JSON est déjà écrit ; on logue l'échec HTML sans
+            # quitter avec un code d'erreur (l'utilisateur peut
+            # relancer ``picarones report`` manuellement).
+            click.echo(
+                f"Avertissement : génération HTML échouée ({exc}).  "
+                f"Relancer ``picarones report --results {output}`` "
+                "pour réessayer.",
+                err=True,
+            )
 
 
 @cli.command("diagnose")
@@ -307,9 +350,14 @@ def _run_workflow(
               help="Désactive la barre de progression")
 @click.option("--verbose", "-v", is_flag=True, default=False,
               help="Mode verbeux")
+@click.option("--no-html", is_flag=True, default=False,
+              help="N'écrit que le JSON, pas le rapport HTML")
+@click.option("--html-lang", default="fr", show_default=True,
+              type=click.Choice(["fr", "en"]),
+              help="Langue du rapport HTML")
 def diagnose_cmd(
     corpus: str, engines: str, output: str, lang: str, psm: int,
-    no_progress: bool, verbose: bool,
+    no_progress: bool, verbose: bool, no_html: bool, html_lang: str,
 ) -> None:
     """Workflow diagnostic : bench + leviers d'amélioration + image_predictive.
 
@@ -318,6 +366,9 @@ def diagnose_cmd(
     (chantier 3) : leviers, profil d'image, baseline, longitudinal.
     Idéal pour comprendre *pourquoi* un moteur produit ces résultats
     sur ce corpus, pas seulement *quel CER*.
+
+    Phase 4.5 du chantier post-rewrite : génère désormais le HTML
+    automatiquement à côté du JSON (``--no-html`` pour skipper).
     """
     _run_workflow(
         corpus=corpus, engines=engines, output=output,
@@ -325,6 +376,8 @@ def diagnose_cmd(
         no_progress=no_progress, verbose=verbose,
         profile="diagnostics",
         workflow_label="diagnose",
+        generate_html=not no_html,
+        html_lang=html_lang,
     )
 
 
@@ -351,9 +404,14 @@ def diagnose_cmd(
               help="Désactive la barre de progression")
 @click.option("--verbose", "-v", is_flag=True, default=False,
               help="Mode verbeux")
+@click.option("--no-html", is_flag=True, default=False,
+              help="N'écrit que le JSON, pas le rapport HTML")
+@click.option("--html-lang", default="fr", show_default=True,
+              type=click.Choice(["fr", "en"]),
+              help="Langue du rapport HTML")
 def economics_cmd(
     corpus: str, engines: str, output: str, lang: str, psm: int,
-    no_progress: bool, verbose: bool,
+    no_progress: bool, verbose: bool, no_html: bool, html_lang: str,
 ) -> None:
     """Workflow économique : bench + throughput effectif + (cost projection).
 
@@ -361,7 +419,8 @@ def economics_cmd(
     les métriques de décision budget : pages/h utilisable (intégrant
     la correction humaine HTR-United à 5 s/erreur), coût marginal par
     erreur évitée. La vue HTML « Coût et performance » (chantier 3)
-    est ensuite branchée.
+    est désormais générée automatiquement (Phase 4.5 chantier
+    post-rewrite — ``--no-html`` pour skipper).
     """
     _run_workflow(
         corpus=corpus, engines=engines, output=output,
@@ -369,6 +428,8 @@ def economics_cmd(
         no_progress=no_progress, verbose=verbose,
         profile="economics",
         workflow_label="economics",
+        generate_html=not no_html,
+        html_lang=html_lang,
     )
 
 
@@ -395,9 +456,14 @@ def economics_cmd(
               help="Désactive la barre de progression")
 @click.option("--verbose", "-v", is_flag=True, default=False,
               help="Mode verbeux")
+@click.option("--no-html", is_flag=True, default=False,
+              help="N'écrit que le JSON, pas le rapport HTML")
+@click.option("--html-lang", default="fr", show_default=True,
+              type=click.Choice(["fr", "en"]),
+              help="Langue du rapport HTML")
 def edition_cmd(
     corpus: str, engines: str, output: str, lang: str, psm: int,
-    no_progress: bool, verbose: bool,
+    no_progress: bool, verbose: bool, no_html: bool, html_lang: str,
 ) -> None:
     """Workflow édition critique : bench + métriques philologiques.
 
@@ -407,6 +473,9 @@ def edition_cmd(
     vue HTML « Taxonomie avancée » (chantier 3) avec comparaison
     miroir leader vs runner-up. Cible : éditeurs de chartes,
     paléographes, archivistes.
+
+    Phase 4.5 du chantier post-rewrite : génère le HTML
+    automatiquement (``--no-html`` pour skipper).
     """
     _run_workflow(
         corpus=corpus, engines=engines, output=output,
@@ -414,6 +483,8 @@ def edition_cmd(
         no_progress=no_progress, verbose=verbose,
         profile="philological",
         workflow_label="edition",
+        generate_html=not no_html,
+        html_lang=html_lang,
     )
 
 

tests/integration/test_chantier4.py

@@ -280,3 +280,60 @@ class TestCliWorkflows:
         assert result.exit_code == 0, result.output
         assert "--corpus" in result.output
         assert "--engines" in result.output
+
+    @pytest.mark.parametrize("cmd_name", ["diagnose", "economics", "edition"])
+    def test_command_exposes_html_options(self, cmd_name):
+        """Phase 4.5 du chantier post-rewrite : les 3 workflows
+        génèrent le HTML automatiquement à côté du JSON ; les options
+        ``--no-html`` (skip HTML pour CI/scripts) et ``--html-lang``
+        (fr/en) doivent être visibles dans ``--help``."""
+        try:
+            from click.testing import CliRunner
+
+            from picarones.interfaces.cli import cli as cli_group
+        except ImportError:
+            pytest.skip("click non installé")
+
+        runner = CliRunner()
+        result = runner.invoke(cli_group, [cmd_name, "--help"])
+        assert result.exit_code == 0, result.output
+        assert "--no-html" in result.output, (
+            f"{cmd_name} doit exposer --no-html (Phase 4.5)"
+        )
+        assert "--html-lang" in result.output, (
+            f"{cmd_name} doit exposer --html-lang (Phase 4.5)"
+        )
+
+    def test_run_workflow_generates_html_by_default(self):
+        """``_run_workflow(..., generate_html=True)`` doit appeler
+        ``ReportGenerator`` avec un path dérivé du JSON output."""
+        from pathlib import Path
+        import ast
+
+        cli_src = (
+            Path(__file__).parent.parent.parent
+            / "picarones" / "interfaces" / "cli" / "_workflows.py"
+        ).read_text(encoding="utf-8")
+        # Vérifications statiques.
+        assert "_html_path_from_json" in cli_src, (
+            "Le helper _html_path_from_json doit dériver "
+            "results.json → results.html"
+        )
+        assert "ReportGenerator" in cli_src, (
+            "Le workflow doit instancier ReportGenerator pour le HTML"
+        )
+        # Le default est ``generate_html=True``.
+        tree = ast.parse(cli_src)
+        for node in ast.walk(tree):
+            if isinstance(node, ast.FunctionDef) and node.name == "_run_workflow":
+                kwarg_defaults = node.args.kw_defaults
+                kwarg_names = [a.arg for a in node.args.kwonlyargs]
+                idx = kwarg_names.index("generate_html")
+                default = kwarg_defaults[idx]
+                assert isinstance(default, ast.Constant)
+                assert default.value is True, (
+                    "generate_html doit être True par défaut "
+                    "(Phase 4.5)"
+                )
+                return
+        raise AssertionError("_run_workflow introuvable")