@spaced-out/ui-design-system 0.5.18 → 0.5.19

package/mcp/build-mcp-data.js

@@ -0,0 +1,247 @@
+#!/usr/bin/env node
+
+/**
+ * Build script to extract design system metadata into JSON
+ * This runs before publishing to npm to bundle all component/token data
+ */
+
+import { readFileSync, writeFileSync, readdirSync, statSync, existsSync, mkdirSync } from 'fs';
+import { join, resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Design system is parent directory
+const DESIGN_SYSTEM_PATH = resolve(__dirname, '..');
+const OUTPUT_DIR = join(__dirname, 'data');
+const OUTPUT_FILE = join(OUTPUT_DIR, 'design-system.json');
+
+console.log('Building Genesis MCP data...\n');
+console.log(`Design System: ${DESIGN_SYSTEM_PATH}`);
+console.log(`Output: ${OUTPUT_FILE}\n`);
+
+function safeReadFile(filePath) {
+  try {
+    return readFileSync(filePath, 'utf-8');
+  } catch (error) {
+    return null;
+  }
+}
+
+function getDirectories(path) {
+  try {
+    return readdirSync(path).filter(f => {
+      const fullPath = join(path, f);
+      return statSync(fullPath).isDirectory() && !f.startsWith('.');
+    });
+  } catch (error) {
+    console.error(`❌ Error reading directories in ${path}:`, error.message);
+    return [];
+  }
+}
+
+/**
+ * Extract all components with their files
+ */
+function buildComponentsData() {
+  console.log('📦 Extracting components...');
+  const componentsPath = join(DESIGN_SYSTEM_PATH, 'src/components');
+  const components = {};
+  
+  if (!existsSync(componentsPath)) {
+    console.warn('⚠️  Components path not found');
+    return components;
+  }
+
+  const componentDirs = getDirectories(componentsPath).filter(name => name !== 'index.ts');
+  
+  for (const componentName of componentDirs) {
+    const componentDir = join(componentsPath, componentName);
+    
+    const mainTsx = join(componentDir, `${componentName}.tsx`);
+    const mainTs = join(componentDir, `${componentName}.ts`);
+    
+    const storyTsx = join(componentDir, `${componentName}.stories.tsx`);
+    const storyTs = join(componentDir, `${componentName}.stories.ts`);
+    
+    const cssFile = join(componentDir, `${componentName}.module.css`);
+    
+    const indexFile = join(componentDir, 'index.ts');
+    
+    const mainContent = safeReadFile(mainTsx) || safeReadFile(mainTs);
+    const storyContent = safeReadFile(storyTsx) || safeReadFile(storyTs);
+    const cssContent = safeReadFile(cssFile);
+    const indexContent = safeReadFile(indexFile);
+    
+    const allFiles = existsSync(componentDir) 
+      ? readdirSync(componentDir).filter(f => !f.startsWith('.'))
+      : [];
+    
+    components[componentName] = {
+      name: componentName,
+      path: `src/components/${componentName}`,
+      files: {
+        main: mainContent ? { path: `${componentName}.tsx`, content: mainContent } : null,
+        story: storyContent ? { path: `${componentName}.stories.tsx`, content: storyContent } : null,
+        css: cssContent ? { path: `${componentName}.module.css`, content: cssContent } : null,
+        index: indexContent ? { path: 'index.ts', content: indexContent } : null,
+      },
+      allFiles,
+    };
+  }
+  
+  console.log(`   ✅ Extracted ${Object.keys(components).length} components`);
+  return components;
+}
+
+/**
+ * Extract all hooks
+ */
+function buildHooksData() {
+  console.log('🪝 Extracting hooks...');
+  const hooksPath = join(DESIGN_SYSTEM_PATH, 'src/hooks');
+  const hooks = {};
+  
+  if (!existsSync(hooksPath)) {
+    console.warn('⚠️  Hooks path not found');
+    return hooks;
+  }
+
+  const hookDirs = getDirectories(hooksPath).filter(name => name !== 'index.ts');
+  
+  for (const hookName of hookDirs) {
+    const hookDir = join(hooksPath, hookName);
+    
+    // Read main hook file
+    const mainTs = join(hookDir, `${hookName}.ts`);
+    const mainTsx = join(hookDir, `${hookName}.tsx`);
+    
+    // Read story file
+    const storyTsx = join(hookDir, `${hookName}.stories.tsx`);
+    const storyTs = join(hookDir, `${hookName}.stories.ts`);
+    
+    // Read index file
+    const indexFile = join(hookDir, 'index.ts');
+    
+    const mainContent = safeReadFile(mainTs) || safeReadFile(mainTsx);
+    const storyContent = safeReadFile(storyTsx) || safeReadFile(storyTs);
+    const indexContent = safeReadFile(indexFile);
+    
+    const allFiles = existsSync(hookDir) 
+      ? readdirSync(hookDir).filter(f => !f.startsWith('.'))
+      : [];
+    
+    hooks[hookName] = {
+      name: hookName,
+      path: `src/hooks/${hookName}`,
+      files: {
+        main: mainContent ? { path: `${hookName}.ts`, content: mainContent } : null,
+        story: storyContent ? { path: `${hookName}.stories.tsx`, content: storyContent } : null,
+        index: indexContent ? { path: 'index.ts', content: indexContent } : null,
+      },
+      allFiles,
+    };
+  }
+  
+  console.log(`   ✅ Extracted ${Object.keys(hooks).length} hooks`);
+  return hooks;
+}
+
+/**
+ * Extract all design tokens
+ */
+function buildTokensData() {
+  console.log('🎨 Extracting design tokens...');
+  const tokensPath = join(DESIGN_SYSTEM_PATH, 'design-tokens');
+  const tokens = {};
+  
+  if (!existsSync(tokensPath)) {
+    console.warn('⚠️  Design tokens path not found');
+    return tokens;
+  }
+
+  const categories = getDirectories(tokensPath);
+  
+  for (const category of categories) {
+    tokens[category] = {};
+    const categoryPath = join(tokensPath, category);
+    
+    try {
+      const files = readdirSync(categoryPath).filter(f => f.endsWith('.json'));
+      
+      for (const file of files) {
+        const filePath = join(categoryPath, file);
+        try {
+          const content = readFileSync(filePath, 'utf-8');
+          const tokenData = JSON.parse(content);
+          tokens[category][file.replace('.json', '')] = tokenData;
+        } catch (error) {
+          console.warn(`   ⚠️  Error parsing ${file}:`, error.message);
+        }
+      }
+    } catch (error) {
+      console.warn(`   ⚠️  Error reading category ${category}:`, error.message);
+    }
+  }
+  
+  const tokenCount = Object.values(tokens).reduce((sum, cat) => sum + Object.keys(cat).length, 0);
+  console.log(`   ✅ Extracted ${tokenCount} token files across ${Object.keys(tokens).length} categories`);
+  return tokens;
+}
+
+/**
+ * Get package version
+ */
+function getVersion() {
+  try {
+    const pkgPath = join(DESIGN_SYSTEM_PATH, 'package.json');
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+    return pkg.version || '0.0.0';
+  } catch (error) {
+    return '0.0.0';
+  }
+}
+
+/**
+ * Main build function
+ */
+function build() {
+  try {
+    const data = {
+      metadata: {
+        buildDate: new Date().toISOString(),
+        version: getVersion(),
+        designSystemPath: DESIGN_SYSTEM_PATH,
+      },
+      components: buildComponentsData(),
+      hooks: buildHooksData(),
+      tokens: buildTokensData(),
+    };
+
+    // Create output directory if it doesn't exist
+    if (!existsSync(OUTPUT_DIR)) {
+      mkdirSync(OUTPUT_DIR, { recursive: true });
+    }
+
+    // Write to JSON file
+    writeFileSync(OUTPUT_FILE, JSON.stringify(data, null, 2));
+
+    console.log('\n✨ Build complete!');
+    console.log(`📊 Summary:`);
+    console.log(`   - Components: ${Object.keys(data.components).length}`);
+    console.log(`   - Hooks: ${Object.keys(data.hooks).length}`);
+    console.log(`   - Token categories: ${Object.keys(data.tokens).length}`);
+    console.log(`   - Version: ${data.metadata.version}`);
+    console.log(`   - Output: ${OUTPUT_FILE}`);
+    console.log(`   - Size: ${(Buffer.byteLength(JSON.stringify(data)) / 1024 / 1024).toFixed(2)} MB\n`);
+
+  } catch (error) {
+    console.error('❌ Build failed:', error);
+    process.exit(1);
+  }
+}
+
+// Run the build
+build();
+