@maz-ui/mcp 5.0.1-beta.0 → 5.1.0-beta.1

package/dist/mcp.mjs

@@ -1,1511 +0,0 @@
-#!/usr/bin/env node
-import { getErrorMessage } from '@maz-ui/utils/helpers/getErrorMessage';
-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, statSync } from 'node:fs';
-import { resolve, join, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const version = "5.0.0";
-
-class MetadataExtractor {
-  extract(name, type, content, manualTags = []) {
-    const frontmatter = this.extractFrontmatter(content);
-    const sections = this.extractSections(content);
-    const props = this.extractProps(content);
-    const slots = this.extractSlots(content);
-    const events = this.extractEvents(content);
-    const displayName = frontmatter.title ?? this.nameToDisplayName(name);
-    const description = frontmatter.description ?? this.extractFirstParagraph(content);
-    const extractedTags = this.buildTags(name, displayName, props, slots, events);
-    const tags = this.mergeTags(manualTags, extractedTags);
-    return {
-      name,
-      displayName,
-      type,
-      description,
-      tags,
-      ...props.length > 0 && { props },
-      ...slots.length > 0 && { slots },
-      ...events.length > 0 && { events },
-      sections
-    };
-  }
-  extractFrontmatter(content) {
-    const match = content.match(/^---\n([\s\S]*?)\n---/);
-    if (!match) {
-      return {};
-    }
-    const result = {};
-    const yaml = match[1];
-    for (const line of yaml.split("\n")) {
-      const trimmed = line.trim();
-      if (trimmed.startsWith("title:")) {
-        result.title = trimmed.slice("title:".length).trim();
-      } else if (trimmed.startsWith("description:")) {
-        result.description = trimmed.slice("description:".length).trim();
-      }
-    }
-    return result;
-  }
-  extractSections(content) {
-    const sections = [];
-    const contentWithoutFrontmatter = this.stripFrontmatter(content);
-    const lines = contentWithoutFrontmatter.split("\n");
-    let currentSection;
-    const flushSection = () => {
-      if (currentSection) {
-        const sectionContent = currentSection.contentLines.join("\n").trim();
-        sections.push({
-          title: currentSection.title,
-          level: currentSection.level,
-          content: this.extractSectionLeadText(sectionContent)
-        });
-      }
-    };
-    for (const line of lines) {
-      const headingMatch = line.match(/^(#{2,3}) +(\S.*)$/);
-      if (headingMatch) {
-        flushSection();
-        currentSection = {
-          level: headingMatch[1].length,
-          title: this.cleanHeadingText(headingMatch[2]),
-          contentLines: []
-        };
-      } else if (currentSection) {
-        currentSection.contentLines.push(line);
-      }
-    }
-    flushSection();
-    return sections;
-  }
-  extractProps(content) {
-    return this.extractTableColumn(content, "Props", "Name");
-  }
-  extractSlots(content) {
-    return this.extractTableColumn(content, "Slots", "Name");
-  }
-  extractEvents(content) {
-    return this.extractTableColumn(content, "Events", "Event name");
-  }
-  mergeTags(manualTags, extractedTags) {
-    const tagSet = /* @__PURE__ */ new Set();
-    for (const tag of manualTags) {
-      tagSet.add(tag.toLowerCase());
-    }
-    for (const tag of extractedTags) {
-      tagSet.add(tag.toLowerCase());
-    }
-    return Array.from(tagSet);
-  }
-  extractTableColumn(content, sectionName, columnName) {
-    const sectionRegex = new RegExp(`## ${sectionName} *\\n`, "i");
-    const sectionMatch = content.match(sectionRegex);
-    if (!sectionMatch || sectionMatch.index === void 0) {
-      return [];
-    }
-    const afterSection = content.slice(sectionMatch.index + sectionMatch[0].length);
-    const lines = afterSection.split("\n");
-    const headerLine = lines.find((l) => l.includes("|") && l.toLowerCase().includes(columnName.toLowerCase()));
-    if (!headerLine) {
-      return [];
-    }
-    const headerIndex = lines.indexOf(headerLine);
-    const columns = headerLine.split("|").map((c) => c.trim()).filter(Boolean);
-    const nameColumnIndex = columns.findIndex((c) => c.toLowerCase().includes(columnName.toLowerCase()));
-    if (nameColumnIndex === -1) {
-      return [];
-    }
-    const results = [];
-    for (let i = headerIndex + 2; i < lines.length; i++) {
-      const line = lines[i];
-      if (!line.includes("|") || line.match(/^#{1,6}\s/)) {
-        break;
-      }
-      if (line.match(/^ *\|[-\s|]+\| *$/)) {
-        continue;
-      }
-      const cells = line.split("|").map((c) => c.trim()).filter(Boolean);
-      if (cells[nameColumnIndex]) {
-        const name = cells[nameColumnIndex].replace(/\*\*/g, "").trim();
-        if (name) {
-          results.push(name);
-        }
-      }
-    }
-    return results;
-  }
-  stripFrontmatter(content) {
-    return content.replace(/^---\n[\s\S]*?\n---\n?/, "");
-  }
-  cleanHeadingText(text) {
-    let result = this.removeTemplateTags(text);
-    result = this.resolveMarkdownLinks(result);
-    return result.trim();
-  }
-  removeTemplateTags(text) {
-    let result = "";
-    let i = 0;
-    while (i < text.length) {
-      if (text[i] === "{" && text[i + 1] === "{") {
-        const end = text.indexOf("}}", i + 2);
-        i = end === -1 ? text.length : end + 2;
-      } else {
-        result += text[i];
-        i++;
-      }
-    }
-    return result;
-  }
-  resolveMarkdownLinks(text) {
-    let result = "";
-    let i = 0;
-    while (i < text.length) {
-      if (text[i] === "[") {
-        const closeBracket = text.indexOf("]", i + 1);
-        if (closeBracket !== -1 && text[closeBracket + 1] === "(") {
-          const closeParen = text.indexOf(")", closeBracket + 2);
-          if (closeParen !== -1) {
-            result += text.slice(i + 1, closeBracket);
-            i = closeParen + 1;
-            continue;
-          }
-        }
-      }
-      result += text[i];
-      i++;
-    }
-    return result;
-  }
-  extractSectionLeadText(content) {
-    const lines = content.split("\n");
-    const paragraphLines = [];
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (!trimmed) {
-        if (paragraphLines.length > 0) {
-          break;
-        }
-        continue;
-      }
-      if (trimmed.startsWith("#") || trimmed.startsWith("<") || trimmed.startsWith("```") || trimmed.startsWith(":::") || trimmed.startsWith("|")) {
-        if (paragraphLines.length > 0) {
-          break;
-        }
-        continue;
-      }
-      paragraphLines.push(trimmed);
-    }
-    return paragraphLines.join(" ");
-  }
-  extractFirstParagraph(content) {
-    const stripped = this.stripFrontmatter(content);
-    const lines = stripped.split("\n");
-    const paragraphLines = [];
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (!trimmed) {
-        if (paragraphLines.length > 0) {
-          break;
-        }
-        continue;
-      }
-      if (trimmed.startsWith("#") || trimmed.startsWith("<") || trimmed.startsWith("```") || trimmed.startsWith(":::") || trimmed.startsWith("|") || trimmed.startsWith("{{")) {
-        if (paragraphLines.length > 0) {
-          break;
-        }
-        continue;
-      }
-      paragraphLines.push(trimmed);
-    }
-    return paragraphLines.join(" ");
-  }
-  nameToDisplayName(name) {
-    return name.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
-  }
-  buildTags(name, displayName, props, slots, events) {
-    const tags = [name, displayName.toLowerCase()];
-    for (const prop of props.slice(0, 10)) {
-      tags.push(`prop:${prop}`);
-    }
-    for (const slot of slots.slice(0, 10)) {
-      tags.push(`slot:${slot}`);
-    }
-    for (const event of events.slice(0, 10)) {
-      tags.push(`event:${event}`);
-    }
-    return tags;
-  }
-}
-
-const _dirname = dirname(fileURLToPath(import.meta.url));
-class DocumentationService {
-  docsRoot;
-  componentsDir;
-  generatedDocsDir;
-  guidesDir;
-  composablesDir;
-  directivesDir;
-  pluginsDir;
-  ecosystemDir;
-  utilsDir;
-  utilsTypesDir;
-  nodeDir;
-  iconsDir;
-  metadataExtractor = new MetadataExtractor();
-  constructor() {
-    const localDocsRoot = resolve(_dirname, "../docs/src");
-    const localGeneratedDocsDir = resolve(_dirname, "../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.ecosystemDir = join(this.docsRoot, "ecosystem");
-    this.utilsDir = join(this.ecosystemDir, "utils");
-    this.utilsTypesDir = join(this.utilsDir, "types");
-    this.nodeDir = join(this.ecosystemDir, "node");
-    this.iconsDir = join(this.ecosystemDir, "icons");
-  }
-  pascalToKebabCase(pascalName) {
-    return pascalName.replace(/([A-Z])/g, "-$1").toLowerCase().replace(/^-/, "");
-  }
-  readMarkdownFile(filePath) {
-    try {
-      if (!existsSync(filePath)) {
-        return "";
-      }
-      return readFileSync(filePath, "utf-8");
-    } catch {
-      return "";
-    }
-  }
-  listMarkdownFiles(dirPath, options = {}) {
-    try {
-      if (!existsSync(dirPath)) {
-        return [];
-      }
-      const entries = readdirSync(dirPath);
-      return entries.filter((entry) => {
-        if (!entry.endsWith(".md"))
-          return false;
-        if (!options.keepIndex && entry === "index.md")
-          return false;
-        const fullPath = join(dirPath, entry);
-        return statSync(fullPath).isFile();
-      }).map((file) => file.replace(".md", "")).sort();
-    } catch {
-      return [];
-    }
-  }
-  // ========== COMPONENTS ==========
-  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();
-  }
-  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 ==========
-  // Aggregates: guide/*.md + ecosystem/*.md (standalone) + ecosystem/icons/*.md (index.md → 'icons')
-  getGuideDocumentation(guideName) {
-    const candidates = [
-      join(this.guidesDir, `${guideName}.md`),
-      join(this.ecosystemDir, `${guideName}.md`),
-      join(this.iconsDir, `${guideName}.md`)
-    ];
-    if (guideName === "icons") {
-      candidates.push(join(this.iconsDir, "index.md"));
-    }
-    for (const path of candidates) {
-      const content = this.readMarkdownFile(path);
-      if (content)
-        return content;
-    }
-    return "";
-  }
-  getAllGuides() {
-    const guides = /* @__PURE__ */ new Set();
-    for (const name of this.listMarkdownFiles(this.guidesDir)) {
-      guides.add(name);
-    }
-    for (const name of this.listMarkdownFiles(this.ecosystemDir)) {
-      guides.add(name);
-    }
-    for (const name of this.listMarkdownFiles(this.iconsDir)) {
-      guides.add(name);
-    }
-    if (existsSync(join(this.iconsDir, "index.md"))) {
-      guides.add("icons");
-    }
-    return Array.from(guides).sort();
-  }
-  // ========== COMPOSABLES ==========
-  getComposableDocumentation(composableName) {
-    const composablePath = join(this.composablesDir, `${composableName}.md`);
-    return this.readMarkdownFile(composablePath);
-  }
-  getAllComposables() {
-    return this.listMarkdownFiles(this.composablesDir);
-  }
-  // ========== DIRECTIVES ==========
-  getDirectiveDocumentation(directiveName) {
-    const directivePath = join(this.directivesDir, `${directiveName}.md`);
-    return this.readMarkdownFile(directivePath);
-  }
-  getAllDirectives() {
-    return this.listMarkdownFiles(this.directivesDir);
-  }
-  // ========== PLUGINS ==========
-  getPluginDocumentation(pluginName) {
-    const pluginPath = join(this.pluginsDir, `${pluginName}.md`);
-    return this.readMarkdownFile(pluginPath);
-  }
-  getAllPlugins() {
-    return this.listMarkdownFiles(this.pluginsDir);
-  }
-  // ========== UTILS ==========
-  // Aggregates: ecosystem/utils/*.md + ecosystem/utils/types/*.md
-  getUtilDocumentation(utilName) {
-    const candidates = [
-      join(this.utilsDir, `${utilName}.md`),
-      join(this.utilsTypesDir, `${utilName}.md`)
-    ];
-    for (const path of candidates) {
-      const content = this.readMarkdownFile(path);
-      if (content)
-        return content;
-    }
-    return "";
-  }
-  getAllUtils() {
-    const utils = /* @__PURE__ */ new Set([
-      ...this.listMarkdownFiles(this.utilsDir),
-      ...this.listMarkdownFiles(this.utilsTypesDir)
-    ]);
-    return Array.from(utils).sort();
-  }
-  // ========== NODE ==========
-  getNodeDocumentation(nodeName) {
-    const nodePath = join(this.nodeDir, `${nodeName}.md`);
-    return this.readMarkdownFile(nodePath);
-  }
-  getAllNode() {
-    return this.listMarkdownFiles(this.nodeDir);
-  }
-  // ========== UNIFIED LOADING ==========
-  getAllDocuments() {
-    const documents = [];
-    for (const name of this.getAllComponents()) {
-      const content = this.getComponentDocumentation(name);
-      if (content) {
-        documents.push(this.buildDocument(name, "component", content));
-      }
-    }
-    const categories = [
-      { type: "guide", names: this.getAllGuides(), getContent: (name) => this.getGuideDocumentation(name) },
-      { type: "composable", names: this.getAllComposables(), getContent: (name) => this.getComposableDocumentation(name) },
-      { type: "directive", names: this.getAllDirectives(), getContent: (name) => this.getDirectiveDocumentation(name) },
-      { type: "plugin", names: this.getAllPlugins(), getContent: (name) => this.getPluginDocumentation(name) },
-      { type: "util", names: this.getAllUtils(), getContent: (name) => this.getUtilDocumentation(name) },
-      { type: "node", names: this.getAllNode(), getContent: (name) => this.getNodeDocumentation(name) }
-    ];
-    for (const category of categories) {
-      for (const name of category.names) {
-        const content = category.getContent(name);
-        if (content) {
-          documents.push(this.buildDocument(name, category.type, content));
-        }
-      }
-    }
-    return documents;
-  }
-  buildDocument(name, type, content) {
-    return {
-      name,
-      type,
-      content,
-      metadata: this.metadataExtractor.extract(name, type, content)
-    };
-  }
-  // ========== UTILITAIRES ==========
-  getOverview() {
-    const overviewPath = join(this.docsRoot, "index.md");
-    return this.readMarkdownFile(overviewPath);
-  }
-  searchDocumentation(query) {
-    const searchTerm = query.toLowerCase();
-    const results = [];
-    const buckets = [
-      { type: "component", names: this.getAllComponents() },
-      { type: "guide", names: this.getAllGuides() },
-      { type: "composable", names: this.getAllComposables() },
-      { type: "directive", names: this.getAllDirectives() },
-      { type: "plugin", names: this.getAllPlugins() },
-      { type: "util", names: this.getAllUtils() },
-      { type: "node", names: this.getAllNode() }
-    ];
-    for (const { type, names } of buckets) {
-      for (const name of names) {
-        if (name.toLowerCase().includes(searchTerm)) {
-          results.push(`${type}:${name}`);
-        }
-      }
-    }
-    return results;
-  }
-  getDiagnostics() {
-    const [components, guides, composables, directives, plugins, utils, nodeItems] = [
-      this.getAllComponents(),
-      this.getAllGuides(),
-      this.getAllComposables(),
-      this.getAllDirectives(),
-      this.getAllPlugins(),
-      this.getAllUtils(),
-      this.getAllNode()
-    ];
-    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
-      },
-      utils: {
-        total: utils.length,
-        list: utils
-      },
-      node: {
-        total: nodeItems.length,
-        list: nodeItems
-      },
-      paths: {
-        docsRoot: this.docsRoot,
-        componentsDir: this.componentsDir,
-        generatedDocsDir: this.generatedDocsDir,
-        guidesDir: this.guidesDir,
-        composablesDir: this.composablesDir,
-        directivesDir: this.directivesDir,
-        pluginsDir: this.pluginsDir,
-        ecosystemDir: this.ecosystemDir,
-        utilsDir: this.utilsDir,
-        nodeDir: this.nodeDir,
-        iconsDir: this.iconsDir
-      }
-    };
-  }
-}
-
-const SNIPPET_LENGTH = 150;
-class SearchEngine {
-  documents = [];
-  invertedIndex = /* @__PURE__ */ new Map();
-  documentLengths = [];
-  buildIndex(documents) {
-    this.documents = documents;
-    this.invertedIndex.clear();
-    this.documentLengths = [];
-    for (let docIndex = 0; docIndex < documents.length; docIndex++) {
-      const tokens = this.tokenize(documents[docIndex].content);
-      this.documentLengths.push(tokens.length);
-      const termFrequencies = /* @__PURE__ */ new Map();
-      for (let pos = 0; pos < tokens.length; pos++) {
-        const token = tokens[pos];
-        const entry = termFrequencies.get(token);
-        if (entry) {
-          entry.count++;
-          entry.positions.push(pos);
-        } else {
-          termFrequencies.set(token, { count: 1, positions: [pos] });
-        }
-      }
-      for (const [term, { count, positions }] of termFrequencies) {
-        let postings = this.invertedIndex.get(term);
-        if (!postings) {
-          postings = [];
-          this.invertedIndex.set(term, postings);
-        }
-        postings.push({ docIndex, frequency: count, positions });
-      }
-    }
-  }
-  search(query, maxResults = 20) {
-    if (this.documents.length === 0 || !query.trim()) {
-      return [];
-    }
-    const exactPhrases = this.extractExactPhrases(query);
-    const remainingQuery = query.replace(/"[^"]*"/g, "").trim();
-    const singleTerms = remainingQuery ? this.tokenize(remainingQuery) : [];
-    const scores = /* @__PURE__ */ new Map();
-    const matchPositions = /* @__PURE__ */ new Map();
-    for (const term of singleTerms) {
-      this.scoreTerm(term, scores, matchPositions);
-    }
-    for (const phrase of exactPhrases) {
-      this.scorePhrase(phrase, scores, matchPositions);
-    }
-    return Array.from(scores.entries()).filter(([, score]) => score > 0).sort(([, a], [, b]) => b - a).slice(0, maxResults).map(([docIndex, score]) => {
-      const doc = this.documents[docIndex];
-      const positions = matchPositions.get(docIndex) ?? [];
-      return {
-        id: doc.id,
-        type: doc.type,
-        name: doc.name,
-        score: Math.round(score * 1e4) / 1e4,
-        snippet: this.extractSnippet(doc.content, positions)
-      };
-    });
-  }
-  getIndexedTermCount() {
-    return this.invertedIndex.size;
-  }
-  getDocumentCount() {
-    return this.documents.length;
-  }
-  scoreTerm(term, scores, matchPositions) {
-    const postings = this.invertedIndex.get(term);
-    if (!postings) {
-      return;
-    }
-    const totalDocs = this.documents.length;
-    const df = postings.length;
-    const idf = Math.log(1 + totalDocs / df);
-    for (const posting of postings) {
-      const docLength = this.documentLengths[posting.docIndex];
-      const tf = docLength > 0 ? posting.frequency / docLength : 0;
-      const tfidf = tf * idf;
-      scores.set(posting.docIndex, (scores.get(posting.docIndex) ?? 0) + tfidf);
-      const existing = matchPositions.get(posting.docIndex) ?? [];
-      existing.push(posting.positions[0]);
-      matchPositions.set(posting.docIndex, existing);
-    }
-  }
-  scorePhrase(phrase, scores, matchPositions) {
-    const phraseTokens = this.tokenize(phrase);
-    if (phraseTokens.length === 0) {
-      return;
-    }
-    const phraseMatches = this.findPhraseMatches(phraseTokens);
-    const matchedDocs = new Set(phraseMatches.map((m) => m.docIndex));
-    if (matchedDocs.size === 0) {
-      return;
-    }
-    const totalDocs = this.documents.length;
-    const idf = Math.log(1 + totalDocs / matchedDocs.size);
-    for (const docIndex of matchedDocs) {
-      const docMatches = phraseMatches.filter((m) => m.docIndex === docIndex);
-      const docLength = this.documentLengths[docIndex];
-      const tf = docLength > 0 ? docMatches.length / docLength : 0;
-      const tfidf = tf * idf * phraseTokens.length;
-      scores.set(docIndex, (scores.get(docIndex) ?? 0) + tfidf);
-      const existing = matchPositions.get(docIndex) ?? [];
-      existing.push(docMatches[0].position);
-      matchPositions.set(docIndex, existing);
-    }
-  }
-  findPhraseMatches(phraseTokens) {
-    const firstTermPostings = this.invertedIndex.get(phraseTokens[0]);
-    if (!firstTermPostings) {
-      return [];
-    }
-    const matches = [];
-    for (const posting of firstTermPostings) {
-      for (const startPos of posting.positions) {
-        if (this.isPhraseAtPosition(phraseTokens, posting.docIndex, startPos)) {
-          matches.push({ docIndex: posting.docIndex, position: startPos });
-        }
-      }
-    }
-    return matches;
-  }
-  isPhraseAtPosition(phraseTokens, docIndex, startPos) {
-    for (let i = 1; i < phraseTokens.length; i++) {
-      const nextPostings = this.invertedIndex.get(phraseTokens[i]);
-      if (!nextPostings) {
-        return false;
-      }
-      const nextPosting = nextPostings.find((p) => p.docIndex === docIndex);
-      if (!nextPosting || !nextPosting.positions.includes(startPos + i)) {
-        return false;
-      }
-    }
-    return true;
-  }
-  extractExactPhrases(query) {
-    const phrases = [];
-    const regex = /"([^"]+)"/g;
-    for (const match of query.matchAll(regex)) {
-      if (match[1].trim()) {
-        phrases.push(match[1].trim());
-      }
-    }
-    return phrases;
-  }
-  tokenize(text) {
-    return text.toLowerCase().replace(/[#*`|[\](){}!@$%^&+=~<>/\\,;:.?'"_-]+/g, " ").split(/\s+/).filter((token) => token.length > 1);
-  }
-  extractSnippet(content, tokenPositions) {
-    if (!content || tokenPositions.length === 0) {
-      return content.slice(0, SNIPPET_LENGTH).trim();
-    }
-    const tokens = this.tokenize(content);
-    if (tokens.length === 0) {
-      return content.slice(0, SNIPPET_LENGTH).trim();
-    }
-    const bestPosition = tokenPositions[0];
-    const targetToken = tokens[Math.min(bestPosition, tokens.length - 1)];
-    const contentLower = content.toLowerCase();
-    const charIndex = contentLower.indexOf(targetToken);
-    if (charIndex === -1) {
-      return content.slice(0, SNIPPET_LENGTH).trim();
-    }
-    const halfSnippet = Math.floor(SNIPPET_LENGTH / 2);
-    let start = Math.max(0, charIndex - halfSnippet);
-    let end = Math.min(content.length, start + SNIPPET_LENGTH);
-    if (end === content.length) {
-      start = Math.max(0, end - SNIPPET_LENGTH);
-    }
-    if (start > 0) {
-      const spaceIndex = content.indexOf(" ", start);
-      if (spaceIndex !== -1 && spaceIndex < start + 20) {
-        start = spaceIndex + 1;
-      }
-    }
-    if (end < content.length) {
-      const spaceIndex = content.lastIndexOf(" ", end);
-      if (spaceIndex !== -1 && spaceIndex > end - 20) {
-        end = spaceIndex;
-      }
-    }
-    let snippet = content.slice(start, end).trim();
-    if (start > 0) {
-      snippet = `...${snippet}`;
-    }
-    if (end < content.length) {
-      snippet = `${snippet}...`;
-    }
-    return snippet;
-  }
-}
-
-const NAME_BOOST = 3;
-const TAG_BOOST = 2;
-const CONTENT_BOOST = 1;
-const DEFAULT_MAX_RESULTS = 10;
-class UnifiedSearchService {
-  searchEngine = new SearchEngine();
-  documents = [];
-  initialize(documents) {
-    this.documents = documents;
-    this.searchEngine.buildIndex(
-      documents.map((doc) => ({
-        id: doc.name,
-        type: doc.type,
-        name: doc.name,
-        content: doc.content
-      }))
-    );
-  }
-  search(query, options = {}) {
-    const { category, maxResults = DEFAULT_MAX_RESULTS } = options;
-    if (!query.trim()) {
-      return [];
-    }
-    const normalizedQuery = query.toLowerCase().trim();
-    const queryTokens = this.searchEngine.tokenize(query);
-    let candidates = this.documents;
-    if (category) {
-      candidates = candidates.filter((doc) => doc.type === category);
-    }
-    const tfidfResults = this.searchEngine.search(query, candidates.length || this.documents.length);
-    const tfidfScoreMap = /* @__PURE__ */ new Map();
-    for (const result of tfidfResults) {
-      tfidfScoreMap.set(result.id, { score: result.score, snippet: result.snippet });
-    }
-    const scored = [];
-    for (const doc of candidates) {
-      const nameScore = this.scoreNameMatch(normalizedQuery, doc) * NAME_BOOST;
-      const tagScore = this.scoreTagMatch(normalizedQuery, queryTokens, doc) * TAG_BOOST;
-      const tfidfEntry = tfidfScoreMap.get(doc.name);
-      const contentScore = (tfidfEntry?.score ?? 0) * CONTENT_BOOST;
-      const totalScore = nameScore + tagScore + contentScore;
-      if (totalScore > 0) {
-        scored.push({
-          name: doc.name,
-          displayName: doc.metadata.displayName,
-          type: doc.type,
-          description: doc.metadata.description,
-          score: Math.round(totalScore * 1e4) / 1e4,
-          snippet: tfidfEntry?.snippet ?? doc.content.slice(0, 150).trim()
-        });
-      }
-    }
-    return scored.sort((a, b) => b.score - a.score).slice(0, maxResults);
-  }
-  scoreNameMatch(normalizedQuery, doc) {
-    const name = doc.name.toLowerCase();
-    const displayName = doc.metadata.displayName.toLowerCase();
-    if (name === normalizedQuery || displayName === normalizedQuery) {
-      return 1;
-    }
-    if (name.includes(normalizedQuery) || displayName.includes(normalizedQuery)) {
-      return 0.7;
-    }
-    if (normalizedQuery.includes(name)) {
-      return 0.5;
-    }
-    return 0;
-  }
-  scoreTagMatch(normalizedQuery, queryTokens, doc) {
-    const tags = doc.metadata.tags;
-    for (const tag of tags) {
-      if (tag === normalizedQuery) {
-        return 1;
-      }
-    }
-    if (queryTokens.length === 0) {
-      return 0;
-    }
-    let matchedTokens = 0;
-    for (const token of queryTokens) {
-      for (const tag of tags) {
-        if (tag.includes(token) || token.includes(tag)) {
-          matchedTokens++;
-          break;
-        }
-      }
-    }
-    return matchedTokens / queryTokens.length * 0.8;
-  }
-}
-
-class MazUiMcpServer {
-  server;
-  documentationService = new DocumentationService();
-  unifiedSearchService = new UnifiedSearchService();
-  documentationIndex = [];
-  constructor() {
-    this.server = new Server(
-      {
-        name: "maz-ui-mcp",
-        version
-      },
-      {
-        capabilities: {
-          resources: {},
-          tools: {}
-        }
-      }
-    );
-    this.buildDocumentationIndex();
-    this.setupHandlers();
-  }
-  getDocumentationService() {
-    return this.documentationService;
-  }
-  /**
-   * Build a comprehensive index of all available documentation
-   * This helps the AI understand what's available and how to access it
-   */
-  buildDocumentationIndex() {
-    const index = [];
-    index.push({
-      type: "guide",
-      name: "overview",
-      displayName: "Library Overview",
-      description: "Complete overview and introduction to Maz-UI Vue.js component library",
-      tags: ["overview", "introduction", "getting-started", "maz-ui"],
-      uri: "overview://"
-    });
-    const components = this.documentationService.getAllComponents();
-    for (const component of components) {
-      const pascalName = component.split("-").map(
-        (part) => part.charAt(0).toUpperCase() + part.slice(1)
-      ).join("");
-      const componentType = this.getComponentType(component);
-      const tags = [
-        "component",
-        "vue",
-        component,
-        pascalName.toLowerCase(),
-        componentType,
-        ...this.generateSearchTags(component)
-      ];
-      index.push({
-        type: "component",
-        name: component,
-        displayName: `${pascalName} Component`,
-        description: `Vue.js ${componentType} component: ${pascalName} - Interactive UI element with props, events, slots and styling options`,
-        tags,
-        uri: `component://${component}`
-      });
-    }
-    const guides = this.documentationService.getAllGuides();
-    for (const guide of guides) {
-      const displayName = guide.split("-").map(
-        (part) => part.charAt(0).toUpperCase() + part.slice(1)
-      ).join(" ");
-      const tags = [
-        "guide",
-        "documentation",
-        guide,
-        displayName.toLowerCase(),
-        ...this.generateSearchTags(guide)
-      ];
-      index.push({
-        type: "guide",
-        name: guide,
-        displayName: `Guide: ${displayName}`,
-        description: `Documentation guide: ${displayName} - Setup instructions, configuration options, and best practices`,
-        tags,
-        uri: `guide://${guide}`
-      });
-    }
-    const composables = this.documentationService.getAllComposables();
-    for (const composable of composables) {
-      const tags = [
-        "composable",
-        "vue3",
-        "composition-api",
-        composable,
-        composable.replace("use", "").toLowerCase(),
-        ...this.generateSearchTags(composable)
-      ];
-      index.push({
-        type: "composable",
-        name: composable,
-        displayName: `${composable} Composable`,
-        description: `Vue 3 Composition API composable: ${composable} - Reactive state management and reusable logic`,
-        tags,
-        uri: `composable://${composable}`
-      });
-    }
-    const directives = this.documentationService.getAllDirectives();
-    for (const directive of directives) {
-      const tags = [
-        "directive",
-        "vue",
-        "dom",
-        directive,
-        `v-${directive}`,
-        ...this.generateSearchTags(directive)
-      ];
-      index.push({
-        type: "directive",
-        name: directive,
-        displayName: `v-${directive} Directive`,
-        description: `Vue directive: v-${directive} - DOM manipulation and behavioral enhancement for elements`,
-        tags,
-        uri: `directive://${directive}`
-      });
-    }
-    const plugins = this.documentationService.getAllPlugins();
-    for (const plugin of plugins) {
-      const tags = [
-        "plugin",
-        "vue",
-        "global",
-        plugin,
-        plugin.toLowerCase(),
-        ...this.generateSearchTags(plugin)
-      ];
-      index.push({
-        type: "plugin",
-        name: plugin,
-        displayName: `${plugin} Plugin`,
-        description: `Vue plugin: ${plugin} - Application-wide functionality and global services integration`,
-        tags,
-        uri: `plugin://${plugin}`
-      });
-    }
-    const utils = this.documentationService.getAllUtils();
-    for (const util of utils) {
-      const utilType = this.getUtilType(util);
-      const tags = [
-        "util",
-        "utility",
-        "function",
-        "maz-ui-utils",
-        util,
-        utilType,
-        ...this.generateSearchTags(util)
-      ];
-      index.push({
-        type: "util",
-        name: util,
-        displayName: `${util} Util`,
-        description: `Utility from @maz-ui/utils: ${util} - ${utilType} utility for data processing and manipulation`,
-        tags,
-        uri: `util://${util}`
-      });
-    }
-    const nodeItems = this.documentationService.getAllNode();
-    for (const nodeItem of nodeItems) {
-      const tags = [
-        "node",
-        "server",
-        "cli",
-        "maz-ui-node",
-        nodeItem,
-        ...this.generateSearchTags(nodeItem)
-      ];
-      index.push({
-        type: "node",
-        name: nodeItem,
-        displayName: `${nodeItem} Node Utility`,
-        description: `Node.js utility from @maz-ui/node: ${nodeItem} - server-side helper for scripts, CLI and SSR runtimes`,
-        tags,
-        uri: `node://${nodeItem}`
-      });
-    }
-    this.documentationIndex = index;
-    this.unifiedSearchService.initialize(this.documentationService.getAllDocuments());
-  }
-  /**
-   * Generate additional search tags based on common patterns
-   */
-  generateSearchTags(name) {
-    const tags = [];
-    const commonMappings = {
-      btn: ["button"],
-      input: ["form", "field"],
-      select: ["dropdown", "option"],
-      dialog: ["modal", "popup"],
-      tooltip: ["hint", "tip"],
-      toast: ["notification", "snackbar"],
-      card: ["panel"],
-      avatar: ["profile", "image"],
-      badge: ["label", "tag"],
-      spinner: ["loader", "loading"],
-      divider: ["separator"],
-      drawer: ["sidebar", "panel"],
-      tabs: ["tab", "navigation"],
-      accordion: ["collapse", "expand"],
-      carousel: ["slider", "slideshow"],
-      gallery: ["images", "photos"],
-      stepper: ["steps", "wizard"],
-      table: ["grid", "data"],
-      chart: ["graph", "visualization"],
-      date: ["calendar", "picker"],
-      time: ["clock", "picker"]
-    };
-    for (const [key, aliases] of Object.entries(commonMappings)) {
-      if (name.toLowerCase().includes(key)) {
-        tags.push(...aliases);
-      }
-    }
-    return tags;
-  }
-  /**
-   * Determine component type for better categorization
-   */
-  getComponentType(componentName) {
-    const formComponents = ["btn", "checkbox", "checklist", "date", "input", "radio", "select", "slider", "switch", "textarea"];
-    const layoutComponents = ["accordion", "card"];
-    const navigationComponents = ["tabs", "stepper", "pagination", "link", "pull", "reading"];
-    const overlayComponents = ["dialog", "drawer", "sheet", "popover", "dropdown", "backdrop"];
-    const dataComponents = ["chart", "table", "dropzone"];
-    const feedbackComponents = ["spinner", "loading", "progress", "badge"];
-    const displayComponents = ["avatar", "gallery", "lazy", "carousel", "icon"];
-    const animationComponents = ["animated", "expand"];
-    const lowerName = componentName.toLowerCase();
-    if (formComponents.some((type) => lowerName.includes(type)))
-      return "form";
-    if (layoutComponents.some((type) => lowerName.includes(type)))
-      return "layout";
-    if (navigationComponents.some((type) => lowerName.includes(type)))
-      return "navigation";
-    if (overlayComponents.some((type) => lowerName.includes(type)))
-      return "overlay";
-    if (dataComponents.some((type) => lowerName.includes(type)))
-      return "data";
-    if (feedbackComponents.some((type) => lowerName.includes(type)))
-      return "feedback";
-    if (displayComponents.some((type) => lowerName.includes(type)))
-      return "display";
-    if (animationComponents.some((type) => lowerName.includes(type)))
-      return "animation";
-    return "general";
-  }
-  /**
-   * Determine util type for better categorization
-   */
-  getUtilType(utilName) {
-    const lowerName = utilName.toLowerCase();
-    if (lowerName.includes("string") || lowerName.includes("text"))
-      return "string";
-    if (lowerName.includes("date") || lowerName.includes("time"))
-      return "date";
-    if (lowerName.includes("number") || lowerName.includes("currency"))
-      return "number";
-    if (lowerName.includes("color") || lowerName.includes("theme"))
-      return "color";
-    if (lowerName.includes("format") || lowerName.includes("parse"))
-      return "formatting";
-    if (lowerName.includes("valid") || lowerName.includes("check"))
-      return "validation";
-    return "general";
-  }
-  /**
-   * Resolve a document name using intelligent matching:
-   * PascalCase (MazBtn), kebab-case (maz-btn), short name (btn), aliases
-   */
-  resolveDocumentName(name, type) {
-    const normalizedName = name.toLowerCase().trim();
-    const candidates = type && type !== "auto" ? this.documentationIndex.filter((item) => item.type === type) : this.documentationIndex;
-    const exactMatch = candidates.find((item) => item.name.toLowerCase() === normalizedName);
-    if (exactMatch) {
-      return exactMatch;
-    }
-    if (/[A-Z]/.test(name)) {
-      const kebabName = name.replace(/([A-Z])/g, "-$1").toLowerCase().replace(/^-/, "");
-      const kebabMatch = candidates.find((item) => item.name.toLowerCase() === kebabName);
-      if (kebabMatch) {
-        return kebabMatch;
-      }
-    }
-    if (!normalizedName.startsWith("maz-")) {
-      const prefixedName = `maz-${normalizedName}`;
-      const prefixMatch = candidates.find((item) => item.name.toLowerCase() === prefixedName);
-      if (prefixMatch) {
-        return prefixMatch;
-      }
-    }
-    const displayMatch = candidates.find(
-      (item) => item.displayName.toLowerCase() === normalizedName
-    );
-    if (displayMatch) {
-      return displayMatch;
-    }
-    const tagMatch = candidates.find(
-      (item) => item.tags.some((tag) => tag.toLowerCase() === normalizedName)
-    );
-    if (tagMatch) {
-      return tagMatch;
-    }
-    const partialMatch = candidates.find(
-      (item) => item.name.toLowerCase().includes(normalizedName) || item.displayName.toLowerCase().includes(normalizedName)
-    );
-    if (partialMatch) {
-      return partialMatch;
-    }
-    return void 0;
-  }
-  handleSearch(args) {
-    const query = args?.query;
-    const category = args?.category;
-    const maxResults = args?.maxResults || 10;
-    if (!query) {
-      throw new Error("Search query is required. Provide a component name, description, prop name, or use case.");
-    }
-    const results = this.unifiedSearchService.search(query, {
-      category,
-      maxResults
-    });
-    if (results.length === 0) {
-      return {
-        content: [{
-          type: "text",
-          text: `No results found for "${query}".${category ? ` (filtered by category: ${category})` : ""}
-
-**Suggestions:**
-- Try broader or different terms (e.g. "button" instead of "btn")
-- Remove the category filter to search all documentation
-- Use \`list\` to browse all available documentation`
-        }]
-      };
-    }
-    let resultText = `# Search Results for "${query}" (${results.length} found)
-
-`;
-    for (const item of results) {
-      resultText += `## ${item.displayName}
-`;
-      resultText += `- **Name**: \`${item.name}\`
-`;
-      resultText += `- **Type**: ${item.type}
-`;
-      resultText += `- **Description**: ${item.description}
-`;
-      resultText += `- **Score**: ${item.score}
-`;
-      resultText += `- **Snippet**: ${item.snippet}
-`;
-      resultText += `- **Get full doc**: Use \`get_doc\` with name \`${item.name}\`
-
-`;
-    }
-    return {
-      content: [{
-        type: "text",
-        text: resultText
-      }]
-    };
-  }
-  handleList(args) {
-    const category = args?.category || "all";
-    const filteredIndex = category === "all" ? this.documentationIndex : this.documentationIndex.filter((item) => item.type === category);
-    const groupedDocs = filteredIndex.reduce((acc, item) => {
-      if (!acc[item.type])
-        acc[item.type] = [];
-      acc[item.type].push(item);
-      return acc;
-    }, {});
-    const typeLabels = {
-      component: "Components",
-      guide: "Guides",
-      composable: "Composables",
-      directive: "Directives",
-      plugin: "Plugins",
-      util: "Utils",
-      node: "Node Utilities"
-    };
-    const typeOrder = ["component", "guide", "composable", "directive", "plugin", "util", "node"];
-    let result = `# Maz-UI Documentation (${filteredIndex.length} items)
-
-`;
-    for (const type of typeOrder) {
-      if (!groupedDocs[type])
-        continue;
-      const items = groupedDocs[type].sort((a, b) => a.name.localeCompare(b.name));
-      result += `## ${typeLabels[type]} (${items.length})
-
-`;
-      for (const item of items) {
-        result += `- **${item.displayName}** (\`${item.name}\`) \u2014 ${item.description}
-`;
-      }
-      result += "\n";
-    }
-    return {
-      content: [{
-        type: "text",
-        text: result.trim()
-      }]
-    };
-  }
-  handleGetDoc(args) {
-    const docName = args?.name;
-    const docType = args?.type || "auto";
-    if (!docName) {
-      throw new Error("Name is required");
-    }
-    const found = this.resolveDocumentName(docName, docType);
-    if (!found) {
-      return this.handleDocNotFound(docName);
-    }
-    const content = this.getDocumentContent(found);
-    if (!content) {
-      return {
-        content: [{
-          type: "text",
-          text: `Found "${found.displayName}" but documentation content is not available. This might be a documentation file that needs to be created.`
-        }]
-      };
-    }
-    return {
-      content: [{
-        type: "text",
-        text: content
-      }]
-    };
-  }
-  handleDocNotFound(docName) {
-    const searchResults = this.unifiedSearchService.search(docName, { maxResults: 3 });
-    if (searchResults.length === 0) {
-      return {
-        content: [{
-          type: "text",
-          text: `Documentation not found for "${docName}".
-
-**Available options:**
-- Use \`search\` to find similar items
-- Use \`list\` to see all available documentation`
-        }]
-      };
-    }
-    const suggestions = searchResults.map((item) => `- **${item.displayName}** (\`${item.name}\`) - ${item.description}`).join("\n");
-    return {
-      content: [{
-        type: "text",
-        text: `Exact match not found for "${docName}". Did you mean:
-
-${suggestions}
-
-**Use \`get_doc\` with the exact name from above.**`
-      }]
-    };
-  }
-  getDocumentContent(doc) {
-    const contentMethods = {
-      component: (name) => this.documentationService.getComponentDocumentation(name),
-      guide: (name) => this.documentationService.getGuideDocumentation(name),
-      composable: (name) => this.documentationService.getComposableDocumentation(name),
-      directive: (name) => this.documentationService.getDirectiveDocumentation(name),
-      plugin: (name) => this.documentationService.getPluginDocumentation(name),
-      util: (name) => this.documentationService.getUtilDocumentation(name),
-      node: (name) => this.documentationService.getNodeDocumentation(name)
-    };
-    const getContent = contentMethods[doc.type];
-    return getContent ? getContent(doc.name) : "";
-  }
-  setupHandlers() {
-    this.server.setRequestHandler(ListResourcesRequestSchema, () => {
-      return {
-        resources: this.documentationIndex.map((item) => ({
-          uri: item.uri,
-          name: item.displayName,
-          description: item.description,
-          mimeType: "text/markdown"
-        }))
-      };
-    });
-    this.server.setRequestHandler(ReadResourceRequestSchema, (request) => {
-      const { uri } = request.params;
-      if (!uri) {
-        throw new Error("URI is required");
-      }
-      let type, name;
-      if (uri === "overview://") {
-        type = "overview";
-        name = "";
-      } else if (uri.includes("://")) {
-        [type, name] = uri.split("://");
-      } else {
-        throw new Error("Invalid URI format. Expected format: type://name");
-      }
-      if (!name && type !== "overview") {
-        throw new Error("Resource name is required");
-      }
-      let content;
-      try {
-        switch (type) {
-          case "overview":
-            content = this.documentationService.getOverview();
-            if (!content) {
-              const diagnostics = this.documentationService.getDiagnostics();
-              content = `# Maz-UI Vue.js Component Library
-
-## Quick Stats
-- **${diagnostics.components.total} Components** - Ready-to-use Vue components
-- **${diagnostics.composables.total} Composables** - Vue 3 reactive utilities
-- **${diagnostics.directives.total} Directives** - DOM helpers
-- **${diagnostics.plugins.total} Plugins** - App-wide services
-- **${diagnostics.utils.total} Utils** - Utility functions from @maz-ui/utils
-- **${diagnostics.node.total} Node Utilities** - Server-side helpers from @maz-ui/node
-- **${diagnostics.guides.total} Guides** - Documentation
-
-## Getting Started
-Use the MCP tools to explore components and features:
-- \`list\` - See everything available
-- \`search\` - Find specific features
-- \`get_doc\` - Get detailed documentation`;
-            }
-            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 "util":
-            content = this.documentationService.getUtilDocumentation(name);
-            break;
-          case "node":
-            content = this.documentationService.getNodeDocumentation(name);
-            break;
-          default:
-            throw new Error(`Unknown resource type: ${type}. Valid types: overview, component, guide, composable, directive, plugin, util, node`);
-        }
-        if (!content) {
-          throw new Error(`Documentation not found for ${type}: ${name}`);
-        }
-        return {
-          contents: [{
-            uri,
-            mimeType: "text/markdown",
-            text: content
-          }]
-        };
-      } catch (error) {
-        throw new Error(`Failed to read ${type} documentation for "${name}": ${getErrorMessage(error)}`, { cause: error });
-      }
-    });
-    this.server.setRequestHandler(ListToolsRequestSchema, () => {
-      return {
-        tools: [
-          {
-            name: "search",
-            description: 'Search across ALL Maz-UI documentation using a powerful unified search engine. Combines exact name matching, tag/alias matching, and full-text content search with TF-IDF scoring. Use this tool for any search query: component names (e.g. "MazBtn"), functional descriptions (e.g. "date picker"), prop names (e.g. "model-value"), use cases (e.g. "form validation"), or aliases (e.g. "modal" for dialog). Returns ranked results with contextual snippets.',
-            inputSchema: {
-              type: "object",
-              properties: {
-                query: {
-                  type: "string",
-                  description: 'Search query \u2014 can be a component name, description, prop name, use case, or alias. Examples: "button", "MazDialog", "model-value", "phone number input", "lazy loading"'
-                },
-                category: {
-                  type: "string",
-                  enum: ["component", "guide", "composable", "directive", "plugin", "util", "node"],
-                  description: "Optional filter to restrict results to a specific documentation category"
-                },
-                maxResults: {
-                  type: "number",
-                  description: "Maximum number of results to return (default: 10)",
-                  default: 10,
-                  minimum: 1,
-                  maximum: 50
-                }
-              },
-              required: ["query"]
-            }
-          },
-          {
-            name: "get_doc",
-            description: "Get the complete documentation for a specific item. Supports exact names and common aliases. If the exact name isn't found, provides intelligent suggestions based on fuzzy matching.",
-            inputSchema: {
-              type: "object",
-              properties: {
-                name: {
-                  type: "string",
-                  description: 'Exact name or common alias. Examples: "maz-btn" or "MazBtn" for components, "useToast" for composables, "tooltip" for directives'
-                },
-                type: {
-                  type: "string",
-                  enum: ["auto", "component", "guide", "composable", "directive", "plugin", "util", "node"],
-                  description: 'Type hint to improve search accuracy (optional). Use "auto" to search all types.',
-                  default: "auto"
-                }
-              },
-              required: ["name"]
-            }
-          },
-          {
-            name: "list",
-            description: "Browse all available Maz-UI documentation grouped by category. Returns a structured list with counters per category and for each item: name, displayName, description. Use this tool to discover what components, composables, directives, plugins, utils, node utilities and guides are available. Examples: list all docs, list only components, list composables.",
-            inputSchema: {
-              type: "object",
-              properties: {
-                category: {
-                  type: "string",
-                  enum: ["all", "component", "guide", "composable", "directive", "plugin", "util", "node"],
-                  description: 'Filter by documentation category. Use "all" or omit to see everything.',
-                  default: "all"
-                }
-              }
-            }
-          }
-        ]
-      };
-    });
-    this.server.setRequestHandler(CallToolRequestSchema, (request) => {
-      const { name, arguments: args } = request.params;
-      try {
-        switch (name) {
-          case "search":
-            return this.handleSearch(args);
-          case "list":
-            return this.handleList(args);
-          case "get_doc":
-            return this.handleGetDoc(args);
-          default:
-            throw new Error(`Unknown tool: ${name}. Available tools: search, get_doc, list`);
-        }
-      } catch (error) {
-        return {
-          content: [{
-            type: "text",
-            text: `Error: ${getErrorMessage(error)}
-
-**Available tools:**
-- \`search\` - Search across all documentation
-- \`get_doc\` - Get specific documentation
-- \`list\` - Browse all available documentation`
-          }],
-          isError: true
-        };
-      }
-    });
-  }
-  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 };