@rgaaudit/mcp-server 0.2.0 → 0.3.0

package/dist/index.js

@@ -19,40 +19,127 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { z } from 'zod';
+import { isLocalUrl, scanLocal, fetchRgaaMappings } from './local-scanner.js';
 const API_URL = process.env.RGAA_API_URL || 'https://app.rgaaudit.fr';
 const API_KEY = process.env.RGAA_API_KEY || '';
 const server = new McpServer({
     name: 'rgaaudit',
-    version: '0.2.0',
+    version: '0.3.0',
 });
+// ── Cache d'audit (TTL 10 min, évite double consommation de quota) ──
+const CACHE_TTL_MS = 10 * 60 * 1000;
+const auditCache = new Map();
 /**
- * Appelle POST /api/ci/scan
+ * Nettoie les entrées expirées du cache
+ */
+function cleanCache() {
+    const now = Date.now();
+    for (const [key, entry] of auditCache) {
+        if (now - entry.timestamp > CACHE_TTL_MS)
+            auditCache.delete(key);
+    }
+}
+/**
+ * Scan local pour URLs localhost — utilise puppeteer-core + axe-core.
+ * Enrichit les résultats avec le mapping RGAA via /api/ci/map si l'API est disponible.
+ *
+ * @param url - URL locale à scanner
+ * @param options - details pour inclure les nœuds HTML
+ */
+async function callLocalScan(url, options) {
+    const localResult = await scanLocal(url);
+    // Enrichir avec le mapping RGAA si API disponible
+    const ruleIds = localResult.violations.map(v => v.ruleId);
+    const mapping = API_KEY ? await fetchRgaaMappings(ruleIds, API_URL, API_KEY) : null;
+    const violations = localResult.violations;
+    const score = violations.length === 0 ? 100 : Math.max(0, Math.round(100 - (violations.length * 3)));
+    const conformity = score >= 100 ? 'conforme' : score >= 50 ? 'partiellement_conforme' : 'non_conforme';
+    const threshold = options?.threshold ?? 0;
+    const result = {
+        url,
+        score,
+        conformity,
+        violations: violations.length,
+        pages: 1,
+        pass: threshold > 0 ? score >= threshold : true,
+        threshold: threshold > 0 ? threshold : null,
+        auditId: `local-${Date.now()}`,
+        auditUrl: url,
+        coverage: mapping?.coverage,
+    };
+    if (options?.details) {
+        result.violationDetails = violations.map(v => {
+            const m = mapping?.mappings[v.ruleId];
+            return {
+                ruleId: v.ruleId,
+                criteria: m?.criteria || null,
+                criteriaTitle: m?.title || null,
+                theme: m?.theme || null,
+                description: m?.help || v.description,
+                impact: m?.impact || v.impact,
+                nodesCount: v.nodesCount,
+                zone: null,
+                suggestion: m?.help || v.help,
+                nodes: v.nodes,
+            };
+        });
+    }
+    return result;
+}
+/**
+ * Appelle POST /api/ci/scan (distant) ou scanLocal (localhost).
+ * Cache intelligent : réutilise l'auditId si un audit récent existe.
+ *
+ * @param url - URL à auditer
+ * @param options - details, threshold, auditId (pour réutiliser un audit existant)
  */
 async function callScan(url, options) {
-    if (!API_KEY) {
-        throw new Error('RGAA_API_KEY non configurée.\n\n' +
-            '1. Créez un compte sur https://app.rgaaudit.fr\n' +
-            '2. Allez dans Paramètres > API\n' +
-            '3. Générez une clé API\n' +
-            '4. Configurez : RGAA_API_KEY=rga_...');
-    }
-    const res = await fetch(`${API_URL}/api/ci/scan`, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-            'X-API-Key': API_KEY,
-        },
-        body: JSON.stringify({
-            url,
-            details: options?.details ?? false,
-            threshold: options?.threshold ?? 0,
-        }),
-    });
-    if (!res.ok) {
-        const body = await res.json().catch(() => ({}));
-        throw new Error(`API erreur ${res.status}: ${body.message || res.statusText}`);
-    }
-    return res.json();
+    cleanCache();
+    // Vérifier le cache
+    const cacheKey = url.toLowerCase().replace(/\/+$/, '');
+    const cached = auditCache.get(cacheKey);
+    if (cached && !options?.auditId) {
+        // Cache hit — retourner directement si on a déjà les détails ou si on n'en demande pas
+        if (!options?.details || cached.result.violationDetails) {
+            return cached.result;
+        }
+    }
+    // Route : localhost → scan local, sinon → API distante
+    let result;
+    if (isLocalUrl(url)) {
+        result = await callLocalScan(url, options);
+    }
+    else {
+        if (!API_KEY) {
+            throw new Error('RGAA_API_KEY non configurée.\n\n' +
+                '1. Créez un compte sur https://app.rgaaudit.fr\n' +
+                '2. Allez dans Paramètres > API\n' +
+                '3. Générez une clé API\n' +
+                '4. Configurez : RGAA_API_KEY=rga_...');
+        }
+        const auditId = options?.auditId || cached?.result.auditId;
+        const res = await fetch(`${API_URL}/api/ci/scan`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-API-Key': API_KEY,
+            },
+            body: JSON.stringify({
+                url,
+                details: options?.details ?? false,
+                threshold: options?.threshold ?? 0,
+                ...(auditId ? { auditId } : {}),
+            }),
+        });
+        if (!res.ok) {
+            const body = await res.json().catch(() => ({}));
+            throw new Error(`API erreur ${res.status}: ${body.message || res.statusText}`);
+        }
+        result = await res.json();
+    }
+    // Mettre en cache
+    auditCache.set(cacheKey, { result, timestamp: Date.now() });
+    return result;
 }
 // ── Outil 1 : rgaa_audit ──
 server.tool('rgaa_audit', 'Lancer un audit d\'accessibilité RGAA 4.1 complet sur une URL. Retourne les violations avec critères RGAA, impact, et suggestions de correction.', {
@@ -64,10 +151,20 @@ server.tool('rgaa_audit', 'Lancer un audit d\'accessibilité RGAA 4.1 complet su
         const critique = violations.filter(v => v.impact === 'critical').length;
         const serieux = violations.filter(v => v.impact === 'serious').length;
         const modere = violations.filter(v => v.impact === 'moderate').length;
+        const uniqueViolations = result.violationsInSharedZones
+            ? result.violations - result.violationsInSharedZones
+            : result.violations;
+        const sharedInfo = result.violationsInSharedZones
+            ? ` (dont ${result.violationsInSharedZones} dans des zones partagées nav/header/footer)`
+            : '';
         let text = `# Audit RGAA 4.1 — ${url}\n\n` +
             `**Score** : ${result.score}% — ${result.conformity}\n` +
-            `**${result.violations} non-conformités** sur ${result.pages} pages\n` +
-            `- ${critique} critique(s), ${serieux} sérieuse(s), ${modere} modérée(s)\n\n`;
+            `**${result.violations} non-conformités**${sharedInfo} sur ${result.pages} pages\n` +
+            `- ${critique} critique(s), ${serieux} sérieuse(s), ${modere} modérée(s)\n`;
+        if (result.coverage) {
+            text += `- **Couverture RGAA** : ${result.coverage.percentage}% (${result.coverage.mappedCriteria}/${result.coverage.totalCriteria} critères testés)\n`;
+        }
+        text += '\n';
         if (result.patterns && result.patterns.length > 0) {
             text += `## Patterns de correction (${result.patterns.length})\n\n`;
             for (const p of result.patterns) {
@@ -81,7 +178,7 @@ server.tool('rgaa_audit', 'Lancer un audit d\'accessibilité RGAA 4.1 complet su
                 text += `### ${i + 1}. ${v.criteriaTitle || v.description}\n`;
                 text += `- **Critère RGAA** : ${v.criteria || 'N/A'}${v.theme ? ` (${v.theme})` : ''}\n`;
                 text += `- **Impact** : ${v.impact}\n`;
-                text += `- **Éléments** : ${v.nodesCount} nœuds sur ${v.pagesCount} pages\n`;
+                text += `- **Éléments** : ${v.nodesCount} nœuds\n`;
                 if (v.zone)
                     text += `- **Zone** : ${v.zone}\n`;
                 if (v.suggestion)
@@ -104,13 +201,29 @@ server.tool('rgaa_score', 'Score de conformité RGAA rapide pour une URL. Retour
     url: z.string().url().describe('URL du site web'),
 }, async ({ url }) => {
     try {
-        const result = await callScan(url);
-        const text = `**Score RGAA** : ${result.score}%\n` +
+        // Appeler avec details pour inclure un résumé des top violations
+        const result = await callScan(url, { details: true });
+        const violations = result.violationDetails || [];
+        // Top 5 violations triées par impact (critique > sérieux > modéré)
+        const impactOrder = { critical: 0, critique: 0, serious: 1, serieux: 1, moderate: 2, modere: 2, minor: 3, mineur: 3 };
+        const top5 = [...violations]
+            .sort((a, b) => (impactOrder[a.impact] ?? 9) - (impactOrder[b.impact] ?? 9))
+            .slice(0, 5);
+        let text = `**Score RGAA** : ${result.score}%\n` +
             `**Conformité** : ${result.conformity}\n` +
             `**Violations** : ${result.violations}\n` +
-            `**Pages analysées** : ${result.pages}\n` +
-            `**URL** : ${url}\n\n` +
-            `🔗 Détails : ${result.auditUrl}`;
+            `**Pages analysées** : ${result.pages}\n`;
+        if (result.coverage) {
+            text += `**Couverture** : ${result.coverage.percentage}% des critères RGAA testés\n`;
+        }
+        text += `**URL** : ${url}\n`;
+        if (top5.length > 0) {
+            text += `\n**Top violations** :\n`;
+            for (const v of top5) {
+                text += `- [${v.impact}] ${v.criteria || ''} ${v.criteriaTitle || v.description} (${v.nodesCount} nœuds)\n`;
+            }
+        }
+        text += `\n🔗 Détails : ${result.auditUrl}`;
         return { content: [{ type: 'text', text }] };
     }
     catch (error) {
@@ -130,7 +243,7 @@ server.tool('rgaa_check', 'Vérifier un critère RGAA spécifique sur une URL. P
         }
         const text = `❌ Critère RGAA ${criteria} : **${matching.length} violation(s)** sur ${url}\n\n` +
             matching.map(v => `- **${v.criteriaTitle || v.description}** (${v.impact})\n` +
-                `  ${v.nodesCount} nœuds sur ${v.pagesCount} pages\n` +
+                `  ${v.nodesCount} nœuds\n` +
                 (v.suggestion ? `  💡 ${v.suggestion}\n` : '')).join('\n') +
             `\n🔗 Détails : ${result.auditUrl}`;
         return { content: [{ type: 'text', text }] };
@@ -171,7 +284,275 @@ server.tool('rgaa_explain', 'Explique un critère RGAA 4.1 avec sa description,
         (info.exemple ? `## Exemple\n${info.exemple}\n` : '');
     return { content: [{ type: 'text', text }] };
 });
-// ── Outil 5 : rgaa_report ──
+// ── Outil 5 : rgaa_fix (local, pas d'API) ──
+/**
+ * Base de corrections pour les règles axe-core / RGAA les plus courantes.
+ * Chaque entrée contient des exemples de code avant/après pour HTML, Vue et React.
+ */
+const RGAA_FIXES = {
+    'image-alt': {
+        rule: 'image-alt',
+        criteria: '1.1',
+        description: 'Image sans alternative textuelle',
+        fixes: {
+            html: '```html\n<!-- Avant -->\n<img src="photo.jpg">\n\n<!-- Après (informative) -->\n<img src="photo.jpg" alt="Description de l\'image">\n\n<!-- Après (décorative) -->\n<img src="decoration.svg" alt="" role="presentation">\n```',
+            vue: '```vue\n<!-- Avant -->\n<img :src="imageUrl" />\n\n<!-- Après -->\n<img :src="imageUrl" :alt="imageAlt" />\n\n<!-- Décorative -->\n<img :src="bgUrl" alt="" role="presentation" />\n```',
+            react: '```tsx\n// Avant\n<img src={imageUrl} />\n\n// Après\n<img src={imageUrl} alt="Description de l\'image" />\n\n// Décorative\n<img src={bgUrl} alt="" role="presentation" />\n```',
+        },
+    },
+    'color-contrast': {
+        rule: 'color-contrast',
+        criteria: '3.3',
+        description: 'Contraste insuffisant entre texte et fond',
+        fixes: {
+            html: '```css\n/* Avant — ratio 2.1:1 */\ncolor: #999; background: #fff;\n\n/* Après — ratio 7.4:1 */\ncolor: #333; background: #fff;\n\n/* Vérifier : https://webaim.org/resources/contrastchecker/ */\n/* Minimum : 4.5:1 (texte normal), 3:1 (texte ≥18pt ou 14pt gras) */\n```',
+            vue: '```vue\n<!-- Utiliser des tokens sémantiques au lieu de couleurs hardcodées -->\n<p class="text-foreground">Texte principal</p>\n<p class="text-muted-foreground">Texte secondaire</p>\n\n<!-- Vérifier dans tailwind.config.ts que les tokens respectent le ratio 4.5:1 -->\n```',
+            react: '```tsx\n// Utiliser des tokens CSS au lieu de couleurs inline\n<p className="text-foreground">Texte principal</p>\n<p className="text-muted-foreground">Texte secondaire</p>\n```',
+        },
+    },
+    'link-name': {
+        rule: 'link-name',
+        criteria: '6.1',
+        description: 'Lien sans intitulé accessible',
+        fixes: {
+            html: '```html\n<!-- Avant (lien icône sans texte) -->\n<a href="/menu"><svg>...</svg></a>\n\n<!-- Après — aria-label -->\n<a href="/menu" aria-label="Ouvrir le menu"><svg aria-hidden="true">...</svg></a>\n\n<!-- Après — texte sr-only -->\n<a href="/menu"><svg aria-hidden="true">...</svg><span class="sr-only">Ouvrir le menu</span></a>\n\n<!-- Après — SVG title -->\n<a href="/menu"><svg><title>Ouvrir le menu</title>...</svg></a>\n```',
+            vue: '```vue\n<!-- Avant -->\n<a :href="url"><Icon name="menu" /></a>\n\n<!-- Après -->\n<a :href="url" aria-label="Ouvrir le menu"><Icon name="menu" aria-hidden="true" /></a>\n\n<!-- Avec composant -->\n<NuxtLink :to="url" aria-label="Ouvrir le menu"><Icon name="menu" aria-hidden="true" /></NuxtLink>\n```',
+            react: '```tsx\n// Avant\n<a href={url}><MenuIcon /></a>\n\n// Après\n<a href={url} aria-label="Ouvrir le menu"><MenuIcon aria-hidden /></a>\n```',
+        },
+    },
+    'label': {
+        rule: 'label',
+        criteria: '11.1',
+        description: 'Champ de formulaire sans étiquette',
+        fixes: {
+            html: '```html\n<!-- Avant -->\n<input type="email" placeholder="Email">\n\n<!-- Après — label explicite -->\n<label for="email">Adresse email</label>\n<input id="email" type="email" placeholder="ex: nom@domaine.fr">\n\n<!-- Après — aria-label (si label visuel impossible) -->\n<input type="search" aria-label="Rechercher sur le site" placeholder="Rechercher...">\n```',
+            vue: '```vue\n<!-- Avant -->\n<Input type="email" placeholder="Email" />\n\n<!-- Après -->\n<div class="space-y-1">\n  <Label for="email">Adresse email</Label>\n  <Input id="email" type="email" placeholder="ex: nom@domaine.fr" />\n</div>\n```',
+            react: '```tsx\n// Avant\n<input type="email" placeholder="Email" />\n\n// Après\n<label htmlFor="email">Adresse email</label>\n<input id="email" type="email" placeholder="ex: nom@domaine.fr" />\n```',
+        },
+    },
+    'button-name': {
+        rule: 'button-name',
+        criteria: '11.9',
+        description: 'Bouton sans intitulé accessible',
+        fixes: {
+            html: '```html\n<!-- Avant -->\n<button><svg>...</svg></button>\n\n<!-- Après -->\n<button aria-label="Fermer"><svg aria-hidden="true">...</svg></button>\n\n<!-- Ou avec texte visible -->\n<button><svg aria-hidden="true">...</svg> Fermer</button>\n```',
+            vue: '```vue\n<!-- Avant -->\n<Button size="icon"><X /></Button>\n\n<!-- Après -->\n<Button size="icon" aria-label="Fermer"><X aria-hidden="true" /></Button>\n```',
+            react: '```tsx\n// Avant\n<button><XIcon /></button>\n\n// Après\n<button aria-label="Fermer"><XIcon aria-hidden /></button>\n```',
+        },
+    },
+    'html-has-lang': {
+        rule: 'html-has-lang',
+        criteria: '8.3',
+        description: 'Langue de la page non déclarée',
+        fixes: {
+            html: '```html\n<!-- Avant -->\n<html>\n\n<!-- Après -->\n<html lang="fr">\n```',
+            vue: '```typescript\n// nuxt.config.ts\nexport default defineNuxtConfig({\n  app: {\n    head: {\n      htmlAttrs: { lang: \'fr\' },\n    },\n  },\n})\n```',
+            react: '```tsx\n// Avant\n<html>\n\n// Après\n<html lang="fr">\n\n// Next.js — layout.tsx\nexport default function RootLayout({ children }) {\n  return <html lang="fr">{children}</html>\n}\n```',
+        },
+    },
+    'bypass': {
+        rule: 'bypass',
+        criteria: '12.7',
+        description: 'Pas de lien d\'évitement vers le contenu principal',
+        fixes: {
+            html: '```html\n<!-- Ajouter en tout premier dans <body> -->\n<a href="#main-content" class="sr-only focus:not-sr-only focus:absolute focus:top-2 focus:left-2 focus:z-50 focus:bg-background focus:p-2 focus:rounded">\n  Aller au contenu principal\n</a>\n\n<!-- Ajouter id sur le contenu principal -->\n<main id="main-content">...</main>\n```',
+            vue: '```vue\n<!-- layouts/default.vue ou app.vue -->\n<template>\n  <a href="#main-content" class="sr-only focus:not-sr-only focus:absolute focus:top-2 focus:left-2 focus:z-50 focus:bg-background focus:p-2 focus:rounded">\n    Aller au contenu principal\n  </a>\n  <header>...</header>\n  <main id="main-content"><slot /></main>\n</template>\n```',
+            react: '```tsx\n// Layout.tsx\nexport default function Layout({ children }) {\n  return (\n    <>\n      <a href="#main-content" className="sr-only focus:not-sr-only ...">\n        Aller au contenu principal\n      </a>\n      <Header />\n      <main id="main-content">{children}</main>\n    </>\n  )\n}\n```',
+        },
+    },
+    'landmark-one-main': {
+        rule: 'landmark-one-main',
+        criteria: '12.9',
+        description: 'Page sans élément <main>',
+        fixes: {
+            html: '```html\n<!-- Avant -->\n<body>\n  <div class="content">...</div>\n</body>\n\n<!-- Après -->\n<body>\n  <header>...</header>\n  <nav>...</nav>\n  <main>...</main>\n  <footer>...</footer>\n</body>\n```',
+            vue: '```vue\n<!-- layouts/default.vue -->\n<template>\n  <header><AppNav /></header>\n  <main><slot /></main>\n  <footer><AppFooter /></footer>\n</template>\n```',
+            react: '```tsx\n// Layout.tsx\nexport default function Layout({ children }) {\n  return (\n    <>\n      <header><Nav /></header>\n      <main>{children}</main>\n      <footer><Footer /></footer>\n    </>\n  )\n}\n```',
+        },
+    },
+    'link-in-text-block': {
+        rule: 'link-in-text-block',
+        criteria: '10.6',
+        description: 'Liens non distinguables du texte environnant',
+        fixes: {
+            html: '```css\n/* Ajouter un soulignement ou un indicateur non-couleur */\na { text-decoration: underline; }\na:hover { text-decoration: none; border-bottom: 2px solid; }\n```',
+            vue: '```vue\n<!-- Tailwind -->\n<a href="/page" class="underline hover:no-underline hover:border-b-2 hover:border-current">\n  Lien dans un paragraphe\n</a>\n```',
+            react: '```tsx\n<a href="/page" className="underline hover:no-underline hover:border-b-2">\n  Lien dans un paragraphe\n</a>\n```',
+        },
+    },
+    'target-blank': {
+        rule: 'custom-new-window-warning',
+        criteria: '13.2',
+        description: 'Lien target="_blank" sans avertissement',
+        fixes: {
+            html: '```html\n<!-- Avant -->\n<a href="https://example.com" target="_blank">Site externe</a>\n\n<!-- Après — texte sr-only -->\n<a href="https://example.com" target="_blank" rel="noopener">\n  Site externe <span class="sr-only">(nouvelle fenêtre)</span>\n</a>\n\n<!-- Après — aria-label -->\n<a href="https://example.com" target="_blank" rel="noopener"\n   aria-label="Site externe (nouvelle fenêtre)">\n  Site externe\n</a>\n```',
+            vue: '```vue\n<!-- Composant réutilisable -->\n<template>\n  <a :href="href" target="_blank" rel="noopener">\n    <slot />\n    <ExternalLinkIcon class="inline h-3 w-3 ml-1" aria-hidden="true" />\n    <span class="sr-only">(nouvelle fenêtre)</span>\n  </a>\n</template>\n```',
+            react: '```tsx\n// Composant réutilisable\nfunction ExternalLink({ href, children }) {\n  return (\n    <a href={href} target="_blank" rel="noopener">\n      {children}\n      <ExternalLinkIcon className="inline h-3 w-3 ml-1" aria-hidden />\n      <span className="sr-only">(nouvelle fenêtre)</span>\n    </a>\n  )\n}\n```',
+        },
+    },
+};
+server.tool('rgaa_fix', 'Retourne le code correctif pour une violation RGAA. Fournit des exemples avant/après en HTML, Vue et React.', {
+    ruleId: z.string().describe('ID de la règle axe-core (ex: image-alt, color-contrast, link-name, label, button-name, bypass, target-blank)'),
+    framework: z.enum(['html', 'vue', 'react']).default('html').describe('Framework cible pour les exemples de code'),
+}, async ({ ruleId, framework }) => {
+    const fix = RGAA_FIXES[ruleId];
+    if (!fix) {
+        const available = Object.keys(RGAA_FIXES).join(', ');
+        return { content: [{ type: 'text', text: `Règle "${ruleId}" non trouvée dans la base de corrections.\n\nRègles disponibles : ${available}\n\nUtilisez \`rgaa_explain\` pour comprendre le critère RGAA associé.` }] };
+    }
+    const code = fix.fixes[framework] || fix.fixes['html'];
+    const text = `# Correction — ${fix.rule} (RGAA ${fix.criteria})\n\n` +
+        `**Problème** : ${fix.description}\n\n` +
+        `## Code correctif (${framework})\n\n${code}\n\n` +
+        (framework !== 'html' && fix.fixes['html'] ? `## Version HTML de référence\n\n${fix.fixes['html']}\n` : '');
+    return { content: [{ type: 'text', text }] };
+});
+// ── Outil 6 : rgaa_remediate ──
+/**
+ * Règles pour lesquelles on sait générer un fix automatique.
+ * Mappées vers les clés de RGAA_FIXES.
+ */
+const FIXABLE_RULES = new Set(Object.keys(RGAA_FIXES));
+/**
+ * Ordre de priorité des impacts pour le tri
+ */
+const IMPACT_PRIORITY = {
+    critical: 0, critique: 0,
+    serious: 1, serieux: 1,
+    moderate: 2, modere: 2,
+    minor: 3, mineur: 3,
+};
+server.tool('rgaa_remediate', 'Plan de remédiation autonome : audite, priorise les violations corrigeables, et retourne un plan d\'action structuré avec le code correctif pour chaque violation. L\'agent AI applique ensuite les fixes via ses outils (file system, browser). Sur localhost = re-audits gratuits. Sur site distant = chaque re-audit consomme le quota.', {
+    url: z.string().url().describe('URL du site à corriger'),
+    framework: z.enum(['html', 'vue', 'react']).default('html').describe('Framework cible pour le code correctif'),
+    targetScore: z.number().min(0).max(100).default(80).describe('Score cible à atteindre (défaut: 80%)'),
+    maxFixes: z.number().min(1).max(30).default(10).describe('Nombre max de violations à traiter (défaut: 10)'),
+}, async ({ url, framework, targetScore, maxFixes }) => {
+    try {
+        const result = await callScan(url, { details: true });
+        const violations = result.violationDetails || [];
+        const isLocal = isLocalUrl(url);
+        if (violations.length === 0) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `# Remédiation RGAA — ${url}\n\n` +
+                            `**Score actuel** : ${result.score}%\n` +
+                            `**Aucune violation détectée.** Le site est conforme aux critères testés.\n\n` +
+                            (result.coverage ? `Note : ${result.coverage.percentage}% des critères RGAA sont testés automatiquement. Les ${100 - result.coverage.percentage}% restants nécessitent un audit humain.` : ''),
+                    }],
+            };
+        }
+        if (result.score >= targetScore) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `# Remédiation RGAA — ${url}\n\n` +
+                            `**Score actuel** : ${result.score}% (cible : ${targetScore}%)\n` +
+                            `**Score cible déjà atteint.** ${violations.length} violation(s) restante(s) de priorité basse.\n\n` +
+                            `Pour aller plus loin, relancez avec un targetScore plus élevé.`,
+                    }],
+            };
+        }
+        // Séparer violations corrigeables (on a un fix) vs manuelles
+        const fixable = [];
+        const manual = [];
+        for (const v of violations) {
+            if (FIXABLE_RULES.has(v.ruleId)) {
+                fixable.push(v);
+            }
+            else {
+                manual.push(v);
+            }
+        }
+        // Trier par impact (critique d'abord) puis par nombre de nœuds (plus d'impact)
+        fixable.sort((a, b) => {
+            const impactDiff = (IMPACT_PRIORITY[a.impact] ?? 9) - (IMPACT_PRIORITY[b.impact] ?? 9);
+            if (impactDiff !== 0)
+                return impactDiff;
+            return b.nodesCount - a.nodesCount;
+        });
+        // Limiter au max demandé
+        const toFix = fixable.slice(0, maxFixes);
+        // Construire le plan de remédiation
+        let text = `# Plan de remédiation RGAA — ${url}\n\n`;
+        text += `| Métrique | Valeur |\n|----------|--------|\n`;
+        text += `| Score actuel | ${result.score}% |\n`;
+        text += `| Score cible | ${targetScore}% |\n`;
+        text += `| Violations totales | ${violations.length} |\n`;
+        text += `| Corrigeables auto | ${fixable.length} |\n`;
+        text += `| Manuelles | ${manual.length} |\n`;
+        text += `| Fixes dans ce plan | ${toFix.length} |\n`;
+        if (isLocal) {
+            text += `| Mode | **Localhost** (re-audits gratuits) |\n`;
+        }
+        else {
+            text += `| Mode | **Distant** (re-audit = 1 quota) |\n`;
+        }
+        text += '\n';
+        // Score estimé après corrections
+        const estimatedGain = Math.min(30, toFix.length * 3);
+        const estimatedScore = Math.min(100, result.score + estimatedGain);
+        text += `**Score estimé après corrections** : ~${estimatedScore}% (+${estimatedGain} points)\n\n`;
+        text += `---\n\n## Corrections à appliquer (${toFix.length})\n\n`;
+        text += `Appliquez chaque fix dans l'ordre. Après le dernier fix, lancez \`rgaa_score\` pour mesurer l'amélioration.\n\n`;
+        for (const [i, v] of toFix.entries()) {
+            const fix = RGAA_FIXES[v.ruleId];
+            const code = fix.fixes[framework] || fix.fixes['html'];
+            text += `### Fix ${i + 1}/${toFix.length} — ${v.ruleId} (RGAA ${v.criteria || '?'})\n\n`;
+            text += `- **Problème** : ${fix.description}\n`;
+            text += `- **Impact** : ${v.impact}\n`;
+            text += `- **Éléments** : ${v.nodesCount} nœuds affectés\n`;
+            if (v.zone)
+                text += `- **Zone** : ${v.zone}\n`;
+            // Exemples de nœuds à corriger
+            if (v.nodes.length > 0) {
+                text += `- **Éléments à corriger** :\n`;
+                for (const n of v.nodes.slice(0, 3)) {
+                    text += `  - \`${n.target}\`\n`;
+                }
+                if (v.nodes.length > 3)
+                    text += `  - ... et ${v.nodes.length - 3} autres\n`;
+            }
+            text += `\n**Code correctif (${framework})** :\n\n${code}\n\n`;
+            if (v.suggestion && v.suggestion !== fix.description) {
+                text += `**Suggestion** : ${v.suggestion}\n\n`;
+            }
+            text += `---\n\n`;
+        }
+        // Violations manuelles (pas de fix automatique)
+        if (manual.length > 0) {
+            text += `## Violations manuelles (${manual.length})\n\n`;
+            text += `Ces violations n'ont pas de fix automatique. Elles nécessitent une analyse humaine :\n\n`;
+            const manualSorted = [...manual].sort((a, b) => (IMPACT_PRIORITY[a.impact] ?? 9) - (IMPACT_PRIORITY[b.impact] ?? 9));
+            for (const v of manualSorted.slice(0, 10)) {
+                text += `- **[${v.impact}]** ${v.criteria || ''} ${v.criteriaTitle || v.description} (${v.nodesCount} nœuds)\n`;
+            }
+            if (manual.length > 10)
+                text += `- ... et ${manual.length - 10} autres\n`;
+            text += '\n';
+        }
+        // Instructions pour l'agent
+        text += `## Instructions pour l'agent\n\n`;
+        text += `1. Pour chaque fix ci-dessus, identifiez le fichier source concerné\n`;
+        text += `2. Appliquez le code correctif adapté au composant\n`;
+        text += `3. Après toutes les corrections, exécutez :\n`;
+        text += `   - \`rgaa_score("${url}")\` pour mesurer l'amélioration\n`;
+        if (isLocal) {
+            text += `   - Re-audits **gratuits** (scan local, pas de quota)\n`;
+        }
+        else {
+            text += `   - Chaque re-audit **consomme 1 crédit** du quota utilisateur\n`;
+        }
+        text += `4. Si le score < ${targetScore}%, relancez \`rgaa_remediate\` pour le cycle suivant\n`;
+        text += `5. Vérifiez visuellement avec \`browser_screenshot\` que le rendu n'est pas cassé\n`;
+        return { content: [{ type: 'text', text }] };
+    }
+    catch (error) {
+        return { content: [{ type: 'text', text: `Erreur : ${error instanceof Error ? error.message : String(error)}` }], isError: true };
+    }
+});
+// ── Outil 7 : rgaa_report ──
 server.tool('rgaa_report', 'Génère un rapport d\'audit RGAA structuré en JSON pour intégration CI/CD ou export.', {
     url: z.string().url().describe('URL du site web'),
     threshold: z.number().min(0).max(100).default(0).describe('Score minimum pour pass/fail (0 = pas de seuil)'),

package/dist/local-scanner.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Scanner local axe-core — Mode localhost
+ *
+ * Utilise puppeteer-core (Chrome existant) + @axe-core/puppeteer
+ * pour auditer des URLs localhost sans passer par l'API distante.
+ *
+ * Le mapping RGAA est ensuite récupéré via POST /api/ci/map.
+ */
+/** Résultat brut d'un scan local axe-core */
+export interface LocalScanResult {
+    url: string;
+    violations: LocalViolation[];
+    passes: number;
+    incomplete: number;
+    timestamp: string;
+}
+export interface LocalViolation {
+    ruleId: string;
+    impact: string;
+    description: string;
+    help: string;
+    helpUrl: string;
+    nodesCount: number;
+    nodes: Array<{
+        html: string;
+        target: string;
+    }>;
+}
+/** Mapping RGAA retourné par /api/ci/map */
+export interface RgaaMapping {
+    criteria: string;
+    title: string;
+    theme: string | null;
+    impact: string | null;
+    help: string | null;
+    level: string | null;
+    example: string | null;
+}
+export interface MapResponse {
+    mappings: Record<string, RgaaMapping>;
+    coverage: {
+        mappedCriteria: number;
+        totalCriteria: number;
+        percentage: number;
+    };
+}
+/**
+ * Détecte si une URL est locale (localhost, 127.0.0.1, 0.0.0.0)
+ */
+export declare function isLocalUrl(url: string): boolean;
+/**
+ * Lance un scan axe-core local sur une URL
+ *
+ * @param url - URL locale à scanner (localhost, 127.0.0.1)
+ * @returns Violations axe-core brutes
+ */
+export declare function scanLocal(url: string): Promise<LocalScanResult>;
+/**
+ * Appelle POST /api/ci/map pour enrichir les violations avec le mapping RGAA
+ *
+ * @param ruleIds - Liste de ruleIds axe-core
+ * @param apiUrl - URL de l'API RGAAudit
+ * @param apiKey - Clé API
+ * @returns Mappings RGAA ou null si l'API est inaccessible
+ */
+export declare function fetchRgaaMappings(ruleIds: string[], apiUrl: string, apiKey: string): Promise<MapResponse | null>;

package/dist/local-scanner.js

@@ -0,0 +1,156 @@
+/**
+ * Scanner local axe-core — Mode localhost
+ *
+ * Utilise puppeteer-core (Chrome existant) + @axe-core/puppeteer
+ * pour auditer des URLs localhost sans passer par l'API distante.
+ *
+ * Le mapping RGAA est ensuite récupéré via POST /api/ci/map.
+ */
+/**
+ * Détecte si une URL est locale (localhost, 127.0.0.1, 0.0.0.0)
+ */
+export function isLocalUrl(url) {
+    try {
+        const parsed = new URL(url);
+        return (parsed.hostname === 'localhost' ||
+            parsed.hostname === '127.0.0.1' ||
+            parsed.hostname === '0.0.0.0' ||
+            parsed.hostname === '::1');
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Trouve le chemin de Chrome/Chromium installé sur le système
+ */
+async function findChromePath() {
+    const { existsSync } = await import('fs');
+    const { join } = await import('path');
+    // Variable d'env explicite (priorité absolue, pas d'exécution shell)
+    if (process.env.CHROME_PATH && existsSync(process.env.CHROME_PATH)) {
+        return process.env.CHROME_PATH;
+    }
+    // Chemins connus par OS (pas d'exécution shell, pas d'injection possible)
+    const candidates = [];
+    // Windows — chemins standards via variables d'env système
+    const winDirs = [
+        process.env['PROGRAMFILES'],
+        process.env['PROGRAMFILES(X86)'],
+        process.env['LOCALAPPDATA'],
+    ].filter(Boolean);
+    for (const dir of winDirs) {
+        candidates.push(join(dir, 'Google', 'Chrome', 'Application', 'chrome.exe'));
+        candidates.push(join(dir, 'Microsoft', 'Edge', 'Application', 'msedge.exe'));
+    }
+    // macOS
+    candidates.push('/Applications/Google Chrome.app/Contents/MacOS/Google Chrome', '/Applications/Chromium.app/Contents/MacOS/Chromium', '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge');
+    // Linux
+    candidates.push('/usr/bin/google-chrome', '/usr/bin/google-chrome-stable', '/usr/bin/chromium', '/usr/bin/chromium-browser', '/snap/bin/chromium');
+    for (const p of candidates) {
+        if (existsSync(p))
+            return p;
+    }
+    return null;
+}
+/**
+ * Lance un scan axe-core local sur une URL
+ *
+ * @param url - URL locale à scanner (localhost, 127.0.0.1)
+ * @returns Violations axe-core brutes
+ */
+export async function scanLocal(url) {
+    // Validation URL : seuls http/https autorisés, longueur limitée
+    const parsed = new URL(url);
+    if (!['http:', 'https:'].includes(parsed.protocol)) {
+        throw new Error('Seuls les protocoles http et https sont autorisés');
+    }
+    if (url.length > 2048) {
+        throw new Error('URL trop longue (max 2048 caractères)');
+    }
+    const chromePath = await findChromePath();
+    if (!chromePath) {
+        throw new Error('Chrome/Chromium non trouvé sur ce système.\n\n' +
+            'Le scan localhost nécessite un navigateur Chromium installé.\n' +
+            'Installez Google Chrome ou Chromium, puis réessayez.\n\n' +
+            'Chemins recherchés :\n' +
+            '- Windows : Program Files\\Google\\Chrome\\Application\\chrome.exe\n' +
+            '- macOS : /Applications/Google Chrome.app\n' +
+            '- Linux : /usr/bin/google-chrome ou /usr/bin/chromium');
+    }
+    // Import dynamique pour ne pas crasher si les deps ne sont pas installées
+    const puppeteer = await import('puppeteer-core');
+    const { AxePuppeteer } = await import('@axe-core/puppeteer');
+    let browser = null;
+    try {
+        browser = await puppeteer.default.launch({
+            executablePath: chromePath,
+            headless: true,
+            args: [
+                '--no-sandbox',
+                '--disable-setuid-sandbox',
+                '--disable-dev-shm-usage',
+                '--disable-gpu',
+                '--disable-extensions',
+            ],
+        });
+        const page = await browser.newPage();
+        await page.setViewport({ width: 1280, height: 720 });
+        // Naviguer avec timeout
+        await page.goto(url, { waitUntil: 'networkidle2', timeout: 30_000 });
+        // Lancer axe-core
+        const results = await new AxePuppeteer(page)
+            .withTags(['wcag2a', 'wcag2aa', 'wcag21a', 'wcag21aa', 'best-practice'])
+            .analyze();
+        const violations = results.violations.map(v => ({
+            ruleId: v.id,
+            impact: v.impact || 'moderate',
+            description: v.description,
+            help: v.help,
+            helpUrl: v.helpUrl,
+            nodesCount: v.nodes.length,
+            nodes: v.nodes.slice(0, 5).map(n => ({
+                html: (n.html || '').slice(0, 200),
+                target: Array.isArray(n.target) ? n.target.join(' > ') : String(n.target),
+            })),
+        }));
+        return {
+            url,
+            violations,
+            passes: results.passes.length,
+            incomplete: results.incomplete.length,
+            timestamp: new Date().toISOString(),
+        };
+    }
+    finally {
+        if (browser)
+            await browser.close().catch(() => { });
+    }
+}
+/**
+ * Appelle POST /api/ci/map pour enrichir les violations avec le mapping RGAA
+ *
+ * @param ruleIds - Liste de ruleIds axe-core
+ * @param apiUrl - URL de l'API RGAAudit
+ * @param apiKey - Clé API
+ * @returns Mappings RGAA ou null si l'API est inaccessible
+ */
+export async function fetchRgaaMappings(ruleIds, apiUrl, apiKey) {
+    try {
+        const res = await fetch(`${apiUrl}/api/ci/map`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-API-Key': apiKey,
+            },
+            body: JSON.stringify({ ruleIds }),
+        });
+        if (!res.ok)
+            return null;
+        return res.json();
+    }
+    catch {
+        // API inaccessible (offline, pas de connexion) → retour null
+        return null;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rgaaudit/mcp-server",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "MCP Server RGAA 4.1 — Audit d'accessibilité pour Claude Code, Cursor, Copilot",
   "type": "module",
   "main": "dist/index.js",
@@ -18,7 +18,9 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
+    "@axe-core/puppeteer": "^4.11.1",
     "@modelcontextprotocol/sdk": "^1.12.1",
+    "puppeteer-core": "^24.40.0",
     "zod": "^3.25.3"
   },
   "devDependencies": {
@@ -28,7 +30,16 @@
   "engines": {
     "node": ">=18.0.0"
   },
-  "keywords": ["mcp", "rgaa", "accessibility", "a11y", "wcag", "audit", "france", "rgaa4"],
+  "keywords": [
+    "mcp",
+    "rgaa",
+    "accessibility",
+    "a11y",
+    "wcag",
+    "audit",
+    "france",
+    "rgaa4"
+  ],
   "license": "MIT",
   "repository": {
     "type": "git",