bricks-builder-mcp 3.2.0 → 3.5.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "bricks-builder-mcp",
-  "version": "3.2.0",
+  "version": "3.5.0",
   "description": "Serveur MCP pour piloter Bricks Builder (WordPress) depuis Claude — édition de pages, gestion d'éléments, réordonnancement des sections.",
   "main": "server.js",
   "bin": {

package/server.js

@@ -386,6 +386,407 @@ mcpServer.setRequestHandler(ListToolsRequestSchema, async () => {
           required: ["title"],
         },
       },
+
+      // ===== OUTILS v3.3.0 — GESTION DES PAGES =====
+
+      {
+        name: "delete_page",
+        description: "Supprime une page WordPress. Par défaut la met à la corbeille (récupérable). Utilise force=true pour supprimer définitivement (irréversible). Refuse de supprimer la page d'accueil active — la changer d'abord.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            pageId: { type: "number", description: "L'ID de la page à supprimer" },
+            force: { type: "boolean", description: "Si true, suppression définitive. Sinon, mise à la corbeille (défaut: false)" },
+          },
+          required: ["pageId"],
+        },
+      },
+      {
+        name: "update_page_meta",
+        description: "Met à jour les méta-données d'une page (titre, slug URL, statut de publication, page parente). Seuls les champs fournis sont modifiés. Utile pour renommer, changer l'URL, publier un draft, organiser la hiérarchie.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            pageId: { type: "number", description: "L'ID de la page à modifier" },
+            title: { type: "string", description: "Nouveau titre (optionnel)" },
+            slug: { type: "string", description: "Nouveau slug URL (optionnel, ex: 'accueil')" },
+            status: { type: "string", enum: ["publish", "draft", "private", "pending"], description: "Nouveau statut de publication (optionnel)" },
+            parentId: { type: "number", description: "ID de la page parente (0 = racine, optionnel)" },
+          },
+          required: ["pageId"],
+        },
+      },
+      {
+        name: "duplicate_page",
+        description: "Duplique une page existante avec son contenu Bricks complet (sections, éléments, settings). Très utile pour créer des variantes à partir d'une page bien faite, ou pour partir d'un template existant. La copie est créée en draft par défaut.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            sourcePageId: { type: "number", description: "ID de la page source à dupliquer" },
+            newTitle: { type: "string", description: "Titre de la copie (optionnel, défaut: 'Copie de {original}')" },
+            status: { type: "string", enum: ["publish", "draft", "private", "pending"], description: "Statut de la copie (défaut: 'draft')" },
+          },
+          required: ["sourcePageId"],
+        },
+      },
+      {
+        name: "set_homepage",
+        description: "Définit une page comme page d'accueil du site WordPress. La page doit être publiée. Pour réinitialiser sur les derniers articles (mode WordPress par défaut), passer reset=true.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            pageId: { type: "number", description: "ID de la page à mettre en accueil" },
+            reset: { type: "boolean", description: "Si true, reset sur les derniers articles (pageId ignoré)" },
+          },
+        },
+      },
+
+      // ===== OUTILS v3.4.0 — HEALTH, MÉDIAS, MENUS, STYLES GLOBAUX =====
+
+      {
+        name: "health_check",
+        description: "Test de connexion au site WordPress + infos système (versions plugin/WP/PHP/Bricks, multisite, URL). Utile pour debug et confirmer qu'on parle au bon site.",
+        inputSchema: { type: "object", properties: {} },
+      },
+      {
+        name: "list_all_pages",
+        description: "Liste TOUTES les pages WordPress du site (pas seulement celles avec contenu Bricks). Inclut les pages WP standard. Utile pour avoir l'inventaire complet avant de créer/dupliquer/nettoyer.",
+        inputSchema: { type: "object", properties: {} },
+      },
+      {
+        name: "upload_media",
+        description: "Télécharge une image depuis une URL et l'ajoute à la médiathèque WordPress. Renvoie l'URL WP de l'image, prête à utiliser dans les éléments Bricks (image, background, etc.). Très utile pour intégrer des photos client sans passer par la médiathèque WP manuellement.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            sourceUrl: { type: "string", description: "URL publique de l'image à télécharger (jpg/png/webp/gif/svg)" },
+            title: { type: "string", description: "Titre de l'image dans la médiathèque (optionnel)" },
+            alt: { type: "string", description: "Alt text pour SEO/accessibilité (optionnel mais fortement recommandé)" },
+            caption: { type: "string", description: "Légende affichée sous l'image (optionnel)" },
+          },
+          required: ["sourceUrl"],
+        },
+      },
+      {
+        name: "list_media",
+        description: "Liste paginée des médias de la médiathèque WordPress avec leurs URLs. Filtrable par recherche. Utile pour retrouver des images déjà uploadées.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            page: { type: "number", description: "Page de pagination (défaut: 1)" },
+            perPage: { type: "number", description: "Nombre par page (défaut: 20, max: 100)" },
+            search: { type: "string", description: "Recherche textuelle dans les titres/noms de fichier" },
+          },
+        },
+      },
+      {
+        name: "list_menus",
+        description: "Liste les menus de navigation WordPress du site avec leur nombre d'items et les emplacements assignés (header, footer, etc.). À utiliser avant add_menu_item.",
+        inputSchema: { type: "object", properties: {} },
+      },
+      {
+        name: "add_menu_item",
+        description: "Ajoute un item à un menu WordPress de navigation. Soit on lie une page existante (via pageId), soit un lien custom (via customUrl + label). Très utile pour ajouter automatiquement les nouvelles pages au menu principal.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            menuId: { type: "number", description: "ID du menu (cf list_menus)" },
+            pageId: { type: "number", description: "ID de la page à ajouter (mode 'page')" },
+            customUrl: { type: "string", description: "URL custom (mode 'lien externe')" },
+            label: { type: "string", description: "Libellé visible. Si pageId fourni, par défaut prend le titre de la page" },
+            parentItemId: { type: "number", description: "Mettre cet item comme enfant d'un autre item (sous-menu)" },
+          },
+          required: ["menuId"],
+        },
+      },
+      {
+        name: "get_global_styles",
+        description: "Récupère les settings globaux de Bricks Builder pour ce site (typographie globale, breakpoints, palette, classes globales, theme styles). Utile au début d'un projet pour comprendre la base visuelle existante.",
+        inputSchema: { type: "object", properties: {} },
+      },
+      {
+        name: "update_global_styles",
+        description: "Met à jour les settings globaux Bricks via fusion récursive. Utile pour appliquer une typo de site ou une convention CSS partout d'un coup. Seuls les champs fournis sont modifiés.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            settings: { type: "object", description: "Settings à fusionner avec l'existant" },
+          },
+          required: ["settings"],
+        },
+      },
+      {
+        name: "list_color_palette",
+        description: "Récupère la palette de couleurs globale Bricks (les couleurs nommées réutilisables sur tout le site).",
+        inputSchema: { type: "object", properties: {} },
+      },
+      {
+        name: "add_color_to_palette",
+        description: "Ajoute une couleur à la palette globale Bricks. Permet ensuite de l'utiliser dans n'importe quel élément via son ID/nom plutôt que de répéter la valeur hex partout.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            name: { type: "string", description: "Nom de la couleur (ex: 'Primaire', 'Accent orange')" },
+            hex: { type: "string", description: "Valeur hexadécimale (ex: '#ff6b35' ou 'ff6b35')" },
+          },
+          required: ["name", "hex"],
+        },
+      },
+
+      // ===== OUTILS v3.5.0 — PHASE A : INSPECTION + CUSTOM CODE + FONTS + CODE EXEC =====
+
+      {
+        name: "list_bricks_options",
+        description: "Dump TOUTES les options WP commençant par 'bricks_'. Outil debug essentiel pour cartographier ce qui existe en base avant de modifier. Retourne nom, type, taille, aperçu de chaque option.",
+        inputSchema: { type: "object", properties: {} },
+      },
+      {
+        name: "get_bricks_option",
+        description: "Récupère une option Bricks spécifique en intégralité (sans tronquer). Le nom doit commencer par 'bricks_'.",
+        inputSchema: {
+          type: "object",
+          properties: { name: { type: "string", description: "Nom de l'option (ex: 'bricks_global_settings')" } },
+          required: ["name"],
+        },
+      },
+      {
+        name: "get_custom_code",
+        description: "Récupère le custom code global Bricks (CSS injecté dans <head>, scripts header, body header, body footer). C'est l'endroit natif pour charger Google Fonts via <link>.",
+        inputSchema: { type: "object", properties: {} },
+      },
+      {
+        name: "set_custom_code",
+        description: "Met à jour le custom code global Bricks. customScriptsHeader est l'endroit IDÉAL pour charger Google Fonts via <link rel='stylesheet'>. Seuls les champs fournis sont modifiés.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            customCss:               { type: "string", description: "CSS injecté dans <head>" },
+            customScriptsHeader:     { type: "string", description: "HTML/scripts injectés dans <head> (idéal pour Google Fonts <link>)" },
+            customScriptsBodyHeader: { type: "string", description: "HTML injecté juste après l'ouverture <body>" },
+            customScriptsBodyFooter: { type: "string", description: "HTML injecté juste avant </body>" },
+          },
+        },
+      },
+      {
+        name: "get_code_execution_status",
+        description: "État de l'exécution des code elements Bricks. Bricks 1.9.7+ désactive code execution par défaut pour sécurité. À vérifier avant de tenter d'utiliser <script>/<svg> inline dans un code element.",
+        inputSchema: { type: "object", properties: {} },
+      },
+      {
+        name: "set_code_execution",
+        description: "Active/désactive l'exécution des code elements Bricks + définit les rôles autorisés. Active la capability WP 'bricks_execute_code'. Note: Bricks exige aussi des code signatures valides côté builder.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            enabled: { type: "boolean", description: "true pour activer, false pour désactiver" },
+            roles:   { type: "array", items: { type: "string" }, description: "Rôles autorisés à exécuter du code (ex: ['administrator'])" },
+          },
+          required: ["enabled"],
+        },
+      },
+      {
+        name: "list_custom_fonts",
+        description: "Liste les custom fonts enregistrées dans Bricks Font Manager (CPT bricks_fonts).",
+        inputSchema: { type: "object", properties: {} },
+      },
+      {
+        name: "register_custom_font",
+        description: "Enregistre une custom font dans Bricks Font Manager. Une fois enregistrée, elle sera dispo dans les selects font-family. Utiliser cet outil quand on a déjà les URLs des fichiers .woff2.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            name:       { type: "string", description: "Nom de la font (ex: 'Anton')" },
+            fontFamily: { type: "string", description: "font-family CSS (souvent identique au name)" },
+            faces:      { type: "array", items: { type: "object" }, description: "Variantes : [{ weight: 400, style: 'normal', url: 'https://.../font-regular.woff2' }, ...]" },
+          },
+          required: ["name", "faces"],
+        },
+      },
+      {
+        name: "delete_custom_font",
+        description: "Supprime une custom font du Font Manager Bricks.",
+        inputSchema: {
+          type: "object",
+          properties: { id: { type: "number", description: "ID du post bricks_fonts à supprimer" } },
+          required: ["id"],
+        },
+      },
+      {
+        name: "register_google_font_locally",
+        description: "Télécharge un Google Font et l'enregistre dans le Font Manager Bricks. Récupère automatiquement les URLs des .woff2 depuis Google Fonts CSS et crée le post bricks_fonts. C'est la méthode native pour utiliser une Google Font dans Bricks.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            name:    { type: "string", description: "Nom de la font Google (ex: 'Anton', 'Inter', 'Bebas Neue')" },
+            weights: { type: "array", items: { type: "number" }, description: "Poids souhaités (défaut: [400], ex: [400, 700, 900])" },
+          },
+          required: ["name"],
+        },
+      },
+
+      // ===== OUTILS v3.5.0 — PHASE B : GLOBAL CLASSES + THEME STYLES + PAGE CODE =====
+
+      {
+        name: "list_global_classes",
+        description: "Liste les classes CSS globales Bricks réutilisables sur tout le site.",
+        inputSchema: { type: "object", properties: {} },
+      },
+      {
+        name: "create_global_class",
+        description: "Crée une classe CSS globale Bricks. Une fois créée, on peut l'appliquer à n'importe quel élément via _cssClasses pour réutiliser des styles partout.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            name:     { type: "string", description: "Nom de la classe (ex: 'btn-primary', 'card')" },
+            settings: { type: "object", description: "Settings Bricks à appliquer (ex: { _typography: ..., _padding: ..., _background: ... })" },
+          },
+          required: ["name", "settings"],
+        },
+      },
+      {
+        name: "update_global_class",
+        description: "Modifie une classe globale par id. Tous les éléments qui utilisent cette classe seront affectés.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            id:       { type: "string", description: "ID de la classe" },
+            name:     { type: "string", description: "Nouveau nom (optionnel)" },
+            settings: { type: "object", description: "Nouveaux settings (optionnel, remplace l'ancien)" },
+          },
+          required: ["id"],
+        },
+      },
+      {
+        name: "delete_global_class",
+        description: "Supprime une classe globale Bricks.",
+        inputSchema: {
+          type: "object",
+          properties: { id: { type: "string", description: "ID de la classe à supprimer" } },
+          required: ["id"],
+        },
+      },
+      {
+        name: "list_theme_styles",
+        description: "Liste les theme styles Bricks (styles globaux conditionnels appliqués selon contexte).",
+        inputSchema: { type: "object", properties: {} },
+      },
+      {
+        name: "create_theme_style",
+        description: "Crée un theme style Bricks. Définit les styles par défaut globaux (typo, couleurs, buttons, etc.) avec conditions optionnelles d'application.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            name:       { type: "string", description: "Nom du theme style" },
+            settings:   { type: "object", description: "Settings (typography, colors, headings, buttons, etc.)" },
+            conditions: { type: "array", items: { type: "object" }, description: "Conditions d'application (optionnel)" },
+          },
+          required: ["name", "settings"],
+        },
+      },
+      {
+        name: "update_theme_style",
+        description: "Modifie un theme style existant.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            id:         { type: "string", description: "ID du theme style" },
+            name:       { type: "string", description: "Nouveau nom (opt)" },
+            settings:   { type: "object", description: "Nouveaux settings (opt)" },
+            conditions: { type: "array", items: { type: "object" }, description: "Nouvelles conditions (opt)" },
+          },
+          required: ["id"],
+        },
+      },
+      {
+        name: "delete_theme_style",
+        description: "Supprime un theme style.",
+        inputSchema: {
+          type: "object",
+          properties: { id: { type: "string", description: "ID du theme style" } },
+          required: ["id"],
+        },
+      },
+      {
+        name: "get_page_custom_code",
+        description: "Récupère le custom code (CSS/JS) spécifique à une page Bricks (Page Settings → Custom Code).",
+        inputSchema: {
+          type: "object",
+          properties: { pageId: { type: "number", description: "ID de la page" } },
+          required: ["pageId"],
+        },
+      },
+      {
+        name: "set_page_custom_code",
+        description: "Définit du CSS et/ou JS spécifique à une page (Page Settings → Custom Code). Utile pour des animations, des polices spécifiques à cette page seulement, etc.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            pageId:        { type: "number", description: "ID de la page" },
+            customCss:     { type: "string", description: "CSS de la page (sera injecté dans <head> uniquement sur cette page)" },
+            customScripts: { type: "string", description: "Scripts/HTML de la page (injectés dans <head>)" },
+          },
+          required: ["pageId"],
+        },
+      },
+
+      // ===== OUTILS v3.5.0 — PHASE C : STYLE MANAGER 2.2 + COMPONENTS =====
+
+      {
+        name: "list_typography_scales",
+        description: "Liste les typography scales globales Bricks (Style Manager 2.2). Définit des tailles de typo réutilisables pour h1, h2, body, etc.",
+        inputSchema: { type: "object", properties: {} },
+      },
+      {
+        name: "set_typography_scale",
+        description: "Crée ou met à jour une typography scale (Style Manager 2.2). Si id existe, met à jour ; sinon crée une nouvelle.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            id:     { type: "string", description: "ID de la scale (laisser vide pour créer)" },
+            name:   { type: "string", description: "Nom de la scale (ex: 'Default')" },
+            values: { type: "object", description: "Valeurs (ex: { h1: '64px', h2: '48px', body: '16px' })" },
+          },
+        },
+      },
+      {
+        name: "list_spacing_scales",
+        description: "Liste les spacing scales globales Bricks (Style Manager 2.2).",
+        inputSchema: { type: "object", properties: {} },
+      },
+      {
+        name: "set_spacing_scale",
+        description: "Crée ou met à jour une spacing scale.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            id:     { type: "string", description: "ID de la scale (laisser vide pour créer)" },
+            name:   { type: "string", description: "Nom de la scale" },
+            values: { type: "object", description: "Valeurs (ex: { xs: '8px', sm: '16px', md: '24px', lg: '48px' })" },
+          },
+        },
+      },
+      {
+        name: "list_css_variables",
+        description: "Liste les CSS variables globales Bricks (Style Manager 2.2). Variables réutilisables comme --primary, --accent, etc.",
+        inputSchema: { type: "object", properties: {} },
+      },
+      {
+        name: "set_css_variable",
+        description: "Crée ou met à jour une CSS variable globale. Si la variable existe, sa valeur est mise à jour ; sinon elle est créée.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            name:  { type: "string", description: "Nom (avec ou sans --, ex: '--primary' ou 'primary')" },
+            value: { type: "string", description: "Valeur (ex: '#FD5B2C', '64px', '1.5')" },
+          },
+          required: ["name", "value"],
+        },
+      },
+      {
+        name: "list_components",
+        description: "Liste les components Bricks (templates avec type=component, Bricks 2.x).",
+        inputSchema: { type: "object", properties: {} },
+      },
     ],
   };
 });
@@ -524,6 +925,276 @@ mcpServer.setRequestHandler(CallToolRequestSchema, async (request) => {
         });
         break;
 
+      // ===== OUTILS v3.3.0 — GESTION DES PAGES =====
+
+      case "delete_page":
+        console.error(`[LOG] Exécution: delete_page pageId=${args.pageId} force=${args.force}`);
+        result = await callWordPressAPI("/delete-page", "POST", {
+          pageId: args.pageId,
+          force: args.force || false,
+        });
+        break;
+
+      case "update_page_meta":
+        console.error(`[LOG] Exécution: update_page_meta pageId=${args.pageId}`);
+        result = await callWordPressAPI("/update-page-meta", "POST", {
+          pageId: args.pageId,
+          title: args.title,
+          slug: args.slug,
+          status: args.status,
+          parentId: args.parentId,
+        });
+        break;
+
+      case "duplicate_page":
+        console.error(`[LOG] Exécution: duplicate_page source=${args.sourcePageId}`);
+        result = await callWordPressAPI("/duplicate-page", "POST", {
+          sourcePageId: args.sourcePageId,
+          newTitle: args.newTitle || "",
+          status: args.status || "draft",
+        });
+        break;
+
+      case "set_homepage":
+        console.error(`[LOG] Exécution: set_homepage pageId=${args.pageId} reset=${args.reset}`);
+        result = await callWordPressAPI("/set-homepage", "POST", {
+          pageId: args.pageId,
+          reset: args.reset || false,
+        });
+        break;
+
+      // ===== OUTILS v3.4.0 — HEALTH, MÉDIAS, MENUS, STYLES GLOBAUX =====
+
+      case "health_check":
+        console.error(`[LOG] Exécution: health_check`);
+        result = await callWordPressAPI("/health", "GET");
+        break;
+
+      case "list_all_pages":
+        console.error(`[LOG] Exécution: list_all_pages`);
+        result = await callWordPressAPI("/list-all-pages", "GET");
+        break;
+
+      case "upload_media":
+        console.error(`[LOG] Exécution: upload_media depuis ${args.sourceUrl}`);
+        result = await callWordPressAPI("/upload-media", "POST", {
+          sourceUrl: args.sourceUrl,
+          title: args.title,
+          alt: args.alt,
+          caption: args.caption,
+        });
+        break;
+
+      case "list_media":
+        console.error(`[LOG] Exécution: list_media page=${args.page} perPage=${args.perPage}`);
+        result = await callWordPressAPI("/list-media", "POST", {
+          page: args.page || 1,
+          perPage: args.perPage || 20,
+          search: args.search,
+        });
+        break;
+
+      case "list_menus":
+        console.error(`[LOG] Exécution: list_menus`);
+        result = await callWordPressAPI("/list-menus", "GET");
+        break;
+
+      case "add_menu_item":
+        console.error(`[LOG] Exécution: add_menu_item menuId=${args.menuId}`);
+        result = await callWordPressAPI("/add-menu-item", "POST", {
+          menuId: args.menuId,
+          pageId: args.pageId,
+          customUrl: args.customUrl,
+          label: args.label,
+          parentItemId: args.parentItemId,
+        });
+        break;
+
+      case "get_global_styles":
+        console.error(`[LOG] Exécution: get_global_styles`);
+        result = await callWordPressAPI("/get-global-styles", "GET");
+        break;
+
+      case "update_global_styles":
+        console.error(`[LOG] Exécution: update_global_styles`);
+        result = await callWordPressAPI("/update-global-styles", "POST", {
+          settings: args.settings || {},
+        });
+        break;
+
+      case "list_color_palette":
+        console.error(`[LOG] Exécution: list_color_palette`);
+        result = await callWordPressAPI("/list-color-palette", "GET");
+        break;
+
+      case "add_color_to_palette":
+        console.error(`[LOG] Exécution: add_color_to_palette name="${args.name}"`);
+        result = await callWordPressAPI("/add-color-to-palette", "POST", {
+          name: args.name,
+          hex: args.hex,
+        });
+        break;
+
+      // ===== OUTILS v3.5.0 — PHASE A : INSPECTION + CUSTOM CODE + FONTS + CODE EXEC =====
+
+      case "list_bricks_options":
+        result = await callWordPressAPI("/list-bricks-options", "GET");
+        break;
+
+      case "get_bricks_option":
+        result = await callWordPressAPI("/get-bricks-option", "POST", { name: args.name });
+        break;
+
+      case "get_custom_code":
+        result = await callWordPressAPI("/get-custom-code", "GET");
+        break;
+
+      case "set_custom_code":
+        result = await callWordPressAPI("/set-custom-code", "POST", {
+          customCss: args.customCss,
+          customScriptsHeader: args.customScriptsHeader,
+          customScriptsBodyHeader: args.customScriptsBodyHeader,
+          customScriptsBodyFooter: args.customScriptsBodyFooter,
+        });
+        break;
+
+      case "get_code_execution_status":
+        result = await callWordPressAPI("/get-code-execution-status", "GET");
+        break;
+
+      case "set_code_execution":
+        result = await callWordPressAPI("/set-code-execution", "POST", {
+          enabled: args.enabled,
+          roles: args.roles || [],
+        });
+        break;
+
+      case "list_custom_fonts":
+        result = await callWordPressAPI("/list-custom-fonts", "GET");
+        break;
+
+      case "register_custom_font":
+        result = await callWordPressAPI("/register-custom-font", "POST", {
+          name: args.name,
+          fontFamily: args.fontFamily || args.name,
+          faces: args.faces,
+        });
+        break;
+
+      case "delete_custom_font":
+        result = await callWordPressAPI("/delete-custom-font", "POST", { id: args.id });
+        break;
+
+      case "register_google_font_locally":
+        result = await callWordPressAPI("/register-google-font-locally", "POST", {
+          name: args.name,
+          weights: args.weights || [400],
+        });
+        break;
+
+      // ===== OUTILS v3.5.0 — PHASE B : GLOBAL CLASSES + THEME STYLES + PAGE CODE =====
+
+      case "list_global_classes":
+        result = await callWordPressAPI("/list-global-classes", "GET");
+        break;
+
+      case "create_global_class":
+        result = await callWordPressAPI("/create-global-class", "POST", {
+          name: args.name,
+          settings: args.settings || {},
+        });
+        break;
+
+      case "update_global_class":
+        result = await callWordPressAPI("/update-global-class", "POST", {
+          id: args.id,
+          name: args.name,
+          settings: args.settings,
+        });
+        break;
+
+      case "delete_global_class":
+        result = await callWordPressAPI("/delete-global-class", "POST", { id: args.id });
+        break;
+
+      case "list_theme_styles":
+        result = await callWordPressAPI("/list-theme-styles", "GET");
+        break;
+
+      case "create_theme_style":
+        result = await callWordPressAPI("/create-theme-style", "POST", {
+          name: args.name,
+          settings: args.settings || {},
+          conditions: args.conditions || [],
+        });
+        break;
+
+      case "update_theme_style":
+        result = await callWordPressAPI("/update-theme-style", "POST", {
+          id: args.id,
+          name: args.name,
+          settings: args.settings,
+          conditions: args.conditions,
+        });
+        break;
+
+      case "delete_theme_style":
+        result = await callWordPressAPI("/delete-theme-style", "POST", { id: args.id });
+        break;
+
+      case "get_page_custom_code":
+        result = await callWordPressAPI("/get-page-custom-code", "POST", { pageId: args.pageId });
+        break;
+
+      case "set_page_custom_code":
+        result = await callWordPressAPI("/set-page-custom-code", "POST", {
+          pageId: args.pageId,
+          customCss: args.customCss,
+          customScripts: args.customScripts,
+        });
+        break;
+
+      // ===== OUTILS v3.5.0 — PHASE C : STYLE MANAGER 2.2 + COMPONENTS =====
+
+      case "list_typography_scales":
+        result = await callWordPressAPI("/list-typography-scales", "GET");
+        break;
+
+      case "set_typography_scale":
+        result = await callWordPressAPI("/set-typography-scale", "POST", {
+          id: args.id,
+          name: args.name,
+          values: args.values || {},
+        });
+        break;
+
+      case "list_spacing_scales":
+        result = await callWordPressAPI("/list-spacing-scales", "GET");
+        break;
+
+      case "set_spacing_scale":
+        result = await callWordPressAPI("/set-spacing-scale", "POST", {
+          id: args.id,
+          name: args.name,
+          values: args.values || {},
+        });
+        break;
+
+      case "list_css_variables":
+        result = await callWordPressAPI("/list-css-variables", "GET");
+        break;
+
+      case "set_css_variable":
+        result = await callWordPressAPI("/set-css-variable", "POST", {
+          name: args.name,
+          value: args.value,
+        });
+        break;
+
+      case "list_components":
+        result = await callWordPressAPI("/list-components", "GET");
+        break;
+
       default:
         console.error(`[LOG] Tool inconnu: ${name}`);
         result = { error: `Tool ${name} not found` };