@lumeo-ui/mcp-server 2.0.0-rc.2 → 2.0.0-rc.20

package/dist/componentsApi.js

@@ -0,0 +1,46 @@
+/**
+ * Loads the auto-generated `components-api.json` produced by
+ * `tools/Lumeo.RegistryGen` (Roslyn-based scan of every `[Parameter]` /
+ * `[CascadingParameter]` property across every Razor component in the repo).
+ *
+ * This is the source-of-truth schema for ALL 131 Lumeo components. The
+ * legacy hand-curated `components.ts` is kept as an OPTIONAL example overlay:
+ * when it has an entry for a component we surface its `example` Razor snippet
+ * verbatim alongside the auto-generated parameter list.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+function findPath() {
+    try {
+        const here = dirname(fileURLToPath(import.meta.url));
+        // dist/ -> ../src/components-api.json
+        // src/  -> ./components-api.json
+        const candidates = [
+            resolve(here, "../src/components-api.json"),
+            resolve(here, "./components-api.json"),
+            // monorepo fallback when running uninstalled
+            resolve(here, "../..", "components-api.json"),
+        ];
+        for (const c of candidates)
+            if (existsSync(c))
+                return c;
+    }
+    catch { /* ignore */ }
+    return null;
+}
+export function loadComponentsApi() {
+    const path = findPath();
+    if (!path)
+        return null;
+    try {
+        const raw = readFileSync(path, "utf8");
+        const parsed = JSON.parse(raw);
+        if (!parsed?.components)
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/index.js

@@ -1,29 +1,44 @@
 #!/usr/bin/env node
 /**
- * Lumeo MCP Server
+ * Lumeo MCP Server v2.0.0
  *
- * Exposes Lumeo's full 125-component catalog (sourced from the generated
- * registry.json, enriched by hand-curated rich entries for the top 35)
- * to MCP-compatible LLM clients (Claude Desktop, Cursor, Copilot, etc.):
+ * Source-of-truth schema for ALL 131 Lumeo components, generated at build time
+ * by `tools/Lumeo.RegistryGen` from the actual Razor source via Roslyn. Every
+ * component now ships full parameter / enum / event / sub-component metadata —
+ * no thin/rich split, no manual catalog drift.
  *
  *   Tools:
- *     - lumeo_list_components  — list/filter the full catalog
- *     - lumeo_get_component    — rich schema when curated, thin otherwise
- *     - lumeo_search           — fuzzy text search across all 125
+ *     - lumeo_list_components  — list/filter all 131 components (name+category+description)
+ *     - lumeo_get_component    — full schema (params, enums, events, sub-components, files)
+ *     - lumeo_search           — fuzzy search across name/category/description
  *
  *   Resources (URI template):
  *     - lumeo://component/{name}   — markdown reference per component
- *     - lumeo://category/{name}    — all components in a category
+ *     - lumeo://category/{name}    — overview of all components in a category
  *
  * Transport: stdio (the standard for spawned MCP servers).
  */
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListResourcesRequestSchema, ListResourceTemplatesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
-import { catalog, CATEGORIES, registry, } from "./components.js";
+import { loadComponentsApi, } from "./componentsApi.js";
+import { components as curatedExamples } from "./components.js";
 const DOCS_BASE = "https://lumeo.nativ.sh";
+// ───────────────── Load source-of-truth schema ─────────────────
+const api = loadComponentsApi() ?? {
+    version: "0.0.0",
+    generated: "",
+    stats: { componentCount: 0, totalParameters: 0, totalEnums: 0, totalRecords: 0, thinFallbacks: [] },
+    components: {},
+};
+const components = Object.values(api.components).sort((a, b) => a.name.localeCompare(b.name));
+const byName = new Map(components.map((c) => [c.name.toLowerCase(), c]));
+const CATEGORIES = Array.from(new Set(components.map((c) => c.category))).sort();
+// Hand-curated examples overlay (~30 components). Auto-gen schema wins for
+// parameters/enums/events; the curated `example` Razor snippet is preserved
+// as a documentation aid because LLMs benefit from seeing real usage.
+const curatedExampleByName = new Map(curatedExamples.map((c) => [c.name.toLowerCase(), c.example]));
 // ───────────────── Helpers ─────────────────
-const byName = new Map(catalog.map((c) => [c.name.toLowerCase(), c]));
 function findComponent(name) {
     return byName.get(name.toLowerCase());
 }
@@ -45,10 +60,9 @@ function score(c, q) {
     return s;
 }
 function searchCatalog(query, category) {
-    let pool = catalog;
-    if (category) {
+    let pool = components;
+    if (category)
         pool = pool.filter((c) => c.category.toLowerCase() === category.toLowerCase());
-    }
     if (!query)
         return pool;
     return pool
@@ -58,94 +72,123 @@ function searchCatalog(query, category) {
         .map((x) => x.c);
 }
 function docsUrl(c) {
-    return `${DOCS_BASE}/components/${c.slug}`;
+    // Convert PascalCase to kebab-case for the docs URL
+    const slug = c.name.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+    return `${DOCS_BASE}/components/${slug}`;
+}
+function paramRow(p) {
+    const def = p.default ?? "—";
+    const desc = p.description ?? "";
+    const flags = [];
+    if (p.isCascading)
+        flags.push("cascading");
+    if (p.captureUnmatched)
+        flags.push("captures unmatched");
+    const flagStr = flags.length ? ` _(${flags.join(", ")})_` : "";
+    return `| \`${p.name}\` | \`${p.type}\` | \`${def}\` | ${desc}${flagStr} |`;
 }
-function toRichMarkdown(c) {
-    const paramRows = c.params
-        .map((p) => `| \`${p.name}\` | \`${p.type}\` | \`${p.default}\` | ${p.description} |`)
+function toComponentMarkdown(c) {
+    const paramRows = c.parameters.map(paramRow).join("\n");
+    const enumRows = c.enums
+        .map((e) => `- **${e.name}**: ${e.values.join(", ")}${e.description ? ` — ${e.description}` : ""}`)
         .join("\n");
-    const slotRows = c.slots
-        .map((s) => `| \`${s.name}\` | ${s.description} |`)
+    const eventRows = c.events
+        .map((e) => `- **${e.name}** \`${e.type}\`${e.description ? ` — ${e.description}` : ""}`)
+        .join("\n");
+    const subRows = Object.values(c.subComponents)
+        .map((s) => `- **${s.componentName}** (${s.parameters.length} params)`)
         .join("\n");
-    const cssVarsBlock = c.cssVars.length
-        ? `## CSS Variables\n\n${c.cssVars.map((v) => `- \`${v}\``).join("\n")}\n\n`
-        : "";
-    return [
-        `# ${c.name}`,
-        ``,
-        `**Category:** ${c.category}`,
-        ``,
-        c.description,
-        ``,
-        `## Parameters`,
-        ``,
-        `| Param | Type | Default | Description |`,
-        `|---|---|---|---|`,
-        paramRows || `| _(none)_ | | | |`,
-        ``,
-        c.slots.length ? `## Slots\n\n| Slot | Description |\n|---|---|\n${slotRows}\n` : ``,
-        `## Example`,
-        ``,
-        "```razor",
-        c.example,
-        "```",
-        ``,
-        cssVarsBlock,
-        `_Docs: ${docsUrl(c)}_`,
-    ].filter(Boolean).join("\n");
-}
-function toThinMarkdown(c) {
     const filesBlock = c.files.length
-        ? `## Files\n\n${c.files.map((f) => `- \`${f}\``).join("\n")}\n\n`
-        : "";
-    const cssVarsBlock = c.cssVars.length
-        ? `## CSS Variables\n\n${c.cssVars.map((v) => `- \`${v}\``).join("\n")}\n\n`
+        ? c.files.map((f) => `- \`${f}\``).join("\n")
         : "";
-    const depsBlock = c.dependencies.length
-        ? `## Dependencies\n\n${c.dependencies.map((d) => `- \`${d}\``).join("\n")}\n\n`
-        : "";
-    return [
+    const example = curatedExampleByName.get(c.name.toLowerCase());
+    const sections = [
         `# ${c.name}`,
-        ``,
-        `**Category:** ${c.category}`,
-        ``,
+        "",
+        `**Category:** ${c.category}${c.subcategory ? ` › ${c.subcategory}` : ""}`,
+        `**NuGet:** \`${c.nugetPackage}\``,
+        `**Namespace:** \`${c.namespace ?? "Lumeo"}\``,
+        "",
         c.description,
-        ``,
-        `> Rich schema (parameters, slots, Razor example) is coming soon for this component.`,
-        `> See the docs site for full usage: [${docsUrl(c)}](${docsUrl(c)})`,
-        ``,
-        filesBlock,
-        depsBlock,
-        cssVarsBlock,
-    ].filter(Boolean).join("\n");
-}
-function toComponentMarkdown(c) {
-    return c.thin ? toThinMarkdown(c) : toRichMarkdown(c);
+        "",
+        "## Parameters",
+        "",
+        "| Name | Type | Default | Description |",
+        "|---|---|---|---|",
+        paramRows || "| _(none)_ | | | |",
+        "",
+    ];
+    if (c.enums.length)
+        sections.push("## Enums", "", enumRows, "");
+    if (c.events.length)
+        sections.push("## Events", "", eventRows, "");
+    if (Object.keys(c.subComponents).length)
+        sections.push("## Sub-components", "", subRows, "");
+    if (example)
+        sections.push("## Example", "", "```razor", example, "```", "");
+    if (filesBlock)
+        sections.push("## Source files", "", filesBlock, "");
+    sections.push(`_Docs: ${docsUrl(c)}_`);
+    return sections.join("\n");
 }
 function toCategoryMarkdown(category) {
-    const inCat = catalog.filter((c) => c.category.toLowerCase() === category.toLowerCase());
-    if (inCat.length === 0) {
-        return `# ${category}\n\nNo components documented in this category yet.`;
-    }
+    const inCat = components.filter((c) => c.category.toLowerCase() === category.toLowerCase());
+    if (inCat.length === 0)
+        return `# ${category}\n\nNo components in this category.`;
     const rows = inCat
-        .map((c) => `| [\`${c.name}\`](lumeo://component/${c.name}) | ${c.thin ? "" : "*"}${c.description}${c.thin ? "" : "*"} |`)
+        .map((c) => `| [\`${c.name}\`](lumeo://component/${c.name}) | ${c.description} |`)
         .join("\n");
     return [
         `# ${category}`,
-        ``,
+        "",
         `${inCat.length} component${inCat.length === 1 ? "" : "s"}:`,
-        ``,
+        "",
         `| Component | Description |`,
         `|---|---|`,
         rows,
-        ``,
+        "",
     ].join("\n");
 }
 function toListPayload(c) {
     return {
         name: c.name,
         category: c.category,
+        subcategory: c.subcategory,
         description: c.description,
+        nugetPackage: c.nugetPackage,
+    };
+}
+function toGetPayload(c) {
+    // Build a rich JSON payload covering everything Claude Code needs to write
+    // correct Razor without consulting external docs.
+    const subComponents = Object.values(c.subComponents).map((s) => ({
+        name: s.componentName,
+        namespace: s.namespace,
+        inheritsFrom: s.inheritsFrom,
+        implements: s.implements,
+        parameters: s.parameters,
+        events: s.events,
+        enums: s.enums,
+        records: s.records,
+    }));
+    return {
+        name: c.name,
+        category: c.category,
+        subcategory: c.subcategory,
+        description: c.description,
+        nugetPackage: c.nugetPackage,
+        namespace: c.namespace,
+        inheritsFrom: c.inheritsFrom,
+        implements: c.implements,
+        parameters: c.parameters,
+        events: c.events,
+        enums: c.enums,
+        records: c.records,
+        cssVars: c.cssVars,
+        files: c.files,
+        subComponents,
+        example: curatedExampleByName.get(c.name.toLowerCase()) ?? null,
+        docs: docsUrl(c),
     };
 }
 // ───────────────── Server setup ─────────────────
@@ -163,51 +206,44 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
     tools: [
         {
             name: "lumeo_list_components",
-            description: `List all ${catalog.length} Lumeo components, optionally filtered by category or a free-text query. ` +
-                "Returns an array of { name, category, description }. " +
-                `Known categories: ${CATEGORIES.join(", ")}.`,
+            description: `List all ${components.length} Lumeo components, optionally filtered by category or query. ` +
+                "Returns { name, category, subcategory, description, nugetPackage } per component. " +
+                `Categories: ${CATEGORIES.join(", ")}.`,
             inputSchema: {
                 type: "object",
                 properties: {
-                    category: {
-                        type: "string",
-                        description: `Filter by category (${CATEGORIES.join(", ")}).`,
-                    },
-                    query: {
-                        type: "string",
-                        description: "Free-text query matched against name, category, and description.",
-                    },
+                    category: { type: "string", description: `Filter by category (${CATEGORIES.join(", ")}).` },
+                    query: { type: "string", description: "Free-text query matched against name, category, description." },
                 },
             },
         },
         {
             name: "lumeo_get_component",
-            description: "Get the reference for a single Lumeo component. " +
-                "For the ~35 hand-curated components this returns full schema " +
-                "(parameters, slots, Razor example, CSS variables). " +
-                "For the remaining components, returns { name, category, description, files, cssVars, dependencies, note } with a link to the docs site.",
+            description: "Get the COMPLETE schema for a Lumeo component: every [Parameter] " +
+                "(name, type, default, XML doc summary), nested enums and records, " +
+                "EventCallback events, sub-components (e.g. Dialog → DialogContent, " +
+                "DialogHeader, DialogTrigger, ...), CSS variables, source files, and a " +
+                "hand-curated Razor example when available. Sourced from the actual " +
+                "Razor source via Roslyn — always in sync with the library.",
             inputSchema: {
                 type: "object",
                 required: ["name"],
                 properties: {
                     name: {
                         type: "string",
-                        description: "Component name (e.g. \"Button\", \"DataGrid\"). Case-insensitive.",
+                        description: "Component name (e.g. \"Button\", \"DataGrid\", \"Sheet\"). Case-insensitive.",
                     },
                 },
             },
         },
         {
             name: "lumeo_search",
-            description: `Fuzzy search across all ${catalog.length} Lumeo components (names, categories, descriptions). Returns best matches first.`,
+            description: `Fuzzy search across all ${components.length} Lumeo components (name, category, description). Best matches first.`,
             inputSchema: {
                 type: "object",
                 required: ["query"],
                 properties: {
-                    query: {
-                        type: "string",
-                        description: "Search terms (e.g. \"modal\", \"date\", \"chat message\").",
-                    },
+                    query: { type: "string", description: "Search terms (e.g. \"modal\", \"date\", \"chat message\")." },
                 },
             },
         },
@@ -221,9 +257,7 @@ server.setRequestHandler(CallToolRequestSchema, async (req) => {
             const category = typeof a.category === "string" ? a.category : undefined;
             const query = typeof a.query === "string" ? a.query : "";
             const results = searchCatalog(query, category).map(toListPayload);
-            return {
-                content: [{ type: "text", text: JSON.stringify(results, null, 2) }],
-            };
+            return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
         }
         case "lumeo_get_component": {
             const wanted = typeof a.name === "string" ? a.name : "";
@@ -237,48 +271,21 @@ server.setRequestHandler(CallToolRequestSchema, async (req) => {
                         }],
                 };
             }
-            const payload = c.thin
-                ? {
-                    name: c.name,
-                    category: c.category,
-                    description: c.description,
-                    files: c.files,
-                    cssVars: c.cssVars,
-                    dependencies: c.dependencies,
-                    note: `Rich schema coming soon — see ${docsUrl(c)}`,
-                }
-                : {
-                    name: c.name,
-                    category: c.category,
-                    description: c.description,
-                    params: c.params,
-                    slots: c.slots,
-                    example: c.example,
-                    cssVars: c.cssVars,
-                    docs: docsUrl(c),
-                };
-            return {
-                content: [{ type: "text", text: JSON.stringify(payload, null, 2) }],
-            };
+            return { content: [{ type: "text", text: JSON.stringify(toGetPayload(c), null, 2) }] };
         }
         case "lumeo_search": {
             const query = typeof a.query === "string" ? a.query : "";
             const results = searchCatalog(query).map(toListPayload);
-            return {
-                content: [{ type: "text", text: JSON.stringify(results, null, 2) }],
-            };
+            return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
         }
         default:
-            return {
-                isError: true,
-                content: [{ type: "text", text: `Unknown tool: ${name}` }],
-            };
+            return { isError: true, content: [{ type: "text", text: `Unknown tool: ${name}` }] };
     }
 });
 // ───── Resources ─────
 server.setRequestHandler(ListResourcesRequestSchema, async () => ({
     resources: [
-        ...catalog.map((c) => ({
+        ...components.map((c) => ({
             uri: `lumeo://component/${c.name}`,
             name: `${c.name} (Lumeo component)`,
             description: c.description,
@@ -297,7 +304,7 @@ server.setRequestHandler(ListResourceTemplatesRequestSchema, async () => ({
         {
             uriTemplate: "lumeo://component/{name}",
             name: "Lumeo component reference",
-            description: "Markdown reference for a single Lumeo component. Rich (params/slots/example) for curated components, thin (files/cssVars + docs link) otherwise.",
+            description: "Markdown reference for a single Lumeo component, generated from Razor source.",
             mimeType: "text/markdown",
         },
         {
@@ -312,29 +319,16 @@ server.setRequestHandler(ReadResourceRequestSchema, async (req) => {
     const uri = req.params.uri;
     const componentMatch = /^lumeo:\/\/component\/(.+)$/i.exec(uri);
     if (componentMatch) {
-        const name = decodeURIComponent(componentMatch[1]);
-        const c = findComponent(name);
-        if (!c) {
-            throw new Error(`Unknown Lumeo component: ${name}`);
-        }
-        return {
-            contents: [{
-                    uri,
-                    mimeType: "text/markdown",
-                    text: toComponentMarkdown(c),
-                }],
-        };
+        const wanted = decodeURIComponent(componentMatch[1]);
+        const c = findComponent(wanted);
+        if (!c)
+            throw new Error(`Unknown Lumeo component: ${wanted}`);
+        return { contents: [{ uri, mimeType: "text/markdown", text: toComponentMarkdown(c) }] };
     }
     const categoryMatch = /^lumeo:\/\/category\/(.+)$/i.exec(uri);
     if (categoryMatch) {
         const cat = decodeURIComponent(categoryMatch[1]);
-        return {
-            contents: [{
-                    uri,
-                    mimeType: "text/markdown",
-                    text: toCategoryMarkdown(cat),
-                }],
-        };
+        return { contents: [{ uri, mimeType: "text/markdown", text: toCategoryMarkdown(cat) }] };
     }
     throw new Error(`Unsupported resource URI: ${uri}`);
 });
@@ -342,14 +336,9 @@ server.setRequestHandler(ReadResourceRequestSchema, async (req) => {
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    // stderr is safe; stdout is the MCP transport
-    const richCount = catalog.filter((c) => !c.thin).length;
-    const thinCount = catalog.length - richCount;
-    const registryNote = registry
-        ? `, registry v${registry.version}`
-        : " (no registry — curated-only mode)";
-    process.stderr.write(`[lumeo-mcp] ready — ${catalog.length} components, ${CATEGORIES.length} categories ` +
-        `(${richCount} rich, ${thinCount} thin)${registryNote}\n`);
+    process.stderr.write(`[lumeo-mcp] ready — ${components.length} components, ${CATEGORIES.length} categories, ` +
+        `${api.stats.totalParameters} params, ${api.stats.totalEnums} enums, ` +
+        `api v${api.version}, generated ${api.generated}\n`);
 }
 main().catch((err) => {
     process.stderr.write(`[lumeo-mcp] fatal: ${err instanceof Error ? err.stack ?? err.message : String(err)}\n`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lumeo-ui/mcp-server",
-  "version": "2.0.0-rc.2",
+  "version": "2.0.0-rc.20",
   "description": "Model Context Protocol server for the Lumeo Blazor component library. Lets LLMs (Claude, Copilot, Cursor) author correct Lumeo markup.",
   "type": "module",
   "main": "dist/index.js",
@@ -10,6 +10,7 @@
   "files": [
     "dist",
     "src/registry.json",
+    "src/components-api.json",
     "README.md"
   ],
   "publishConfig": {