@public-ui/mcp 4.3.0-rc.6 → 4.3.0-rc.8

package/dist/cli.cjs

@@ -13,13 +13,16 @@ require('express');
 require('zod');
 require('./search.cjs');
 require('fuse.js');
+require('node:path');
+require('glob');
+require('simple-git');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 const require$1 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('cli.cjs', document.baseURI).href)));
 const { version: PACKAGE_VERSION = "0.0.0" } = require$1("../package.json");
 const ENABLE_LOGGING = process.env.MCP_LOGGING === "true" || process.env.MCP_LOGGING === "1";
 async function main() {
-  const server = mcp.createKolibriMcpServer();
+  const server = await mcp.createKolibriMcpServer();
   const transport = new stdio_js.StdioServerTransport();
   await server.connect(transport);
   const metadata = data.getSampleIndexMetadata();

package/dist/cli.mjs

@@ -11,12 +11,15 @@ import 'express';
 import 'zod';
 import './search.mjs';
 import 'fuse.js';
+import 'node:path';
+import 'glob';
+import 'simple-git';
 
 const require$1 = createRequire(import.meta.url);
 const { version: PACKAGE_VERSION = "0.0.0" } = require$1("../package.json");
 const ENABLE_LOGGING = process.env.MCP_LOGGING === "true" || process.env.MCP_LOGGING === "1";
 async function main() {
-  const server = createKolibriMcpServer();
+  const server = await createKolibriMcpServer();
   const transport = new StdioServerTransport();
   await server.connect(transport);
   const metadata = getSampleIndexMetadata();

package/dist/mcp.cjs

@@ -7,7 +7,10 @@ const node_module = require('node:module');
 const zod = require('zod');
 const data = require('./data.cjs');
 const search = require('./search.cjs');
-require('node:fs');
+const node_fs = require('node:fs');
+const node_path = require('node:path');
+const glob = require('glob');
+const simpleGit = require('simple-git');
 require('node:url');
 require('fuse.js');
 
@@ -15,6 +18,297 @@ var _documentCurrentScript = typeof document !== 'undefined' ? document.currentS
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
 
 const express__default = /*#__PURE__*/_interopDefaultCompat(express);
+const simpleGit__default = /*#__PURE__*/_interopDefaultCompat(simpleGit);
+
+const TEMPLATE_REPOS = [
+  {
+    id: "public-ui-templates",
+    name: "KoliBri Generic Templates",
+    owner: "public-ui",
+    repo: "templates",
+    branch: "main",
+    description: "Generische KoliBri-Templates und Vorlagen f\xFCr verschiedene Use Cases",
+    includePatterns: ["**/*.md", "src/**/*"],
+    excludePatterns: ["**/node_modules/**", "**/dist/**", "**/.git/**", "*.lock"],
+    type: "generic",
+    tags: ["template", "generic", "kolibri", "starter"]
+  },
+  {
+    id: "public-ui-template-react",
+    name: "KoliBri React Templates",
+    owner: "public-ui",
+    repo: "template-react",
+    branch: "main",
+    description: "React-spezifische Templates mit KoliBri-Integration",
+    includePatterns: ["**/*.md", "src/**/*", "*.tsx", "*.ts"],
+    excludePatterns: ["**/node_modules/**", "**/dist/**", "**/.git/**", "*.lock"],
+    type: "react",
+    tags: ["template", "react", "typescript", "kolibri"]
+  },
+  {
+    id: "public-ui-template-theme",
+    name: "KoliBri Theme Templates",
+    owner: "public-ui",
+    repo: "template-theme",
+    branch: "main",
+    description: "Thema-Vorlagen und Design-System-Konfigurationen",
+    includePatterns: ["**/*.md", "src/**/*", "*.css", "*.scss", "*.json"],
+    excludePatterns: ["**/node_modules/**", "**/dist/**", "**/.git/**", "*.lock"],
+    type: "theme",
+    tags: ["template", "theme", "design", "css", "kolibri"]
+  }
+];
+
+const CACHE_DIR$1 = node_path.join(process.cwd(), "data", "templates");
+async function cloneOrUpdateRepo(repoConfig) {
+  const repoPath = node_path.join(CACHE_DIR$1, repoConfig.id);
+  const git = simpleGit__default();
+  try {
+    const exists = await node_fs.promises.access(repoPath).then(() => true).catch(() => false);
+    if (exists) {
+      await git.cwd(repoPath).pull();
+      console.log(`\u2705 Updated ${repoConfig.id}`);
+    } else {
+      await git.clone(`https://github.com/${repoConfig.owner}/${repoConfig.repo}.git`, repoPath, [
+        "--branch",
+        repoConfig.branch,
+        "--single-branch",
+        "--depth",
+        "1"
+      ]);
+      console.log(`\u2705 Cloned ${repoConfig.id}`);
+    }
+    return repoPath;
+  } catch (error) {
+    console.error(`\u274C Error cloning/updating ${repoConfig.id}:`, error);
+    throw error;
+  }
+}
+async function findFilesInRepo(repoPath, repoConfig) {
+  const allFiles = [];
+  for (const pattern of repoConfig.includePatterns) {
+    const files = await glob.glob(pattern, {
+      cwd: repoPath,
+      ignore: repoConfig.excludePatterns,
+      nodir: true
+    });
+    allFiles.push(...files);
+  }
+  return [...new Set(allFiles)];
+}
+function getResourceType(filePath) {
+  if (filePath.endsWith(".md") || filePath.endsWith(".markdown")) {
+    return "markdown";
+  }
+  if (filePath.endsWith(".json") || filePath.endsWith(".yaml") || filePath.endsWith(".yml")) {
+    return "config";
+  }
+  return "code";
+}
+function getLanguage(filePath) {
+  const extension = filePath.split(".").pop()?.toLowerCase();
+  const languageMap = {
+    ts: "typescript",
+    tsx: "typescript",
+    js: "javascript",
+    jsx: "javascript",
+    css: "css",
+    scss: "scss",
+    html: "html",
+    json: "json",
+    yaml: "yaml",
+    yml: "yaml"
+  };
+  return languageMap[extension || ""] || extension || "unknown";
+}
+function extractFrontmatter(content) {
+  const frontmatterRegex = /^---[\s\S]*?---/;
+  const match = content.match(frontmatterRegex);
+  if (!match) return {};
+  try {
+    const frontmatter = match[0].replace(/^---|---$/g, "").trim();
+    const metadata = {};
+    frontmatter.split("\n").forEach((line) => {
+      const [key, value] = line.split(":").map((s) => s.trim());
+      if (key && value) {
+        metadata[key] = value.replace(/^['"]|['"]$/g, "");
+      }
+    });
+    return metadata;
+  } catch {
+    return {};
+  }
+}
+async function indexFile(repoPath, filePath, repoConfig) {
+  const absolutePath = node_path.join(repoPath, filePath);
+  const content = await node_fs.promises.readFile(absolutePath, "utf-8");
+  const stats = await node_fs.promises.stat(absolutePath);
+  const resourceType = getResourceType(filePath);
+  const frontmatter = resourceType === "markdown" ? extractFrontmatter(content) : {};
+  const lines = content.split("\n").length;
+  return {
+    id: `${repoConfig.id}:${filePath.replace(/[/\\]/g, ":")}`,
+    repoId: repoConfig.id,
+    path: filePath,
+    type: resourceType,
+    content,
+    metadata: {
+      name: frontmatter.title || filePath.split("/").pop() || "",
+      description: frontmatter.description || void 0,
+      tags: [...repoConfig.tags || [], ...frontmatter.tags ?? []].filter((t) => t),
+      templateType: repoConfig.type,
+      language: resourceType === "code" ? getLanguage(filePath) : void 0
+    },
+    stats: {
+      size: stats.size,
+      lines,
+      lastModified: stats.mtime.toISOString()
+    }
+  };
+}
+async function indexTemplateRepo(repoConfig) {
+  console.log(`\u{1F4C1} Indexing ${repoConfig.id}...`);
+  const repoPath = await cloneOrUpdateRepo(repoConfig);
+  const files = await findFilesInRepo(repoPath, repoConfig);
+  console.log(`   Found ${files.length} files to index`);
+  const resources = [];
+  for (const file of files) {
+    try {
+      const resource = await indexFile(repoPath, file, repoConfig);
+      resources.push(resource);
+    } catch (error) {
+      console.warn(`   \u26A0\uFE0F  Could not index ${file}:`, error);
+    }
+  }
+  console.log(`\u2705 Indexed ${resources.length} resources from ${repoConfig.id}`);
+  return resources;
+}
+async function indexAllTemplateRepos() {
+  const allResources = [];
+  for (const repoConfig of TEMPLATE_REPOS) {
+    try {
+      const resources = await indexTemplateRepo(repoConfig);
+      allResources.push(...resources);
+    } catch (error) {
+      console.error(`\u274C Failed to index ${repoConfig.id}:`, error);
+    }
+  }
+  return allResources;
+}
+async function updateTemplateIndex() {
+  console.log("\u{1F504} Updating template index...");
+  const resources = await indexAllTemplateRepos();
+  const indexPath = node_path.join(CACHE_DIR$1, "template-index.json");
+  await node_fs.promises.mkdir(CACHE_DIR$1, { recursive: true });
+  await node_fs.promises.writeFile(indexPath, JSON.stringify(resources, null, 2));
+  console.log(`\u2705 Template index updated with ${resources.length} resources`);
+}
+
+function extractCodeBlocksFromMarkdown(markdown) {
+  const codeBlockRegex = /```(\w*)\s*([\s\S]*?)```/g;
+  const blocks = [];
+  let match;
+  while ((match = codeBlockRegex.exec(markdown)) !== null) {
+    const language = match[1] || "";
+    const code = match[2].trim();
+    const titleMatch = code.match(/^\/\/\s*title:\s*(.+)$/m);
+    const title = titleMatch ? titleMatch[1].trim() : void 0;
+    blocks.push({ language, code, title });
+  }
+  return blocks;
+}
+function calculateSimilarityScore(resource, query) {
+  let score = 0;
+  if (resource.metadata.name.toLowerCase().includes(query.toLowerCase())) {
+    score += 100;
+  }
+  if (resource.metadata.description?.toLowerCase().includes(query.toLowerCase())) {
+    score += 50;
+  }
+  const queryLower = query.toLowerCase();
+  for (const tag of resource.metadata.tags) {
+    if (tag.toLowerCase().includes(queryLower)) {
+      score += 30;
+    }
+  }
+  const contentLower = resource.content.toLowerCase();
+  const firstMatchIndex = contentLower.indexOf(queryLower);
+  if (firstMatchIndex !== -1) {
+    const positionScore = Math.max(0, 100 - firstMatchIndex / 100);
+    score += positionScore;
+  }
+  return score;
+}
+
+const CACHE_DIR = node_path.join(process.cwd(), "data", "templates");
+let templateIndex = [];
+async function loadTemplateIndex() {
+  try {
+    const indexPath = node_path.join(CACHE_DIR, "template-index.json");
+    const content = await node_fs.promises.readFile(indexPath, "utf-8");
+    const parsed = JSON.parse(content);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+async function initializeTemplateIndex() {
+  console.log("\u{1F4DA} Initializing template index...");
+  try {
+    templateIndex = await loadTemplateIndex();
+    if (templateIndex.length === 0) {
+      await updateTemplateIndex();
+      templateIndex = await loadTemplateIndex();
+    }
+    console.log(`\u2705 Template index loaded with ${templateIndex.length} resources`);
+  } catch (error) {
+    console.error("\u274C Failed to initialize template index:", error);
+    templateIndex = [];
+  }
+}
+function searchTemplates(query, options = {}) {
+  const { type, repoId, tags, templateType, limit = 20 } = options;
+  let results = templateIndex.filter((resource) => {
+    if (repoId && resource.repoId !== repoId) return false;
+    if (type && resource.type !== type) return false;
+    if (templateType && resource.metadata.templateType !== templateType) return false;
+    if (tags && tags.length > 0) {
+      const hasAllTags = tags.every((tag) => resource.metadata.tags.includes(tag));
+      if (!hasAllTags) return false;
+    }
+    return true;
+  });
+  results = results.map((resource) => ({
+    ...resource,
+    score: calculateSimilarityScore(resource, query)
+  })).sort((a, b) => b.score - a.score).slice(0, limit);
+  return results;
+}
+function getTemplateResource(id) {
+  return templateIndex.find((resource) => resource.id === id);
+}
+function getTemplateCodeBlocks(resource) {
+  if (resource.type !== "markdown") {
+    return [{ language: resource.metadata.language || "unknown", code: resource.content }];
+  }
+  return extractCodeBlocksFromMarkdown(resource.content);
+}
+function getTemplateTypes() {
+  const types = /* @__PURE__ */ new Set();
+  for (const repo of TEMPLATE_REPOS) {
+    types.add(repo.type);
+  }
+  return Array.from(types);
+}
+function getAllTemplateTags() {
+  const tags = /* @__PURE__ */ new Set();
+  for (const resource of templateIndex) {
+    for (const tag of resource.metadata.tags) {
+      tags.add(tag);
+    }
+  }
+  return Array.from(tags).sort();
+}
 
 const KIND_OPTIONS = ["doc", "sample", "scenario", "spec"];
 function isValidKind(value) {
@@ -45,14 +339,19 @@ function log(type, message, data) {
     console.error(`${prefix} ${message}`);
   }
 }
-function createKolibriMcpServer() {
+async function createKolibriMcpServer() {
   const server = new mcp_js.McpServer({
     name: PACKAGE_NAME,
     version: PACKAGE_VERSION
   });
   return configureServer(server);
 }
-function configureServer(server) {
+async function configureServer(server) {
+  try {
+    await initializeTemplateIndex();
+  } catch (error) {
+    console.error("Failed to initialize template index:", error);
+  }
   server.registerTool(
     "search",
     {
@@ -272,39 +571,212 @@ Use the 'fetch' tool to retrieve full code samples for specific components.
       };
     }
   );
+  server.registerTool(
+    "search_templates",
+    {
+      title: "Search KoliBri Templates",
+      description: "Searches through KoliBri template repositories (generic, react, theme) for code examples and documentation. Returns matching templates with metadata, previews, and code blocks. Use `type` to filter by resource type (markdown, code, config). Use `templateType` to filter by template type (generic, react, theme). Use `repoId` to filter by specific repository. Use `tags` to filter by tags. Use `limit` to control max results (default: 20).",
+      inputSchema: {
+        query: zod.z.string().describe('Search query (e.g., "button", "form", "dark theme").'),
+        type: zod.z.enum(["all", "markdown", "code", "config"]).optional().default("all").describe("Filter by resource type."),
+        templateType: zod.z.string().optional().describe("Filter by template type (generic, react, theme)."),
+        repoId: zod.z.string().optional().describe("Filter by repository ID."),
+        tags: zod.z.array(zod.z.string()).optional().describe("Filter by tags."),
+        limit: zod.z.number().int().min(1).max(50).optional().default(20).describe("Maximum number of results.")
+      }
+    },
+    ({ query, type, templateType, repoId, tags, limit }) => {
+      log("tool", "search_templates called", { query, type, templateType, repoId, limit });
+      const results = searchTemplates(query, {
+        type: type === "all" ? void 0 : type,
+        templateType,
+        repoId,
+        tags,
+        limit
+      });
+      log("tool", "search_templates completed", { resultCount: results.length });
+      return {
+        content: [
+          {
+            type: "text",
+            text: results.length === 0 ? `No templates found for "${query}"` : `Found ${results.length} template(s) for "${query}":
+
+` + results.map((result, index) => {
+              const matchScore = (result.score ?? 0).toFixed(1);
+              return `${index + 1}. **${result.metadata.name}** (${result.repoId})
+   Type: ${result.type} | Template: ${result.metadata.templateType}
+   Tags: ${result.metadata.tags.join(", ")}
+   Score: ${matchScore}
+   Preview: ${result.content.substring(0, 100)}...`;
+            }).join("\n\n")
+          }
+        ],
+        structuredContent: {
+          query,
+          total: results.length,
+          results: results.map((result) => ({
+            id: result.id,
+            name: result.metadata.name,
+            description: result.metadata.description,
+            repoId: result.repoId,
+            path: result.path,
+            type: result.type,
+            templateType: result.metadata.templateType,
+            tags: result.metadata.tags,
+            score: result.score,
+            stats: result.stats
+          }))
+        }
+      };
+    }
+  );
+  server.registerTool(
+    "fetch_template",
+    {
+      title: "Fetch KoliBri Template",
+      description: "Fetches a specific template resource by ID. Returns the full content with metadata and extracted code blocks. Use `search_templates` first to find valid IDs.",
+      inputSchema: {
+        id: zod.z.string().describe('Template resource ID (e.g., "public-ui-templates:src/button/button.stories.md").'),
+        includeCodeBlocks: zod.z.boolean().optional().default(true).describe("Whether to extract code blocks from markdown.")
+      }
+    },
+    ({ id, includeCodeBlocks }) => {
+      log("tool", "fetch_template called", { id, includeCodeBlocks });
+      const resource = getTemplateResource(id);
+      if (!resource) {
+        log("error", "fetch_template failed: resource not found", { id });
+        throw new Error(`Template not found: ${id}. Use \`search_templates\` to find valid IDs.`);
+      }
+      const codeBlocks = includeCodeBlocks && resource.type === "markdown" ? getTemplateCodeBlocks(resource) : [];
+      log("tool", "fetch_template completed", {
+        id,
+        contentLength: resource.content.length,
+        codeBlockCount: codeBlocks.length
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: `# ${resource.metadata.name}
+
+**Repository:** ${resource.repoId}
+
+**Path:** ${resource.path}
+
+**Type:** ${resource.type}
+
+**Template Type:** ${resource.metadata.templateType}
+
+**Tags:** ${resource.metadata.tags.join(", ")}
+
+---
+
+` + resource.content
+          }
+        ],
+        structuredContent: {
+          id: resource.id,
+          name: resource.metadata.name,
+          description: resource.metadata.description,
+          repoId: resource.repoId,
+          path: resource.path,
+          type: resource.type,
+          templateType: resource.metadata.templateType,
+          tags: resource.metadata.tags,
+          language: resource.metadata.language,
+          stats: resource.stats,
+          codeBlocks: codeBlocks.map((block) => ({
+            language: block.language,
+            title: block.title,
+            codeLength: block.code.length
+          }))
+        }
+      };
+    }
+  );
+  server.registerTool(
+    "list_template_tags",
+    {
+      title: "List Template Tags",
+      description: "Returns all available tags for filtering templates.",
+      inputSchema: {}
+    },
+    () => {
+      const tags = getAllTemplateTags();
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Available template tags (${tags.length}):
+
+` + tags.map((tag) => `- ${tag}`).join("\n")
+          }
+        ],
+        structuredContent: {
+          tags
+        }
+      };
+    }
+  );
+  server.registerTool(
+    "list_template_types",
+    {
+      title: "List Template Types",
+      description: "Returns all available template types (generic, react, theme).",
+      inputSchema: {}
+    },
+    () => {
+      const types = getTemplateTypes();
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Available template types:
+
+` + types.map((type) => `- ${type}`).join("\n")
+          }
+        ],
+        structuredContent: {
+          types
+        }
+      };
+    }
+  );
   return server;
 }
 if ((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('mcp.cjs', document.baseURI).href)) === `file://${process.argv[1]}` || process.argv[1]?.endsWith("/mcp.ts") || process.argv[1]?.endsWith("/mcp.cjs") || process.argv[1]?.endsWith("/mcp.mjs")) {
-  const server = createKolibriMcpServer();
-  const app = express__default();
-  app.use(express__default.json());
-  app.post("/mcp", async (req, res) => {
-    const transport = new streamableHttp_js.StreamableHTTPServerTransport({
-      sessionIdGenerator: void 0,
-      enableJsonResponse: true
+  void (async () => {
+    const server = await createKolibriMcpServer();
+    const app = express__default();
+    app.use(express__default.json());
+    app.post("/mcp", async (req, res) => {
+      const transport = new streamableHttp_js.StreamableHTTPServerTransport({
+        sessionIdGenerator: void 0,
+        enableJsonResponse: true
+      });
+      res.on("close", () => {
+        void transport.close();
+      });
+      await server.connect(transport);
+      await transport.handleRequest(req, res, req.body);
     });
-    res.on("close", () => {
-      void transport.close();
+    const port = parseInt(process.env.PORT || "3000");
+    void app.listen(port, () => {
+      console.log(`KoliBri MCP Server v${PACKAGE_VERSION} running on http://localhost:${port}/mcp`);
+      const metadata = data.getSampleIndexMetadata();
+      console.log(
+        `Loaded ${metadata.counts.total} entries (${metadata.counts.totalDocs} docs, ${metadata.counts.totalSamples} samples, ${metadata.counts.totalScenarios ?? 0} scenarios)`
+      );
+      if (ENABLE_LOGGING) {
+        console.log("\u{1F50D} Logging is ENABLED (MCP_LOGGING=true)");
+      } else {
+        console.log("\u{1F4A1} Logging is disabled. Set MCP_LOGGING=true to enable request logging");
+      }
+    }).on("error", (error) => {
+      console.error("Server error:", error);
+      process.exit(1);
     });
-    await server.connect(transport);
-    await transport.handleRequest(req, res, req.body);
-  });
-  const port = parseInt(process.env.PORT || "3000");
-  void app.listen(port, () => {
-    console.log(`KoliBri MCP Server v${PACKAGE_VERSION} running on http://localhost:${port}/mcp`);
-    const metadata = data.getSampleIndexMetadata();
-    console.log(
-      `Loaded ${metadata.counts.total} entries (${metadata.counts.totalDocs} docs, ${metadata.counts.totalSamples} samples, ${metadata.counts.totalScenarios ?? 0} scenarios)`
-    );
-    if (ENABLE_LOGGING) {
-      console.log("\u{1F50D} Logging is ENABLED (MCP_LOGGING=true)");
-    } else {
-      console.log("\u{1F4A1} Logging is disabled. Set MCP_LOGGING=true to enable request logging");
-    }
-  }).on("error", (error) => {
-    console.error("Server error:", error);
-    process.exit(1);
-  });
+  })();
 }
 
 exports.createKolibriMcpServer = createKolibriMcpServer;

package/dist/mcp.d.cts

@@ -4,6 +4,6 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
  * Create a configured KoliBri MCP server instance.
  * Can be used with both stdio and HTTP transports.
  */
-declare function createKolibriMcpServer(): McpServer;
+declare function createKolibriMcpServer(): Promise<McpServer>;
 
 export { createKolibriMcpServer };

package/dist/mcp.d.mts

@@ -4,6 +4,6 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
  * Create a configured KoliBri MCP server instance.
  * Can be used with both stdio and HTTP transports.
  */
-declare function createKolibriMcpServer(): McpServer;
+declare function createKolibriMcpServer(): Promise<McpServer>;
 
 export { createKolibriMcpServer };

package/dist/mcp.d.ts

@@ -4,6 +4,6 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
  * Create a configured KoliBri MCP server instance.
  * Can be used with both stdio and HTTP transports.
  */
-declare function createKolibriMcpServer(): McpServer;
+declare function createKolibriMcpServer(): Promise<McpServer>;
 
 export { createKolibriMcpServer };