@mostajs/mjs-unit 0.8.0 → 0.10.0

package/README.md

@@ -100,6 +100,54 @@ Le fichier suit le schéma lu par Jenkins, GitLab (`artifacts:reports:junit`), G
 tombée, `<error>` pour une exception inattendue ou un délai dépassé, `<skipped message>` pour un cas ignoré,
 les étiquettes en `<property name="tag">`. `--tag=securite` ne joue que les cas étiquetés.
 
+## Compte rendu de validation — cycle CRA (0.9.0)
+
+```bash
+npx mjs-sbom                                            # la SBOM de la version publiée (@mostajs/mjs-sbom)
+npx mjs-unit test-scripts/**/*.test.mjs \
+  --sbom=sbom.cyclonedx.json --plan=docs/DEVTEST-PLAN.<projet>.json \
+  --compte-rendu --ctrf --intoto
+# 📄 Compte rendu : test-scripts/.out/compte-rendu.json — @acme/produit@1.2.0 — verdict : conforme
+npx mjs-unit-menu                                       # ou le menu : essais, SBOM, compte rendu, envoi à qatrax.dev
+```
+
+Le compte rendu lie les résultats à la version (lue dans la SBOM), au plan et aux scripts (empreintes) ; son verdict
+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.
+
 ## API
 
 | Fonction | Rôle |

package/bin/cli.mjs

@@ -10,13 +10,29 @@
  *   --timeout=ms         délai par défaut de chaque cas (un cas le surcharge par { timeout })
  *   --tag=a,b            ne joue que les cas étiquetés a ou b ; les autres sont rapportés ignorés
  *   --title="…"          titre des rapports
+ *   0.9.0 — LE COMPTE RENDU DE VALIDATION (cycle CRA) :
+ *   --sbom=fichier       la version éprouvée, LUE dans la SBOM CycloneDX (nom, version, purl, serialNumber, empreinte)
+ *   --plan=fichier       le DEVTEST-PLAN (empreinte ; cas rattachés par leur ref ; cas du plan non exécutés relevés)
+ *   --compte-rendu[=f]   écrit le compte rendu mostajs-compte-rendu/1 (défaut : test-scripts/.out/compte-rendu.json),
+ *                        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
+ *   --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
  */
 import { register } from "node:module";
 import { pathToFileURL } from "node:url";
-import { writeFileSync } from "node:fs";
+import { writeFileSync, readFileSync, mkdirSync, statSync, readdirSync } from "node:fs";
 import { hostname } from "node:os";
+import { createHash } from "node:crypto";
+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");
@@ -35,8 +51,12 @@ const junitOut = opt("junit");
 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("--"));
-if (!files.length) { console.error("usage: mjs-unit <fichier-de-test...> [--report[=f]] [--json[=f]]"); process.exit(2); }
+const debut = new Date().toISOString();
+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
@@ -44,7 +64,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)
@@ -67,12 +125,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));
@@ -90,4 +148,31 @@ 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 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: genereLe ?? new Date().toISOString(), title: title || undefined, hostname: hostname() }, {
+    sbom: s.p, sbomErreur: s.e, plan: pl.p, planErreur: pl.e,
+    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, ...(lecteur ? { mode: "lecteur" } : {}) },
+  });
+  const ecrire = (f, texte) => { mkdirSync(dirname(f), { recursive: true }); writeFileSync(f, texte); return sha(texte); };
+  const exports_ = {};
+  if (ctrfOut !== undefined) { const f = ctrfOut || "test-scripts/.out/ctrf.json"; exports_.ctrf = ecrire(f, renderCtrf(cr)); console.log(`📄 CTRF : ${f}`); }
+  if (intotoOut !== undefined) { const f = intotoOut || "test-scripts/.out/test-result.intoto.json"; exports_.intoto = ecrire(f, renderInTotoTestResult(cr)); console.log(`📄 in-toto test-result : ${f}`); }
+  if (crOut !== undefined) {
+    const f = crOut || "test-scripts/.out/compte-rendu.json";
+    ecrire(f, `${JSON.stringify({ ...cr, integrite: { algorithme: "sha256", empreinte: sha(JSON.stringify(cr)), exports: exports_ } }, null, 2)}\n`);
+    console.log(`📄 Compte rendu : ${f} — ${cr.produit.nom}@${cr.produit.version} — verdict : ${cr.synthese.verdict}${cr.defauts.length ? ` (${cr.defauts.length} défaut(s))` : ""}`);
+  }
+}
+
 if (totalFail > 0) process.exitCode = 1;

package/bin/mjs-unit-menu.sh

@@ -0,0 +1,109 @@
+#!/usr/bin/env bash
+#
+# 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
+#      (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_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.
+#
+# @author Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later
+set -uo pipefail
+shopt -s globstar nullglob
+
+ICI="$(cd "$(dirname "$(readlink -f "$0")")" && pwd)"
+CLI="${MJS_UNIT_CLI:-$ICI/cli.mjs}"
+OUT="${MJS_OUT:-test-scripts/.out}"
+SBOM="${MJS_SBOM:-sbom.cyclonedx.json}"
+PLAN="${MJS_PLAN:-$(ls docs/DEVTEST-PLAN*.json 2>/dev/null | head -1)}"
+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"
+}
+
+generer_sbom() {
+  npx --no-install mjs-sbom --diff || { echo "✗ @mostajs/mjs-sbom n'est pas installé (npm i -D @mostajs/mjs-sbom)"; return 2; }
+}
+
+compte_rendu() {
+  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")
+  node "$CLI" "${F[@]}" "${opts[@]}"
+}
+
+# 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" 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, 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";
+    const appel = async (methode, chemin, corps) => {
+      const r = await fetch(`${base}${chemin}`, { method: methode, headers: { ...auth, ...(corps ? { "content-type": "application/json" } : { accept: "application/json" }) }, body: corps });
+      const t = await r.text(); console.log(`${r.ok ? "✓" : "✗"} ${methode} ${chemin} → ${r.status}`); if (!r.ok) console.log(t.slice(0, 500)); return { ok: r.ok, t };
+    };
+    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;
+      process.exit(bon ? 0 : 1);
+    } else {
+      const r = await appel("GET", `/vulnerabilites?p=${e(p)}&version=${e(v)}&format=json`);
+      console.log(r.t.slice(0, 4000)); process.exit(r.ok ? 0 : 1);
+    }'
+}
+
+dernier() {
+  [ -f "$CR" ] || { echo "✗ pas de compte rendu ($CR) : choix 3 d'abord"; return 2; }
+  CR="$CR" node --input-type=module -e '
+    import { readFileSync } from "node:fs";
+    const c = JSON.parse(readFileSync(process.env.CR, "utf8")); const s = c.synthese ?? {};
+    console.log(`${c.produit?.nom}@${c.produit?.version} — verdict : ${s.verdict}`);
+    console.log(`  ${s.executes}/${s.declares} exécutés · ${s.succes} succès · ${s.echecs} échec(s) · ${s.erreurs} erreur(s) · ${s.ignores} ignoré(s)`);
+    if (c.sbom) console.log(`  SBOM ${c.sbom.serialNumber} (révision ${c.sbom.revision}) sha256 ${c.sbom.sha256.slice(0, 16)}…`);
+    for (const d of c.defauts ?? []) console.log(`  ⚠ ${d}`);'
+}
+
+faire() {
+  case "$1" in
+    1) lancer_essais ;; 2) generer_sbom ;; 3) compte_rendu ;; 4) qatrax envoyer ;; 5) qatrax vulnerabilites ;; 6) dernier ;;
+    *) echo "✗ choix inconnu : $1"; return 2 ;;
+  esac
+}
+
+for a in "$@"; do case "$a" in --choix=*) faire "${a#--choix=}"; exit $? ;; -h|--help) sed -n '2,19p' "$0"; exit 0 ;; esac; done
+
+while true; do
+  printf '\n── mjs-unit — cycle de validation ──\n 1) essais   2) SBOM   3) compte rendu complet   4) envoyer à qatrax.dev\n 5) vulnérabilités (qatrax.dev)   6) dernier compte rendu   q) quitter\n> '
+  read -r c || exit 0
+  [ "$c" = "q" ] && exit 0
+  faire "$c"
+done

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"}