@kiubi/mcp-designer 1.0.0

package/src/tools/detail_type.ts

@@ -0,0 +1,208 @@
+import {z} from "zod";
+import {defineTool} from "../tool.ts";
+import {ThemeInspector, resolveLangs} from "#lib/theme-checker/index";
+import type {TypeDefinition, ModelDef, SymbolDef, ComponentDef} from "#lib/theme-checker/types";
+import {join} from "node:path";
+
+type ListType = "billet_page" | "symbole" | "composant" | "produit" | "billet_blog" | "template";
+
+type TypeVariant = {
+    lang: string ;
+    title?: string;
+    position: number | null;
+    path: string;
+    files: string[];
+    fields: string[];
+    collection: string[];
+    zones: string[];
+}
+
+const TYPE_MAP: Record<ListType, (inspector: ThemeInspector) => TypeDefinition[]> = {
+    billet_page: (i) => i.listCms(),
+    symbole:     (i) => i.listSymbols(),
+    composant:   (i) => i.listComponents(),
+    produit:     (i) => i.listProducts(),
+    billet_blog: (i) => i.listBlogs(),
+    template:    (i) => i.listModels(),
+};
+
+const PATH_MAP: Record<ListType, string> = {
+    billet_page: 'billets',
+    symbole:     'symboles',
+    composant:   'composants',
+    produit:     'produits',
+    billet_blog: 'billets_blog',
+    template:    'templates',
+};
+
+function isModelDef(d: TypeDefinition): d is ModelDef {
+    return 'zones' in d && 'structure' in d && !('fields' in d);
+}
+
+function isSymbolDef(d: TypeDefinition): d is SymbolDef {
+    return 'zones' in d && 'fields' in d && 'structure' in d;
+}
+
+function isComponentDef(d: TypeDefinition): d is ComponentDef {
+    return 'hasCollection' in d;
+}
+
+function formatDetail(variant: TypeVariant): string {
+    const lines: string[] = [
+        '',
+        `Version [${variant.lang}]`
+    ];
+    
+    if (variant.title) {
+        lines.push(`Intitulé : ${variant.title}`);
+    }
+    if (variant.position) {
+        lines.push(`Position : ${variant.position}`);
+    }
+    lines.push(`Dossier : ${variant.path}`);
+    
+    if (variant.files.length > 0) {
+        lines.push('Fichiers :');  
+        lines.push(...variant.files);  
+    }
+
+    if (variant.fields.length > 0) {
+        lines.push('Champs :');
+        lines.push(...variant.fields);
+    }
+
+    if (variant.collection.length > 0) {
+        lines.push('Collection :');
+        lines.push(...variant.collection);
+    }
+
+    if (variant.zones.length > 0) {
+        lines.push('Zones :');
+        lines.push(...variant.zones);
+    }
+    
+    return lines.join('\n');
+}
+
+function detailTypeForLang(themePath: string, lang: string, type: ListType, name: string) : TypeVariant | null {
+    const inspector = new ThemeInspector(themePath, lang);
+    const items = TYPE_MAP[type](inspector);
+    const item = items.find(i => i.id === name);
+
+    if (!item) {
+        return null;
+    }
+    
+    const label = 'name' in item && item.name ? item.name
+        : 'desc' in item && item.name ? item.name
+            : undefined;
+
+    const basePath = join(inspector.getRelLgPath(PATH_MAP[type]), name);
+    
+    const files = [];
+    switch (type) {
+        case "composant" :
+        case "produit" :
+        case "billet_page" :
+            files.push(basePath + '/index.html // template');  
+            files.push(basePath + '/config.xml // définition');
+            break;
+        case "billet_blog" :
+            files.push(basePath + '/config.xml // définition');
+            files.push('Attention : le template est commun à tous les billets du blog dans ' + join(inspector.getRelLgPath('widgets/blog/detail_billet/index.html')));
+            break;
+        case "symbole" :
+        case "template" :
+            files.push(basePath + '/index.html // template');
+            files.push(basePath + '/desc.xml // définition');
+            files.push(basePath + '/structure.xhml // structure des zones');
+            break;
+    }
+
+    const fields = [];
+    const collection = [];
+    const zones = [];
+
+    if ("fields" in item && item.fields && item.fields.length > 0) {
+        for (const field of item.fields) {
+            const def = field.default ? ` (défaut: ${field.default})` : '';
+            fields.push(`${field.field} : ${field.name} [${field.type}]${def}`);
+        }
+    }
+
+    if (isComponentDef(item) && item.hasCollection && item.collection.length > 0) {
+        for (const field of item.collection) {
+            const def = field.default ? ` (défaut: ${field.default})` : '';
+            collection.push(`${field.field} : ${field.name} [${field.type}]${def}`);
+        }
+    }
+
+    if ((isModelDef(item) || isSymbolDef(item)) && item.zones.length > 0) {
+        for (const zone of item.zones) {
+            const content = zone.isContent ? ' [contenu]' : '';
+            zones.push(`${zone.id} : ${zone.name}${content} (colmax: ${zone.colmax})`);
+        }
+    }
+    
+    return {
+        lang:lang,
+        title: label,
+        position: ('position' in item) ? item.position : null,
+        path: basePath,
+        files: files,
+        fields: fields,
+        collection: collection,
+        zones: zones,
+    };
+}
+
+export function detailType({themePath, type, name, lang}: {themePath: string; type: ListType; name: string; lang?: string[] | null}): string {
+    const resolved = resolveLangs(themePath, lang);
+    if ('error' in resolved) return `Erreur : ${resolved.error}`;
+
+    const variants = resolved.map((l) => {
+            return {lang: l, detail: detailTypeForLang(themePath, l, type, name)};
+        }
+    );
+    if (variants.filter(x => x.detail !== null).length === 0) {
+        return `Aucun élément "${name}" de type "${type}" trouvé dans le thème "${themePath}"`; // TODO add fuzzy search accross all lang
+    }
+    
+    const blocks = [
+        `Type : ${type}`,
+        `Identifiant : ${name}`
+    ];
+    
+    blocks.push(...variants.map(
+        (variant) =>{
+            if (variant.detail === null) {
+                if (lang === null || lang === undefined) return null;
+                return `\nVersion [${variant.lang}]\nType non défini`
+            }
+            return formatDetail(variant.detail); 
+        }
+    ).filter(x => x !== null));
+    return blocks.join('\n');
+}
+
+export const detailTypeTool = defineTool({
+    name: "detail_type",
+    description:
+        "Retourne le détail d'un élément du thème graphique (champs, zones, collection) à partir de son type et de son identifiant. " +
+        "lang : si omis (ou vide), inspecte tous les dossiers de langue (2 lettres) trouvés à la racine du thème ; si " +
+        "précisé, uniquement les langues listées (erreur si un dossier de langue demandé n'existe pas). " +
+        "Le résultat liste le détail (ou l'absence) de l'élément par langue.",
+    inputSchema: {
+        themePath: z.string().min(1).describe("Chemin absolu vers le dossier racine du thème graphique"),
+        type: z.enum(["billet_page", "symbole", "composant", "produit", "billet_blog", "template"]).describe("Type d'élément"),
+        name: z.string().min(1).describe("Identifiant de l'élément (son nom de répertoire)"),
+        lang: z.array(z.string().regex(/^[a-z]{2}$/, "code langue sur 2 lettres minuscules attendu (ex. \"fr\")"))
+            .optional()
+            .describe("Codes langue (2 lettres minuscules, ex. [\"fr\",\"de\"]) à inspecter. Omis ou vide : tous les dossiers de langue du thème."),
+    },
+    handler: async ({themePath, type, name, lang}) => {
+        return {
+            content: [{type: "text" as const, text: detailType({themePath, type, name, lang})}],
+        };
+    }
+});

package/src/tools/get_doc_section.ts

@@ -0,0 +1,201 @@
+import { z } from "zod";
+import { defineTool } from "../tool.ts";
+import { readFileSync, existsSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { normalize } from "#lib/stemmer";
+
+const DOCS_BASE = new URL("../../storage/documents", import.meta.url).pathname;
+const INTEGRATION_DIR = join(DOCS_BASE, "generated/integration");
+const EXEMPLES_PATH = join(DOCS_BASE, "generated/exemples.md");
+const API_PATH = join(DOCS_BASE, "kiubi_api.md");
+const WORKFLOWS_PATH = join(DOCS_BASE, "kiubi_workflows.md");
+
+type Category = "integration" | "exemples" | "api" | "workflows";
+
+const singleDocument = {
+    "exemples" :  EXEMPLES_PATH,
+    "api" :  API_PATH,
+    "workflows" :  WORKFLOWS_PATH,
+};
+
+function listH2Titles(content: string): Array<{section: string}> {
+    return content
+        .split("\n")
+        .filter((line) => /^## /.test(line))
+        .map((line) => {
+            return {section: line.replace(/^## /, "").trim()}
+        });
+}
+
+function getIntegrationSections(): Array<{ section: string; file: string }> {
+    if (!existsSync(INTEGRATION_DIR)) return [];
+
+    return readdirSync(INTEGRATION_DIR)
+        .filter((f) => f.endsWith(".md"))
+        .sort()
+        .flatMap((file) => {
+            const content = readFileSync(join(INTEGRATION_DIR, file), "utf-8");
+            const titles = listH2Titles(content);
+            return titles.length > 0 ? titles.map((title) => ({ section: title.section, file: file })) : [{ section: file, file: file }];
+        });
+}
+
+function listSections(category: "all" | Category): string {
+    const parts: string[] = [];
+
+    if (category === "all" || category === "integration") {
+        const sections = getIntegrationSections();
+        const lines = sections.map((s) => ` - ${s.section}`).join("\n");
+        parts.push(`La catégorie "integration" contient les chapitres suivants :\n${lines}`);
+    }
+
+    if (category === "all" || category === "exemples") {
+        if (existsSync(EXEMPLES_PATH)) {
+            const content = readFileSync(EXEMPLES_PATH, "utf-8");
+            const lines = listH2Titles(content)
+                .map((t) => ` - ${t.section}`)
+                .join("\n");
+            parts.push(`La catégorie "exemples" contient les chapitres suivants :\n${lines}`);
+        }
+    }
+
+    if (category === "all" || category === "api") {
+        if (existsSync(API_PATH)) {
+            const content = readFileSync(API_PATH, "utf-8");
+            const lines = listH2Titles(content)
+                .map((t) => ` - ${t.section}`)
+                .join("\n");
+            parts.push(`La catégorie "api" contient les chapitres suivants :\n${lines}`);
+        }
+    }
+
+    if (category === "all" || category === "workflows") {
+        if (existsSync(WORKFLOWS_PATH)) {
+            const content = readFileSync(WORKFLOWS_PATH, "utf-8");
+            const lines = listH2Titles(content)
+                .map((t) => ` - ${t.section}`)
+                .join("\n");
+            parts.push(`La catégorie "workflows" contient les workflows suivants :\n${lines}`);
+        }
+    }
+
+    return parts.join("\n\n");
+}
+
+function matchSection<T extends {section: string}>(list: T[], matchingWords: string[]): T | null {
+    
+    if (matchingWords.length === 0 || list.length === 0) return null;
+
+    const scored = list.map((item) => {
+        const normSection = normalize(item.section);
+        const score = matchingWords.reduce(
+            (acc, word) => acc + (normSection.includes(word) ? 1 : 0),
+            0
+        );
+        return { item, score };
+    });
+
+    const max = scored.reduce((best, current) => {
+        return current.score > best.score ? current : best;
+    });
+
+    if (max.score === 0) return null;
+
+    return max.item;
+}
+
+function extractSectionFromFile(content: string, section: string) : string | null {
+
+    const rawSections = content.split(/(?=^## )/m).filter((s) => s.trim().length > 0);
+    const match = rawSections.find((s) => s.split("\n")[0].replace(/^## /, "").trim() === section) ?? '';
+    if (match) {
+        return match.trimEnd();
+    }
+    
+    return null;
+}
+
+function fetchSection(category: Category, section: string): string {
+    
+    let matchingWords = normalize(section)
+        .split(/[^a-z0-9]+/)
+        .filter((w) => w.length >= 3);
+    
+    if (category === "integration") {
+        const sectionList = getIntegrationSections();
+        const matchingSection = matchSection(sectionList, matchingWords);
+        
+        if (matchingSection) {
+            const content = readFileSync(join(INTEGRATION_DIR, matchingSection.file), "utf-8");
+            return extractSectionFromFile(content, matchingSection.section) ?? 'Erreur innatendue';
+        }
+
+        const titles = sectionList.map((s) => ` - ${s.section}`).join("\n");
+        return `Aucune section ne correspond à « ${section} » dans la catégorie "integration".\n\nSections disponibles :\n${titles}`;
+    }
+
+    const filePath = singleDocument[category];
+    if (!existsSync(filePath)) {
+        return `Fichier de documentation introuvable pour la catégorie "${category}".`;
+    }
+    
+    const content = readFileSync(filePath, "utf-8");
+    const sectionList = listH2Titles(content);
+    
+    if (category === 'workflows') {
+        matchingWords = normalize(section)
+            .split(/[^a-z0-9]+/)
+            .map((s) => (s.length === 1 ? `workflow ${s}` : s));
+    }
+    const matchingSection = matchSection(sectionList, matchingWords);
+    
+    if (matchingSection) {
+        return extractSectionFromFile(content, matchingSection.section) ?? 'Erreur innatendue';    
+    }
+
+    const titles = sectionList
+        .filter((t) => t.section.length > 0)
+        .map((t) => ` - ${t.section}`)
+        .join("\n");
+    return `Aucune section ne correspond à « ${section} » dans la catégorie "${category}".\n\nSections disponibles :\n${titles}`;
+}
+
+export function getDocSection(category: string, section?: string): string {
+    if (category === "all" || !section) {
+        return listSections(category as "all" | Category);
+    }
+    return fetchSection(category as Category, section);
+}
+
+export const getDocSectionTool = defineTool({
+    name: "get_doc_section",
+    description:
+        "Accès à la documentation Kiubi : guide d'intégration, catalogue d'exemples, API front-office et workflows. L'outil fonctionne selon 2 modes : \n" +
+        " - Sans le paramètre facultatif 'section' : liste les titres de chapitres disponibles pour la catégorie (ou pour toutes les catégories avec category='all'). \n" +
+        " - Avec le paramètre facultatif 'section' : retourne le contenu complet du chapitre demandé (recherche insensible à la casse, partielle). \n" +
+        "Si le chapitre n'est pas trouvé, retourne la liste des chapitres disponibles dans la catégorie.",
+    inputSchema: {
+        category: z
+            .enum(["all", "integration", "exemples", "api", "workflows"])
+            .describe(
+                "Catégorie de documentation : 'all' pour lister toute la documentation, " +
+                    "'integration' pour le guide d'intégration des thèmes graphiques, " +
+                    "'exemples' pour le catalogue d'exemples de templates et widgets, " +
+                    "'api' pour les endpoints de l'API front-office Kiubi, " +
+                    "'workflows' pour les workflows d'intégration étape par étape."
+            ),
+        section: z
+            .string()
+            .optional()
+            .describe(
+                "Titre (ou fragment) du chapitre à récupérer. " +
+                    "Si omis, retourne la liste des chapitres de la catégorie. " +
+                    "Exemples : 'Blocs', 'Widgets', 'Site web'."
+            ),
+    },
+    handler: async ({ category, section }) => {
+        return {
+            content: [{ type: "text" as const, text: getDocSection(category, section) }],
+        };
+    },
+});

package/src/tools/list_types.ts

@@ -0,0 +1,87 @@
+import {z} from "zod";
+import {defineTool} from "../tool.ts";
+import {ThemeInspector, resolveLangs} from "#lib/theme-checker/index";
+import type {TypeDefinition} from "#lib/theme-checker/types";
+import {join} from "node:path";
+
+export const LIST_TYPES = ["billet_page", "symbole", "composant", "produit", "billet_blog", "template"] as const;
+type ListType = typeof LIST_TYPES[number];
+
+const TYPE_MAP: Record<ListType, (inspector: ThemeInspector) => {items: TypeDefinition[], subdir: string}> = {
+    billet_page: (i) => {
+        return {items : i.listCms(), subdir: 'billets'}
+    },
+    symbole: (i) => {
+        return {items : i.listSymbols(), subdir: 'symboles'}
+    },
+    composant: (i) => {
+        return {items : i.listComponents(), subdir: 'composants'}
+    },
+    produit: (i) => {
+        return {items : i.listProducts(), subdir: 'produits'}
+    },
+    billet_blog: (i) => {
+        return {items : i.listBlogs(), subdir: 'billets_blog'}
+    },
+    template: (i) => {
+        return {items : i.listModels(), subdir: 'templates'}
+    },
+};
+
+function listTypesForLang(themePath: string, lang: string, type: ListType): string {
+    const inspector = new ThemeInspector(themePath, lang);
+    const infos = TYPE_MAP[type](inspector);
+    const path = join(lang, infos.subdir);
+
+    const lines = [`Éléments de type "${type}" [${lang}] :`, ''];
+
+    if (infos.items.length === 0) {
+        lines.push(`Aucun élément de type "${type}" trouvé dans le thème "${themePath}" pour la langue "${lang}".`)
+        return lines.join('\n');
+    }
+
+    infos.items.forEach(item => {
+        lines.push('- ' + join(path, item.id) + (item.name !== '' ? ' : ' + item.name : ''));
+    });
+
+    if (type === "billet_blog") {
+        const wPath = inspector.getRelLgPath('widgets/blog/detail_billet/index.html');
+        lines.push('', `Attention : les config.xml sont dans ${path}/ mais le template est centralisé dans ${wPath}`);
+    }
+
+    return lines.join('\n');
+}
+
+export function listTypes({themePath, type, lang}: { themePath: string; type: ListType; lang?: string[] | null }): string {
+    const resolved = resolveLangs(themePath, lang);
+    if ('error' in resolved) return `Erreur : ${resolved.error}`;
+
+    const blocks = resolved.map(l => `${listTypesForLang(themePath, l, type)}`);
+    return blocks.join('\n\n');
+}
+
+export const listTypesTool = defineTool({
+    name: "list_types",
+    description: "Liste tous les éléments présent dans le thème graphique d'un type : \n" +
+        " - billet_page (billets des pages)\n" +
+        " - billet_blog (billets du blog)\n" +
+        " - composant\n" +
+        " - produit\n" +
+        " - symbole\n" +
+        " - template (templates principaux)\n" +
+        "lang : si omis (ou vide), liste dans tous les dossiers de langue (2 lettres) trouvés à la racine du thème ; " +
+        "si précisé, uniquement les langues listées (erreur si un dossier de langue demandé n'existe pas). " +
+        "Le résultat liste les éléments par langue.",
+    inputSchema: {
+        themePath: z.string().min(1).describe("Chemin absolu vers le dossier racine du thème graphique"),
+        type: z.enum(["billet_page", "symbole", "composant", "produit", "billet_blog", "template"]).describe("Type d'élément à lister"),
+        lang: z.array(z.string().regex(/^[a-z]{2}$/, "code langue sur 2 lettres minuscules attendu (ex. \"fr\")"))
+            .optional()
+            .describe("Codes langue (2 lettres minuscules, ex. [\"fr\",\"de\"]) à lister. Omis ou vide : tous les dossiers de langue du thème."),
+    },
+    handler: async ({themePath, type, lang}) => {
+        return {
+            content: [{type: "text" as const, text: listTypes({themePath, type, lang})}],
+        };
+    }
+});

package/src/tools/list_widgets.ts

@@ -0,0 +1,181 @@
+import { z } from "zod";
+import { defineTool } from "../tool.ts";
+import { readdirSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { resolveLangs } from "#lib/theme-checker/index";
+
+type WidgetInfo = {
+    name: string;
+    templates: string[];
+};
+
+type CategoryInfo = {
+    name: string;
+    widgets: WidgetInfo[];
+};
+
+function scanLangWidgets(themePath: string, lang: string): CategoryInfo[] | null {
+    const widgetsDir = join(themePath, lang, "widgets");
+    if (!existsSync(widgetsDir)) {
+        return null;
+    }
+    return scanWidgetsDir(widgetsDir);
+}
+
+export function listWidgets({ themePath, lang }: { themePath: string; lang?: string[] | null }): string {
+    const resolved = resolveLangs(themePath, lang);
+    if ('error' in resolved) return `Erreur : ${resolved.error}`;
+
+    // Regroupe les widgets par langue avant de les fusionner par clé "catégorie/widget",
+    // pour pouvoir afficher toutes les versions (ou l'absence) de chaque widget.
+    const widgetKeys = new Map<string, { category: string; widget: string }>();
+    const templatesByLang = new Map<string, Map<string, string[]>>();
+
+    for (const l of resolved) {
+        const categories = scanLangWidgets(themePath, l);
+        const templates = new Map<string, string[]>();
+
+        for (const category of categories ?? []) {
+            for (const widget of category.widgets) {
+                const key = `${category.name}/${widget.name}`;
+                widgetKeys.set(key, { category: category.name, widget: widget.name });
+                templates.set(key, widget.templates);
+            }
+        }
+
+        templatesByLang.set(l, templates);
+    }
+
+    if (widgetKeys.size === 0) {
+        return `Aucun widget trouvé dans le thème "${themePath}" pour la/les langue(s) ${resolved.join(', ')}.`;
+    }
+
+    const lines: string[] = [];
+
+    for (const key of [...widgetKeys.keys()].sort()) {
+        const { category, widget } = widgetKeys.get(key)!;
+        lines.push(`Widget ${category} / ${widget} :`);
+
+        for (const l of resolved) {
+            lines.push(`    Version [${l}]`);
+            const templates = templatesByLang.get(l)!.get(key);
+            if (templates) {
+                lines.push(`    Dossier : ${l}/widgets/${category}/${widget}`);
+                lines.push(`    Fichiers :`);
+                for (const template of templates) {
+                    lines.push(`    - ${template}`);
+                }
+            } else {
+                lines.push(`    Widget non défini`);
+            }
+            lines.push("");
+        }
+    }
+
+    return lines.join("\n").trimEnd();
+}
+
+function scanWidgetsDir(widgetsDir: string): CategoryInfo[] {
+    const categories: CategoryInfo[] = [];
+
+    let categoryEntries: string[];
+    try {
+        categoryEntries = readdirSync(widgetsDir);
+    } catch {
+        return categories;
+    }
+
+    for (const categoryName of categoryEntries.sort()) {
+        const categoryPath = join(widgetsDir, categoryName);
+
+        let widgetEntries: string[];
+        try {
+            widgetEntries = readdirSync(categoryPath);
+        } catch {
+            continue;
+        }
+
+        const widgets: WidgetInfo[] = [];
+
+        for (const widgetName of widgetEntries.sort()) {
+            const widgetPath = join(categoryPath, widgetName);
+            const indexPath = join(widgetPath, "index.html");
+
+            if (!existsSync(indexPath)) {
+                continue;
+            }
+
+            const templates: string[] = ["index.html"];
+
+            let widgetChildren: string[];
+            try {
+                widgetChildren = readdirSync(widgetPath);
+            } catch {
+                widgetChildren = [];
+            }
+
+            // Collect alternative .html files at widget level (excluding index.html)
+            const htmlFiles = widgetChildren
+                .filter((f) => f.endsWith(".html") && f !== "index.html")
+                .sort();
+            templates.push(...htmlFiles);
+
+            // Collect alternative templates from subdirectories (level 3)
+            const subDirs = widgetChildren
+                .filter((f) => !f.endsWith(".html"))
+                .sort();
+
+            for (const subDir of subDirs) {
+                const subDirPath = join(widgetPath, subDir);
+                let subEntries: string[];
+                try {
+                    subEntries = readdirSync(subDirPath);
+                } catch {
+                    continue;
+                }
+
+                const subHtmlFiles = subEntries
+                    .filter((f) => f.endsWith(".html"))
+                    .sort();
+
+                for (const htmlFile of subHtmlFiles) {
+                    templates.push(`${subDir}/${htmlFile}`);
+                }
+            }
+
+            widgets.push({ name: widgetName, templates });
+        }
+
+        if (widgets.length > 0) {
+            categories.push({ name: categoryName, widgets });
+        }
+    }
+
+    return categories;
+}
+
+export const listWidgetsTool = defineTool({
+    name: "list_widgets",
+    description:
+        "Liste tous les widgets présents dans le thème graphique et leurs templates alternatifs. " +
+        "À utiliser avant toute création de template secondaire de widget. " +
+        "Retourne un bloc par widget (catégorie / nom), avec pour chaque langue : le dossier et la liste des " +
+        "templates (index.html + templates alternatifs), ou la mention \"Widget non défini\" si ce widget n'existe " +
+        "pas pour cette langue. " +
+        "lang : si omis (ou vide), inclut tous les dossiers de langue (2 lettres) trouvés à la racine du thème ; " +
+        "si précisé, uniquement les langues listées (erreur si un dossier de langue demandé n'existe pas).",
+    inputSchema: {
+        themePath: z
+            .string()
+            .min(1)
+            .describe("Chemin absolu vers le dossier racine du thème graphique"),
+        lang: z.array(z.string().regex(/^[a-z]{2}$/, "code langue sur 2 lettres minuscules attendu (ex. \"fr\")"))
+            .optional()
+            .describe("Codes langue (2 lettres minuscules, ex. [\"fr\",\"de\"]) à lister. Omis ou vide : tous les dossiers de langue du thème."),
+    },
+    handler: async ({ themePath, lang }) => {
+        return {
+            content: [{ type: "text" as const, text: listWidgets({ themePath, lang }) }],
+        };
+    },
+});