@kiubi/mcp-designer 1.0.0

package/src/lib/theme-checker/parsers/post-type-xml.ts

@@ -0,0 +1,92 @@
+import { readFileSync, statSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { XMLParser } from 'fast-xml-parser';
+import type { PostTypeDef, FieldDef, 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) : '';
+
+// Field name validators by post kind
+const FIELD_NAME_VALIDATORS: Record<string, RegExp> = {
+    cms: /^(titre|sstitre|texte[0-9]+)$/,
+    blog: /^(texte[a-z0-9]*)$/,
+    product: /^(texte[a-z0-9]*)$/,
+};
+
+const ALLOWED_TYPES = new Set([
+    'text', 'textarea', 'image', 'fichier', 'wysiwyg', 'select', 'checkbox', 'color', 'date', 'datetime',
+]);
+
+export function parsePostTypeXml(
+    dir: string,
+    id: string,
+    kind: 'cms' | 'blog' | 'product',
+): ParseResult<PostTypeDef> {
+    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 type = doc?.type;
+        if (!type) return { definition: null, error: 'Balise <type> manquante' };
+
+        const validator = FIELD_NAME_VALIDATORS[kind];
+        const fields: FieldDef[] = [];
+        const champSource = (type.listechamps as Record<string, unknown> | undefined) ?? type;
+        const rawChamps: Record<string, unknown>[] = Array.isArray(champSource.champ)
+            ? champSource.champ as Record<string, unknown>[]
+            : (champSource.champ ? [champSource.champ as Record<string, unknown>] : []);
+
+        for (const c of rawChamps) {
+            const champName = s(c.CHAMP);
+            if (!validator.test(champName)) return { definition: null, error: `Nom de champ invalide pour le type ${kind} : '${champName}'` };
+            const fieldType = ALLOWED_TYPES.has(s(c.TYPE)) ? s(c.TYPE) : 'text';
+            const help = s(c.AIDE).slice(0, 255);
+            const name = s(c.INTITULE).slice(0, 255) || champName;
+
+            const rawOptions: unknown[] = Array.isArray(c.option)
+                ? c.option as unknown[]
+                : (c.option ? [c.option] : []);
+
+            const field: FieldDef = { field: champName, name, type: fieldType, help };
+            if ((fieldType === 'select' || fieldType === 'checkbox') && rawOptions.length > 0) {
+                const options: Array<{ value: string; label: string }> = [];
+                for (const o of rawOptions.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 });
+                    }
+                }
+                field.options = options;
+            }
+            fields.push(field);
+        }
+
+        const def: PostTypeDef = {
+            id,
+            fields,
+            name: s(type.desc),
+            position: parseInt(s(type.TRI), 10) || 0,
+        };
+
+        // Only cms and product have a template
+        if (kind !== 'blog') {
+            def.tpl = nodePath.join(dir, 'index.html');
+        }
+
+        return { definition: def, error: null };
+    } catch {
+        return { definition: null, error: 'Impossible de lire ou parser le fichier' };
+    }
+}

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

@@ -0,0 +1,162 @@
+import { readFileSync, statSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { XMLParser } from 'fast-xml-parser';
+import type { SymbolDef, ZoneDef, FieldDef, OptionDef, ParseResult } from '../types.ts';
+
+const parser = new XMLParser({
+    ignoreAttributes: false,
+    attributeNamePrefix: '',
+    textNodeName: '#text',
+    isArray: (name: string) => ['zone', '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 ALLOWED_COLMAX = ['1', '2', '2d', '2g', '3'];
+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 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 parseZones(zonesEl: Record<string, unknown>): { zones: ZoneDef[]; defaultContentZone: string | null } {
+    const rawZones: Record<string, unknown>[] = Array.isArray(zonesEl.zone)
+        ? zonesEl.zone as Record<string, unknown>[]
+        : (zonesEl.zone ? [zonesEl.zone as Record<string, unknown>] : []);
+
+    const zones: ZoneDef[] = [];
+    const seenIds = new Set<string>();
+
+    for (const z of rawZones) {
+        const id = s(z.ID).trim();
+        if (!id || seenIds.has(id)) continue;
+        seenIds.add(id);
+        const colmax = ALLOWED_COLMAX.includes(s(z.COLMAX)) ? s(z.COLMAX) : '1';
+        const defaut = ALLOWED_COLMAX.includes(s(z.DEFAUT)) ? s(z.DEFAUT) : '1';
+        zones.push({
+            id,
+            isContent: s(z.TYPE).toUpperCase() === 'CONTENU',
+            colmax,
+            name: s(z.INTITULE),
+            defaut,
+        });
+    }
+
+    // Resolve default content zone
+    const defautId = s(zonesEl.DEFAUT);
+    let defaultContentZone: string | null = null;
+    let firstContent: string | null = null;
+
+    for (const z of zones) {
+        if (z.id === defautId) {
+            z.isContent = true;
+            defaultContentZone = z.id;
+            break;
+        }
+        if (z.isContent && firstContent === null) {
+            firstContent = z.id;
+        }
+    }
+
+    if (defaultContentZone === null && firstContent !== null) {
+        defaultContentZone = firstContent;
+    }
+
+    return { zones, defaultContentZone };
+}
+
+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;
+}
+
+export function parseSymbolXml(dir: string, id: string): ParseResult<SymbolDef> {
+    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 symbole = doc?.symbole;
+        if (!symbole) return { definition: null, error: 'Balise <symbole> manquante' };
+
+        const zonesEl = symbole.zones as Record<string, unknown> | undefined;
+        const { zones } = zonesEl ? parseZones(zonesEl) : { zones: [] };
+
+        const listechampsEl = symbole.listechamps as Record<string, unknown> | undefined;
+        const fields = listechampsEl ? parseFields(toArray(listechampsEl.champ)) : [];
+        
+        // ensure title field
+        if (!fields.some(f => f.field === 'title')) {
+            fields.push({ field: 'title', name: 'Titre', type: 'text', default: null, help: '' });
+        }
+
+        return {
+            definition: {
+                id,
+                tpl: nodePath.join(dir, 'index.html'),
+                structure: nodePath.join(dir, 'structure.xhtml'),
+                zones,
+                fields,
+                name: s(symbole.INTITULE),
+                position: parseInt(s(symbole.TRI), 10) || 0,
+            },
+            error: null,
+        };
+    } catch {
+        return { definition: null, error: 'Impossible de lire ou parser le fichier' };
+    }
+}

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

@@ -0,0 +1,102 @@
+import { readFileSync, statSync } from 'node:fs';
+import { XMLParser } from 'fast-xml-parser';
+import type { ThemeDesc, ThemeVariant, ParseResult } from '../types.ts';
+
+const parser = new XMLParser({
+    ignoreAttributes: false,
+    attributeNamePrefix: '',
+    textNodeName: '#text',
+    isArray: (name: string) => name === 'variante',
+    transformTagName: (name: string) => name.toLowerCase(),
+    transformAttributeName: (name: string) => name.toUpperCase(),
+});
+
+const s = (v: unknown): string => v != null ? String(v) : '';
+
+const VALID_ETATS = ['production', 'incomplete', 'testing', 'deprecated'];
+
+export function parseThemeXml(filePath: string): ParseResult<ThemeDesc> {
+    try {
+        const stat = statSync(filePath);
+        if (stat.size > 5 * 1024) return { definition: null, error: 'Fichier trop volumineux (> 5 Ko)' };
+        const content = readFileSync(filePath, 'latin1');
+        const doc = parser.parse(content);
+        const theme = doc?.theme;
+        if (!theme) return { definition: null, error: 'Balise <theme> manquante' };
+
+        // Validate etat
+        const etatRaw = s(theme.ETAT).toLowerCase();
+        let etat: string;
+        if (!etatRaw) {
+            etat = 'production';
+        } else if (!VALID_ETATS.includes(etatRaw)) {
+            return { definition: null, error: `Valeur ETAT invalide : '${etatRaw}'` };
+        } else {
+            etat = etatRaw;
+        }
+
+        // Parse img (reject invalid chars)
+        const img = /[\\\/&#%]/.test(s(theme.IMG)) ? '' : s(theme.IMG);
+
+        // Parse auteur
+        const auteurRaw = theme.auteur;
+        const auteur = auteurRaw ? {
+            nom: s(auteurRaw.NOM),
+            contact: s(auteurRaw.CONTACT),
+            site: s(auteurRaw.SITE),
+        } : undefined;
+
+        // Parse apercu
+        const apercuRaw = s(theme.apercu ?? theme['#text'] ?? '');
+        const apercu = apercuRaw && !/^https?:\/\//.test(apercuRaw)
+            ? 'http://' + apercuRaw
+            : apercuRaw || undefined;
+
+        // Parse variantes
+        const variantes: ThemeVariant[] = [];
+        const rawVariantes: unknown[] = Array.isArray(theme.variante)
+            ? theme.variante
+            : (theme.variante ? [theme.variante] : []);
+        const seenIds = new Set<string>();
+
+        for (const v of rawVariantes as Record<string, unknown>[]) {
+            const css = s(v.CSS).trim();
+            const id = s(v.ID).trim();
+            if (!css || !id) continue;
+            if (id.length > 30 || seenIds.has(id)) continue;
+            if (/[\\]/.test(css)) continue;
+            const colorKeys = ['COLOR1', 'COLOR2', 'COLOR3', 'COLOR4'] as const;
+            if (!colorKeys.every(c => s(v[c]) && /^#[0-9a-f]+$/i.test(s(v[c])))) continue;
+            if (variantes.length >= 30) break;
+            seenIds.add(id);
+            variantes.push({
+                id,
+                css,
+                colors: {
+                    color1: s(v.COLOR1),
+                    color2: s(v.COLOR2),
+                    color3: s(v.COLOR3),
+                    color4: s(v.COLOR4),
+                },
+            });
+        }
+
+        return {
+            definition: {
+                name: s(theme.INTITULE),
+                version: s(theme.VERSION) || undefined,
+                date: s(theme.DATE) || undefined,
+                etat,
+                javascripts: s(theme.JAVASCRIPTS) === 'none' ? 'none' : 'kiubi',
+                style: s(theme.STYLE) || undefined,
+                img,
+                auteur,
+                apercu,
+                variantes,
+            },
+            error: null,
+        };
+    } catch {
+        return { definition: null, error: 'Impossible de lire ou parser le fichier' };
+    }
+}

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

@@ -0,0 +1,97 @@
+export type IssueLevel = 'error' | 'warning';
+
+export interface Issue {
+    level: IssueLevel;
+    category: string;
+    msg: string;
+    file?: string;
+    line?: number;
+}
+
+export interface ThemeReport {
+    issues: Issue[];
+    hasErrors: boolean;
+}
+
+export interface ZoneDef {
+    id: string;
+    isContent: boolean;
+    colmax: string;
+    name: string;
+    defaut?: string;
+}
+
+export interface OptionDef {
+    value: string;
+    label: string;
+}
+
+export interface FieldDef {
+    field: string;
+    name: string;
+    type: string;
+    default?: string | null;
+    help?: string;
+    options?: OptionDef[];
+}
+
+export interface ModelDef {
+    id: string;
+    tpl: string;
+    structure: string;
+    zones: ZoneDef[];
+    name: string;
+}
+
+export interface SymbolDef {
+    id: string;
+    tpl: string;
+    structure: string;
+    zones: ZoneDef[];
+    fields: FieldDef[];
+    name: string;
+    position: number;
+}
+
+export interface ComponentDef {
+    id: string;
+    tpl: string;
+    name: string;
+    position: number;
+    fields: FieldDef[];
+    collection: FieldDef[];
+    hasCollection: boolean;
+}
+
+export interface PostTypeDef {
+    id: string;
+    tpl?: string; // Only cms and product have a template
+    fields: FieldDef[];
+    name: string;
+    position: number;
+}
+
+export interface ThemeVariant {
+    id: string;
+    css: string;
+    colors: { color1: string; color2: string; color3: string; color4: string };
+}
+
+export interface ThemeDesc {
+    name: string;
+    version?: string;
+    date?: string;
+    etat: string;
+    javascripts?: string;
+    style?: string;
+    img?: string;
+    auteur?: { nom: string; contact?: string; site?: string };
+    apercu?: string;
+    variantes: ThemeVariant[];
+}
+
+export type ThemeType = 'model' | 'symbol' | 'component' | 'cms' | 'blog' | 'product';
+
+export type TypeDefinition = ModelDef | SymbolDef | ComponentDef | PostTypeDef;
+
+export type ParseResult<T> = { definition: T; error: null } | { definition: null; error: string };

package/src/logger.ts

@@ -0,0 +1,28 @@
+import { appendFileSync, mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const logDir = join(dirname(fileURLToPath(import.meta.url)), "../storage/logs");
+mkdirSync(logDir, { recursive: true });
+const logFile = join(logDir, "server.log");
+
+function truncate(value: unknown): unknown {
+    if (typeof value === "string") return value.length > 50 ? value.slice(0, 50) + "…" : value;
+    if (Array.isArray(value)) return value.map(truncate);
+    if (value !== null && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value as object).map(([k, v]) => [k, truncate(v)]));
+    }
+    return value;
+}
+
+function write(level: "info" | "error", message: string, data?: unknown): void {
+    const entry: Record<string, unknown> = { ts: new Date().toISOString(), level, message };
+    if (data !== undefined) entry["data"] = data;
+    appendFileSync(logFile, JSON.stringify(entry) + "\n");
+}
+
+export const logger = {
+    info: (message: string, data?: unknown) => write("info", message, data),
+    error: (message: string, data?: unknown) => write("error", message, data),
+    tool: (name: string, args: unknown) => write("info", `tool:${name}`, truncate(args)),
+};

package/src/tool.ts

@@ -0,0 +1,13 @@
+import type { ZodRawShape } from "zod";
+import type { ToolCallback } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+export type ToolDefinition<T extends ZodRawShape> = {
+    name: string;
+    description: string;
+    inputSchema: T;
+    handler: ToolCallback<T>;
+};
+
+export function defineTool<T extends ZodRawShape>(def: ToolDefinition<T>) {
+    return def;
+}