@kiubi/mcp-designer 1.0.0

package/src/lib/theme-checker/filter-validator.ts

@@ -0,0 +1,163 @@
+export type FilterValidationIssue = {
+    level: 'error' | 'warning';
+    msg: string;
+    line: number;
+};
+
+// Définitions des filtres : min/max arguments acceptés
+const FILTER_DEFS: Record<string, { min: number; max: number }> = {
+    ucfirst:      { min: 0, max: 0 },
+    strtoupper:   { min: 0, max: 0 },
+    strtolower:   { min: 0, max: 0 },
+    sanitize:     { min: 0, max: 0 },
+    escapejson:   { min: 0, max: 0 },
+    htmlentities: { min: 0, max: 1 },
+    rawurlencode: { min: 0, max: 1 },
+    left:         { min: 1, max: 1 },
+    striptext:    { min: 1, max: 1 },
+    mot:          { min: 1, max: 1 },
+    alternate:    { min: 1, max: 1 },
+    formatfloat:  { min: 1, max: 1 },
+    date:         { min: 1, max: 1 },
+    mapvalue:     { min: 1, max: 2 },
+    empty:        { min: 2, max: 2 },
+    slice:        { min: 3, max: 3 },
+};
+
+const DATE_ARGS = new Set([
+    'annee', 'num_mois', 'num_jour', 'mois', 'mois_abrev',
+    'jour_semaine', 'heure', 'minute', 'seconde',
+]);
+
+const NUMERIC_FILTER_ARGS = new Set(['left', 'striptext', 'mot', 'alternate', 'formatfloat']);
+
+/**
+ * Valide les filtres de balises Kiubi dans un contenu HTML.
+ * Détecte : espaces dans la balise, filtre inconnu, mauvais nombre d'arguments,
+ * arguments invalides (non numérique, non-ASCII pour mapValue, etc.).
+ */
+export function validateFilters(content: string): FilterValidationIssue[] {
+    const issues: FilterValidationIssue[] = [];
+    const lines = content.split('\n');
+
+    for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+        const line = lines[lineIdx];
+        const lineNo = lineIdx + 1;
+        const re = /\{([^}]+)\}/g;
+        let m: RegExpExecArray | null;
+
+        while ((m = re.exec(line)) !== null) {
+            const inner = m[1];
+
+            // Ignorer les includes {FILE "..."} et les zones {ZONE.xxx}
+            if (inner.startsWith('FILE ') || inner.startsWith('ZONE.')) continue;
+
+            // Ignorer les balises sans filtre
+            if (!inner.includes('|')) continue;
+
+            // 1. Espace interdit dans une balise filtrée
+            if (/\s/.test(inner)) {
+                issues.push({
+                    level: 'error',
+                    msg: `Espace interdit dans la balise filtrée : {${inner}}`,
+                    line: lineNo,
+                });
+                continue;
+            }
+
+            const parts = inner.split('|');
+            // parts[0] = nom de la balise, parts[1] = filtre, parts[2..] = arguments
+            if (parts.length < 2) continue;
+
+            const filterRaw = parts[1];
+            const filterKey = filterRaw.toLowerCase();
+            const args = parts.slice(2);
+
+            // 2. Filtre inconnu
+            if (!(filterKey in FILTER_DEFS)) {
+                issues.push({
+                    level: 'error',
+                    msg: `Filtre inconnu : '${filterRaw}'`,
+                    line: lineNo,
+                });
+                continue;
+            }
+
+            const def = FILTER_DEFS[filterKey];
+
+            // 3. Nombre d'arguments incorrect
+            if (args.length < def.min) {
+                issues.push({
+                    level: 'error',
+                    msg: `Le filtre '${filterRaw}' requiert au moins ${def.min} argument(s), ${args.length} fourni(s)`,
+                    line: lineNo,
+                });
+                continue;
+            }
+            if (args.length > def.max) {
+                issues.push({
+                    level: 'error',
+                    msg: `Le filtre '${filterRaw}' accepte au plus ${def.max} argument(s), ${args.length} fourni(s)`,
+                    line: lineNo,
+                });
+                continue;
+            }
+
+            // 4. Validations spécifiques par filtre
+            if ((filterKey === 'htmlentities' || filterKey === 'rawurlencode') && args.length === 1 && args[0] !== 'utf8') {
+                issues.push({
+                    level: 'error',
+                    msg: `Argument invalide pour '${filterRaw}' : '${args[0]}' (seul 'utf8' est accepté)`,
+                    line: lineNo,
+                });
+            }
+
+            if (NUMERIC_FILTER_ARGS.has(filterKey) && !/^\d+$/.test(args[0])) {
+                issues.push({
+                    level: 'error',
+                    msg: `Le filtre '${filterRaw}' requiert un argument numérique, '${args[0]}' fourni`,
+                    line: lineNo,
+                });
+            }
+
+            if (filterKey === 'date' && !DATE_ARGS.has(args[0])) {
+                issues.push({
+                    level: 'error',
+                    msg: `Argument invalide pour 'date' : '${args[0]}' (valeurs : annee, num_mois, num_jour, mois, mois_abrev, jour_semaine, heure, minute, seconde)`,
+                    line: lineNo,
+                });
+            }
+
+            if (filterKey === 'mapvalue') {
+                for (const arg of args) {
+                    if (/[^\x20-\x7E]/.test(arg)) {
+                        issues.push({
+                            level: 'error',
+                            msg: `Caractère non autorisé dans les arguments de 'mapValue' : '${arg}'`,
+                            line: lineNo,
+                        });
+                    }
+                }
+            }
+
+            if (filterKey === 'slice') {
+                if (!['-', '_', 'space'].includes(args[0])) {
+                    issues.push({
+                        level: 'error',
+                        msg: `Séparateur invalide pour 'slice' : '${args[0]}' (attendu : '-', '_' ou 'space')`,
+                        line: lineNo,
+                    });
+                }
+                if (!/^\d+$/.test(args[1]) || !/^\d+$/.test(args[2])) {
+                    issues.push({
+                        level: 'error',
+                        msg: `Les positions de 'slice' (start, length) doivent être numériques`,
+                        line: lineNo,
+                    });
+                }
+            }
+        }
+    }
+
+    return issues;
+}

package/src/lib/theme-checker/index.ts

@@ -0,0 +1,6 @@
+export { ThemeInspector } from './inspector.ts';
+export { ThemeChecker } from './checker.ts';
+export type { ThemeReport, Issue, IssueLevel, ThemeType } from './types.ts';
+export { validateFilters } from './filter-validator.ts';
+export type { FilterValidationIssue } from './filter-validator.ts';
+export { resolveLangs, isLangValid } from './lang.ts';

package/src/lib/theme-checker/inspector.ts

@@ -0,0 +1,193 @@
+import { readdirSync, statSync, existsSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { parseThemeXml } from './parsers/theme-xml.ts';
+import { parseSymbolXml } from './parsers/symbol-xml.ts';
+import { parseModelXml } from './parsers/model-xml.ts';
+import { parseComponentXml } from './parsers/component-xml.ts';
+import { parsePostTypeXml } from './parsers/post-type-xml.ts';
+import type {
+    ThemeType,
+    ThemeDesc,
+    TypeDefinition,
+    ModelDef,
+    SymbolDef,
+    ComponentDef,
+    PostTypeDef,
+    ParseResult,
+} from './types.ts';
+
+const VALID_NAME = /^[a-zA-Z0-9_-]{1,40}$/;
+const VALID_LANG = /^[a-z]{2}$/;
+
+type TypeConfig = {
+    subdir: string;
+    descriptor: string;
+    parse: (dir: string, id: string) => ParseResult<TypeDefinition>;
+};
+
+const TYPE_CONFIGS: Record<ThemeType, TypeConfig> = {
+    model: {
+        subdir: '/templates/',
+        descriptor: 'desc.xml',
+        parse: (dir, id) => parseModelXml(dir, id),
+    },
+    symbol: {
+        subdir: '/symboles/',
+        descriptor: 'desc.xml',
+        parse: (dir, id) => parseSymbolXml(dir, id),
+    },
+    component: {
+        subdir: '/composants/',
+        descriptor: 'config.xml',
+        parse: (dir, id) => parseComponentXml(dir, id),
+    },
+    cms: {
+        subdir: '/billets/',
+        descriptor: 'config.xml',
+        parse: (dir, id) => parsePostTypeXml(dir, id, 'cms'),
+    },
+    blog: {
+        subdir: '/billets_blog/',
+        descriptor: 'config.xml',
+        parse: (dir, id) => parsePostTypeXml(dir, id, 'blog'),
+    },
+    product: {
+        subdir: '/produits/',
+        descriptor: 'config.xml',
+        parse: (dir, id) => parsePostTypeXml(dir, id, 'product'),
+    },
+};
+
+function listSubdirs(dir: string): string[] {
+    try {
+        return readdirSync(dir).filter(name => {
+            try {
+                return statSync(nodePath.join(dir, name)).isDirectory();
+            } catch {
+                return false;
+            }
+        });
+    } catch {
+        return [];
+    }
+}
+
+export class ThemeInspector {
+    private readonly themePath: string;
+    private readonly lg: string;
+    private cacheTypes = new Map<ThemeType, TypeDefinition[]>();
+    private cacheTypeErrors = new Map<ThemeType, { id: string; error: string }[]>();
+    private cacheDesc: ThemeDesc | null | undefined = undefined;
+    private cacheDescError: string | null = null;
+
+    constructor(themePath: string, lang: string = 'fr') {
+        this.themePath = themePath;
+        this.lg = lang;
+    }
+
+    // Liste les dossiers de langue (2 lettres minuscules) à la racine du thème
+    static listThemeLangs(themePath: string): string[] {
+        return listSubdirs(themePath).filter(name => VALID_LANG.test(name)).sort();
+    }
+
+    getPath(): string {
+        return this.themePath;
+    }
+
+    getLgPath(subdir: string = ''): string {
+        return nodePath.join(this.themePath, this.lg, subdir);
+    }
+    
+    getRelLgPath(subdir: string = ''): string {
+        return nodePath.join(this.lg, subdir);
+    }
+
+    getDescription(): ThemeDesc | null {
+        if (this.cacheDesc !== undefined) return this.cacheDesc;
+        const xmlPath = nodePath.join(this.themePath, 'theme.xml');
+        if (!existsSync(xmlPath)) {
+            this.cacheDesc = null;
+        } else {
+            const result = parseThemeXml(xmlPath);
+            this.cacheDesc = result.definition;
+            this.cacheDescError = result.error;
+        }
+        return this.cacheDesc;
+    }
+
+    getDescriptionError(): string | null {
+        return this.cacheDescError;
+    }
+
+    private listTypes(type: ThemeType): TypeDefinition[] {
+        const cached = this.cacheTypes.get(type);
+        if (cached !== undefined) return cached;
+
+        const config = TYPE_CONFIGS[type];
+        const basePath = nodePath.join(this.themePath, this.lg, config.subdir);
+        const dirs = listSubdirs(basePath);
+
+        const items: TypeDefinition[] = [];
+        const errors: { id: string; error: string }[] = [];
+        for (const dir of dirs) {
+            if (!VALID_NAME.test(dir)) continue;
+            const fullDir = nodePath.join(basePath, dir);
+            if (!existsSync(nodePath.join(fullDir, config.descriptor))) continue;
+            const result = config.parse(fullDir, dir);
+            if (result.definition !== null) {
+                items.push(result.definition);
+            } else {
+                errors.push({ id: dir, error: result.error });
+            }
+        }
+
+        this.cacheTypes.set(type, items);
+        this.cacheTypeErrors.set(type, errors);
+        return items;
+    }
+
+    getTypeErrors(type: ThemeType): { id: string; error: string }[] {
+        if (!this.cacheTypeErrors.has(type)) this.listTypes(type);
+        return this.cacheTypeErrors.get(type) ?? [];
+    }
+
+    listModels(): ModelDef[] {
+        return this.listTypes('model') as ModelDef[];
+    }
+
+    listSymbols(): SymbolDef[] {
+        return this.listTypes('symbol') as SymbolDef[];
+    }
+
+    listComponents(): ComponentDef[] {
+        return this.listTypes('component') as ComponentDef[];
+    }
+
+    listCms(): PostTypeDef[] {
+        return this.listTypes('cms') as PostTypeDef[];
+    }
+
+    listBlogs(): PostTypeDef[] {
+        return this.listTypes('blog') as PostTypeDef[];
+    }
+
+    listProducts(): PostTypeDef[] {
+        return this.listTypes('product') as PostTypeDef[];
+    }
+
+    getRequiredFilesForType(type: ThemeType): string[] {
+        switch (type) {
+            case 'component': return ['index.html', 'config.xml'];
+            case 'blog': return ['config.xml'];
+            case 'cms': return ['index.html', 'config.xml'];
+            case 'symbol': return ['index.html', 'desc.xml', 'structure.xhtml'];
+            case 'product': return ['index.html', 'config.xml'];
+            case 'model': return ['index.html', 'desc.xml', 'structure.xhtml'];
+        }
+    }
+
+    getTypeSubdir(type: ThemeType): string {
+        return TYPE_CONFIGS[type].subdir;
+    }
+}
+

package/src/lib/theme-checker/lang.ts

@@ -0,0 +1,42 @@
+import { statSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { ThemeInspector } from './inspector.ts';
+
+const VALID_LANG = /^[a-z]{2}$/;
+
+function isDir(path: string): boolean {
+    try {
+        return statSync(path).isDirectory();
+    } catch {
+        return false;
+    }
+}
+
+export function isLangValid(lang: string): boolean {
+    return VALID_LANG.test(lang);
+}
+
+// Résout la liste des langues cibles pour un thème : dossiers de 2 lettres à la racine
+// (défaut) ou sous-ensemble validé/dédupliqué si `lang` est précisé.
+export function resolveLangs(themePath: string, lang: string[] | null | undefined): string[] | { error: string } {
+    if (!lang || lang.length === 0) {
+        const found = ThemeInspector.listThemeLangs(themePath);
+        if (found.length === 0) {
+            return { error: `aucun dossier de langue (2 lettres) trouvé à la racine du thème.` };
+        }
+        return found;
+    }
+
+    const deduped = [...new Set(lang)];
+    const invalid = deduped.filter(l => !isLangValid(l));
+    if (invalid.length > 0) {
+        return { error: `code(s) de langue invalide(s) : ${invalid.map(l => `"${l}"`).join(', ')} (2 lettres minuscules attendues, ex. "fr").` };
+    }
+
+    const missing = deduped.filter(l => !isDir(nodePath.join(themePath, l)));
+    if (missing.length > 0) {
+        return { error: `dossier(s) de langue introuvable(s) à la racine du thème : ${missing.join(', ')}.` };
+    }
+
+    return deduped;
+}

package/src/lib/theme-checker/parsers/component-xml.ts

@@ -0,0 +1,120 @@
+import { readFileSync, statSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { XMLParser } from 'fast-xml-parser';
+import type { ComponentDef, FieldDef, OptionDef, ParseResult } from '../types.ts';
+
+const parser = new XMLParser({
+    ignoreAttributes: false,
+    attributeNamePrefix: '',
+    textNodeName: '#text',
+    isArray: (name: string) => ['champ', 'option'].includes(name),
+    transformTagName: (name: string) => name.toLowerCase(),
+    transformAttributeName: (name: string) => name.toUpperCase(),
+});
+
+const s = (v: unknown): string => v != null ? String(v) : '';
+
+const MAX_FIELDS = 20;
+const VALID_FIELD_NAME = /^([a-zA-Z0-9_]{1,40})$/;
+const ALLOWED_TYPES = new Set([
+    'text', 'textarea', 'image', 'wysiwyg', 'select', 'checkbox', 'color', 'date', 'datetime', 'file',
+]);
+
+function parseFieldType(raw: string): string {
+    if (raw === 'fichier') return 'file';
+    return ALLOWED_TYPES.has(raw) ? raw : 'text';
+}
+
+function parseFields(rawChamps: Record<string, unknown>[]): FieldDef[] {
+    const fields: FieldDef[] = [];
+    const seenNames = new Set<string>();
+
+    for (const c of rawChamps) {
+        const name = s(c.CHAMP);
+        if (!VALID_FIELD_NAME.test(name)) continue;
+        if (seenNames.has(name)) continue;
+        if (fields.length >= MAX_FIELDS) break;
+
+        const type = parseFieldType(s(c.TYPE));
+        seenNames.add(name);
+
+        const rawOptions: Record<string, unknown>[] = Array.isArray(c.option)
+            ? c.option as Record<string, unknown>[]
+            : (c.option ? [c.option as Record<string, unknown>] : []);
+
+        const options: OptionDef[] = [];
+        for (const o of (rawOptions as unknown[]).slice(0, 100)) {
+            const isObj = o !== null && typeof o === 'object';
+            const label = isObj ? s((o as Record<string, unknown>)['#text']) : s(o);
+            const value = isObj ? (s((o as Record<string, unknown>).VALUE) || label) : label;
+            if (!options.some(existing => existing.value === value)) {
+                options.push({ value, label: label || value });
+            }
+        }
+
+        let defaultVal: string | null = s(c.DEFAUT) || null;
+        if (type === 'image' || type === 'file') defaultVal = null;
+        if (type === 'select' && defaultVal !== null && !options.some(o => o.value === defaultVal)) defaultVal = null;
+
+        const field: FieldDef = {
+            field: name,
+            name: s(c.INTITULE).slice(0, 80) || name,
+            type,
+            default: defaultVal,
+            help: s(c.AIDE).slice(0, 255),
+        };
+        if (type === 'select' || type === 'checkbox') field.options = options;
+        fields.push(field);
+    }
+
+    return fields;
+}
+
+function toArray(v: unknown): Record<string, unknown>[] {
+    if (Array.isArray(v)) return v as Record<string, unknown>[];
+    if (v) return [v as Record<string, unknown>];
+    return [];
+}
+
+function ensureTitleField(fields: FieldDef[]): void {
+    if (!fields.some(f => f.field === 'title')) {
+        fields.push({ field: 'title', name: 'Titre', type: 'text', default: null, help: '' });
+    }
+}
+
+export function parseComponentXml(dir: string, id: string): ParseResult<ComponentDef> {
+    try {
+        const filePath = nodePath.join(dir, 'config.xml');
+        const stat = statSync(filePath);
+        if (stat.size > 10 * 1024) return { definition: null, error: 'Fichier trop volumineux (> 10 Ko)' };
+        const content = readFileSync(filePath, 'latin1');
+        const doc = parser.parse(content);
+        const composant = doc?.composant;
+        if (!composant) return { definition: null, error: 'Balise <composant> manquante' };
+
+        const listechampsEl = composant.listechamps as Record<string, unknown> | undefined;
+        const fields = listechampsEl ? parseFields(toArray(listechampsEl.champ)) : [];
+
+        const collectionEl = composant.collection as Record<string, unknown> | undefined;
+        const hasCollection = !!collectionEl;
+        const collection = hasCollection ? parseFields(toArray(collectionEl!.champ)) : [];
+
+        ensureTitleField(fields);
+        if (hasCollection) ensureTitleField(collection);
+
+        return {
+            definition: {
+                id,
+                tpl: nodePath.join(dir, 'index.html'),
+                name: s(composant.INTITULE),
+                position: parseInt(s(composant.TRI), 10) || 0,
+                fields,
+                collection,
+                hasCollection,
+            },
+            error: null,
+        };
+    } catch {
+        return { definition: null, error: 'Impossible de lire ou parser le fichier' };
+    }
+}

package/src/lib/theme-checker/parsers/model-xml.ts

@@ -0,0 +1,82 @@
+import { readFileSync, statSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { XMLParser } from 'fast-xml-parser';
+import type { ModelDef, ZoneDef, ParseResult } from '../types.ts';
+
+const parser = new XMLParser({
+    ignoreAttributes: false,
+    attributeNamePrefix: '',
+    textNodeName: '#text',
+    isArray: (name: string) => name === 'zone',
+    transformTagName: (name: string) => name.toLowerCase(),
+    transformAttributeName: (name: string) => name.toUpperCase(),
+});
+
+const s = (v: unknown): string => v != null ? String(v) : '';
+
+const ALLOWED_COLMAX = ['1', '2', '2d', '2g', '3'];
+
+export function parseModelXml(dir: string, id: string): ParseResult<ModelDef> {
+    try {
+        const filePath = nodePath.join(dir, 'desc.xml');
+        const stat = statSync(filePath);
+        if (stat.size > 10 * 1024) return { definition: null, error: 'Fichier trop volumineux (> 10 Ko)' };
+        const content = readFileSync(filePath, 'latin1');
+        const doc = parser.parse(content);
+        const modele = doc?.modele;
+        if (!modele) return { definition: null, error: 'Balise <modele> manquante' };
+
+        const zonesEl = modele.zones as Record<string, unknown> | undefined;
+        const zones: ZoneDef[] = [];
+        let defaultContentZone: string | null = null;
+
+        if (zonesEl) {
+            const rawZones: Record<string, unknown>[] = Array.isArray(zonesEl.zone)
+                ? zonesEl.zone as Record<string, unknown>[]
+                : (zonesEl.zone ? [zonesEl.zone as Record<string, unknown>] : []);
+
+            const defautId = s(zonesEl.DEFAUT);
+            const seenIds = new Set<string>();
+            let firstContent: string | null = null;
+
+            for (const z of rawZones) {
+                const zoneId = s(z.ID).trim();
+                if (!zoneId || seenIds.has(zoneId)) continue;
+                seenIds.add(zoneId);
+                const colmax = ALLOWED_COLMAX.includes(s(z.COLMAX)) ? s(z.COLMAX) : '1';
+                const defaut = ALLOWED_COLMAX.includes(s(z.DEFAUT)) ? s(z.DEFAUT) : '1';
+                const isContent = s(z.TYPE).toUpperCase() === 'CONTENU';
+                zones.push({ id: zoneId, isContent, colmax, name: s(z.INTITULE), defaut });
+                if (isContent && firstContent === null) firstContent = zoneId;
+            }
+
+            // Resolve default content zone (force is_content on DEFAUT zone)
+            if (defautId) {
+                const defautZone = zones.find(z => z.id === defautId);
+                if (defautZone) {
+                    defautZone.isContent = true;
+                    defaultContentZone = defautZone.id;
+                } else {
+                    defaultContentZone = firstContent;
+                }
+            } else {
+                defaultContentZone = firstContent;
+            }
+        }
+
+        void defaultContentZone; // used for internal logic only
+
+        return {
+            definition: {
+                id,
+                tpl: nodePath.join(dir, 'index.html'),
+                structure: nodePath.join(dir, 'structure.xhtml'),
+                zones,
+                name: s(modele.INTITULE),
+            },
+            error: null,
+        };
+    } catch {
+        return { definition: null, error: 'Impossible de lire ou parser le fichier' };
+    }
+}