designwithai-mcp 0.10.0 → 0.13.0

package/README.md

@@ -119,6 +119,9 @@ règles, anti-patterns, prompts, checklists, scorecards), en lecture.
 | `save_framing` | Écrit un dossier de cadrage dans le projet, au format que `framing_criteria` relit | refuse la FORME, jamais le contenu ; le **verdict** ne s'y pose qu'après passage devant le juge |
 | `list_framings` | Les cadrages du projet et leur verdict — ou son absence, dite telle quelle | `judged_only` ne rend que ceux qui ont passé leur juge |
 | `submit_annotations` | Reçoit un lot d'éléments POINTÉS dans une app qui tourne (route, sélecteur, note) | normaliseur tolérant ; ce qui n'est pas compris est GARDÉ, ce qui n'est pas rangeable est NOMMÉ |
+| `craft_report` | Mesure les règles de l'art : espacements, tailles, couleurs, rayons, bascules, cibles | **déterministe, zéro modèle** ; dit toujours contre quoi il a mesuré |
+| `list_craft_rules` | Le référentiel : chaque règle, sa mesure, sa tolérance, ses exceptions, sa source | une règle non calculable n'y entre pas |
+| `declare_source_of_truth` *(étendu)* | Déclare aussi le SYSTÈME : base d'espacement, ratio typo, bascules, plancher de cible | ce qui est déclaré fait foi — la convention ne passe jamais devant |
 | `framing_criteria` *(étendu)* | Les critères d'acceptation à vérifier, **projet d'abord**, compte ensuite | la source lue est nommée ; un dossier jamais jugé le dit |
 
 **Recherche sémantique** (optionnelle, sans clé) : `npm run embed` pré-calcule des embeddings locaux (modèle multilingue, ONNX) → `handbook-embeddings.json`. Présent, `search_handbook` devient hybride (mots-clés + sens) ; absent, il retombe sur les mots-clés seuls. À relancer après chaque régénération de `handbook.json`.
@@ -196,6 +199,30 @@ ni nouveaux.
 Les lots vivent dans `.designwithai/annotations/` (`DWAI_ANNOTATIONS_PATH`).
 Un constat sans ancre suit exactement le chemin d'avant.
 
+### Les règles de l'art, mesurées et non récitées
+
+Les conventions du métier — base 8, échelles à ratio, plages de bascule — entrent
+dans le produit **codifiées**, pas en dogme dans un prompt. Chaque règle est un
+objet (`craft-rules.ts`) : un identifiant stable, la fonction qui la calcule
+(`craft-measures.ts`, pur et sans modèle), sa tolérance, ses exceptions, et le
+chapitre du manuel qui la fonde — vérifié contre le manuel par un test.
+
+**Une règle qu'aucune fonction ne peut calculer n'entre pas dans le
+référentiel.** Elle reste dans le `SKILL.md` du juge concerné, où elle a
+toujours vécu.
+
+Et la préséance, qui empêche le référentiel de devenir un dogme :
+
+1. **le système DÉCLARÉ fait foi.** Une base de 5 pixels déclarée et tenue n'est
+   pas un défaut de grille ;
+2. à défaut, **la cohérence interne** mesurée sur le code ;
+3. à défaut de tout, **la convention** — annoncée comme telle dans la phrase.
+
+Un rapport dit toujours contre quoi il a mesuré. `better-layout`,
+`better-responsive`, `better-interface` et `better-consistency` appellent
+`craft_report` en premier : ils interprètent et priorisent des chiffres, ils ne
+les refont pas à l'œil.
+
 **Prompts** — les 10 skills de `skills/` exposés comme prompts MCP (`/better-layout`,
 `/better-interface`, `/review-ai-product`…). Chaque prompt est *self-contained* :
 socle commun + corps du skill + invocation renseignée par les arguments

package/dist/cli.js

@@ -0,0 +1,135 @@
+/**
+ * LE MÊME MOTEUR, EN LIGNE DE COMMANDE.
+ *
+ * Une page d'état qui n'existe que dans un IDE ne sert pas l'équipe : elle sert
+ * la personne qui a l'IDE. La CI, elle, n'a pas de client MCP — elle a un shell.
+ * Ces sous-commandes exposent EXACTEMENT les mêmes fonctions de rendu que les
+ * outils MCP, sans en dupliquer une ligne. Une définition, un endroit : si la
+ * page change, elle change aux deux endroits parce qu'il n'y en a qu'un.
+ *
+ * Tout va sur la sortie standard, pour que `>` et `|` fassent leur travail.
+ */
+import { mkdirSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { workspaceRoot } from "./paths.js";
+import { lireRegistre } from "./registry-read.js";
+import { rendreStatusPage } from "./status-page.js";
+import { dernierUpdate, enregistrerUpdate, rendreStatusUpdate } from "./status-update.js";
+import { delta, rendreDelta } from "./pr-delta.js";
+import { lireReviewsA } from "./registry-git.js";
+import { constats } from "./pr-delta.js";
+export const SOUS_COMMANDES = ["status-page", "status-update", "pr-delta", "--help", "-h"];
+const AIDE = `designwithai-mcp — le serveur MCP du Handbook, et trois rendus en ligne de commande.
+
+  designwithai-mcp                          démarre le serveur MCP (stdio)
+
+  designwithai-mcp status-page [--out F] [--product N]
+      Écrit la page d'état du produit, dérivée du registre.
+      Défaut : docs/etat-produit/index.html. --out - écrit sur la sortie standard.
+
+  designwithai-mcp status-update [--since ISO] [--product N] [--no-save]
+      Écrit le point d'avancement en Markdown sur la sortie standard.
+      Sans --since : depuis le dernier point enregistré.
+
+  designwithai-mcp pr-delta --base <ref> [--head <ref>] [--branch N]
+      Compare le registre de la base à celui du répertoire courant (ou de --head)
+      et rend le commentaire de PR. Suppose que .designwithai/ est VERSIONNÉ.
+
+Le registre vit dans .designwithai/ du projet courant (DWAI_WORKSPACE pour l'imposer).`;
+function option(argv, nom) {
+    const i = argv.indexOf(`--${nom}`);
+    if (i === -1)
+        return undefined;
+    const v = argv[i + 1];
+    return v && !v.startsWith("--") ? v : undefined;
+}
+/**
+ * Rend vrai quand une sous-commande a été traitée — le serveur ne doit alors
+ * PAS ouvrir stdio : un client MCP qui reçoit du Markdown sur stdout croit
+ * lire du protocole et se coupe sans message lisible.
+ */
+export async function traiterCli(argv) {
+    const cmd = argv[0];
+    if (!cmd)
+        return false;
+    if (cmd === "--help" || cmd === "-h") {
+        process.stdout.write(`${AIDE}\n`);
+        return true;
+    }
+    if (cmd === "status-page") {
+        const r = lireRegistre();
+        const produit = option(argv, "product");
+        const html = rendreStatusPage(r, {
+            maintenant: new Date().toISOString(),
+            ...(produit ? { produit } : {}),
+        });
+        const out = option(argv, "out") ?? "docs/etat-produit/index.html";
+        if (out === "-") {
+            process.stdout.write(html);
+            return true;
+        }
+        const cible = path.resolve(workspaceRoot(), out);
+        mkdirSync(path.dirname(cible), { recursive: true });
+        writeFileSync(cible, html, "utf8");
+        process.stderr.write(`Page écrite : ${path.relative(workspaceRoot(), cible)}\n`);
+        /* Les fichiers illisibles vont sur stderr ET dans la page. Un registre à
+           moitié lu qui rendrait une page sereine serait le pire de cette surface. */
+        for (const i of r.illisibles)
+            process.stderr.write(`⚠ illisible : ${i.chemin} — ${i.raison}\n`);
+        return true;
+    }
+    if (cmd === "status-update") {
+        const r = lireRegistre();
+        const maintenant = new Date();
+        const depuis = option(argv, "since") ??
+            dernierUpdate() ??
+            new Date(maintenant.getTime() - 30 * 24 * 3600 * 1000).toISOString();
+        const produit = option(argv, "product");
+        const md = rendreStatusUpdate(r, {
+            depuis,
+            maintenant: maintenant.toISOString(),
+            ...(produit ? { produit } : {}),
+        });
+        process.stdout.write(`${md}\n`);
+        if (!argv.includes("--no-save")) {
+            const chemin = enregistrerUpdate(md, maintenant);
+            process.stderr.write(`Point enregistré : ${path.relative(workspaceRoot(), chemin)}\n`);
+        }
+        return true;
+    }
+    if (cmd === "pr-delta") {
+        const base = option(argv, "base");
+        if (!base) {
+            process.stderr.write("pr-delta a besoin de --base <ref>.\n");
+            process.exitCode = 2;
+            return true;
+        }
+        const cwd = workspaceRoot();
+        let avant;
+        try {
+            avant = lireReviewsA(base, cwd);
+        }
+        catch (e) {
+            process.stderr.write(`${e instanceof Error ? e.message : String(e)}\n`);
+            process.exitCode = 2;
+            return true;
+        }
+        const tete = option(argv, "head");
+        const apres = tete ? lireReviewsA(tete, cwd).reviews : lireRegistre().reviews;
+        if (avant.absent) {
+            process.stdout.write(`${rendreDelta({ reglesProuves: [], declaresCorriges: [], nouveaux: [], deplaces: [], persistants: [] }, { base, baseSansRegistre: true })}\n`);
+            return true;
+        }
+        const d = delta(avant.reviews, apres);
+        const branche = option(argv, "branch");
+        process.stdout.write(`${rendreDelta(d, { ...(branche ? { branche } : {}), base })}\n`);
+        if (avant.illisibles.length > 0) {
+            process.stderr.write(`⚠ ${avant.illisibles.length} fichier(s) illisible(s) côté base : la comparaison est incomplète.\n`);
+        }
+        void constats;
+        return true;
+    }
+    process.stderr.write(`Sous-commande inconnue : ${cmd}\n\n${AIDE}\n`);
+    process.exitCode = 2;
+    return true;
+}