@mostajs/mjs-unit 0.9.0 → 0.11.0

package/README.md

@@ -115,6 +115,54 @@ Le compte rendu lie les résultats à la version (lue dans la SBOM), au plan et
 est `conforme`, `non conforme` ou `incomplet` (avec les défauts) ; il s'écrit toujours. qatrax.dev l'enregistre, le
 relie à l'analyse des vulnérabilités de la même SBOM, et scelle le dossier.
 
+## Java, C#, Python, Go, C++… — le mode lecteur (0.10.0)
+
+Vos essais restent joués par l'outil de votre langage ; mjs-unit **lit** leur rapport et produit le même compte
+rendu scellé (lié à la SBOM et au plan), avec CTRF et in-toto. Node ≥ 18 suffit dans la CI ; aucun JavaScript à écrire.
+
+**Formats lus tels quels, reconnus à leur contenu** : JUnit XML · NUnit 2 et 3 · TRX (VSTest) · TestNG natif ·
+Robot Framework (`output.xml`) · CTest (`Test.xml`) · Cucumber JSON · Behave JSON · Allure 2 (`allure-results`) ·
+CTRF · TAP · JSON mjs-unit. Votre rapport natif suffit : aucune conversion.
+
+| Langage | Rapport | Commande |
+|---|---|---|
+| Java (Maven) | `target/surefire-reports/TEST-*.xml` | `npx @mostajs/mjs-unit --depuis=target/surefire-reports --sbom=target/bom.json --plan=plan.json --compte-rendu` |
+| Java (Gradle) | `build/test-results/test/TEST-*.xml` | `npx @mostajs/mjs-unit --depuis=build/test-results/test …` |
+| C# (.NET) | `dotnet test --logger "junit;LogFilePath=resultats.xml"` | `npx @mostajs/mjs-unit --depuis=resultats.xml …` |
+| Python | `pytest --junitxml=resultats.xml` | `npx @mostajs/mjs-unit --depuis=resultats.xml …` |
+| Go | `go test -v ./... 2>&1 \| go-junit-report > resultats.xml` | `npx @mostajs/mjs-unit --depuis=resultats.xml …` |
+| C# (NUnit) | `TestResult.xml` (nunit3-console) | `npx @mostajs/mjs-unit --depuis=TestResult.xml …` |
+| C# (TRX) | `dotnet test --logger trx` → `TestResults/*.trx` | `npx @mostajs/mjs-unit --depuis=TestResults …` |
+| Java (TestNG) | `target/surefire-reports/testng-results.xml` | `npx @mostajs/mjs-unit --depuis=target/surefire-reports/testng-results.xml …` |
+| Robot Framework | `output.xml` | `npx @mostajs/mjs-unit --depuis=output.xml …` |
+| C/C++ (CTest) | `ctest -T Test` → `Testing/<date>/Test.xml` | `npx @mostajs/mjs-unit --depuis Testing/*/Test.xml …` |
+| BDD (Cucumber) | `--format json:cucumber.json` (JS, JVM, Ruby) | `npx @mostajs/mjs-unit --depuis=cucumber.json …` |
+| BDD (Behave) | `behave -f json -o behave.json` | `npx @mostajs/mjs-unit --depuis=behave.json …` |
+| Allure (tout langage) | `allure-results/` | `npx @mostajs/mjs-unit --depuis=allure-results …` (conteneurs et pièces jointes écartés ; un essai rejoué : le dernier fait foi) |
+
+Nommez vos essais d'après le plan : `test_T_MOD_01_…` est rattaché à `T-MOD-01`. En BDD, Robot ou Allure, une
+**étiquette** égale à la référence suffit (`@T-MOD-01`). Avec le menu :
+`MJS_DEPUIS=target/surefire-reports npx mjs-unit-menu --choix=3`, puis `--choix=4` (plan, SBOM, compte rendu vers
+qatrax.dev). Les lecteurs sont exportés : `import { lireRapportEssais, refDuPlan } from "@mostajs/mjs-unit/lecteurs"`.
+
+Ce que le sceau prouve : le rapport n'a pas changé **après sa lecture**, avec **cette** SBOM et **ce** plan. Il ne
+prouve pas que l'outil du langage a joué les essais honnêtement.
+
+## La boucle avec qatrax (0.11.0)
+
+```bash
+npx mjs-unit qatrax etat          # « 2 nouveau(x), 1 changé(s) en recette » — rien d'autre si rien n'a bougé
+npx mjs-unit qatrax rapatrier     # la fiche des défauts et les captures, dans docs/recette/defauts/
+npx mjs-unit qatrax pris <id>     # puis réparer, écrire l'essai, npm test
+npx mjs-unit qatrax corrige <id>  # « corrigé dans <projet> <version> — à rejouer en recette »
+npx mjs-unit qatrax pousser --si-vert   # plan, run, SBOM — seulement si le dernier run est vert
+```
+
+Dans le `package.json` du projet : `"qatrax": { "projet": "speaking", "url": "https://speaking.qatrax.dev", "nom": "Speaking" }`.
+La clé de CI (opération « pousser ») : `QATRAX_CLE_CI`, sinon `~/.config/qatrax/cle-ci-<projet>` en mode 600.
+qatrax prévient de son côté (webhook signé, courriel) quand un rapport de recette arrive. En code :
+`import { configQatrax, creerClientQatrax } from '@mostajs/mjs-unit/qatrax'`.
+
 ## API
 
 | Fonction | Rôle |

package/bin/cli.mjs

@@ -17,15 +17,28 @@
  *                        TOUJOURS — même invalide, avec ses défauts ; le code de sortie reste celui des essais
  *   --ctrf[=f]           export CTRF (défaut : test-scripts/.out/ctrf.json)
  *   --intoto[=f]         énoncé in-toto test-result v0.1, non signé (défaut : test-scripts/.out/test-result.intoto.json)
+ *   0.10.0 — LE MODE LECTEUR (Java, C#, Python, Go) : aucun essai exécuté, le rapport de l'outil du langage est LU
+ *   --depuis             les arguments sont des RAPPORTS : mjs-unit --depuis target/surefire-reports/*.xml
+ *                        JUnit XML, NUnit 2/3, TRX, TestNG, Robot Framework, CTest, Cucumber JSON, Behave JSON,
+ *                        Allure 2, CTRF, TAP, JSON mjs-unit — reconnus à leur contenu
+ *   0.11.0 — LE CLIENT QATRAX : mjs-unit qatrax <etat|rapatrier|pris|corrige|pousser> (voir : mjs-unit qatrax aide)
+ *   --depuis=chemin      un dossier (tous ses .xml, .json, .tap, .trx ; dans allure-results, les *-container et
+ *                        *-attachment sont écartés) ou un fichier
+ *                        → les mêmes sorties : --compte-rendu, --ctrf, --intoto, --json, --junit, --report
  *
  * @author Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later
  */
+// 0.11.0 — `mjs-unit qatrax …` : le client qatrax, chargé SEULEMENT pour cette sous-commande (le runner reste sans réseau).
+if (process.argv[2] === "qatrax") {
+  const { principal } = await import("../dist/qatrax.js");
+  process.exit(await principal(process.argv.slice(3)));
+}
 import { register } from "node:module";
 import { pathToFileURL } from "node:url";
-import { writeFileSync, readFileSync, mkdirSync } from "node:fs";
+import { writeFileSync, readFileSync, mkdirSync, statSync, readdirSync } from "node:fs";
 import { hostname } from "node:os";
 import { createHash } from "node:crypto";
-import { dirname } from "node:path";
+import { dirname, join } from "node:path";
 
 register(new URL("../loader.mjs", import.meta.url));
 const { run, pending, registered, takeRuns, setDefaultTimeout, setTagFilter } = await import("../dist/index.js");
@@ -45,9 +58,11 @@ const title = opt("title");
 if (opt("timeout")) setDefaultTimeout(Number(opt("timeout")));
 if (opt("tag")) setTagFilter(opt("tag").split(","));
 const crOut = opt("compte-rendu"), ctrfOut = opt("ctrf"), intotoOut = opt("intoto"), sbomIn = opt("sbom"), planIn = opt("plan");
+const depuis = opt("depuis");    // 0.10.0 — mode lecteur : "" (les arguments sont des rapports) ou un chemin
+const lecteur = depuis !== undefined;
 const files = argv.filter((a) => !a.startsWith("--"));
 const debut = new Date().toISOString();
-if (!files.length) { console.error("usage: mjs-unit <fichier-de-test...> [--report[=f]] [--json[=f]]"); process.exit(2); }
+if (!files.length && !depuis) { console.error("usage: mjs-unit <fichier-de-test...> [--report[=f]] [--json[=f]] — ou : mjs-unit --depuis <rapport...> (JUnit, NUnit, TRX, TestNG, Robot, CTest, Cucumber, Behave, Allure, CTRF, TAP)"); process.exit(2); }
 
 // ── Exécution, une suite par fichier ─────────────────────────────────────────
 // Le CLI DEMANDE au module ce qui a été enregistré et ce qui a été exécuté, fichier par fichier : il
@@ -55,7 +70,45 @@ if (!files.length) { console.error("usage: mjs-unit <fichier-de-test...> [--repo
 // hors du rapport, et un fichier sans aucun test disparaissait sans un mot.
 let totalFail = 0, totalDeclares = 0, totalExecutes = 0;
 const suites = [];
-for (const f of files) {
+const sha = (b) => createHash("sha256").update(b).digest("hex");
+// ── 0.10.0 — LE MODE LECTEUR : lire le rapport de l'outil du langage (Surefire, pytest, xUnit, go test…) ─────────
+// Aucun essai n'est exécuté : les suites sont REMPLIES depuis les rapports, puis toute la chaîne suit (compte rendu,
+// CTRF, in-toto, JSON, JUnit, HTML). Un rapport illisible est un défaut DIT ; un statut incompris est une erreur.
+const lecture = lecteur ? { rapports: [], defauts: [] } : null;
+let genereLe = null;
+if (lecteur) {
+  const { lireRapportEssais } = await import("../dist/lecteurs.js");
+  const RAPPORT = /\.(xml|json|tap|trx)$/i;
+  const ANNEXE = /-(container|attachment)\.[^.]+$/i;   // Allure : fixtures et pièces jointes, pas des résultats
+  const sources = depuis ? (statSync(depuis, { throwIfNoEntry: false })?.isDirectory() ? readdirSync(depuis).filter((n) => RAPPORT.test(n) && !ANNEXE.test(n)).sort().map((n) => join(depuis, n)) : [depuis]) : files;
+  if (!sources.length) { console.error(`✗ --depuis : aucun rapport (.xml, .json, .tap, .trx) dans ${depuis}`); process.exit(2); }
+  const STATUT = { pass: ["pass"], fail: ["fail", "failure"], skipped: ["skip"], blocked: ["fail", "error"] };
+  const ajouter = (rapport, f) => {
+    if (rapport.generatedAt && (!genereLe || rapport.generatedAt < genereLe)) genereLe = rapport.generatedAt;
+    for (const s of rapport.suites) {
+      const results = s.results.map((r) => { const [status, kind] = STATUT[r.status] ?? STATUT.blocked;
+        return { name: r.name, title: r.name, status, durationMs: r.durationMs ?? 0, ...(kind ? { kind } : {}), ...(r.error ? { error: r.error } : {}), ...(r.tags?.length ? { tags: r.tags } : {}),
+          ...(r.status === "blocked" ? { error: r.error ?? "statut incompris : ni réussi, ni échoué, ni ignoré" } : {}), ...(status === "skip" ? { skipReason: r.error ?? "ignoré par l'outil d'essai" } : {}) }; });
+      totalFail += results.filter((r) => r.status === "fail").length;
+      totalDeclares += results.length; totalExecutes += results.length;
+      suites.push({ file: s.file || f, results });
+    }
+  };
+  // Allure : un fichier par essai — lus ENSEMBLE, pour qu'un essai rejoué (même historyId) ne compte qu'une fois
+  const allure = []; let allureSource = null;
+  for (const f of sources) {
+    let brut;
+    try { brut = readFileSync(f); } catch (e) { lecture.defauts.push(`rapport illisible : ${f} — ${e?.code ?? e?.message ?? e}`); totalFail++; continue; }
+    const lu = lireRapportEssais(brut.toString("utf8"));
+    lecture.rapports.push({ fichier: f, format: lu.format, sha256: sha(brut) });
+    if (!lu.rapport) { lecture.defauts.push(`rapport illisible : ${f} — ${lu.erreur ?? lu.format}`); console.error(`✗ ${f} : ${lu.erreur ?? lu.format}`); totalFail++; continue; }
+    if (lu.format === "allure") { allure.push(...(Array.isArray(lu.brut) ? lu.brut : [lu.brut])); allureSource ??= depuis && statSync(depuis).isDirectory() ? depuis : f; continue; }
+    ajouter(lu.rapport, f);
+  }
+  if (allure.length) ajouter(lireRapportEssais(allure).rapport, allureSource);
+  console.log(`\n${totalFail ? "✗" : "✓"} ${totalExecutes} cas lu(s) dans ${lecture.rapports.length} rapport(s) — mode lecteur : aucun essai exécuté par mjs-unit`);
+}
+for (const f of lecteur ? [] : files) {
   const avant = registered();
   takeRuns();                                // rien d'un fichier précédent ne doit être attribué à celui-ci
   await import(pathToFileURL(f).href);       // le fichier enregistre ses cas (et peut appeler run() lui-même)
@@ -78,12 +131,12 @@ for (const f of files) {
   totalDeclares += declares; totalExecutes += cas.length;
   suites.push({ file: f, results });
 }
-console.log(`\n${totalExecutes === totalDeclares ? "✓" : "✗"} ${totalExecutes}/${totalDeclares} test(s) exécutés sur ${suites.length} fichier(s) — compte relevé auprès du module, pas supposé`);
+if (!lecteur) console.log(`\n${totalExecutes === totalDeclares ? "✓" : "✗"} ${totalExecutes}/${totalDeclares} test(s) exécutés sur ${suites.length} fichier(s) — compte relevé auprès du module, pas supposé`);
 
 // ── Reporters optionnels ─────────────────────────────────────────────────────
 if (htmlOut !== undefined || jsonOut !== undefined || junitOut !== undefined) {
   const { renderHtmlReport, renderJsonReport, renderJunitReport } = await import("../dist/report.js");
-  const report = { suites, generatedAt: new Date().toISOString(), title: title || undefined, hostname: hostname() };
+  const report = { suites, generatedAt: genereLe ?? new Date().toISOString(), title: title || undefined, hostname: hostname() };
   if (htmlOut !== undefined) {
     const out = htmlOut || "test-report.html";
     writeFileSync(out, renderHtmlReport(report));
@@ -104,18 +157,18 @@ if (htmlOut !== undefined || jsonOut !== undefined || junitOut !== undefined) {
 // ── 0.9.0 — le compte rendu de validation, écrit TOUJOURS quand il est demandé (même invalide) ─────────────
 if (crOut !== undefined || ctrfOut !== undefined || intotoOut !== undefined) {
   const { construireCompteRendu, renderCtrf, renderInTotoTestResult } = await import("../dist/report.js");
-  const sha = (b) => createHash("sha256").update(b).digest("hex");
   const piece = (f) => { const b = readFileSync(f); return { fichier: f, sha256: sha(b), contenu: JSON.parse(b.toString("utf8")) }; };
   const lire = (f) => { if (!f) return { p: null }; try { return { p: piece(f) }; } catch (e) { return { p: null, e: `${f} — ${e?.code ?? e?.message ?? e}` }; } };
   const s = lire(sbomIn), pl = lire(planIn);
   const moi = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
   const env = process.env;
   const ci = env.CI_PIPELINE_URL || env.CI_JOB_URL || (env.GITHUB_RUN_ID && env.GITHUB_SERVER_URL && env.GITHUB_REPOSITORY ? `${env.GITHUB_SERVER_URL}/${env.GITHUB_REPOSITORY}/actions/runs/${env.GITHUB_RUN_ID}` : undefined);
-  const cr = construireCompteRendu({ suites, generatedAt: new Date().toISOString(), title: title || undefined, hostname: hostname() }, {
+  const cr = construireCompteRendu({ suites, generatedAt: genereLe ?? new Date().toISOString(), title: title || undefined, hostname: hostname() }, {
     sbom: s.p, sbomErreur: s.e, plan: pl.p, planErreur: pl.e,
-    scripts: files.map((f) => { try { return { fichier: f, sha256: sha(readFileSync(f)) }; } catch { return { fichier: f, sha256: "" }; } }),
+    scripts: lecteur ? [] : files.map((f) => { try { return { fichier: f, sha256: sha(readFileSync(f)) }; } catch { return { fichier: f, sha256: "" }; } }),
+    lecture,
     environnement: { node: process.version, plateforme: `${process.platform}-${process.arch}`, hote: hostname(), ...(ci ? { ci } : {}), debut, fin: new Date().toISOString() },
-    declares: totalDeclares, outil: { name: moi.name, version: moi.version },
+    declares: totalDeclares, outil: { name: moi.name, version: moi.version, ...(lecteur ? { mode: "lecteur" } : {}) },
   });
   const ecrire = (f, texte) => { mkdirSync(dirname(f), { recursive: true }); writeFileSync(f, texte); return sha(texte); };
   const exports_ = {};

package/bin/mjs-unit-menu.sh

@@ -1,16 +1,18 @@
 #!/usr/bin/env bash
 #
-# mjs-unit-menu — le cycle de validation en un menu (0.9.0) : essais → SBOM → compte rendu → qatrax.dev.
+# mjs-unit-menu — le cycle de validation en un menu (0.10.0) : essais → SBOM → compte rendu → qatrax.dev.
 #
 #   1) lancer les essais (rapports HTML, JSON, JUnit)
 #   2) générer ou continuer la SBOM (npx mjs-sbom --diff)
 #   3) compte rendu complet : SBOM + plan + essais + CTRF + in-toto
-#   4) envoyer à qatrax.dev : POST /sbom puis POST /runs (le compte rendu), clé de CI du projet
+#      (MJS_DEPUIS posé : les essais ne sont pas exécutés, le rapport de l'outil du langage est LU — Java, C#, Python, Go, C++ : JUnit, NUnit, TRX, TestNG, Robot, CTest, Cucumber, Behave, Allure…)
+#   4) envoyer à qatrax.dev : POST /import (le plan, s'il existe), POST /sbom, puis POST /runs (le compte rendu)
 #   5) lire les vulnérabilités de la version sur qatrax.dev (GET /vulnerabilites)
 #   6) afficher le dernier compte rendu (verdict, défauts)
 #
 # Sans interaction : mjs-unit-menu --choix=N (CI, scripts).
-# Variables : MJS_TESTS (fichiers d'essai, motif shell ; défaut test-scripts/**/*.test.mjs), MJS_SBOM (défaut
+# Variables : MJS_TESTS (fichiers d'essai, motif shell ; défaut test-scripts/**/*.test.mjs), MJS_DEPUIS (0.10 : rapports
+# d'un autre langage — dossier, fichier ou motif shell : target/surefire-reports, resultats.xml), MJS_SBOM (défaut
 # sbom.cyclonedx.json), MJS_PLAN (défaut : premier docs/DEVTEST-PLAN*.json), MJS_OUT (défaut test-scripts/.out),
 # QATRAX_URL, QATRAX_CLE (clé de CI, lue dans l'environnement, jamais écrite), QATRAX_PROJET.
 #
@@ -28,6 +30,7 @@ CR="$OUT/compte-rendu.json"
 essais() { local motif="${MJS_TESTS:-test-scripts/**/*.test.mjs}"; local f; f=( $motif ); printf '%s\n' "${f[@]}"; }
 
 lancer_essais() {
+  if [ -n "${MJS_DEPUIS:-}" ]; then echo "ℹ MJS_DEPUIS posé : lancez vos essais avec votre outil (mvn test, dotnet test, pytest, go test, robot, ctest, cucumber, behave…), puis choix 3 — mjs-unit LIT leur rapport"; return 0; fi
   mkdir -p "$OUT"; mapfile -t F < <(essais)
   [ ${#F[@]} -gt 0 ] || { echo "✗ aucun fichier d'essai (MJS_TESTS)"; return 2; }
   node "$CLI" "${F[@]}" --report="$OUT/report.html" --json="$OUT/report.json" --junit="$OUT/report.xml"
@@ -38,8 +41,13 @@ generer_sbom() {
 }
 
 compte_rendu() {
-  mkdir -p "$OUT"; mapfile -t F < <(essais)
-  [ ${#F[@]} -gt 0 ] || { echo "✗ aucun fichier d'essai (MJS_TESTS)"; return 2; }
+  mkdir -p "$OUT"
+  if [ -n "${MJS_DEPUIS:-}" ]; then
+    if [ -d "$MJS_DEPUIS" ] || [ -f "$MJS_DEPUIS" ]; then F=("--depuis=$MJS_DEPUIS"); else F=(--depuis $MJS_DEPUIS); fi
+  else
+    mapfile -t F < <(essais)
+    [ ${#F[@]} -gt 0 ] || { echo "✗ aucun fichier d'essai (MJS_TESTS)"; return 2; }
+  fi
   local opts=(--compte-rendu="$CR" --ctrf="$OUT/ctrf.json" --intoto="$OUT/test-result.intoto.json" --json="$OUT/report.json" --junit="$OUT/report.xml")
   [ -f "$SBOM" ] && opts+=(--sbom="$SBOM") || echo "⚠ pas de SBOM ($SBOM) : le compte rendu sera « incomplet » (choix 2)"
   [ -n "$PLAN" ] && [ -f "$PLAN" ] && opts+=(--plan="$PLAN")
@@ -49,9 +57,9 @@ compte_rendu() {
 # Les appels à qatrax.dev passent par Node (fetch) : pas de dépendance à curl, et la clé ne paraît dans aucune ligne de commande.
 qatrax() { # $1 = action (envoyer | vulnerabilites)
   : "${QATRAX_URL:?QATRAX_URL manquante}" "${QATRAX_CLE:?QATRAX_CLE manquante (clé de CI du projet)}" "${QATRAX_PROJET:?QATRAX_PROJET manquant}"
-  ACTION="$1" SBOM="$SBOM" CR="$CR" node --input-type=module -e '
+  ACTION="$1" SBOM="$SBOM" CR="$CR" PLAN="$PLAN" node --input-type=module -e '
     import { readFileSync, existsSync } from "node:fs";
-    const { QATRAX_URL: base, QATRAX_CLE: cle, QATRAX_PROJET: p, ACTION, SBOM, CR } = process.env;
+    const { QATRAX_URL: base, QATRAX_CLE: cle, QATRAX_PROJET: p, ACTION, SBOM, CR, PLAN } = process.env;
     const e = encodeURIComponent; const auth = { authorization: `Bearer ${cle}` };
     if (!existsSync(CR)) { console.error(`✗ pas de compte rendu (${CR}) : choix 3 d’abord`); process.exit(2); }
     const cr = JSON.parse(readFileSync(CR, "utf8")); const v = cr.produit?.version ?? "inconnue";
@@ -61,6 +69,8 @@ qatrax() { # $1 = action (envoyer | vulnerabilites)
     };
     if (ACTION === "envoyer") {
       let bon = true;
+      // 0.10.0 — le plan d’abord : sans lui, qatrax.dev ne sait pas quelle exigence chaque essai prouve.
+      if (PLAN && existsSync(PLAN)) bon = (await appel("POST", "/import", readFileSync(PLAN, "utf8"))).ok && bon;
       if (existsSync(SBOM)) bon = (await appel("POST", `/sbom?p=${e(p)}&version=${e(v)}`, readFileSync(SBOM, "utf8"))).ok && bon;
       else console.log(`⚠ pas de SBOM (${SBOM}) : seul le compte rendu part — qatrax.dev le consignera « SBOM non reçue »`);
       bon = (await appel("POST", `/runs?p=${e(p)}&format=json`, readFileSync(CR, "utf8"))).ok && bon;

package/dist/lecteurs.d.ts

@@ -0,0 +1,82 @@
+/**
+ * @mostajs/mjs-unit/lecteurs — LIRE UN RAPPORT D'ESSAIS, QUEL QU'EN SOIT L'OUTIL (0.10.0).
+ * @author Dr Hamid MADANI <drmdh@msn.com>
+ * @license AGPL-3.0-or-later
+ *
+ * Descendus de @mostajs/qa-engine/formats (DEVRULES R-G : la logique partagée vit à la couche la plus basse) pour le
+ * mode lecteur de mjs-unit (`--depuis`) : un projet Java, C#, Python ou Go garde son outil d'essai, et mjs-unit LIT
+ * son rapport pour en faire le compte rendu de validation. qa-engine les reprend d'ici.
+ *
+ *   JUnit XML (Surefire, Gradle, pytest, xUnit/JunitXml.TestLogger, go-junit-report, mjs-unit --junit) → 'junit'
+ *   NUnit 2 et 3 (TestResult.xml)                                                                     → 'nunit'
+ *   TRX (dotnet test --logger trx : VSTest, xUnit, MSTest, NUnit)                                     → 'trx'
+ *   TestNG natif (testng-results.xml)                                                                 → 'testng'
+ *   Robot Framework (output.xml, RF 6 et 7)                                                           → 'robot'
+ *   CTest (ctest -T Test → Testing/<horodatage>/Test.xml)                                             → 'ctest'
+ *   Cucumber JSON (cucumber-js, Cucumber-JVM, SpecFlow/Reqnroll…)                                     → 'cucumber'
+ *   Behave JSON (behave -f json)                                                                      → 'behave'
+ *   Allure 2 (allure-results/*-result.json, un fichier ou un tableau)                                 → 'allure'
+ *   TAP (node --test, Perl…)                                                                          → 'tap'
+ *   CTRF (ctrf-io, mjs-unit --ctrf)                                                                   → 'ctrf'
+ *   mjs-unit --json / --compte-rendu / --intoto                                                → 'mjs-unit' / 'compte-rendu' / 'intoto'
+ *   rapport HTML                                                     → 'html' : preuve lisible par un humain, non lue
+ *
+ * Les formats NUnit à Allure ont été ajoutés le 10/10/2026 à la demande du fondateur : ce sont ceux que lisent Xray,
+ * Allure TestOps, TestRail, Zephyr, ReportPortal et Azure DevOps (docs/01c §5 bis). Le rapport du client reste le sien.
+ *
+ * Le format se reconnaît au CONTENU. Un statut incompris devient `blocked`, jamais `pass`. Pur : aucune E/S, aucune
+ * dépendance — `./lecteurs` s'importe partout (navigateur compris).
+ */
+export type FormatRapport = 'mjs-unit' | 'compte-rendu' | 'junit' | 'nunit' | 'trx' | 'testng' | 'robot' | 'ctest' | 'cucumber' | 'behave' | 'allure' | 'ctrf' | 'intoto' | 'tap' | 'html' | 'illisible';
+export type StatutLu = 'pass' | 'fail' | 'skipped' | 'blocked';
+/** `tags` : les étiquettes de l'outil (Cucumber @T-MOD-01, Robot, Allure) — `rattacherAuPlan` y cherche une référence du plan. */
+export interface ResultatLu {
+    name: string;
+    status: StatutLu;
+    durationMs?: number;
+    error?: string;
+    tags?: string[];
+}
+export interface RapportLu {
+    title: string;
+    generatedAt: string | null;
+    suites: {
+        file: string;
+        results: ResultatLu[];
+    }[];
+}
+export interface LectureRapport {
+    format: FormatRapport;
+    /** la forme que lit importTestRun ; null si le corps n'est pas un rapport d'essais lisible par une machine */
+    rapport: RapportLu | null;
+    /** l'objet reçu (JSON), tel quel — c'est sur lui que porte l'empreinte d'un compte rendu */
+    brut: unknown;
+    erreur?: string;
+}
+/** Les formats lus, NOMMÉS dans chaque motif de refus : le client sait quoi envoyer sans chercher. */
+export declare const FORMATS_LUS: {
+    readonly xml: "JUnit XML, NUnit 2/3, TRX (VSTest), TestNG, Robot Framework (output.xml), CTest (Test.xml)";
+    readonly json: "CTRF, Cucumber JSON, Behave JSON, Allure 2, in-toto test-result, JSON et compte rendu mjs-unit";
+    readonly texte: "TAP";
+};
+/** Le format d'un corps de rapport, reconnu à son contenu. */
+export declare function detecterFormat(corps: unknown): FormatRapport;
+/** Lit un rapport d'essais, quel qu'en soit le format ; jamais d'exception : un corps illisible est DIT illisible. */
+export declare function lireRapportEssais(corps: unknown): LectureRapport;
+/** La référence du plan que désigne ce nom d'essai, ou '' : le nom exact d'abord, puis par jetons. */
+export declare function refDuPlan(nom: string, refs: Iterable<string>): string;
+/**
+ * Pose sur chaque essai sa référence du plan (`T-MOD-01 — test_T_MOD_01_…`) et le fichier de son `autoRef`
+ * (`<fichier>::<ref>`). Un fichier déjà conforme au plan est gardé ; une référence présente dans plusieurs fichiers
+ * ne fait rien deviner (le fichier d'origine reste) ; un essai hors plan est laissé tel quel. Pur.
+ */
+export declare function rattacherAuPlan<R extends {
+    name: string;
+}>(suites: {
+    file: string;
+    results: R[];
+}[], autoRefs: Iterable<string>): {
+    file: string;
+    results: R[];
+}[];
+//# sourceMappingURL=lecteurs.d.ts.map

package/dist/lecteurs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lecteurs.d.ts","sourceRoot":"","sources":["../src/lecteurs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,MAAM,MAAM,aAAa,GAAG,UAAU,GAAG,cAAc,GAAG,OAAO,GAAG,OAAO,GAAG,KAAK,GAAG,QAAQ,GAAG,OAAO,GAAG,OAAO,GAAG,UAAU,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,GAAG,QAAQ,GAAG,KAAK,GAAG,MAAM,GAAG,WAAW,CAAC;AACzM,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,SAAS,CAAC;AAC/D,kIAAkI;AAClI,MAAM,WAAW,UAAU;IAAG,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,QAAQ,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE;AACpH,MAAM,WAAW,SAAS;IAAG,KAAK,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,UAAU,EAAE,CAAA;KAAE,EAAE,CAAA;CAAE;AAC3H,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,aAAa,CAAC;IACtB,8GAA8G;IAC9G,OAAO,EAAE,SAAS,GAAG,IAAI,CAAC;IAC1B,4FAA4F;IAC5F,IAAI,EAAE,OAAO,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AASD,sGAAsG;AACtG,eAAO,MAAM,WAAW;;;;CAId,CAAC;AAwCX,8DAA8D;AAC9D,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,aAAa,CAM5D;AAwQD,sHAAsH;AACtH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,cAAc,CA4BhE;AASD,sGAAsG;AACtG,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,MAAM,CAWrE;AAcD;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,EAAE,MAAM,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,CAAC,EAAE,CAAA;CAAE,EAAE,EAAE,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,CAAC,EAAE,CAAA;CAAE,EAAE,CAuBlK"}