designwithai-mcp 0.5.0 → 0.6.0

package/dist/export-findings.js

@@ -0,0 +1,142 @@
+/**
+ * L'EXPORT DES CONSTATS — vers les outils que l'équipe emploie déjà.
+ *
+ * Trois verbes manquaient au produit : assigner, informer, tracer. Ils
+ * demandaient jusqu'ici trois intégrations, trois jeux de secrets à stocker et
+ * trois API à maintenir — pour un produit dont la promesse est de ne rien
+ * garder de ce qui ne lui appartient pas.
+ *
+ * LA SORTIE PAR LE HAUT : on n'écrit dans aucun outil. On produit un texte
+ * parfaitement formaté, et c'est l'assistant de l'utilisateur — chez lui, avec
+ * SES serveurs déjà branchés — qui le pose dans Jira, Linear ou Slack. Zéro
+ * secret stocké, zéro jeton à révoquer, zéro API à suivre quand elle change.
+ *
+ * DÉTERMINISTE, ET C'EST LA CONDITION. Aucun appel de modèle ici : le même
+ * audit rend exactement le même texte, à la virgule près. Un export qui varie
+ * d'une fois sur l'autre produirait deux tickets pour un seul défaut — et
+ * personne ne saurait lequel fermer.
+ */
+import { severityRank, worstSeverity, deriveVerdict, verdictLisible } from "./severity.js";
+/** Le seuil : ce qui mérite un ticket. Un mineur encombre une file, il ne la sert pas. */
+export const SEUIL_TICKET = 2; // majeur et au-dessus
+/**
+ * Ce qu'on lit en tête d'un constat.
+ *
+ * Les reviews d'avant n'ont pas de titre. Le repli le DIT au lieu d'afficher un
+ * vide — un ticket sans intitulé est un ticket que personne n'ouvre.
+ */
+export function titre(f) {
+    return (f.title || f.summary || "Constat sans intitulé — voir la preuve").trim();
+}
+const ordonner = (findings) => [...findings].sort((a, b) => severityRank(a.severity) - severityRank(b.severity));
+/** Ce qui reste ouvert. Un constat corrigé n'a rien à faire dans une file. */
+const ouverts = (findings) => findings.filter((f) => (f.status ?? "open") === "open");
+/**
+ * Le bloc des limites, en pied de chaque sortie.
+ *
+ * IL NE S'OMET JAMAIS QUAND IL Y A QUELQUE CHOSE À DIRE. Un ticket se lit par
+ * quelqu'un qui n'a pas vu l'analyse : sans le périmètre, il prend un constat
+ * partiel pour un constat complet, et l'absence d'un défaut pour sa correction.
+ */
+function blocLimites(review) {
+    const l = review.limites ?? [];
+    if (l.length === 0)
+        return "";
+    return (`\n\n---\nCe que cette lecture n'a pas couvert :\n` +
+        l.map((x) => `- ${x}`).join("\n") +
+        `\nUn constat absent d'ici ne prouve donc pas qu'il n'existe pas.`);
+}
+/** Le renvoi vers l'analyse. Un ticket sans retour est un ticket orphelin. */
+function retour(review) {
+    return `designwithai · ${review.skill} · ${review.artifact_ref} · analyse ${review.id}`;
+}
+/**
+ * Le format « tickets » — un bloc par constat, prêt à devenir une issue.
+ *
+ * Chaque bloc porte les quatre choses qu'une issue exige et qu'on oublie
+ * toujours : ce qui cloche en langage courant, la preuve qui permet de le
+ * retrouver, la correction proposée, et le critère qui dira que c'est fini.
+ * Sans le dernier, un ticket se ferme sur une impression.
+ */
+export function enTickets(review) {
+    const retenus = ordonner(ouverts(review.findings)).filter((f) => severityRank(f.severity) <= SEUIL_TICKET);
+    if (retenus.length === 0) {
+        return (`Aucun constat de gravité majeure ou plus sur ${review.artifact_ref}.\n\n` +
+            `Rien à mettre en file. Les constats mineurs et les notes restent dans l'analyse — ` +
+            `les sortir ici encombrerait la file de ton équipe sans la servir.` +
+            blocLimites(review));
+    }
+    const blocs = retenus.map((f, i) => {
+        const lignes = [
+            `## ${i + 1}. ${titre(f)}`,
+            "",
+            `**Gravité** : ${f.severity ?? "non précisée"}${f.location ? ` · **Où** : ${f.location}` : ""}`,
+        ];
+        if (f.evidence)
+            lignes.push("", `**Ce qui le prouve**`, f.evidence);
+        if (f.impact)
+            lignes.push("", `**Pourquoi ça compte**`, f.impact);
+        if (f.correction)
+            lignes.push("", `**Correction proposée**`, f.correction);
+        lignes.push("", `**C'est fait quand** : ${f.acceptance ?? "à définir avec l'équipe — l'analyse n'a pas fourni de critère de fin"}`);
+        if (f.confidence && f.confidence !== "élevée") {
+            lignes.push("", `_Confiance ${f.confidence} : à vérifier avant d'engager du travail._`);
+        }
+        lignes.push("", `_${retour(review)}_`);
+        return lignes.join("\n");
+    });
+    const entete = `${retenus.length} ticket${retenus.length > 1 ? "s" : ""} à créer — ${review.artifact_ref}\n` +
+        `Un bloc par constat. Les mineurs et les notes ne sont pas ici : ils encombreraient la file.`;
+    return `${entete}\n\n${blocs.join("\n\n---\n\n")}${blocLimites(review)}`;
+}
+/**
+ * Le format « message » — ce qu'on poste dans un canal, tel quel.
+ *
+ * Il tient en quelques lignes parce qu'un message d'équipe se lit en passant.
+ * Le verdict traduit d'abord — personne ne doit traduire « PASS WITH FIXES » —
+ * puis ce qui a bougé, puis les trois points les plus graves. Pas dix : trois.
+ */
+export function enMessage(review, mouvement) {
+    const ouvertsTries = ordonner(ouverts(review.findings));
+    const lisible = verdictLisible(review.verdict) ?? verdictLisible(deriveVerdict(ouvertsTries)) ?? "Analysé";
+    const lignes = [`**${review.artifact_ref} — ${lisible.toLowerCase()}**`];
+    if (mouvement) {
+        /* Le mouvement se dit en clair, et « rien n'a bougé » est un résultat.
+           Annoncer un progrès qui n'a pas eu lieu est la faute qu'on a mis un
+           chantier entier à retirer du rapport ; elle ne rentrera pas par ici. */
+        const parts = [];
+        if (mouvement.regles > 0)
+            parts.push(`${mouvement.regles} réglé${mouvement.regles > 1 ? "s" : ""}`);
+        if (mouvement.nouveaux > 0)
+            parts.push(`${mouvement.nouveaux} nouveau${mouvement.nouveaux > 1 ? "x" : ""}`);
+        if (mouvement.restants > 0)
+            parts.push(`${mouvement.restants} encore ouvert${mouvement.restants > 1 ? "s" : ""}`);
+        lignes.push(parts.length > 0 ? `Depuis la dernière fois : ${parts.join(" · ")}.` : "Rien n'a bougé depuis la dernière fois.");
+    }
+    if (ouvertsTries.length === 0) {
+        lignes.push("", "Rien d'ouvert à signaler.");
+    }
+    else {
+        lignes.push("", `Les ${Math.min(3, ouvertsTries.length)} plus graves :`);
+        for (const f of ouvertsTries.slice(0, 3)) {
+            lignes.push(`• ${titre(f)}${f.location ? ` — ${f.location}` : ""} _(${f.severity ?? "?"})_`);
+        }
+        if (ouvertsTries.length > 3) {
+            lignes.push(`_et ${ouvertsTries.length - 3} autre${ouvertsTries.length - 3 > 1 ? "s" : ""}, dans l'analyse complète._`);
+        }
+    }
+    lignes.push("", `_${retour(review)}_`);
+    return lignes.join("\n") + blocLimites(review);
+}
+/** Le compte de ce qui partirait, pour le dire avant d'exporter. */
+export function compter(review) {
+    const o = ouverts(review.findings);
+    return {
+        total: review.findings.length,
+        exportables: o.filter((f) => severityRank(f.severity) <= SEUIL_TICKET).length,
+        pire: worstSeverity(o),
+    };
+}
+export function exporter(review, format, mouvement) {
+    return format === "tickets" ? enTickets(review) : enMessage(review, mouvement);
+}

package/dist/server.js

@@ -18,6 +18,8 @@ import { compareReviews, getReview, listReviews, saveReview, updateFindingStatus
 import { saveDecision } from "./decisions.js";
 import { clearGate, loadState, reopenGate, saveState } from "./state.js";
 import { readRepoSnapshot } from "./connectors.js";
+import { SEVERITES } from "./severity.js";
+import { compter, exporter } from "./export-findings.js";
 import { inventorierCode } from "./ds-inventory.js";
 import { buildPayload, rendreEnvoi, rendreInventaire } from "./inventory-tool.js";
 import { trySemanticScores } from "./embeddings.js";
@@ -196,7 +198,7 @@ const TOOLS = [
                     items: {
                         type: "object",
                         properties: {
-                            severity: { type: "string", enum: ["bloquant", "critique", "majeur", "mineur", "note"] },
+                            severity: { type: "string", enum: [...SEVERITES] },
                             location: { type: "string" },
                             category: { type: "string" },
                             summary: { type: "string" },
@@ -443,6 +445,28 @@ const TOOLS = [
             },
         },
     },
+    {
+        name: "export_findings",
+        description: "Transforme les constats d'une review en TICKETS prêts à créer, ou en MESSAGE prêt à " +
+            "poster. Rien n'est envoyé nulle part : tu reçois un texte, et c'est TOI qui le poses " +
+            "dans Jira, Linear, GitHub ou Slack avec les serveurs que l'utilisateur a déjà branchés. " +
+            "Déterministe — le même audit rend le même texte.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                format: {
+                    type: "string",
+                    enum: ["tickets", "message"],
+                    description: "tickets = un bloc par constat majeur ou plus, avec preuve, correction et critère " +
+                        "de fin. message = le verdict, ce qui a bougé, et les trois plus graves.",
+                },
+                review_id: { type: "string", description: "La review à exporter. Par défaut, la dernière." },
+                regles: { type: "number", description: "Constats réglés depuis la fois d'avant, si tu le sais." },
+                nouveaux: { type: "number", description: "Constats apparus depuis." },
+            },
+            required: ["format"],
+        },
+    },
     {
         name: "framing_criteria",
         description: "Charge les CRITÈRES D'ACCEPTATION d'un cadrage écrit avant de construire, pour vérifier " +
@@ -644,7 +668,7 @@ function toolPlan(args) {
 }
 // ─── Reviews suivies (étape C) ───────────────────────────────────────────────
 function sevCounts(findings) {
-    const order = ["bloquant", "critique", "majeur", "mineur", "note"];
+    const order = SEVERITES;
     const c = {};
     for (const f of findings) {
         const s = f.severity ?? "note";
@@ -1050,6 +1074,48 @@ function toolNextGate(args) {
  * dit explicitement quoi en faire — c'est `verify_fix` qui statue, un critère à
  * la fois, avec sa preuve.
  */
+/**
+ * `export_findings` — les trois verbes, sans une seule intégration.
+ *
+ * Assigner, informer, tracer manquaient au produit. Les câbler aurait demandé
+ * trois API, trois jeux de secrets et leur maintenance — pour un produit dont
+ * la promesse est de ne rien garder qui ne lui appartienne pas.
+ *
+ * On sort par le haut : le texte est produit ici, parfaitement formaté, et
+ * c'est l'assistant de l'utilisateur qui le pose dans SES outils, avec SES
+ * serveurs déjà branchés. Aucun secret ne transite, aucune API à suivre quand
+ * elle change.
+ */
+function toolExportFindings(args) {
+    const format = String(args.format ?? "");
+    if (format !== "tickets" && format !== "message") {
+        return refusal("export_findings attend un format : « tickets » ou « message ».");
+    }
+    const review = args.review_id ? getReview(String(args.review_id)) : (listReviews()[0] ?? null);
+    if (!review) {
+        return refusal("Aucune review à exporter. Lance d'abord un skill et enregistre le résultat avec save_review.");
+    }
+    const compte = compter(review);
+    /* Le mouvement n'est employé QUE si l'appelant le connaît. On ne le déduit
+       pas d'une comparaison de photos : c'est exactement ce qui avait produit un
+       « ton produit monte » sur un site que personne n'avait touché. */
+    const mouvement = typeof args.regles === "number" || typeof args.nouveaux === "number"
+        ? {
+            regles: Number(args.regles ?? 0),
+            nouveaux: Number(args.nouveaux ?? 0),
+            restants: review.findings.filter((f) => (f.status ?? "open") === "open").length,
+        }
+        : undefined;
+    const corps = exporter(review, format, mouvement);
+    const entete = format === "tickets"
+        ? `${compte.exportables} constat(s) exportable(s) sur ${compte.total} — les mineurs et les notes restent dans l'analyse.\n` +
+            `CE QUE TU EN FAIS : crée une issue par bloc, avec les serveurs que l'utilisateur a déjà branchés ` +
+            `(Jira, Linear, GitHub). Ne réécris pas les titres : ils sont déjà écrits pour être lus par quelqu'un ` +
+            `qui n'a pas vu l'analyse. Si aucun serveur n'est branché, rends-lui le texte tel quel.`
+        : `CE QUE TU EN FAIS : poste ce message tel quel dans le canal qu'il te dira (Slack, Teams). ` +
+            `Ne l'allonge pas : il est court parce qu'un message d'équipe se lit en passant.`;
+    return text(`${entete}\n\n${corps}`);
+}
 async function toolFramingCriteria(args) {
     const token = process.env.DWAI_TOKEN?.trim();
     if (!token) {
@@ -1255,6 +1321,8 @@ server.setRequestHandler(CallToolRequestSchema, async (req) => {
             return toolGenerateDecision(args);
         case "next_gate":
             return toolNextGate(args);
+        case "export_findings":
+            return toolExportFindings(args);
         case "framing_criteria":
             return toolFramingCriteria(args);
         case "inventory_ds":

package/dist/severity.js

@@ -0,0 +1,71 @@
+/**
+ * LA SÉVÉRITÉ ET LE VERDICT, CÔTÉ MCP.
+ *
+ * La définition de référence vit dans `supabase/functions/_shared/severity.ts` :
+ * c'est elle que le serveur applique et que le site affiche. Ce paquet-ci ne
+ * peut pas l'importer — il est publié seul sur npm, et un import qui remonte
+ * hors de son dossier ne survivrait pas à l'emballage. C'est la même frontière
+ * que celle de l'inventaire Figma, et elle se paie une fois.
+ *
+ * Ce fichier est donc une RÉÉCRITURE, pas une copie de confort. Et
+ * `scripts/test-severite-frontiere.ts` empêche les deux de diverger : il
+ * compare les deux tables terme à terme, depuis le site qui peut lire les deux.
+ *
+ * CE QU'IL REMPLACE. La même échelle était écrite à trois endroits du paquet —
+ * le type dans `reviews.ts`, l'énumération du schéma d'outil, et un tableau
+ * d'ordre au milieu du serveur. Trois copies qui n'avaient aucun moyen de se
+ * contredire bruyamment.
+ */
+/** Du plus grave au moins grave. L'ordre EST la définition. */
+export const SEVERITES = ["bloquant", "critique", "majeur", "mineur", "note"];
+const RANK = Object.fromEntries(SEVERITES.map((s, i) => [s, i]));
+/** Une sévérité inconnue passe en dernier — jamais devant un défaut réel. */
+export function severityRank(s) {
+    return RANK[(s ?? "").toLowerCase().trim()] ?? 9;
+}
+/** La plus grave d'un lot, ou `null` s'il n'y a rien. */
+export function worstSeverity(findings) {
+    let pire = null;
+    for (const f of findings) {
+        const s = (f.severity ?? "").toLowerCase().trim();
+        if (!RANK[s])
+            if (RANK[s] !== 0)
+                continue;
+        if (pire === null || severityRank(s) < severityRank(pire))
+            pire = s;
+    }
+    return pire;
+}
+/**
+ * Le verdict se DÉDUIT des sévérités, il ne se décide pas.
+ *
+ * Un bloquant, ou deux critiques, et c'est un échec. Un critique isolé ou un
+ * majeur laissent passer avec des corrections. La règle est celle du serveur,
+ * terme à terme.
+ */
+export function deriveVerdict(findings) {
+    const compte = (s) => findings.filter((f) => (f.severity ?? "").toLowerCase().trim() === s).length;
+    if (compte("bloquant") > 0)
+        return "FAIL";
+    if (compte("critique") >= 2)
+        return "FAIL";
+    if (compte("critique") === 1 || compte("majeur") > 0)
+        return "PASS WITH FIXES";
+    return "PASS";
+}
+/**
+ * LES VERDICTS, DITS EN FRANÇAIS.
+ *
+ * `PASS`, `FAIL`, `BLOCKED` sont du vocabulaire de fabrication. Ils n'ont rien à
+ * faire dans un ticket que lira quelqu'un qui n'a jamais ouvert ce produit.
+ */
+export const VERDICT_LISIBLE = {
+    PASS: "Ça tient",
+    "PASS WITH FIXES": "Presque prêt — des choses à corriger",
+    FAIL: "À corriger avant d'ouvrir",
+    BLOCKED: "Pas assez d'infos pour juger",
+};
+export function verdictLisible(v) {
+    const cle = String(v ?? "").trim().toUpperCase();
+    return VERDICT_LISIBLE[cle] ?? null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "designwithai-mcp",
-  "version": "0.5.0",
+  "version": "0.6.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.",
@@ -26,7 +26,7 @@
   ],
   "scripts": {
     "build": "tsc",
-    "test": "tsx scripts/test-finding-identity.ts && tsx scripts/test-scoring.ts && tsx scripts/test-ds-diff.ts && tsx scripts/test-ds-match.ts && tsx scripts/test-ds-corpus.ts && tsx scripts/test-ds-inventory.ts && tsx scripts/test-inventory-tool.ts && tsx scripts/check-goldens.ts",
+    "test": "tsx scripts/test-finding-identity.ts && tsx scripts/test-scoring.ts && tsx scripts/test-ds-diff.ts && tsx scripts/test-ds-match.ts && tsx scripts/test-ds-corpus.ts && tsx scripts/test-export-findings.ts && tsx scripts/test-ds-inventory.ts && tsx scripts/test-inventory-tool.ts && tsx scripts/check-goldens.ts",
     "start": "node dist/server.js",
     "dev": "tsx src/server.ts",
     "embed": "node scripts/embed.mjs",

package/skills/better-interface/SKILL.md

@@ -133,6 +133,9 @@ Lot 4 - Polish et prévention
 - Axes non vérifiés, nommés
 ```
 
+
+Ces constats s'exportent en tickets ou en message d'équipe — `export_findings`. Rien n'est envoyé nulle part : l'outil rend un texte, et c'est l'assistant de la personne qui le pose dans SES outils, avec SES accès.
+
 ## Critères de qualité du skill
 
 - Les skills activés sont justifiés par le contenu de l'artefact.

package/skills/review-ai-product/SKILL.md

@@ -219,6 +219,9 @@ Lot 4 Accélérer
 - Axes non vérifiés, nommés
 ```
 
+
+Ces constats s'exportent en tickets ou en message d'équipe — `export_findings`. Rien n'est envoyé nulle part : l'outil rend un texte, et c'est l'assistant de la personne qui le pose dans SES outils, avec SES accès.
+
 ## Critères de qualité du skill
 
 - Le verdict sépare clairement prototype, V0, production et industrialisation.