designwithai-mcp 0.13.0 → 0.14.0

package/dist/craft-measures.js

@@ -174,8 +174,30 @@ export const LARGEUR_DEFAUT_REM = {
  * `h-auto`, `p-[7px]` ne se résolvent pas ici, et c'est très bien — ils ont
  * chacun leur chemin.
  */
-export function resoudrePasNomme(famille, pas, racine, theme = {}) {
+export function resoudrePasNomme(famille, pas, racine, theme = {}, 
+/**
+ * L'échelle typographique DÉCLARÉE, quand elle est énumérée.
+ *
+ * `--font-size-4` ne veut rien dire dans l'absolu : c'est le quatrième pas de
+ * l'échelle que l'équipe a choisie. Sans cette liste, la mesure ne peut que
+ * l'ignorer — et une échelle ignorée fait tomber le compte à zéro, ce qui
+ * ressemble à une victoire.
+ */
+echelleDeclaree, 
+/** L'échelle de rayons déclarée. Même rôle, même raison. */
+rayonsDeclares) {
     const cle = pas.toLowerCase();
+    /* Un pas du kit : `font-size-1` est le PREMIER de la liste, pas l'index 1. */
+    const kitTexte = cle.match(/^font-size-(\d+)$/);
+    if (kitTexte && echelleDeclaree?.length) {
+        const px = echelleDeclaree[Number(kitTexte[1]) - 1];
+        return px !== undefined ? { px, provenance: "theme" } : null;
+    }
+    const kitRayon = cle.match(/^radius-(\d+)$/);
+    if (kitRayon && rayonsDeclares?.length) {
+        const px = rayonsDeclares[Number(kitRayon[1]) - 1];
+        return px !== undefined ? { px, provenance: "theme" } : null;
+    }
     if (famille === "espacement") {
         if (cle in PAS_LITTERAUX) {
             const v = PAS_LITTERAUX[cle];
@@ -242,9 +264,76 @@ function lireTheme(items) {
  * C'est ce qui permet d'ajouter une unité ou une échelle sans rouvrir les huit
  * fonctions de mesure — et ce qui garantit que toutes convertissent pareil.
  */
-export function resoudreItems(brut) {
+/**
+ * LA TABLE DES ALIAS — `--radius-carte` vaut `var(--radius-4)` vaut 8 pixels.
+ *
+ * Un dépôt qui a fini sa migration n'écrit plus de valeurs : il écrit des noms
+ * qui pointent sur des noms. Sans suivre la chaîne, la mesure voit
+ * `var(--radius-carte)`, n'en tire rien, et rend « 0 rayon distinct » sur un
+ * produit qui en emploie six.
+ *
+ * ELLE NE REND JAMAIS « CONFORME » CE QU'ELLE NE SAIT PAS RÉSOUDRE. Une chaîne
+ * qui n'aboutit pas ressort en illisible AVEC la chaîne citée — c'est ce qui
+ * distingue « 0 divergent sur 13 résolus » de « 0 divergent parce que 13
+ * invisibles ». La deuxième phrase est un mensonge qui a l'air d'un succès.
+ */
+function tableDesAlias(brut) {
+    const t = new Map();
+    for (const it of brut) {
+        if (it.kind !== "token")
+            continue;
+        const v = (it.value ?? "").trim();
+        if (!v)
+            continue;
+        /* L'inventaire range les variables CSS SANS leurs deux tirets — `radius-sm`
+           et non `--radius-sm`. Chercher la forme écrite dans le code ne trouvait
+           donc jamais rien, et toute la table restait vide : la chaîne d'alias
+           échouait au premier maillon sans qu'on voie pourquoi. On indexe les deux
+           formes plutôt que d'en imposer une : les deux existent dans le dépôt. */
+        if (it.name.startsWith("--"))
+            t.set(it.name, v);
+        else if ((it.type ?? "") === "css-variable")
+            t.set(`--${it.name}`, v);
+    }
+    return t;
+}
+/** Le maillon final d'une chaîne, ou la chaîne parcourue si elle n'aboutit pas. */
+export function suivreAlias(valeur, alias, pasKit, profondeurMax = 8) {
+    const chaine = [valeur];
+    let courant = valeur.trim();
+    for (let i = 0; i < profondeurMax; i++) {
+        const m = courant.match(/^var\(\s*(--[a-zA-Z0-9-]+)\s*(?:,[^)]*)?\)$/);
+        if (!m)
+            break;
+        const nom = m[1];
+        /* Un pas du kit ne se trouve pas dans le fichier : il vient de l'échelle
+           DÉCLARÉE. C'est le bout de la chaîne, et le seul endroit où elle peut
+           aboutir sur un nombre sans que ce nombre soit écrit quelque part. */
+        const kit = pasKit(nom);
+        if (kit !== null)
+            return { px: kit };
+        const suivant = alias.get(nom);
+        if (suivant === undefined)
+            return { chaine };
+        courant = suivant.trim();
+        chaine.push(courant);
+    }
+    const px = brutEnPixels(courant, RACINE_PAR_DEFAUT);
+    return px === null ? { chaine } : { px };
+}
+export function resoudreItems(brut, echelleDeclaree, rayonsDeclares) {
     const racine = resoudreRacine(brut);
     const theme = lireTheme(brut);
+    const alias = tableDesAlias(brut);
+    const pasKit = (nom) => {
+        const r = nom.match(/^--radius-(\d+)$/);
+        if (r && rayonsDeclares?.length)
+            return rayonsDeclares[Number(r[1]) - 1] ?? null;
+        const t = nom.match(/^--font-size-(\d+)$/);
+        if (t && echelleDeclaree?.length)
+            return echelleDeclaree[Number(t[1]) - 1] ?? null;
+        return null;
+    };
     const items = [];
     const illisibles = [];
     const em = [];
@@ -276,7 +365,7 @@ export function resoudreItems(brut) {
         /* Un pas nommé : sa valeur ne se lit pas, elle se résout. */
         if (it.attrs?.provenance === "nomme") {
             const famille = (it.attrs.famille ?? type);
-            const r = resoudrePasNomme(famille, it.attrs.pas ?? "", racine.px, theme);
+            const r = resoudrePasNomme(famille, it.attrs.pas ?? "", racine.px, theme, echelleDeclaree, rayonsDeclares);
             if (!r) {
                 illisibles.push(`${it.name}${it.location ? ` (${it.location})` : ""} — pas nommé inconnu de l'échelle`);
                 continue;
@@ -290,7 +379,19 @@ export function resoudreItems(brut) {
             em.push(`${it.name} = ${v}${it.location ? ` (${it.location})` : ""}`);
             continue;
         }
-        const px = brutEnPixels(v, racine.px);
+        let px = brutEnPixels(v, racine.px);
+        if (px === null && v.startsWith("var(")) {
+            const suivi = suivreAlias(v, alias, pasKit);
+            if ("px" in suivi) {
+                px = suivi.px;
+            }
+            else {
+                /* La chaîne est CITÉE : sans elle, « illisible » n'aide personne à
+                   réparer, et le compte des non-résolues resterait un chiffre nu. */
+                illisibles.push(`${it.name}${it.location ? ` (${it.location})` : ""} — chaîne non résolue : ${suivi.chaine.join(" → ")}`);
+                continue;
+            }
+        }
         if (px === null) {
             illisibles.push(`${it.name} = « ${v || "(vide)"} »${it.location ? ` (${it.location})` : ""}`);
             continue;

package/dist/craft-report.js

@@ -31,7 +31,7 @@ export function craftReport(brut, opts = {}) {
     /* UNE SEULE PASSE DE RÉSOLUTION, avant tout. Les mesures qui suivent ne
        voient plus que des pixels : la racine, le thème et l'échelle du cadre ont
        déjà fait leur travail, et de la même façon pour toutes. */
-    const resolution = resoudreItems(brut);
+    const resolution = resoudreItems(brut, opts.systeme?.taillesTypo, opts.systeme?.rayons);
     const items = resolution.items;
     const reference = referenceEspacement(items, opts.systeme);
     const refCibles = referenceCible(opts.systeme);
@@ -42,7 +42,19 @@ export function craftReport(brut, opts = {}) {
     const tailles = distinctes(items, estTailleTypo);
     const doublons = quasiDoublonsCouleur(items);
     const couleurs = new Set(items.filter(estCouleur).map((i) => (i.value ?? "").trim().toLowerCase()));
-    const rayons = distinctes(items, estRayon);
+    /* L'EXCLUSION S'APPLIQUE ICI, ET ELLE SE COMPTE.
+       On ne retire pas des éléments en silence : on les met de côté, on compte
+       ce qu'on a mis de côté, et le rapport le dit fichier par fichier. Une
+       mesure qui rétrécit sans le dire ment plus efficacement qu'une mesure
+       fausse — elle a l'air juste. */
+    const exclusions = opts.systeme?.exclusions ?? [];
+    const estExclu = (it) => exclusions.some((e) => (it.location ?? "").includes(e.fichier));
+    const ecartes = exclusions.map((e) => ({
+        fichier: e.fichier,
+        raison: e.raison,
+        valeurs: items.filter((it) => estRayon(it) && (it.location ?? "").includes(e.fichier)).length,
+    }));
+    const rayons = distinctes(items.filter((it) => !estExclu(it)), estRayon);
     const bp = bascules(items);
     const plafonds = largeursMax(items);
     const cibles = opts.annotations ? ciblesTactiles(opts.annotations, refCibles.base) : null;
@@ -82,7 +94,12 @@ export function craftReport(brut, opts = {}) {
             paires: doublons.detail.paires.map((p) => ({ a: p.a, b: p.b, ecart: p.ecart })),
             nonMesures: doublons.completude.nonMesures,
         },
-        rayons: { distincts: rayons.valeur, liste: rayons.detail, nonMesures: rayons.completude.nonMesures },
+        rayons: {
+            distincts: rayons.valeur,
+            liste: rayons.detail,
+            nonMesures: rayons.completude.nonMesures,
+            ecartes: ecartes.filter((e) => e.valeurs > 0),
+        },
         grille: {
             bascules: bp.detail.trouvees,
             horsPlages: bp.detail.horsPlages,
@@ -240,6 +257,13 @@ export function rendreCraftReport(r, opts = {}) {
         l.push("  Aucune paire trop proche pour être distinguée.");
     }
     l.push(`  ${r.rayons.distincts} rayon(s) distinct(s)${r.rayons.liste.length ? ` : ${r.rayons.liste.join(", ")}` : ""}.` + cite("RADIUS-01"));
+    /* CE BLOC N'EST PAS FACULTATIF. Un chiffre obtenu en écartant des valeurs ne
+       vaut que si le lecteur sait lesquelles, combien, et pourquoi — sinon il
+       compare une mesure rétrécie à une mesure pleine sans le savoir. */
+    for (const e of r.rayons.ecartes) {
+        l.push(`  1 fichier écarté de ce compte : ${e.fichier}, ${e.valeurs} valeur(s).`);
+        l.push(`    Raison déclarée : ${e.raison}`);
+    }
     l.push("");
     /* ── Grilles ── */
     l.push("LES BASCULES ET LES PLAFONDS");

package/dist/ds-inventory.js

@@ -191,6 +191,30 @@ function lireTaillesTexte(etat, contenu, fichier) {
     const vus = new Set();
     for (const m of contenu.matchAll(/font-size\s*:\s*([^;}]+)/gi)) {
         const brut = m[1].trim();
+        /* UN PAS DU KIT SE RÉSOUT, IL NE SE JETTE PAS.
+           `font-size: var(--font-size-4)` partait dans `unread` avec les `clamp()`,
+           et les deux n'ont rien à voir. Un clamp dépend de la largeur de la
+           fenêtre : prendre une de ses bornes ferait entrer dans l'échelle un
+           chiffre que personne n'a choisi. Un pas nommé, lui, désigne une valeur
+           précise — celle que l'équipe a déclarée dans `taillesTypo`.
+           Tant qu'on les traitait pareil, migrer les valeurs sauvages vers
+           l'échelle faisait tomber le compte à zéro : la mesure devenait aveugle,
+           et le zéro ressemblait à une victoire. */
+        const pas = brut.match(/^var\(\s*--font-size-(\d+)\s*\)$/i);
+        if (pas) {
+            const cle = `font-size-${pas[1]}`;
+            if (vus.has(cle))
+                continue;
+            vus.add(cle);
+            etat.items.push({
+                kind: "token",
+                name: cle,
+                type: "typographie",
+                location: fichier,
+                attrs: { provenance: "nomme", famille: "typographie", pas: cle },
+            });
+            continue;
+        }
         const px = brut.match(/^([\d.]+)px$/i);
         if (!px) {
             if (/clamp|calc|var\(/i.test(brut)) {
@@ -410,8 +434,47 @@ function lireValeursArbitraires(etat, contenu, fichier) {
             attrs: { provenance: "arbitraire" },
         });
     }
+    lireVariablesEnClasse(etat, contenu, fichier);
     lirePasNommes(etat, contenu, fichier);
 }
+/**
+ * LES VARIABLES ÉCRITES DANS UNE CLASSE — `rounded-[var(--radius-carte)]`.
+ *
+ * C'est la forme que prend un dépôt qui a fini sa migration : plus une valeur
+ * en pixels dans le markup, rien que des noms. Tant qu'on ne la lisait pas, la
+ * mesure devenait AVEUGLE au moment précis où le travail était fait — elle
+ * rendait « 0 rayon distinct » sur un produit qui en emploie six, et le zéro
+ * ressemblait à une victoire.
+ *
+ * On note le nom ; la résolution se fait dans `craft-measures`, qui connaît la
+ * chaîne des alias et l'échelle déclarée. L'inventaire rapporte, il ne calcule
+ * pas.
+ */
+function lireVariablesEnClasse(etat, contenu, fichier) {
+    const vus = new Set();
+    for (const m of contenu.matchAll(/\b([a-z]+(?:-[a-z]+)?)-\[var\(\s*(--[a-z0-9-]+)\s*\)\]/gi)) {
+        const type = PREFIXE_TYPE.find(([re]) => re.test(m[1]))?.[1];
+        if (!type)
+            continue;
+        /* `text-[var(--color-…)]` est une COULEUR, pas une taille. Le préfixe est
+           le même — Tailwind s'en sert pour les deux — et la ranger en typographie
+           remplissait la liste des illisibles de fausses tailles de texte. */
+        if (type === "typographie" && /color|ink|brand|surface|border|pilier/i.test(m[2]))
+            continue;
+        const cle = `${m[1]}:${m[2]}`;
+        if (vus.has(cle))
+            continue;
+        vus.add(cle);
+        etat.items.push({
+            kind: "token",
+            name: `${m[1]}-[var(${m[2]})]`,
+            type,
+            value: `var(${m[2]})`,
+            location: fichier,
+            attrs: { provenance: "variable" },
+        });
+    }
+}
 /**
  * LES PAS NOMMÉS — la moitié du travail qui manquait.
  *

package/dist/truth-store.js

@@ -47,6 +47,24 @@ export function lireSysteme() {
         const out = {
             ...(nombre(o.base) ? { base: nombre(o.base) } : {}),
             ...(nombre(o.ratioTypo) ? { ratioTypo: nombre(o.ratioTypo) } : {}),
+            ...(Array.isArray(o.rayons) && o.rayons.length > 0 &&
+                o.rayons.every((x) => typeof x === "number" && Number.isFinite(x) && x >= 0)
+                ? { rayons: [...new Set(o.rayons)].sort((a, b) => a - b) }
+                : {}),
+            ...(Array.isArray(o.exclusions) && o.exclusions.length > 0
+                ? {
+                    exclusions: o.exclusions
+                        .filter((x) => Boolean(x) &&
+                        typeof x === "object" &&
+                        typeof x.fichier === "string" &&
+                        /* UNE EXCLUSION SANS RAISON N'EST PAS LUE. C'est la seule
+                           façon d'empêcher que ce champ devienne une liste où l'on
+                           range ce qu'on ne veut plus voir. */
+                        typeof x.raison === "string" &&
+                        x.raison.trim().length > 0)
+                        .map((x) => ({ fichier: x.fichier.trim(), raison: x.raison.trim() })),
+                }
+                : {}),
             ...(Array.isArray(o.taillesTypo) && o.taillesTypo.length > 0 &&
                 o.taillesTypo.every((x) => typeof x === "number" && Number.isFinite(x) && x > 0)
                 ? { taillesTypo: [...new Set(o.taillesTypo)].sort((a, b) => a - b) }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "designwithai-mcp",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "type": "module",
   "license": "UNLICENSED",
   "description": "Le serveur designwithai pour ton éditeur : audite ton produit — interface, navigation, performance, sécurité des données, hygiène Figma — trace les corrections, et fait remonter les résultats dans ton tableau de bord.",