@maz-ui/mcp 4.0.0-beta.26

package/dist/mcp.mjs

@@ -0,0 +1,586 @@
+#!/usr/bin/env node
+import { getErrorMessage } from '@maz-ui/utils';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { ListResourcesRequestSchema, ReadResourceRequestSchema, ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { resolve, join } from 'node:path';
+
+const version = "4.0.0-beta.25";
+
+class DocumentationService {
+  docsRoot;
+  componentsDir;
+  generatedDocsDir;
+  guidesDir;
+  composablesDir;
+  directivesDir;
+  pluginsDir;
+  helpersDir;
+  constructor() {
+    const localDocsRoot = resolve(process.cwd(), "docs/src");
+    const localGeneratedDocsDir = resolve(process.cwd(), "docs/generated-docs");
+    this.docsRoot = localDocsRoot;
+    this.generatedDocsDir = localGeneratedDocsDir;
+    this.componentsDir = join(this.docsRoot, "components");
+    this.guidesDir = join(this.docsRoot, "guide");
+    this.composablesDir = join(this.docsRoot, "composables");
+    this.directivesDir = join(this.docsRoot, "directives");
+    this.pluginsDir = join(this.docsRoot, "plugins");
+    this.helpersDir = join(this.docsRoot, "helpers");
+  }
+  /**
+   * Convert un nom de composant PascalCase vers kebab-case
+   * MazBtn -> maz-btn
+   */
+  pascalToKebabCase(pascalName) {
+    return pascalName.replace(/([A-Z])/g, "-$1").toLowerCase().replace(/^-/, "");
+  }
+  /**
+   * Lit un fichier markdown et retourne son contenu ou une chaîne vide
+   */
+  readMarkdownFile(filePath) {
+    try {
+      if (!existsSync(filePath)) {
+        return "";
+      }
+      return readFileSync(filePath, "utf-8");
+    } catch {
+      return "";
+    }
+  }
+  /**
+   * Liste les fichiers markdown dans un répertoire
+   */
+  listMarkdownFiles(dirPath) {
+    try {
+      if (!existsSync(dirPath)) {
+        return [];
+      }
+      const files = readdirSync(dirPath);
+      return files.filter((file) => file.endsWith(".md") && file !== "index.md").map((file) => file.replace(".md", "")).sort();
+    } catch {
+      return [];
+    }
+  }
+  // ========== COMPOSANTS ==========
+  /**
+   * Récupère la documentation complète d'un composant (manuelle + générée)
+   */
+  getComponentDocumentation(componentName) {
+    const kebabName = componentName.startsWith("Maz") ? this.pascalToKebabCase(componentName) : componentName;
+    const manualDocPath = join(this.componentsDir, `${kebabName}.md`);
+    const generatedDocPath = join(this.generatedDocsDir, `${kebabName}.doc.md`);
+    const [manualDoc, generatedDoc] = [
+      this.readMarkdownFile(manualDocPath),
+      this.readMarkdownFile(generatedDocPath)
+    ];
+    if (!manualDoc && !generatedDoc) {
+      return "";
+    }
+    let combinedDoc = "";
+    if (manualDoc) {
+      combinedDoc += `${manualDoc}
+
+`;
+    }
+    if (generatedDoc) {
+      combinedDoc += `---
+
+# API Reference
+
+${generatedDoc}`;
+    }
+    return combinedDoc.trim();
+  }
+  /**
+   * Liste tous les composants disponibles
+   */
+  getAllComponents() {
+    const [manualFiles, generatedFiles] = [
+      this.listMarkdownFiles(this.componentsDir),
+      this.listMarkdownFiles(this.generatedDocsDir).map((file) => file.replace(".doc", ""))
+    ];
+    const allComponents = /* @__PURE__ */ new Set([...manualFiles, ...generatedFiles]);
+    return Array.from(allComponents).sort();
+  }
+  // ========== GUIDES ==========
+  /**
+   * Récupère la documentation d'un guide
+   */
+  getGuideDocumentation(guideName) {
+    const guidePath = join(this.guidesDir, `${guideName}.md`);
+    return this.readMarkdownFile(guidePath);
+  }
+  /**
+   * Liste tous les guides disponibles
+   */
+  getAllGuides() {
+    return this.listMarkdownFiles(this.guidesDir);
+  }
+  // ========== COMPOSABLES ==========
+  /**
+   * Récupère la documentation d'un composable
+   */
+  getComposableDocumentation(composableName) {
+    const composablePath = join(this.composablesDir, `${composableName}.md`);
+    return this.readMarkdownFile(composablePath);
+  }
+  /**
+   * Liste tous les composables disponibles
+   */
+  getAllComposables() {
+    return this.listMarkdownFiles(this.composablesDir);
+  }
+  // ========== DIRECTIVES ==========
+  /**
+   * Récupère la documentation d'une directive
+   */
+  getDirectiveDocumentation(directiveName) {
+    const directivePath = join(this.directivesDir, `${directiveName}.md`);
+    return this.readMarkdownFile(directivePath);
+  }
+  /**
+   * Liste toutes les directives disponibles
+   */
+  getAllDirectives() {
+    return this.listMarkdownFiles(this.directivesDir);
+  }
+  // ========== PLUGINS ==========
+  /**
+   * Récupère la documentation d'un plugin
+   */
+  getPluginDocumentation(pluginName) {
+    const pluginPath = join(this.pluginsDir, `${pluginName}.md`);
+    return this.readMarkdownFile(pluginPath);
+  }
+  /**
+   * Liste tous les plugins disponibles
+   */
+  getAllPlugins() {
+    return this.listMarkdownFiles(this.pluginsDir);
+  }
+  // ========== HELPERS ==========
+  /**
+   * Récupère la documentation d'un helper
+   */
+  getHelperDocumentation(helperName) {
+    const helperPath = join(this.helpersDir, `${helperName}.md`);
+    return this.readMarkdownFile(helperPath);
+  }
+  /**
+   * Liste tous les helpers disponibles
+   */
+  getAllHelpers() {
+    return this.listMarkdownFiles(this.helpersDir);
+  }
+  // ========== UTILITAIRES ==========
+  /**
+   * Récupère la vue d'ensemble de la librairie
+   */
+  getOverview() {
+    const overviewPath = join(this.docsRoot, "index.md");
+    return this.readMarkdownFile(overviewPath);
+  }
+  /**
+   * Recherche dans toute la documentation
+   */
+  // eslint-disable-next-line sonarjs/cognitive-complexity
+  searchDocumentation(query) {
+    const searchTerm = query.toLowerCase();
+    const results = [];
+    const components = this.getAllComponents();
+    for (const component of components) {
+      if (component.toLowerCase().includes(searchTerm)) {
+        results.push(`component:${component}`);
+      }
+    }
+    const guides = this.getAllGuides();
+    for (const guide of guides) {
+      if (guide.toLowerCase().includes(searchTerm)) {
+        results.push(`guide:${guide}`);
+      }
+    }
+    const composables = this.getAllComposables();
+    for (const composable of composables) {
+      if (composable.toLowerCase().includes(searchTerm)) {
+        results.push(`composable:${composable}`);
+      }
+    }
+    const directives = this.getAllDirectives();
+    for (const directive of directives) {
+      if (directive.toLowerCase().includes(searchTerm)) {
+        results.push(`directive:${directive}`);
+      }
+    }
+    const plugins = this.getAllPlugins();
+    for (const plugin of plugins) {
+      if (plugin.toLowerCase().includes(searchTerm)) {
+        results.push(`plugin:${plugin}`);
+      }
+    }
+    const helpers = this.getAllHelpers();
+    for (const helper of helpers) {
+      if (helper.toLowerCase().includes(searchTerm)) {
+        results.push(`helper:${helper}`);
+      }
+    }
+    return results;
+  }
+  /**
+   * Récupère les diagnostics détaillés pour debugging
+   */
+  getDiagnostics() {
+    const [components, guides, composables, directives, plugins, helpers] = [
+      this.getAllComponents(),
+      this.getAllGuides(),
+      this.getAllComposables(),
+      this.getAllDirectives(),
+      this.getAllPlugins(),
+      this.getAllHelpers()
+    ];
+    let withManualDoc = 0;
+    let withGeneratedDoc = 0;
+    let withBothDocs = 0;
+    for (const component of components) {
+      const manualExists = existsSync(join(this.componentsDir, `${component}.md`));
+      const generatedExists = existsSync(join(this.generatedDocsDir, `${component}.doc.md`));
+      if (manualExists)
+        withManualDoc++;
+      if (generatedExists)
+        withGeneratedDoc++;
+      if (manualExists && generatedExists)
+        withBothDocs++;
+    }
+    return {
+      components: {
+        total: components.length,
+        withManualDoc,
+        withGeneratedDoc,
+        withBothDocs
+      },
+      guides: {
+        total: guides.length,
+        list: guides
+      },
+      composables: {
+        total: composables.length,
+        list: composables
+      },
+      directives: {
+        total: directives.length,
+        list: directives
+      },
+      plugins: {
+        total: plugins.length,
+        list: plugins
+      },
+      helpers: {
+        total: helpers.length,
+        list: helpers
+      },
+      paths: {
+        docsRoot: this.docsRoot,
+        componentsDir: this.componentsDir,
+        generatedDocsDir: this.generatedDocsDir,
+        guidesDir: this.guidesDir,
+        composablesDir: this.composablesDir,
+        directivesDir: this.directivesDir,
+        pluginsDir: this.pluginsDir,
+        helpersDir: this.helpersDir
+      }
+    };
+  }
+}
+
+class MazUiMcpServer {
+  server;
+  documentationService = new DocumentationService();
+  constructor() {
+    this.server = new Server(
+      {
+        name: "maz-ui-mcp",
+        version
+      },
+      {
+        capabilities: {
+          resources: {},
+          tools: {}
+        }
+      }
+    );
+    this.setupHandlers();
+  }
+  setupHandlers() {
+    this.server.setRequestHandler(ListResourcesRequestSchema, () => {
+      const [components, guides, composables, directives, plugins, helpers] = [
+        this.documentationService.getAllComponents(),
+        this.documentationService.getAllGuides(),
+        this.documentationService.getAllComposables(),
+        this.documentationService.getAllDirectives(),
+        this.documentationService.getAllPlugins(),
+        this.documentationService.getAllHelpers()
+      ];
+      const resources = [];
+      resources.push({
+        uri: "maz-ui://overview",
+        name: "Maz-UI Library Overview",
+        description: "Complete overview of the Maz-UI component library",
+        mimeType: "text/markdown"
+      });
+      for (const component of components) {
+        const pascalName = component.split("-").map(
+          (part) => part.charAt(0).toUpperCase() + part.slice(1)
+        ).join("");
+        resources.push({
+          uri: `maz-ui://component/${pascalName}`,
+          name: `${pascalName} Component`,
+          description: `Documentation for the ${pascalName} Vue component`,
+          mimeType: "text/markdown"
+        });
+      }
+      for (const guide of guides) {
+        resources.push({
+          uri: `maz-ui://guide/${guide}`,
+          name: `Guide: ${guide}`,
+          description: `Guide for ${guide}`,
+          mimeType: "text/markdown"
+        });
+      }
+      for (const composable of composables) {
+        resources.push({
+          uri: `maz-ui://composable/${composable}`,
+          name: `Composable: ${composable}`,
+          description: `Documentation for ${composable} Vue composable`,
+          mimeType: "text/markdown"
+        });
+      }
+      for (const directive of directives) {
+        resources.push({
+          uri: `maz-ui://directive/${directive}`,
+          name: `Directive: ${directive}`,
+          description: `Documentation for ${directive} Vue directive`,
+          mimeType: "text/markdown"
+        });
+      }
+      for (const plugin of plugins) {
+        resources.push({
+          uri: `maz-ui://plugin/${plugin}`,
+          name: `Plugin: ${plugin}`,
+          description: `Documentation for ${plugin} Vue plugin`,
+          mimeType: "text/markdown"
+        });
+      }
+      for (const helper of helpers) {
+        resources.push({
+          uri: `maz-ui://helper/${helper}`,
+          name: `Helper: ${helper}`,
+          description: `Documentation for ${helper} utility function`,
+          mimeType: "text/markdown"
+        });
+      }
+      return { resources };
+    });
+    this.server.setRequestHandler(ReadResourceRequestSchema, (request) => {
+      const { uri } = request.params;
+      if (!uri || !uri.startsWith("maz-ui://")) {
+        throw new Error("Invalid URI");
+      }
+      const path = uri.replace("maz-ui://", "");
+      const [type, name] = path.split("/");
+      let content = "";
+      switch (type) {
+        case "overview":
+          content = this.documentationService.getOverview();
+          break;
+        case "component":
+          content = this.documentationService.getComponentDocumentation(name);
+          break;
+        case "guide":
+          content = this.documentationService.getGuideDocumentation(name);
+          break;
+        case "composable":
+          content = this.documentationService.getComposableDocumentation(name);
+          break;
+        case "directive":
+          content = this.documentationService.getDirectiveDocumentation(name);
+          break;
+        case "plugin":
+          content = this.documentationService.getPluginDocumentation(name);
+          break;
+        case "helper":
+          content = this.documentationService.getHelperDocumentation(name);
+          break;
+        default:
+          throw new Error(`Unknown resource type: ${type}`);
+      }
+      if (!content) {
+        throw new Error("Resource not found");
+      }
+      return {
+        contents: [{
+          uri,
+          mimeType: "text/markdown",
+          text: content
+        }]
+      };
+    });
+    this.server.setRequestHandler(ListToolsRequestSchema, () => {
+      return {
+        tools: [
+          {
+            name: "list_all_components",
+            description: "Get complete list of all available Vue components",
+            inputSchema: {
+              type: "object",
+              properties: {}
+            }
+          },
+          {
+            name: "list_guides",
+            description: "List all documentation guides (installation, setup, etc.)",
+            inputSchema: {
+              type: "object",
+              properties: {}
+            }
+          },
+          {
+            name: "get_getting_started",
+            description: "Get installation and setup guide for Maz-UI",
+            inputSchema: {
+              type: "object",
+              properties: {}
+            }
+          },
+          {
+            name: "list_composables",
+            description: "List all Vue 3 composables (useToast, useDialog, etc.)",
+            inputSchema: {
+              type: "object",
+              properties: {}
+            }
+          },
+          {
+            name: "list_directives",
+            description: "List all Vue directives (v-tooltip, v-click-outside, etc.)",
+            inputSchema: {
+              type: "object",
+              properties: {}
+            }
+          },
+          {
+            name: "list_plugins",
+            description: "List all Vue plugins (Toast, Dialog, AOS, Wait)",
+            inputSchema: {
+              type: "object",
+              properties: {}
+            }
+          },
+          {
+            name: "list_helpers",
+            description: "List all utility functions (string, date, number formatting)",
+            inputSchema: {
+              type: "object",
+              properties: {}
+            }
+          }
+        ]
+      };
+    });
+    this.server.setRequestHandler(CallToolRequestSchema, (request) => {
+      const { name } = request.params;
+      switch (name) {
+        case "list_all_components": {
+          const components = this.documentationService.getAllComponents();
+          return {
+            content: [{
+              type: "text",
+              text: `Available components (${components.length}):
+
+${components.map((c) => `- ${c}`).join("\n")}`
+            }]
+          };
+        }
+        case "list_guides": {
+          const guides = this.documentationService.getAllGuides();
+          return {
+            content: [{
+              type: "text",
+              text: `Available guides (${guides.length}):
+
+${guides.map((g) => `- ${g}`).join("\n")}`
+            }]
+          };
+        }
+        case "get_getting_started": {
+          const guide = this.documentationService.getGuideDocumentation("getting-started");
+          return {
+            content: [{
+              type: "text",
+              text: guide || "Getting started guide not found"
+            }]
+          };
+        }
+        case "list_composables": {
+          const composables = this.documentationService.getAllComposables();
+          return {
+            content: [{
+              type: "text",
+              text: `Available composables (${composables.length}):
+
+${composables.map((c) => `- ${c}`).join("\n")}`
+            }]
+          };
+        }
+        case "list_directives": {
+          const directives = this.documentationService.getAllDirectives();
+          return {
+            content: [{
+              type: "text",
+              text: `Available directives (${directives.length}):
+
+${directives.map((d) => `- ${d}`).join("\n")}`
+            }]
+          };
+        }
+        case "list_plugins": {
+          const plugins = this.documentationService.getAllPlugins();
+          return {
+            content: [{
+              type: "text",
+              text: `Available plugins (${plugins.length}):
+
+${plugins.map((p) => `- ${p}`).join("\n")}`
+            }]
+          };
+        }
+        case "list_helpers": {
+          const helpers = this.documentationService.getAllHelpers();
+          return {
+            content: [{
+              type: "text",
+              text: `Available helpers (${helpers.length}):
+
+${helpers.map((h) => `- ${h}`).join("\n")}`
+            }]
+          };
+        }
+        default:
+          throw new Error(`Unknown tool: ${name}`);
+      }
+    });
+  }
+  async run() {
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+  }
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const server = new MazUiMcpServer();
+  server.run().catch((error) => {
+    console.error("Failed to start MCP server:", getErrorMessage(error));
+    process.exit(1);
+  });
+}
+
+export { MazUiMcpServer };

package/docs/generated-docs/maz-accordion.doc.md

@@ -0,0 +1,21 @@
+## Props
+
+| Name              | Description | Type      | Required | Default     |
+| ----------------- | ----------- | --------- | -------- | ----------- |
+| **id**            |             | `string`  | No       | `undefined` |
+| **model-value**   |             | `number`  | No       | `0`         |
+| **content-class** |             | `unknown` | No       | `undefined` |
+
+## Events
+
+| Event name         | Properties | Description |
+| ------------------ | ---------- | ----------- |
+| update:model-value |            |
+
+## Slots
+
+| Name              | Description | Bindings |
+| ----------------- | ----------- | -------- |
+| `title-${step}`   |             | <br/>    |
+| content           |             |          |
+| `content-${step}` |             | <br/>    |

package/docs/generated-docs/maz-animated-counter.doc.md

@@ -0,0 +1,17 @@
+## Props
+
+| Name         | Description                                       | Type      | Required | Default     |
+| ------------ | ------------------------------------------------- | --------- | -------- | ----------- |
+| **count**    | The number to animate                             | `number`  | Yes      | `undefined` |
+| **duration** | Duration of the animation in milliseconds         | `number`  | No       | `1000`      |
+| **prefix**   | Suffix to display next to the number              | `string`  | No       | `undefined` |
+| **suffix**   | Suffix to display next to the number              | `string`  | No       | `undefined` |
+| **delay**    | Delay before the animation starts in milliseconds | `number`  | No       | `100`       |
+| **once**     | Play the animation only once                      | `boolean` | No       | `true`      |
+
+## Slots
+
+| Name   | Description | Bindings |
+| ------ | ----------- | -------- |
+| prefix |             |          |
+| suffix |             |          |

package/docs/generated-docs/maz-animated-element.doc.md

@@ -0,0 +1,14 @@
+## Props
+
+| Name          | Description                    | Type                                  | Required | Default | Possible values               |
+| ------------- | ------------------------------ | ------------------------------------- | -------- | ------- | ----------------------------- |
+| **direction** | The direction of the animation | `"up" \| "down" \| "left" \| "right"` | No       | `up`    | `up", "down", "left", "right` |
+| **delay**     | The delay of the animation     | `number`                              | No       | `0`     | -                             |
+| **duration**  | The duration of the animation  | `number`                              | No       | `2000`  | -                             |
+| **once**      | Play the animation only once   | `boolean`                             | No       | `true`  | -                             |
+
+## Slots
+
+| Name    | Description | Bindings |
+| ------- | ----------- | -------- |
+| default |             |          |

package/docs/generated-docs/maz-animated-text.doc.md

@@ -0,0 +1,14 @@
+## Props
+
+| Name           | Description                                                   | Type                                  | Required | Default     | Possible values               |
+| -------------- | ------------------------------------------------------------- | ------------------------------------- | -------- | ----------- | ----------------------------- |
+| **text**       | The text to animate<br/>**Example:** `"Hello"`                | `string`                              | Yes      | `undefined` | -                             |
+| **last-word**  | The last word(s) to be highlighted<br/>**Example:** `"world"` | `string`                              | No       | `undefined` | -                             |
+| **delay**      | The delay of the animation                                    | `number`                              | No       | `0`         | -                             |
+| **direction**  | The direction of the animation                                | `"up" \| "down" \| "left" \| "right"` | No       | `up`        | `up", "down", "left", "right` |
+| **tag**        | The tag to use for the text                                   | `string`                              | No       | `span`      | -                             |
+| **word-delay** | The delay between each word                                   | `number`                              | No       | `75`        | -                             |
+| **column-gap** | The column gap between each word                              | `number`                              | No       | `0.5`       | -                             |
+| **row-gap**    | The row gap between each word                                 | `number`                              | No       | `0`         | -                             |
+| **duration**   | The duration of the animation                                 | `number`                              | No       | `2000`      | -                             |
+| **once**       | Play the animation only once                                  | `boolean`                             | No       | `true`      | -                             |