@kiubi/mcp-designer 1.0.0

package/src/tools/ruleset.ts

@@ -0,0 +1,25 @@
+import { defineTool } from "../tool.ts";
+import { readFileSync, existsSync } from "node:fs";
+
+const RULES_PATH = new URL("../../storage/documents/kiubi_ruleset.md", import.meta.url).pathname;
+
+export function integrationRules(): string {
+    if (!existsSync(RULES_PATH)) {
+        return "Fichier de règles d'intégration introuvable.";
+    }
+    return readFileSync(RULES_PATH, "utf-8");
+}
+
+export const integrationRulesTool = defineTool({
+    name: "ruleset",
+    description:
+        "Retourne les règles d'intégration du moteur de template Kiubi. " +
+        "Contient la syntaxe des balises, les filtres disponibles et leurs contraintes d'utilisation. " +
+        "À consulter pour valider ou générer des templates conformes.",
+    inputSchema: {},
+    handler: async () => {
+        return {
+            content: [{ type: "text" as const, text: integrationRules() }],
+        };
+    },
+});

package/src/tools/search_doc.ts

@@ -0,0 +1,160 @@
+import { z } from "zod";
+import { defineTool } from "../tool.ts";
+import { readFileSync, existsSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { normalize, stem } from "#lib/stemmer";
+
+const DOCS_BASE = new URL("../../storage/documents", import.meta.url).pathname;
+const INTEGRATION_DIR = join(DOCS_BASE, "generated/integration");
+const REGLES_PATH = join(DOCS_BASE, "kiubi_ruleset.md");
+const EXEMPLES_PATH = join(DOCS_BASE, "generated/exemples.md");
+const API_PATH = join(DOCS_BASE, "kiubi_api.md");
+
+const TITLE_WEIGHT = 5;
+const MIN_TOKEN_LENGTH = 3;
+
+type SectionEntry = {
+    category: string;
+    title: string;
+    content: string;
+};
+
+function tokenize(text: string): string[] {
+    return normalize(text)
+        .split(/[^a-z0-9]+/)
+        .filter((w) => w.length >= MIN_TOKEN_LENGTH)
+        .map(stem);
+}
+
+function parseSections(content: string, category: string): SectionEntry[] {
+    return content
+        .split(/(?=^## )/m)
+        .filter((s) => s.trim().length > 0)
+        .map((s) => {
+            const title = s.split("\n")[0].replace(/^## /, "").trim();
+            return { category, title, content: s.trimEnd() };
+        })
+        .filter((s) => s.title.length > 0);
+}
+
+function buildIndex(): SectionEntry[] {
+    const entries: SectionEntry[] = [];
+
+    if (existsSync(INTEGRATION_DIR)) {
+        for (const file of readdirSync(INTEGRATION_DIR).filter((f) => f.endsWith(".md")).sort()) {
+            const content = readFileSync(join(INTEGRATION_DIR, file), "utf-8");
+            entries.push(...parseSections(content, "integration"));
+        }
+    }
+
+    if (existsSync(REGLES_PATH)) {
+        entries.push(...parseSections(readFileSync(REGLES_PATH, "utf-8"), "regles"));
+    }
+
+    if (existsSync(EXEMPLES_PATH)) {
+        entries.push(...parseSections(readFileSync(EXEMPLES_PATH, "utf-8"), "exemples"));
+    }
+
+    if (existsSync(API_PATH)) {
+        entries.push(...parseSections(readFileSync(API_PATH, "utf-8"), "api"));
+    }
+
+    return entries;
+}
+
+function scoreSection(entry: SectionEntry, queryTokens: string[]): number {
+    const titleTokens = new Set(tokenize(entry.title));
+    const bodyTokens = tokenize(entry.content);
+
+    let score = 0;
+    for (const qt of queryTokens) {
+        if (titleTokens.has(qt)) score += TITLE_WEIGHT;
+        score += bodyTokens.filter((t) => t === qt).length;
+    }
+    return score;
+}
+
+function truncateAtLine(content: string, limit: number): { text: string; truncated: boolean } {
+    if (content.length <= limit) return { text: content, truncated: false };
+    const cut = content.lastIndexOf("\n", limit);
+    const pos = cut > 0 ? cut : limit;
+    return { text: content.slice(0, pos), truncated: true };
+}
+
+export type SearchDocParams = {
+    query: string;
+    max_results?: number;
+    char_limit?: number;
+};
+
+export function searchDoc({ query, max_results = 5, char_limit = 3000 }: SearchDocParams): string {
+    const clampedMax = Math.min(Math.max(1, max_results), 10);
+    const clampedLimit = Math.max(100, char_limit);
+
+    const queryTokens = tokenize(query);
+    if (queryTokens.length === 0) {
+        return "Aucun mot-clé valide dans la requête.";
+    }
+
+    const scored = buildIndex()
+        .map((entry) => ({ entry, score: scoreSection(entry, queryTokens) }))
+        .filter(({ score }) => score > 0)
+        .sort((a, b) => b.score - a.score)
+        .slice(0, clampedMax);
+
+    if (scored.length === 0) {
+        return `Aucune section trouvée pour : « ${query} »`;
+    }
+
+    return scored
+        .map(({ entry }) => {
+            const header = `### [${entry.category}] ${entry.title}`;
+            const { text, truncated } = truncateAtLine(entry.content, clampedLimit);
+            const suffix = truncated
+                ? "\n[...contenu tronqué — utiliser get_doc_section pour le contenu complet]"
+                : "";
+            return `${header}\n${text}${suffix}`;
+        })
+        .join("\n\n---\n\n");
+}
+
+export const searchDocTool = defineTool({
+    name: "search_doc",
+    description:
+        "Recherche plein texte dans toute la documentation Kiubi (guide integration, exemples de templates, api front-office). " +
+        "À utiliser en fallback quand le titre exact de la section n'est pas connu, " +
+        "ou pour une recherche transversale dans toute la documentation. " +
+        "Retourne les sections les plus pertinentes (contenu potentiellement tronqué : " +
+        "utiliser get_doc_section pour le contenu complet). " +
+        "Exemples : 'type billet site web index.html', 'fiche produit detail balises', " +
+        "'balises widget blog liste_billets', 'blocs composant collection item', " +
+        "'filtre mapValue', 'config.xml produit', 'symbole desc.xml structure'",
+    inputSchema: {
+        query: z.string().min(1).describe("Mots-clés de recherche"),
+        max_results: z
+            .number()
+            .int()
+            .min(1)
+            .max(10)
+            .optional()
+            .describe("Nombre maximum de sections à retourner (défaut: 5, max: 10)"),
+        char_limit: z
+            .number()
+            .int()
+            .min(100)
+            .optional()
+            .describe(
+                "Limite de caractères par section retournée. Augmenter (ex: 8000) pour des sections longues comme les widgets. Défaut: 3000."
+            ),
+    },
+    handler: async ({ query, max_results, char_limit }) => {
+        return {
+            content: [
+                {
+                    type: "text" as const,
+                    text: searchDoc({ query, max_results: max_results ?? 5, char_limit: char_limit ?? 3000 }),
+                },
+            ],
+        };
+    },
+});

package/src/tools/validate_theme.ts

@@ -0,0 +1,63 @@
+import { z } from "zod";
+import { defineTool } from "../tool.ts";
+import { ThemeInspector, ThemeChecker } from "#lib/theme-checker/index";
+import type { ThemeReport, Issue } from "#lib/theme-checker/index";
+
+export function validateTheme({ themePath }: { themePath: string }): string {
+    const inspector = new ThemeInspector(themePath);
+    const report = new ThemeChecker().run(inspector);
+    return formatReport(report, themePath);
+}
+
+function formatReport(report: ThemeReport, themePath: string): string {
+    if (report.issues.length === 0) {
+        return `OK — aucun problème détecté dans le thème "${themePath}"`;
+    }
+
+    const byCategory = new Map<string, { errors: Issue[]; warnings: Issue[] }>();
+    for (const issue of report.issues) {
+        if (!byCategory.has(issue.category)) {
+            byCategory.set(issue.category, { errors: [], warnings: [] });
+        }
+        const cat = byCategory.get(issue.category)!;
+        if (issue.level === 'error') cat.errors.push(issue);
+        else cat.warnings.push(issue);
+    }
+
+    const lines: string[] = [`Rapport de validation — ${themePath}`, ''];
+    const totalErrors = report.issues.filter(i => i.level === 'error').length;
+    const totalWarnings = report.issues.filter(i => i.level === 'warning').length;
+
+    for (const [category, { errors, warnings }] of byCategory) {
+        const parts: string[] = [];
+        if (errors.length > 0) parts.push(`${errors.length} erreur${errors.length > 1 ? 's' : ''}`);
+        if (warnings.length > 0) parts.push(`${warnings.length} avertissement${warnings.length > 1 ? 's' : ''}`);
+        lines.push(`[${category.toUpperCase()}] — ${parts.join(', ')}`);
+
+        for (const issue of errors) {
+            const loc = issue.file ? `  ${issue.file}${issue.line ? `:${issue.line}` : ''}` : '';
+            lines.push(`  ✗ ${issue.msg}${loc}`);
+        }
+        for (const issue of warnings) {
+            const loc = issue.file ? `  ${issue.file}${issue.line ? `:${issue.line}` : ''}` : '';
+            lines.push(`  ⚠ ${issue.msg}${loc}`);
+        }
+        lines.push('');
+    }
+
+    lines.push(`Total : ${totalErrors} erreur${totalErrors > 1 ? 's' : ''}, ${totalWarnings} avertissement${totalWarnings > 1 ? 's' : ''}`);
+    return lines.join('\n');
+}
+
+export const validateThemeTool = defineTool({
+    name: "validate_theme",
+    description: "Vérifie la syntaxe et la cohérence de tous les fichiers du thème graphique",
+    inputSchema: {
+        themePath: z.string().min(1).describe("Chemin absolu vers le dossier racine du thème graphique"),
+    },
+    handler: async ({ themePath }) => {
+        return {
+            content: [{ type: "text" as const, text: validateTheme({ themePath }) }],
+        };
+    }
+});