@aleph-alpha/ui-library 1.9.0 → 1.10.0

package/dist/mcp/index.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { startServer } from './server.js';
+
+startServer().catch((error) => {
+  console.error('Failed to start MCP server:', error);
+  process.exit(1);
+});

package/dist/mcp/scripts/generate-component-meta.js

@@ -0,0 +1,236 @@
+#!/usr/bin/env node
+
+// mcp/scripts/generate-component-meta.ts
+import * as fs4 from "node:fs";
+import * as path3 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+
+// mcp/constants.ts
+import * as fs3 from "node:fs";
+import * as path2 from "node:path";
+
+// mcp/utils/paths.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+function getLibrarySourcePath() {
+  const possiblePaths = [
+    // Bundled: from dist/mcp/ -> ../../src
+    path.resolve(__dirname, "../../src"),
+    // Fallback: running from package root
+    path.join(process.cwd(), "src")
+  ];
+  for (const srcPath of possiblePaths) {
+    if (fs.existsSync(srcPath)) {
+      return srcPath;
+    }
+  }
+  throw new Error(
+    "Could not find UI library source directory. Is the package installed correctly?"
+  );
+}
+
+// mcp/utils/file-utils.ts
+import * as fs2 from "node:fs";
+
+// mcp/constants.ts
+function detectCategoryDirs() {
+  const srcPath = getSrcPath();
+  if (!srcPath || !fs3.existsSync(srcPath)) {
+    return [];
+  }
+  const entries = fs3.readdirSync(srcPath, { withFileTypes: true });
+  return entries.filter((entry) => entry.isDirectory()).filter((entry) => !entry.name.startsWith(".") && entry.name !== "node_modules").filter((entry) => {
+    try {
+      const dirPath = path2.join(srcPath, entry.name);
+      const subEntries = fs3.readdirSync(dirPath, { withFileTypes: true });
+      return subEntries.some((sub) => sub.isDirectory() && sub.name.startsWith("Ui"));
+    } catch {
+      return false;
+    }
+  }).map((entry) => entry.name);
+}
+var cachedCategoryDirs = null;
+function getCategoryDirs() {
+  if (cachedCategoryDirs) return cachedCategoryDirs;
+  cachedCategoryDirs = detectCategoryDirs();
+  return cachedCategoryDirs;
+}
+function getSrcPath() {
+  try {
+    return getLibrarySourcePath();
+  } catch {
+    return null;
+  }
+}
+
+// mcp/scripts/generate-component-meta.ts
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = path3.dirname(__filename2);
+var PACKAGE_ROOT = path3.resolve(__dirname2, "../../..");
+var SRC_PATH = path3.join(PACKAGE_ROOT, "src");
+var OUTPUT_PATH = path3.join(PACKAGE_ROOT, "mcp", "components-meta.json");
+function extractJSDocTags(content, interfaceName) {
+  const declarationRegex = new RegExp(
+    `export\\s+(?:interface|type)\\s+${escapeRegex(interfaceName)}\\b`
+  );
+  const declarationMatch = content.match(declarationRegex);
+  if (!declarationMatch || declarationMatch.index === void 0) {
+    return { description: "", useCases: [], keywords: [], related: [] };
+  }
+  const contentBefore = content.substring(0, declarationMatch.index);
+  const jsdocEndIndex = contentBefore.lastIndexOf("*/");
+  if (jsdocEndIndex === -1) {
+    return { description: "", useCases: [], keywords: [], related: [] };
+  }
+  const betweenJsdocAndDeclaration = contentBefore.substring(jsdocEndIndex + 2);
+  if (betweenJsdocAndDeclaration.trim() !== "") {
+    return { description: "", useCases: [], keywords: [], related: [] };
+  }
+  const jsdocStartIndex = contentBefore.lastIndexOf("/**");
+  if (jsdocStartIndex === -1 || jsdocStartIndex > jsdocEndIndex) {
+    return { description: "", useCases: [], keywords: [], related: [] };
+  }
+  const jsdoc = contentBefore.substring(jsdocStartIndex + 3, jsdocEndIndex);
+  const lines = jsdoc.split("\n").map((l) => l.replace(/^\s*\*\s?/, "").trim());
+  let description = "";
+  const useCases = [];
+  const keywords = [];
+  const related = [];
+  let category;
+  for (const line of lines) {
+    if (line.startsWith("@useCases") || line.startsWith("@use-cases")) {
+      const values = line.replace(/@use-?[cC]ases\s*/, "").split(",").map((s) => s.trim()).filter(Boolean);
+      useCases.push(...values);
+    } else if (line.startsWith("@keywords")) {
+      const values = line.replace(/@keywords\s*/, "").split(",").map((s) => s.trim()).filter(Boolean);
+      keywords.push(...values);
+    } else if (line.startsWith("@related")) {
+      const values = line.replace(/@related\s*/, "").split(",").map((s) => s.trim()).filter(Boolean);
+      related.push(...values);
+    } else if (line.startsWith("@category")) {
+      category = line.replace(/@category\s*/, "").trim();
+    } else if (!line.startsWith("@") && line) {
+      description += (description ? " " : "") + line;
+    }
+  }
+  return { description, useCases, keywords, related, category };
+}
+function extractKeywordsFromName(componentName) {
+  const name = componentName.replace(/^Ui/, "");
+  return name.replace(/([a-z])([A-Z])/g, "$1 $2").toLowerCase().split(/\s+/).filter((word) => word.length > 2);
+}
+function extractProps(content, interfaceName) {
+  const regex = new RegExp(
+    `export\\s+interface\\s+${escapeRegex(interfaceName)}\\s*\\{([\\s\\S]*?)\\n\\}`,
+    "m"
+  );
+  const match = content.match(regex);
+  if (!match) return [];
+  const interfaceBody = match[1].replace(/\/\*\*[\s\S]*?\*\//g, "");
+  const propRegex = /^\s*(\w+)\??:/gm;
+  const props = [];
+  let propMatch;
+  while ((propMatch = propRegex.exec(interfaceBody)) !== null) {
+    props.push(propMatch[1]);
+  }
+  return [...new Set(props)];
+}
+function extractExamples(storiesPath) {
+  if (!fs4.existsSync(storiesPath)) return [];
+  const content = fs4.readFileSync(storiesPath, "utf-8");
+  const examples = [];
+  const storyRegex = /export\s+const\s+(\w+):\s*Story/g;
+  let match;
+  while ((match = storyRegex.exec(content)) !== null) {
+    if (match[1] !== "default") {
+      examples.push(match[1]);
+    }
+  }
+  return examples;
+}
+function processComponent(componentDir, componentName) {
+  const typesPath = path3.join(componentDir, "types.ts");
+  const storiesPath = path3.join(componentDir, `${componentName}.stories.ts`);
+  let typesContent = "";
+  if (fs4.existsSync(typesPath)) {
+    typesContent = fs4.readFileSync(typesPath, "utf-8");
+  }
+  const escapedName = escapeRegex(componentName);
+  const exactPropsRegex = new RegExp(`export\\s+(?:interface|type)\\s+(${escapedName}Props)\\b`);
+  const exactMatch = typesContent.match(exactPropsRegex);
+  const subComponentPropsRegex = new RegExp(
+    `export\\s+(?:interface|type)\\s+(${escapedName}\\w*Props)\\b`
+  );
+  const subComponentMatch = typesContent.match(subComponentPropsRegex);
+  const anyPropsMatch = typesContent.match(/export\s+(?:interface|type)\s+(Ui\w+Props)/);
+  const interfaceName = exactMatch?.[1] || subComponentMatch?.[1] || anyPropsMatch?.[1] || `${componentName}Props`;
+  const jsdocData = extractJSDocTags(typesContent, interfaceName);
+  const nameKeywords = extractKeywordsFromName(componentName);
+  const keywords = jsdocData.keywords.length > 0 ? jsdocData.keywords : nameKeywords;
+  const category = jsdocData.category || "Uncategorized";
+  if (!jsdocData.category) {
+    console.warn(
+      `  \u26A0\uFE0F  ${componentName}: Missing @category in types.ts. See docs/CONTRIBUTION_GUIDELINES.md`
+    );
+  }
+  const props = extractProps(typesContent, interfaceName);
+  const examples = extractExamples(storiesPath);
+  return {
+    description: jsdocData.description || `${componentName} component`,
+    category,
+    useCases: jsdocData.useCases,
+    keywords: [.../* @__PURE__ */ new Set([...keywords, ...nameKeywords])],
+    related: jsdocData.related,
+    props,
+    examples,
+    _autoGenerated: true
+  };
+}
+function scanComponents() {
+  const meta = {};
+  for (const category of getCategoryDirs()) {
+    const categoryPath = path3.join(SRC_PATH, category);
+    if (!fs4.existsSync(categoryPath)) continue;
+    const entries = fs4.readdirSync(categoryPath, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (!entry.name.startsWith("Ui")) continue;
+      if (entry.name === "shadcn") continue;
+      const componentDir = path3.join(categoryPath, entry.name);
+      const componentMeta = processComponent(componentDir, entry.name);
+      if (componentMeta) {
+        meta[entry.name] = componentMeta;
+      }
+    }
+  }
+  return meta;
+}
+function main() {
+  console.log("Scanning components...");
+  const meta = scanComponents();
+  console.log(`Found ${Object.keys(meta).length} components`);
+  console.log(`Writing to ${OUTPUT_PATH}...`);
+  fs4.writeFileSync(OUTPUT_PATH, JSON.stringify(meta, null, 2));
+  console.log("Done!");
+  const withUseCases = Object.values(meta).filter((m) => m.useCases.length > 0).length;
+  const withKeywords = Object.values(meta).filter((m) => m.keywords.length > 0).length;
+  console.log(`
+Summary:`);
+  console.log(`  Components with @useCases: ${withUseCases}/${Object.keys(meta).length}`);
+  console.log(`  Components with keywords: ${withKeywords}/${Object.keys(meta).length}`);
+}
+var isMain = import.meta.url === `file://${process.argv[1]}`;
+if (isMain) {
+  main();
+}
+export {
+  extractJSDocTags,
+  extractKeywordsFromName,
+  extractProps
+};