@reburn-ui/mcp-server 0.0.0-stage → 9.8.1

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2025 Moritz Weber
+Copyright (c) 2021 Vitaly Rtishchev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,51 @@
-# Temporary Holding Version
+# @reburn-ui/mcp-server
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+MCP server for the reburn-ui documentation, a port of `@mantine/mcp-server`. It reads the static
+data the docs build writes to `/mcp` (`src/docs/llms/compile-mcp-data.ts`) and serves it over
+stdio.
+
+This folder is its own package, not part of the published `reburn-ui` package: it is a Node CLI
+with its own dependencies (`@modelcontextprotocol/server`, `zod`) that `reburn-ui` users don't
+need, and `svelte-package` only builds `src/`. The docs build imports the data types from
+`src/types.ts`, so the format stays in one place.
+
+## Usage
+
+```bash
+npx @reburn-ui/mcp-server
+```
+
+From this repository:
+
+```bash
+bun install            # in mcp-server/
+bun src/index.ts
+```
+
+`bun run build` bundles `dist/index.js` for the bin (`bin/reburn-ui-mcp-server.js`, Node 22+),
+`bun run check` type-checks the sources.
+
+## Configuration
+
+- `REBURN_MCP_DATA_URL` – static MCP data base URL (`https://mantine-reburn-ui.vercel.app/mcp` by
+  default), e.g. `http://localhost:4174/mcp` for a local preview of the docs
+- `REBURN_MCP_TIMEOUT_MS` – HTTP timeout in milliseconds (`10000` by default)
+
+## Tools
+
+- `search_docs` – search all documentation; returns ranked matches, often pointing at a specific section
+- `get_item_doc` – outline by default, one section with `section`, whole page with `full: true`
+- `get_item_props` – component props, or a hook's TypeScript signature
+- `list_items` – filter by `kind`, `group`, `category`, `package` or `query`
+- `get_api` – resolve a symbol (`useDisclosure`, `ButtonBuilder`) to its signature or section
+
+## Testing
+
+From the repository root, after `bun run build`:
+
+```bash
+bun run mcp:smoke            # TypeScript source with bun
+bun run mcp:smoke --built    # bundled bin with node (run `bun run build` in mcp-server first)
+```
+
+It uses the preview on port 4174, or starts and stops one, and calls all five tools.

package/bin/reburn-ui-mcp-server.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+// Port of `@mantine/mcp-server` `bin/mcp-server.cjs` (ESM here, the package is `"type": "module"`)
+import { readFileSync } from 'node:fs';
+
+const args = process.argv.slice(2);
+
+if (args.includes('--help') || args.includes('-h')) {
+	console.log(`Usage: reburn-ui-mcp-server
+
+Starts the reburn-ui MCP server.
+
+Environment:
+  REBURN_MCP_DATA_URL    /mcp URL of the reburn-ui docs
+                         (https://mantine-reburn-ui.vercel.app/mcp by default)
+  REBURN_MCP_TIMEOUT_MS  HTTP timeout in milliseconds (10000 by default)
+
+Options:
+  -h, --help     Show help
+  -v, --version  Show version`);
+	process.exit(0);
+}
+
+if (args.includes('--version') || args.includes('-v')) {
+	const packageJson = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+	console.log(packageJson.version);
+	process.exit(0);
+}
+
+const unknownOption = args.find((arg) => arg.startsWith('-'));
+
+if (unknownOption) {
+	console.error(`Unknown option: ${unknownOption}`);
+	console.error('Run reburn-ui-mcp-server --help for usage.');
+	process.exit(1);
+}
+
+await import('../dist/index.js');

package/dist/index.js

@@ -0,0 +1,569 @@
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/server";
+import { serveStdio } from "@modelcontextprotocol/server/stdio";
+// package.json
+var package_default = {
+  name: "@reburn-ui/mcp-server",
+  version: "9.8.1",
+  description: "MCP server for reburn-ui documentation",
+  keywords: [
+    "ai",
+    "docs",
+    "mantine",
+    "mcp",
+    "model-context-protocol",
+    "reburn-ui",
+    "svelte"
+  ],
+  homepage: "https://github.com/Mo310/mantine-reburn-ui/tree/main/mcp-server#readme",
+  license: "MIT",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/Mo310/mantine-reburn-ui.git",
+    directory: "mcp-server"
+  },
+  bin: {
+    "reburn-ui-mcp-server": "bin/reburn-ui-mcp-server.js"
+  },
+  files: [
+    "bin",
+    "dist"
+  ],
+  type: "module",
+  main: "./dist/index.js",
+  publishConfig: {
+    access: "public"
+  },
+  scripts: {
+    build: "bun build src/index.ts --target node --packages external --outfile dist/index.js",
+    check: "tsc --noEmit",
+    prepack: "bun run build",
+    start: "bun src/index.ts"
+  },
+  dependencies: {
+    "@modelcontextprotocol/server": "2.1.0",
+    zod: "^4.6.5"
+  },
+  devDependencies: {
+    "@types/node": "^22.0.0",
+    typescript: "^6.0.3"
+  },
+  engines: {
+    node: ">=22"
+  }
+};
+
+// src/search.ts
+var STOPWORDS = new Set([
+  "a",
+  "an",
+  "the",
+  "and",
+  "or",
+  "of",
+  "to",
+  "in",
+  "on",
+  "for",
+  "with",
+  "how",
+  "do",
+  "i",
+  "my",
+  "is",
+  "it",
+  "can",
+  "use",
+  "using",
+  "when",
+  "what",
+  "that",
+  "this",
+  "be",
+  "as",
+  "at",
+  "by",
+  "from",
+  "are",
+  "get"
+]);
+function normalize(value) {
+  return value.trim().toLowerCase();
+}
+function tokenize(value) {
+  return normalize(value).split(/[^a-z0-9.-]+/).filter(Boolean);
+}
+function queryTokens(query) {
+  const raw = tokenize(query);
+  const filtered = raw.filter((token) => token.length > 2 && !STOPWORDS.has(token));
+  return filtered.length > 0 ? filtered : raw;
+}
+function createSearchScorer(index, sections) {
+  const sectionDocs = sections.map((section) => normalize(`${section.heading} ${section.snippet}`));
+  const itemDocs = index.map((item) => normalize(item.searchText));
+  const corpus = [...sectionDocs, ...itemDocs];
+  const corpusSize = corpus.length;
+  const documentFrequencyCache = new Map;
+  function documentFrequency(token) {
+    const cached = documentFrequencyCache.get(token);
+    if (cached !== undefined) {
+      return cached;
+    }
+    let count = 0;
+    for (const doc of corpus) {
+      if (doc.includes(token)) {
+        count += 1;
+      }
+    }
+    documentFrequencyCache.set(token, count);
+    return count;
+  }
+  function idf(token) {
+    return Math.log((corpusSize + 1) / (documentFrequency(token) + 1));
+  }
+  function coverage(haystack, tokens) {
+    if (tokens.length === 0) {
+      return 0;
+    }
+    let matchedWeight = 0;
+    let totalWeight = 0;
+    for (const token of tokens) {
+      const weight = idf(token);
+      totalWeight += weight;
+      if (haystack.includes(token)) {
+        matchedWeight += weight;
+      }
+    }
+    return totalWeight > 0 ? matchedWeight / totalWeight : 0;
+  }
+  return {
+    scoreItem(item, query) {
+      const q = normalize(query);
+      if (!q) {
+        return 0;
+      }
+      const tokens = queryTokens(query);
+      const name = normalize(item.name);
+      const haystack = normalize(item.searchText);
+      const coverageScore = coverage(haystack, tokens);
+      let bonus = 0;
+      if (name === q) {
+        bonus = 60;
+      } else if (name.startsWith(q)) {
+        bonus = 40;
+      } else if (name.includes(q)) {
+        bonus = 25;
+      }
+      if (tokens.some((token) => name.includes(token))) {
+        bonus += 15;
+      }
+      return coverageScore * 55 + bonus;
+    },
+    scoreSection(section, query) {
+      const q = normalize(query);
+      if (!q) {
+        return 0;
+      }
+      const tokens = queryTokens(query);
+      const heading = normalize(section.heading);
+      const haystack = normalize(`${section.heading} ${section.snippet}`);
+      const coverageScore = coverage(haystack, tokens);
+      let bonus = 0;
+      if (heading === q) {
+        bonus += 40;
+      } else if (heading.includes(q)) {
+        bonus += 25;
+      }
+      if (tokens.some((token) => heading.includes(token))) {
+        bonus += 15;
+      }
+      return coverageScore * 60 + bonus;
+    }
+  };
+}
+function editDistance(a, b) {
+  const rows = Array.from({ length: a.length + 1 }, (_, i) => [i, ...Array(b.length).fill(0)]);
+  for (let j = 0;j <= b.length; j += 1) {
+    rows[0][j] = j;
+  }
+  for (let i = 1;i <= a.length; i += 1) {
+    for (let j = 1;j <= b.length; j += 1) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      rows[i][j] = Math.min(rows[i - 1][j] + 1, rows[i][j - 1] + 1, rows[i - 1][j - 1] + cost);
+    }
+  }
+  return rows[a.length][b.length];
+}
+function suggestNames(index, query, limit = 3) {
+  const q = normalize(query);
+  const threshold = Math.max(2, Math.floor(q.length / 3));
+  return index.map((item) => ({ name: item.name, distance: editDistance(q, normalize(item.name)) })).filter((entry) => entry.distance <= threshold).sort((a, b) => a.distance - b.distance).slice(0, limit).map((entry) => entry.name);
+}
+
+// src/data-client.ts
+function normalize2(value) {
+  return value.trim().toLowerCase();
+}
+function compact(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+function hasSearchTag(item, symbol) {
+  const requested = compact(symbol);
+  return !!requested && (item.searchTags || "").split(",").some((tag) => compact(tag) === requested);
+}
+function findSymbolSection(sections, symbol) {
+  const requested = compact(symbol);
+  return sections.find((s) => compact(s.heading).startsWith(requested)) || sections.find((s) => compact(s.heading).includes(requested));
+}
+function clampLimit(limit, fallback, max) {
+  if (typeof limit !== "number" || Number.isNaN(limit)) {
+    return fallback;
+  }
+  return Math.max(1, Math.min(max, Math.floor(limit)));
+}
+var INDEX_REVALIDATE_INTERVAL_MS = 5 * 60 * 1000;
+
+class ReburnMcpDataClient {
+  baseUrl;
+  timeoutMs;
+  indexCache = null;
+  indexEtag = null;
+  indexCheckedAt = 0;
+  sectionsCache = null;
+  docCache = new Map;
+  scorer = null;
+  constructor(baseUrl, timeoutMs = 1e4) {
+    this.baseUrl = baseUrl.replace(/\/+$/, "");
+    this.timeoutMs = timeoutMs;
+  }
+  async fetchJson(relativePath, etag) {
+    const controller = new AbortController;
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      const url = `${this.baseUrl}/${relativePath.replace(/^\/+/, "")}`;
+      const headers = etag ? { "If-None-Match": etag } : undefined;
+      const response = await fetch(url, { signal: controller.signal, headers });
+      if (response.status === 304) {
+        return { data: null, etag };
+      }
+      if (!response.ok) {
+        throw new Error(`Failed to fetch ${url}: ${response.status}`);
+      }
+      return { data: await response.json(), etag: response.headers.get("etag") };
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async revalidateIndex() {
+    try {
+      const { data, etag } = await this.fetchJson("index.json", this.indexEtag);
+      if (data) {
+        this.indexCache = data;
+        this.indexEtag = etag ?? null;
+        this.sectionsCache = null;
+        this.docCache.clear();
+        this.scorer = null;
+      }
+    } catch (error) {
+      console.error("Failed to revalidate reburn-ui MCP index, serving cached data", error);
+    }
+  }
+  async getIndex() {
+    if (!this.indexCache) {
+      const { data, etag } = await this.fetchJson("index.json");
+      this.indexCache = data ?? [];
+      this.indexEtag = etag ?? null;
+      this.indexCheckedAt = Date.now();
+      return this.indexCache;
+    }
+    const now = Date.now();
+    if (now - this.indexCheckedAt >= INDEX_REVALIDATE_INTERVAL_MS) {
+      this.indexCheckedAt = now;
+      await this.revalidateIndex();
+    }
+    return this.indexCache;
+  }
+  async getSections() {
+    if (this.sectionsCache) {
+      return this.sectionsCache;
+    }
+    const { data } = await this.fetchJson("sections.json");
+    this.sectionsCache = data ?? [];
+    return this.sectionsCache;
+  }
+  async getScorer() {
+    if (this.scorer) {
+      return this.scorer;
+    }
+    const index = await this.getIndex();
+    const sections = await this.getSections();
+    this.scorer = createSearchScorer(index, sections);
+    return this.scorer;
+  }
+  async getDocData(id) {
+    const cached = this.docCache.get(id);
+    if (cached) {
+      return cached;
+    }
+    const { data } = await this.fetchJson(`docs/${id}.json`);
+    if (!data) {
+      throw new Error(`Missing document data for ${id}`);
+    }
+    this.docCache.set(id, data);
+    return data;
+  }
+  async listItems(args = {}) {
+    const limit = clampLimit(args.limit, 30, 500);
+    const query = args.query ? normalize2(args.query) : null;
+    const index = await this.getIndex();
+    return index.filter((item) => args.kind ? item.kind === args.kind : true).filter((item) => args.group ? item.group === args.group : true).filter((item) => args.category ? normalize2(item.category) === normalize2(args.category) : true).filter((item) => args.package ? normalize2(item.package || "") === normalize2(args.package) : true).filter((item) => query ? item.searchText.includes(query) : true).slice(0, limit);
+  }
+  async findItem(args) {
+    const requested = normalize2(args.name);
+    const index = await this.getIndex();
+    const candidates = args.kind ? index.filter((item) => item.kind === args.kind) : index;
+    return candidates.find((item) => normalize2(item.id) === requested) || candidates.find((item) => normalize2(item.name) === requested) || candidates.find((item) => normalize2(item.name).startsWith(requested)) || candidates.find((item) => item.searchText.includes(requested)) || null;
+  }
+  async suggestFor(name) {
+    return suggestNames(await this.getIndex(), name);
+  }
+  async search(args) {
+    const limit = clampLimit(args.limit, 20, 100);
+    const query = args.query.trim();
+    if (!query) {
+      return [];
+    }
+    const index = await this.getIndex();
+    const sections = await this.getSections();
+    const scorer = await this.getScorer();
+    const allowed = index.filter((item) => args.kind ? item.kind === args.kind : true).filter((item) => args.package ? normalize2(item.package || "") === normalize2(args.package) : true);
+    const allowedIds = new Map(allowed.map((item) => [item.id, item]));
+    const sectionHits = sections.filter((section) => allowedIds.has(section.id)).map((section) => ({ section, score: scorer.scoreSection(section, query) })).filter((entry) => entry.score > 0);
+    const pageHits = allowed.map((item) => ({ item, score: scorer.scoreItem(item, query) })).filter((entry) => entry.score > 0);
+    const merged = new Map;
+    pageHits.forEach((hit) => {
+      merged.set(hit.item.id, { item: hit.item, score: hit.score });
+    });
+    sectionHits.forEach((hit) => {
+      const item = allowedIds.get(hit.section.id);
+      const key = `${hit.section.id}#${hit.section.slug}`;
+      merged.set(key, { item, section: hit.section, score: hit.score });
+    });
+    return Array.from(merged.values()).sort((a, b) => b.score - a.score).slice(0, limit).map((entry) => ({
+      id: entry.item.id,
+      name: entry.item.name,
+      kind: entry.item.kind,
+      package: entry.item.package,
+      route: entry.item.route,
+      docsUrl: entry.item.docsUrl,
+      description: entry.item.description,
+      section: entry.section?.slug,
+      heading: entry.section?.heading,
+      snippet: entry.section?.snippet,
+      score: Number(entry.score.toFixed(2))
+    }));
+  }
+  async getDoc(args) {
+    const item = await this.findItem(args);
+    if (!item) {
+      return null;
+    }
+    const data = await this.getDocData(item.id);
+    if (args.full) {
+      const body = [data.intro, ...data.sections.map((s) => `## ${s.heading}
+
+${s.body}`)].join(`
+
+`);
+      return { item, mode: "full", markdown: body };
+    }
+    if (args.section) {
+      const requested = normalize2(args.section);
+      const section = data.sections.find((s) => s.slug === requested) || data.sections.find((s) => normalize2(s.heading) === requested);
+      if (!section) {
+        return {
+          item,
+          mode: "section-not-found",
+          availableSections: data.sections.map((s) => s.slug)
+        };
+      }
+      return { item, mode: "section", heading: section.heading, markdown: section.body };
+    }
+    return {
+      item,
+      mode: "outline",
+      intro: data.intro,
+      sections: data.sections.map((s) => ({ slug: s.slug, heading: s.heading })),
+      source: data.source,
+      docs: data.docs
+    };
+  }
+  findApiSection(sections) {
+    return sections.find((s) => /api|return type|overview/i.test(s.heading));
+  }
+  async getProps(args) {
+    const item = await this.findItem(args);
+    if (!item) {
+      return null;
+    }
+    const data = await this.getDocData(item.id);
+    if (data.props.length > 0) {
+      return { item, kind: "props", props: data.props };
+    }
+    if (data.signature) {
+      return {
+        item,
+        kind: "signature",
+        signature: data.signature,
+        exportedTypeNames: data.exportedTypeNames
+      };
+    }
+    const apiSection = this.findApiSection(data.sections);
+    return {
+      item,
+      kind: "sections",
+      message: `${item.name} has no generated props or signature. Use get_item_doc with a section instead.`,
+      suggestedSection: apiSection?.slug,
+      availableSections: data.sections.map((s) => s.slug)
+    };
+  }
+  async getApi(symbol) {
+    const index = await this.getIndex();
+    const requested = normalize2(symbol);
+    const candidates = index.filter((item) => item.hasSignature || item.propsCount > 0 || item.kind === "hook");
+    const directMatch = candidates.find((item) => normalize2(item.name).replace(/-/g, "") === requested.replace(/-/g, "")) || candidates.find((item) => item.searchText.includes(requested));
+    const match = directMatch || index.find((item) => hasSearchTag(item, symbol));
+    if (!match) {
+      return null;
+    }
+    const data = await this.getDocData(match.id);
+    const hasExportedTypeNames = !!data.exportedTypeNames && data.exportedTypeNames.length > 0;
+    if (!data.signature && !hasExportedTypeNames) {
+      const apiSection = !directMatch && findSymbolSection(data.sections, symbol) || this.findApiSection(data.sections);
+      return {
+        item: match,
+        signature: data.signature,
+        exportedTypeNames: data.exportedTypeNames,
+        propsCount: data.props.length,
+        suggestedSection: apiSection?.slug,
+        availableSections: data.sections.map((s) => s.slug)
+      };
+    }
+    return {
+      item: match,
+      signature: data.signature,
+      exportedTypeNames: data.exportedTypeNames,
+      propsCount: data.props.length
+    };
+  }
+}
+
+// src/tools.ts
+import * as z from "zod";
+var kindSchema = z.enum(["component", "hook", "guide", "faq"]);
+var groupSchema = z.enum([
+  "gettingStarted",
+  "components",
+  "hooks",
+  "dates",
+  "charts",
+  "others",
+  "headless"
+]);
+var nameSchema = z.string().trim().min(1);
+function text(payload) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: typeof payload === "string" ? payload : JSON.stringify(payload, null, 2)
+      }
+    ]
+  };
+}
+function error(message) {
+  return { isError: true, content: [{ type: "text", text: message }] };
+}
+function registerTools(server, client) {
+  server.registerTool("search_docs", {
+    title: "Search reburn-ui documentation",
+    description: "Search all reburn-ui documentation — components, headless builders, hooks, dates, charts, extensions and guides. Returns ranked matches; a match may point at a specific section, which can then be fetched with get_item_doc.",
+    inputSchema: z.object({
+      query: z.string().describe('Free text query, e.g. "close a modal on outside click"'),
+      kind: kindSchema.optional(),
+      package: z.string().optional().describe('Filter by package, e.g. "reburn-ui/builders"'),
+      limit: z.number().optional().describe("Maximum number of results (default 20, max 100)")
+    })
+  }, async (args) => text(await client.search(args)));
+  server.registerTool("get_item_doc", {
+    title: "Get reburn-ui documentation",
+    description: "Get documentation for a reburn-ui component, headless builder, hook or guide page. Without a section it returns an outline (description plus section list) — pass a section to fetch just that part, or full:true for the whole page.",
+    inputSchema: z.object({
+      name: nameSchema.describe('Item name or id, e.g. "use-disclosure", "Button", "core-button-headless"'),
+      kind: kindSchema.optional(),
+      section: z.string().optional().describe('Section slug from the outline, e.g. "usage"'),
+      full: z.boolean().optional().describe("Return the entire page; can be very large")
+    })
+  }, async (args) => {
+    const result = await client.getDoc(args);
+    if (!result) {
+      const suggestions = await client.suggestFor(args.name);
+      return error(suggestions.length > 0 ? `No exact match for "${args.name}". Did you mean: ${suggestions.join(", ")}?` : `No reburn-ui documentation found for "${args.name}". Try search_docs first.`);
+    }
+    return text(result);
+  });
+  server.registerTool("get_item_props", {
+    title: "Get reburn-ui props or signature",
+    description: "Get props for a reburn-ui component, or the TypeScript signature for a hook. Pages documenting an API in prose point at the relevant section instead.",
+    inputSchema: z.object({ name: nameSchema, kind: kindSchema.optional() })
+  }, async (args) => {
+    const result = await client.getProps(args);
+    if (!result) {
+      const suggestions = await client.suggestFor(args.name);
+      return error(suggestions.length > 0 ? `No exact match for "${args.name}". Did you mean: ${suggestions.join(", ")}?` : `No reburn-ui documentation found for "${args.name}".`);
+    }
+    return text(result);
+  });
+  server.registerTool("list_items", {
+    title: "List reburn-ui documentation items",
+    description: "List reburn-ui documentation items, filtered by kind, nav group, category, package or a text query.",
+    inputSchema: z.object({
+      kind: kindSchema.optional(),
+      group: groupSchema.optional(),
+      category: z.string().optional(),
+      package: z.string().optional(),
+      query: z.string().optional(),
+      limit: z.number().optional().describe("Maximum number of results (default 30, max 500)")
+    })
+  }, async (args) => text(await client.listItems(args)));
+  server.registerTool("get_api", {
+    title: "Resolve a reburn-ui symbol",
+    description: "Resolve a reburn-ui symbol (useDisclosure, ButtonBuilder) to its TypeScript signature and exported types, without knowing which page documents it.",
+    inputSchema: z.object({ symbol: nameSchema })
+  }, async ({ symbol }) => {
+    const result = await client.getApi(symbol);
+    if (!result) {
+      const suggestions = await client.suggestFor(symbol);
+      return error(suggestions.length > 0 ? `No API found for "${symbol}". Did you mean: ${suggestions.join(", ")}?` : `No API found for "${symbol}". Try search_docs.`);
+    }
+    return text(result);
+  });
+}
+
+// src/server.ts
+var DEFAULT_DATA_URL = "https://mantine-reburn-ui.vercel.app/mcp";
+function startServer() {
+  const timeoutMs = Number(process.env.REBURN_MCP_TIMEOUT_MS || 1e4);
+  const dataUrl = process.env.REBURN_MCP_DATA_URL || DEFAULT_DATA_URL;
+  serveStdio(() => {
+    const server = new McpServer({ name: package_default.name, version: package_default.version });
+    registerTools(server, new ReburnMcpDataClient(dataUrl, timeoutMs));
+    return server;
+  });
+}
+
+// src/index.ts
+startServer();
+export {
+  startServer
+};

package/package.json

@@ -1,6 +1,50 @@
 {
-  "name": "@reburn-ui/mcp-server",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+	"name": "@reburn-ui/mcp-server",
+	"version": "9.8.1",
+	"description": "MCP server for reburn-ui documentation",
+	"keywords": [
+		"ai",
+		"docs",
+		"mantine",
+		"mcp",
+		"model-context-protocol",
+		"reburn-ui",
+		"svelte"
+	],
+	"homepage": "https://github.com/Mo310/mantine-reburn-ui/tree/main/mcp-server#readme",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/Mo310/mantine-reburn-ui.git",
+		"directory": "mcp-server"
+	},
+	"bin": {
+		"reburn-ui-mcp-server": "bin/reburn-ui-mcp-server.js"
+	},
+	"files": [
+		"bin",
+		"dist"
+	],
+	"type": "module",
+	"main": "./dist/index.js",
+	"publishConfig": {
+		"access": "public"
+	},
+	"scripts": {
+		"build": "bun build src/index.ts --target node --packages external --outfile dist/index.js",
+		"check": "tsc --noEmit",
+		"prepack": "bun run build",
+		"start": "bun src/index.ts"
+	},
+	"dependencies": {
+		"@modelcontextprotocol/server": "2.1.0",
+		"zod": "^4.6.5"
+	},
+	"devDependencies": {
+		"@types/node": "^22.0.0",
+		"typescript": "^6.0.3"
+	},
+	"engines": {
+		"node": ">=22"
+	}
+}