nodefony 7.0.2 → 10.0.0-alpha.2

package/dist/node/cli/gitHooks.js

@@ -0,0 +1,191 @@
+import "./sysexits.js";
+import { printUsage, printUsageError } from "./usageReport.js";
+import { findProjectRoot } from "./projectRoot.js";
+import { stripGlobalCliFlags } from "./globalFlags.js";
+import { GIT_HOOKS_DIR, planGitHooks, renderGitHooksPlan } from "./gitHooksReport.js";
+import { chmodSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+//#region src/cli/gitHooks.ts
+/** La page d'aide — `nodefony git:hooks --help`, et le rappel après un refus. */
+const PAGE = {
+	command: "nodefony git:hooks",
+	tagline: "pose les hooks git de ce projet : contrôles au commit, vérification au push",
+	sections: [{
+		title: "CE QU'ELLE FAIT",
+		paragraph: "Elle écrit deux scripts shell et pose une seule clé de configuration git, qui désigne le dossier où git ira les chercher. Rien n'est installé à votre insu : la pose des hooks est un geste EXPLICITE, jamais l'effet de bord d'un `npm install`. Elle ne démarre pas l'application."
+	}],
+	options: [
+		{
+			term: "--dry-run",
+			text: "le plan, sans rien écrire ni configurer"
+		},
+		{
+			term: "--json",
+			text: "le même plan, exploitable par un script"
+		},
+		{
+			term: "--cwd <chemin>",
+			text: "point de départ (la racine de l'app est résolue en remontant)"
+		}
+	],
+	examples: [{
+		term: "nodefony git:hooks",
+		text: "pose les hooks dans ce dépôt"
+	}, {
+		term: "nodefony git:hooks --dry-run",
+		text: "ce qu'elle écrirait, avant de la laisser faire"
+	}],
+	exitCodes: [{
+		term: "66",
+		text: "aucune application, ou aucun dépôt git ici (EX_NOINPUT)"
+	}]
+};
+/**
+* Interroge git — sortie capturée, échec rendu `null`.
+*
+* @param args - arguments de git.
+* @param cwd - répertoire d'exécution.
+* @returns stdout épuré, ou `null` si git refuse (pas un dépôt, clé absente).
+*/
+function git(args, cwd) {
+	try {
+		return execFileSync("git", args, {
+			cwd,
+			encoding: "utf8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			]
+		}).trim();
+	} catch {
+		return null;
+	}
+}
+/**
+* Analyse les arguments de `git:hooks`.
+*
+* @param argv - `process.argv` complet.
+* @returns les options, ou une erreur d'usage.
+*/
+function parseGitHooksArgv(argv) {
+	const args = stripGlobalCliFlags(argv.slice(2).filter((a) => a !== "git:hooks"));
+	let cwd = process.cwd();
+	let json = false;
+	let dryRun = false;
+	let help = false;
+	for (let i = 0; i < args.length; i += 1) {
+		const a = args[i];
+		if (a === "--help" || a === "-h") help = true;
+		else if (a === "--json") json = true;
+		else if (a === "--dry-run") dryRun = true;
+		else if (a === "--cwd") {
+			const v = args[i + 1];
+			if (v === void 0) return { error: "--cwd attend un chemin" };
+			cwd = path.resolve(v);
+			i += 1;
+		} else return { error: `option inconnue : ${a}` };
+	}
+	return {
+		cwd,
+		json,
+		dryRun,
+		help
+	};
+}
+/**
+* Pose les hooks natifs dans un projet, et rend le plan de ce qui a été fait.
+*
+* Le geste ENTIER — lire, décider, écrire, configurer — en un exemplaire, pour
+* ses appelants présents et futurs (la commande ; un jour `create app
+* --git-hooks`). Tout refus (hook étranger, `core.hooksPath` géré autrement)
+* interdit TOUT le geste : pas d'état à moitié posé.
+*
+* ⚠️ `core.hooksPath` RELATIF se résout depuis le TOPLEVEL du dépôt git, pas
+* depuis l'application. Quand l'application n'est pas le toplevel (monorepo),
+* la valeur posée est le chemin du dossier de hooks VU DU toplevel — calculée
+* ici, écrite en `/` (elle voyage dans la config du clone).
+*
+* @param projectRoot - racine de l'application, DÉJÀ résolue.
+* @param dryRun - `true` pour calculer sans rien écrire ni configurer.
+* @returns le plan, ou `null` si `projectRoot` n'est dans aucun dépôt git.
+*/
+function installGitHooks(projectRoot, dryRun = false) {
+	const toplevel = git(["rev-parse", "--show-toplevel"], projectRoot);
+	if (toplevel === null) return null;
+	const projectReal = realpathSync.native(projectRoot);
+	const toplevelReal = realpathSync.native(toplevel);
+	const hooksDirAbs = path.join(projectReal, GIT_HOOKS_DIR);
+	const wanted = path.relative(toplevelReal, hooksDirAbs).split(path.sep).join("/") || ".githooks";
+	const existing = {};
+	for (const name of ["pre-commit", "pre-push"]) try {
+		existing[name] = readFileSync(path.join(hooksDirAbs, name), "utf8");
+	} catch {
+		existing[name] = null;
+	}
+	const plan = planGitHooks(existing, git([
+		"config",
+		"--get",
+		"core.hooksPath"
+	], projectRoot), wanted);
+	if (dryRun || plan.refused) return plan;
+	for (const hook of plan.hooks) {
+		if (hook.action === "inchange") continue;
+		const dest = path.join(projectRoot, ...hook.target.split("/"));
+		mkdirSync(path.dirname(dest), { recursive: true });
+		writeFileSync(dest, hook.content, "utf8");
+		try {
+			chmodSync(dest, 493);
+		} catch {}
+	}
+	if (plan.hooksPath.action === "pose") execFileSync("git", [
+		"config",
+		"core.hooksPath",
+		plan.hooksPath.wanted
+	], {
+		cwd: projectRoot,
+		stdio: [
+			"ignore",
+			"ignore",
+			"ignore"
+		]
+	});
+	return plan;
+}
+/**
+* Commande `nodefony git:hooks` — hooks git natifs (`core.hooksPath`), zéro
+* dépendance.
+*
+* Standalone (0 boot) : elle écrit deux fichiers et une clé de config, et doit
+* répondre dans un terminal qui n'a pas posé `NODE_ENV` — même famille que
+* `ai:sync` et `ai:mcp`, mêmes raisons. Et comme eux, AUCUN `postinstall` ne
+* l'appelle : la pose de hooks est un choix, pas un effet de bord d'un
+* `npm install`.
+*
+* @param argv - `process.argv` complet.
+* @returns exit code sémantique (`OK`, `USAGE`, `NOINPUT` hors projet,
+*   `UNAVAILABLE` hors dépôt git, `CANTCREAT` sur refus d'écrasement).
+*/
+function runGitHooksCommand(argv) {
+	const parsed = parseGitHooksArgv(argv);
+	if ("error" in parsed) return printUsageError(PAGE, parsed.error);
+	if (parsed.help) return printUsage(PAGE);
+	const projectRoot = findProjectRoot(parsed.cwd);
+	if (projectRoot === null) {
+		process.stderr.write(`git:hooks: aucun projet Nodefony ici (nodefony.config.ts introuvable en remontant).\n`);
+		return 66;
+	}
+	const plan = installGitHooks(projectRoot, parsed.dryRun);
+	if (plan === null) {
+		process.stderr.write(`git:hooks: ${projectRoot} n'est dans aucun dépôt git.\nPour en créer un :\n  git init\n`);
+		return 69;
+	}
+	process.stdout.write(parsed.json ? `${JSON.stringify({
+		...plan,
+		dryRun: parsed.dryRun
+	}, null, 2)}\n` : renderGitHooksPlan(plan, !parsed.dryRun && !plan.refused));
+	return plan.refused ? 73 : 0;
+}
+//#endregion
+export { installGitHooks, parseGitHooksArgv, runGitHooksCommand };

package/dist/node/cli/gitHooksReport.js

@@ -0,0 +1,119 @@
+//#region src/cli/gitHooksReport.ts
+/**
+* Composition PURE de `nodefony git:hooks` — hooks git natifs, zéro dépendance.
+*
+* Reçoit un état déjà lu (contenu actuel des hooks, valeur de `core.hooksPath`)
+* et conclut : que poser, que laisser, que REFUSER. Aucune lecture de disque,
+* aucun `git config` — même séparation que `aiSyncReport.ts` / `aiSync.ts`.
+*
+* ## Pourquoi natif, et pas husky
+*
+* Depuis sa v9, husky n'est plus qu'un habillage de `git config core.hooksPath` :
+* la fonctionnalité est dans git lui-même. Une dépendance + un script `prepare`
+* pour ce que deux fichiers sh et une ligne de config font déjà, c'est une
+* surface en trop — et un `postinstall` est exactement ce que `ai:sync` a
+* refusé (`--ignore-scripts` courant, vecteur d'attaque connu). La pose est un
+* GESTE EXPLICITE : cette commande, jamais un script d'installation.
+*
+* ## Pourquoi les hooks générés sont LÉGERS
+*
+* Le filet complet appartient à l'intégration continue — un hook local bloquant
+* est un doublon qui ralentit chaque commit et se contourne d'un `--no-verify`.
+* Qui opte pour les hooks reçoit donc le strict utile : typecheck + lint au
+* commit (rapide), `verify` complet au push (le dernier rempart avant de
+* partager).
+*/
+/** Dossier des hooks, relatif à la racine de l'application, écrit en `/`. */
+const GIT_HOOKS_DIR = ".githooks";
+/**
+* Marqueur d'APPARTENANCE, présent dans chaque hook généré.
+*
+* C'est lui qui sépare « à nous, remplaçable » de « écrit par quelqu'un » : un
+* hook existant qui ne le porte pas n'est JAMAIS écrasé — effacer le travail
+* d'un utilisateur n'est pas le rôle d'une commande de pose.
+*/
+const GIT_HOOKS_MARKER = "posé par `nodefony git:hooks`";
+/** Les hooks que la commande sait poser, dans l'ordre d'affichage. */
+const GIT_HOOK_NAMES = ["pre-commit", "pre-push"];
+/**
+* Le contenu d'un hook.
+*
+* Sh POSIX strict : sous Windows, git exécute les hooks via le `sh.exe` de Git
+* for Windows — un script simple passe partout, un bashisme non. Le `npx` est
+* nécessaire : un hook git n'a pas `node_modules/.bin` dans son PATH.
+*
+* @param name - lequel des deux.
+* @returns le script complet, marqueur compris.
+*/
+function renderGitHook(name) {
+	return `#!/usr/bin/env sh
+# ${GIT_HOOKS_MARKER} — se met à jour en la relançant.
+# Bypass d'urgence : git commit/push --no-verify.
+# Désactiver : git config --unset core.hooksPath
+
+${name === "pre-commit" ? `# Léger VOLONTAIREMENT (typecheck + lint, pas de tests) : le filet complet
+# est l'intégration continue — un commit doit rester rapide.
+npm run typecheck && npm run lint` : `# Le dernier rempart avant de partager : \`verify\` enchaîne typecheck,
+# lint, tests et \`nodefony doctor\`.
+npm run verify`}
+`;
+}
+/**
+* Décide, pour chaque hook et pour `core.hooksPath`, le geste à faire.
+*
+* @param existing - contenu actuel de chaque hook, `null` si absent.
+* @param currentHooksPath - valeur actuelle de `core.hooksPath`, `null` si absente.
+* @param wantedHooksPath - valeur cible (relative au toplevel git, en `/`) —
+*   l'appelant la calcule, car SEUL lui sait où est le toplevel : un chemin
+*   relatif dans `core.hooksPath` se résout depuis la racine du dépôt git, pas
+*   depuis l'application (cas réel : app dans un sous-dossier d'un monorepo).
+* @returns le plan, applicable ou refusé.
+*/
+function planGitHooks(existing, currentHooksPath, wantedHooksPath) {
+	const hooks = GIT_HOOK_NAMES.map((name) => {
+		const content = renderGitHook(name);
+		const current = existing[name] ?? null;
+		return {
+			name,
+			action: current === null ? "pose" : current === content ? "inchange" : current.includes("posé par `nodefony git:hooks`") ? "remplace" : "refus-etranger",
+			target: `${GIT_HOOKS_DIR}/${name}`,
+			content
+		};
+	});
+	const hooksPath = {
+		current: currentHooksPath,
+		wanted: wantedHooksPath,
+		action: currentHooksPath === null || currentHooksPath === "" ? "pose" : currentHooksPath === wantedHooksPath ? "inchange" : "refus-autre"
+	};
+	return {
+		directory: GIT_HOOKS_DIR,
+		hooks,
+		hooksPath,
+		refused: hooksPath.action === "refus-autre" || hooks.some((h) => h.action === "refus-etranger")
+	};
+}
+/**
+* Rend le plan pour un humain.
+*
+* @param plan - le plan calculé.
+* @param applique - `false` quand rien n'a été écrit (`--dry-run` ou refus).
+* @returns le texte à écrire sur la sortie standard.
+*/
+function renderGitHooksPlan(plan, applique) {
+	const lines = [`\n  Hooks git natifs — ${plan.directory}\n`];
+	for (const h of plan.hooks) {
+		const marque = h.action === "pose" ? "+" : h.action === "remplace" ? "~" : h.action === "inchange" ? "=" : "✗";
+		lines.push(`  ${marque} ${h.name.padEnd(12)}`);
+		if (h.action === "refus-etranger") lines.push(` un hook ÉTRANGER occupe ce nom — rien n'est écrasé.\n      → le déplacer, ou le fusionner à la main avec ${h.target}`);
+		lines.push(`\n`);
+	}
+	const hp = plan.hooksPath;
+	if (hp.action === "refus-autre") lines.push(`  ✗ core.hooksPath vaut déjà « ${hp.current ?? ""} » — tes hooks sont gérés\n    autrement, rien n'est touché. Pour adopter ceux-ci :\n      git config --unset core.hooksPath   puis relancer\n`);
+	else lines.push(`  ${hp.action === "pose" ? "+" : "="} core.hooksPath → ${hp.wanted}\n`);
+	if (plan.refused) lines.push(`\n  REFUS — rien n'a été écrit ni configuré.\n`);
+	else if (!applique) lines.push(`\n  Rien n'a été écrit (--dry-run).\n`);
+	else lines.push("\n  Bypass ponctuel : --no-verify · désactiver :\n    git config --unset core.hooksPath\n");
+	return lines.join("");
+}
+//#endregion
+export { GIT_HOOKS_DIR, GIT_HOOKS_MARKER, GIT_HOOK_NAMES, planGitHooks, renderGitHook, renderGitHooksPlan };

package/dist/node/cli/globalFlags.js

@@ -0,0 +1,67 @@
+//#region src/cli/globalFlags.ts
+/**
+* Les options que le CLI déclare pour TOUTES ses commandes — et ce que les
+* commandes autonomes doivent en faire.
+*
+* ## Le défaut que ce module ferme
+*
+* `nodefony --help` promet `-i, --interactive` et `-d, --debug` : ce sont des
+* options POSÉES sur commander pour l'ensemble du CLI (`Cli.initCommander`).
+* Mais les commandes qui répondent par le raccourci autonome — `create`,
+* `doctor`, `env`, `card`, `symbols` — ne passent jamais par commander : elles
+* lisent `process.argv` elles-mêmes, précisément pour répondre sans démarrer
+* l'application. Elles refusaient donc, avec « option inconnue », ce que l'aide
+* de la ligne au-dessus venait d'annoncer.
+*
+* C'est la faute la plus décourageante qu'un outil puisse commettre : l'aide dit
+* une chose, la commande en dit une autre, et l'utilisateur n'a aucun moyen de
+* savoir laquelle a raison. Vécu sur `nodefony create app --interactive`, la
+* toute première commande qu'on tape.
+*
+* ## Pourquoi ici, et pas dans chaque parseur
+*
+* Cinq parseurs, cinq copies : la sixième commande autonome écrite demain
+* rouvrirait le trou sans que personne le voie. La liste des options globales
+* vit à UN endroit, et chaque parseur l'APPELLE.
+*
+* ## Ce que « accepter » veut dire
+*
+* Absorber, pas exécuter. Ces options n'ont aucun effet propre sur une commande
+* qui ne pose aucune question et n'ouvre aucun journal de débogage — et c'est
+* exactement ce que « mode interactif » signifie là où il n'y a rien à demander.
+* Là où le mode interactif EXISTE (`create`), il est déjà le comportement par
+* défaut en terminal : le drapeau confirme ce qui se produit déjà, il ne
+* l'active pas.
+*
+* @module
+*/
+/**
+* Les options déclarées pour tout le CLI, formes courtes et longues.
+*
+* Miroir de ce que pose {@link Cli.initCommander}. `--version` n'y figure pas :
+* elle est servie par son propre raccourci, avant tout parsing de commande.
+*/
+const GLOBAL_FLAGS = /* @__PURE__ */ new Set([
+	"-i",
+	"--interactive",
+	"-d",
+	"--debug"
+]);
+/** Ce mot est-il une option que le CLI déclare pour toutes ses commandes ? */
+function isGlobalCliFlag(word) {
+	return GLOBAL_FLAGS.has(word);
+}
+/**
+* Retire d'un `argv` les options globales du CLI.
+*
+* À appeler par un parseur autonome AVANT sa propre lecture : ce qui reste est
+* ce qui appartient en propre à la commande.
+*
+* @param argv - les mots de la ligne de commande.
+* @returns les mots restants, dans l'ordre.
+*/
+function stripGlobalCliFlags(argv) {
+	return argv.filter((w) => !isGlobalCliFlag(w));
+}
+//#endregion
+export { isGlobalCliFlag, stripGlobalCliFlags };

package/dist/node/cli/helpReport.js

@@ -0,0 +1,288 @@
+import { createPalette, sectionTitle, wrap, wrapList } from "../kernel/checks/report.js";
+//#region src/cli/helpReport.ts
+/**
+* L'aide de `nodefony` telle qu'un HUMAIN — et un agent — la lisent : rendu PUR.
+*
+* Ce module ne connaît ni le terminal, ni commander : la largeur, les couleurs
+* et les commandes lui sont DONNÉES, et il rend des lignes. Deux raisons, et la
+* seconde est la vraie.
+*
+* 1. Il devient éprouvable ailleurs que dans le terminal où il tourne — donc en
+*    intégration continue, où il n'y en a pas.
+* 2. L'aide de commander groupe par ORIGINE du code (« Commands: », « Module
+*    drizzle »). C'est le seul axe qu'un programme sache dériver seul, et c'est
+*    pourquoi il existe — pas parce qu'il sert. Personne ne demande « qu'offre
+*    le module http ? » : on demande comment LANCER, ce qui CLOCHE, comment
+*    faire ÉVOLUER. L'humain balaie des titres, l'agent projette une intention
+*    sur une commande : c'est le même geste, donc un seul axe — et surtout pas
+*    une section « pour agent » en fin de page, qui dupliquerait les commandes
+*    en disant à l'humain que ceci n'est pas pour lui.
+*
+* @module
+*/
+/**
+* Les groupes d'intention, dans l'ordre de la JOURNÉE de travail.
+*
+* On lance, on regarde ce qui cloche, on fait évoluer — puis viennent les
+* domaines (base, comptes, front) et l'outillage. L'ordre est le contenu : il
+* répond avant qu'on ait lu les titres.
+*/
+const HELP_GROUPS = [
+	"LANCER",
+	"COMPRENDRE",
+	"GÉNÉRER ET CONSTRUIRE",
+	"BASE DE DONNÉES",
+	"COMPTES ET SECRETS",
+	"FRONT ET RÉSEAU",
+	"AGENTS ET OUTILLAGE"
+];
+/**
+* Le libellé de chaque intention DANS LE MENU interactif.
+*
+* 🔴 Une seule taxonomie, deux rendus. Le menu s'adresse à quelqu'un qui hésite
+* (phrase, minuscules) et l'aide à quelqu'un qui balaie (titre, capitales) : les
+* libellés diffèrent, le CLASSEMENT non. Écrits séparément, ils divergeaient
+* déjà — une commande rangée sous « Comprendre » au menu et ailleurs dans
+* l'aide apprend au lecteur à ne se fier ni à l'un ni à l'autre.
+*/
+const MENU_GROUP_LABELS = {
+	LANCER: "Serveur",
+	COMPRENDRE: "Comprendre",
+	"GÉNÉRER ET CONSTRUIRE": "Faire évoluer",
+	"BASE DE DONNÉES": "Base de données",
+	"COMPTES ET SECRETS": "Comptes et secrets",
+	"FRONT ET RÉSEAU": "Front et réseau",
+	"AGENTS ET OUTILLAGE": "Outillage"
+};
+/**
+* L'ordre à l'intérieur d'un groupe, quand il ne doit rien au hasard.
+*
+* Dans COMPRENDRE, c'est l'ordre de la DÉCOUVERTE : la carte de visite dit où
+* l'on est, le diagnostic ce qui cloche, l'inspection ce qui tourne. Trier par
+* ordre alphabétique y mettrait `card` après `env` et ferait commencer par un
+* détail. Une commande absente de cette table passe après, par ordre
+* alphabétique — un module tiers ne peut pas être classé par nous.
+*/
+const ORDER_IN_GROUP = {
+	LANCER: [
+		"development",
+		"production",
+		"cluster",
+		"status",
+		"stop"
+	],
+	COMPRENDRE: [
+		"card",
+		"doctor",
+		"inspect",
+		"env",
+		"symbols"
+	],
+	"GÉNÉRER ET CONSTRUIRE": [
+		"create",
+		"build",
+		"install",
+		"outdated"
+	]
+};
+/**
+* Largeur maximale de la colonne des noms.
+*
+* 🔴 Plafonnée, et c'est tout l'écart avec commander : une seule commande
+* longue (`test-frontend-angular:build`) élargissait la colonne pour les
+* trente-huit autres, et l'aide devenait un mur de blanc. Au-delà, la
+* description passe SOUS le nom — un cas isolé ne coûte plus qu'à lui-même.
+*/
+const COLUMN_MAX = 24;
+/** L'indentation d'une commande, sous le titre de son groupe. */
+const ITEM = "    ";
+/**
+* La largeur de la colonne des noms — UNE seule pour toute la page.
+*
+* Deux largeurs différentes selon le groupe feraient sauter l'œil d'un bloc à
+* l'autre. Les noms qui dépassent {@link COLUMN_MAX} sont écartés du calcul :
+* ils prennent leur propre ligne, et ne coûtent donc qu'à eux-mêmes.
+*
+* @param commands - les commandes qui composent la page.
+* @returns la largeur de la colonne de gauche.
+*/
+function nameColumnWidth(commands) {
+	return Math.min(COLUMN_MAX, Math.max(0, ...commands.map((c) => displayName(c).length).filter((n) => n <= COLUMN_MAX)));
+}
+/**
+* Le nom d'une commande avec ses alias, tel qu'il se tape.
+*
+* @param cmd - la commande.
+* @returns `doctor|check`, ou le nom seul.
+*/
+function displayName(cmd) {
+	return cmd.aliases.length ? `${cmd.name}|${cmd.aliases.join("|")}` : cmd.name;
+}
+/**
+* Range les commandes par groupe, dans l'ordre d'affichage.
+*
+* Les commandes sans groupe connu tombent sous leur MODULE — ce qui reste vrai
+* pour un module tiers, dont personne ici ne peut deviner l'intention. Sans
+* module ni groupe, elles ferment la marche sous « AUTRES ».
+*
+* @param commands - toutes les commandes connues.
+* @returns les groupes non vides, dans l'ordre de lecture.
+*/
+function groupCommands(commands) {
+	const par = /* @__PURE__ */ new Map();
+	const add = (title, cmd) => {
+		const list = par.get(title);
+		if (list) list.push(cmd);
+		else par.set(title, [cmd]);
+	};
+	for (const cmd of commands) if (cmd.group && HELP_GROUPS.includes(cmd.group)) add(cmd.group, cmd);
+	else if (cmd.module) add(`MODULE ${cmd.module.toUpperCase()}`, cmd);
+	else add("AUTRES", cmd);
+	const rang = (title, cmd) => {
+		const order = ORDER_IN_GROUP[title];
+		if (!order) return Number.POSITIVE_INFINITY;
+		const at = order.indexOf(cmd.name);
+		return at === -1 ? Number.POSITIVE_INFINITY : at;
+	};
+	const sort = (title, list) => [...list].sort((a, b) => {
+		const ra = rang(title, a);
+		const rb = rang(title, b);
+		return ra === rb ? a.name.localeCompare(b.name) : ra - rb;
+	});
+	const output = [];
+	for (const title of HELP_GROUPS) {
+		const list = par.get(title);
+		if (list) output.push({
+			title,
+			commands: sort(title, list)
+		});
+	}
+	const modules = [...par.keys()].filter((t) => t.startsWith("MODULE ")).sort((a, b) => a.localeCompare(b));
+	for (const title of modules) output.push({
+		title,
+		commands: sort(title, par.get(title) ?? [])
+	});
+	const others = par.get("AUTRES");
+	if (others) output.push({
+		title: "AUTRES",
+		commands: sort("AUTRES", others)
+	});
+	return output;
+}
+/**
+* Une entrée à deux colonnes, qui ne déborde jamais.
+*
+* @param terme - la colonne de gauche (nom, drapeaux).
+* @param text - la colonne de droite.
+* @param column - largeur de la colonne de gauche.
+* @param width - largeur utile.
+* @param p - la peinture.
+* @param teinte - le rôle de peinture de la colonne de gauche.
+* @returns une ou plusieurs lignes.
+*/
+function input(terme, text, column, width, p, teinte, accepts) {
+	const longestWord = Math.max(0, ...text.split(" ").map((m) => m.length));
+	const alignee = `${ITEM}${" ".repeat(column + 2)}`;
+	const indent = width - alignee.length >= longestWord ? alignee : `${ITEM}  `;
+	const lines = [];
+	if (terme.length > column) {
+		lines.push(`${ITEM}${teinte(terme)}`);
+		for (const l of wrap(text, width - indent.length, "")) lines.push(indent + p.dim(l));
+	} else {
+		const pad = " ".repeat(column - terme.length);
+		const [premiere, ...suite] = wrap(text, width - indent.length, "");
+		lines.push(`${ITEM}${teinte(terme)}${pad}  ${p.dim(premiere ?? "")}`);
+		for (const l of suite) lines.push(indent + p.dim(l));
+	}
+	if (accepts?.values.length) lines.push(...values(accepts, indent, width, p));
+	return lines;
+}
+/**
+* Ce qu'une commande ACCEPTE, aligné SOUS sa description.
+*
+* 🔴 Aligné sous la description, jamais rejeté à gauche derrière une flèche :
+* l'œil suit une colonne, et une puce exotique à mi-hauteur casse précisément
+* celle qu'il vient d'établir. Les valeurs se lisent alors comme la suite de la
+* phrase — ce qu'elles sont —, et leur continuation s'aligne sous la première
+* valeur plutôt que sous le libellé.
+*
+* @param accepts - le libellé de l'argument et ses valeurs.
+* @param indent - l'indentation de la description.
+* @param width - largeur utile.
+* @param p - la peinture.
+* @returns les lignes de l'énumération.
+*/
+function values(accepts, indent, width, p) {
+	const prefixe = `${accepts.label} : `;
+	const dispo = width - indent.length - prefixe.length;
+	if (dispo < 12) {
+		const output = [indent + p.dim(prefixe.trimEnd())];
+		for (const l of wrapList([...accepts.values], width - indent.length)) output.push(indent + p.dim(l));
+		return output;
+	}
+	return wrapList([...accepts.values], dispo).map((l, i) => i === 0 ? indent + p.dim(prefixe + l) : indent + " ".repeat(prefixe.length) + p.dim(l));
+}
+/**
+* L'aide complète, ligne par ligne, sans retour chariot final.
+*
+* @param model - ce qu'il y a à dire.
+* @param opts - le décor (largeur, couleur).
+* @returns les lignes à écrire, dans l'ordre.
+*/
+function renderHelp(model, opts) {
+	const { width, color } = opts;
+	const p = createPalette(color);
+	const lines = [];
+	const marque = `⬢ Nodefony${model.version ? ` v${model.version}` : ""}`;
+	const baseline = "framework fullstack Node.js — HTTP · WS · ORM · IA";
+	const peint = `  ${p.strong("⬢ Nodefony")}${model.version ? ` ${p.dim(`v${model.version}`)}` : ""}`;
+	if (`  ${marque}   ${baseline}`.length <= width) lines.push(`${peint}   ${p.dim(baseline)}`);
+	else if (`  ${baseline}`.length <= width) lines.push(peint, `  ${p.dim(baseline)}`);
+	else lines.push(peint);
+	lines.push("");
+	for (const [terme, value] of [["usage :", "nodefony <commande> [options]"], ["aide d'une commande :", "nodefony <commande> --help"]]) {
+		const une = `  ${terme} ${value}`;
+		lines.push(une.length <= width ? `  ${p.dim(terme)} ${value}` : `  ${p.dim(terme)}`);
+		if (une.length > width) lines.push(`    ${value}`);
+	}
+	const groups = groupCommands(model.commands);
+	const column = nameColumnWidth(model.commands);
+	const section = (title) => {
+		const { title: t, divider } = sectionTitle(title, width);
+		lines.push("", p.strong(t) + p.dim(divider), "");
+	};
+	for (const group of groups) {
+		section(group.title);
+		for (const cmd of group.commands) lines.push(...input(displayName(cmd), cmd.description, column, width, p, p.action, cmd.accepts));
+	}
+	if (model.globalOptions.length > 0) {
+		section("OPTIONS GLOBALES");
+		const colOpt = Math.min(COLUMN_MAX, Math.max(0, ...model.globalOptions.map((o) => o.flags.length)));
+		for (const opt of model.globalOptions) lines.push(...input(opt.flags, opt.description, colOpt, width, p, p.strong));
+	}
+	if (model.modules && model.modules.length > 0) {
+		lines.push("", `  ${p.strong(`Modules chargés (${model.modules.length})`)}`);
+		for (const l of wrapList([...model.modules], width - 2)) lines.push(`  ${p.dim(l)}`);
+	}
+	if (model.note) {
+		lines.push("");
+		for (const l of wrap(model.note, width - 4, "")) lines.push(`  ${p.warning("!")} ${p.dim(l)}`);
+		if (model.noteAction) lines.push(`  ${p.dim("Pour commencer :")} ${p.action(model.noteAction)}`);
+	}
+	if (model.jsonCommands && model.jsonCommands.length > 0) {
+		lines.push("");
+		const prefixe = "  Réponse machine (--json) :";
+		const dispo = width - 28 - 1;
+		const plies = wrapList([...model.jsonCommands], Math.max(dispo, 1));
+		if (plies.every((l) => l.length <= dispo)) for (const [i, l] of plies.entries()) lines.push(i === 0 ? `${p.dim(prefixe)} ${p.dim(l)}` : `${" ".repeat(29)}${p.dim(l)}`);
+		else {
+			lines.push(p.dim(prefixe));
+			for (const l of wrapList([...model.jsonCommands], width - 4)) lines.push(`    ${p.dim(l)}`);
+		}
+	}
+	lines.push("");
+	for (const [terme, value] of [["Manuel :", "man nodefony"], ["Docs :", "nodefony.github.io/nodefony-core"]]) lines.push(`  ${p.dim(terme)} ${value}`);
+	return lines;
+}
+//#endregion
+export { HELP_GROUPS, MENU_GROUP_LABELS, groupCommands, renderHelp };