@tpitre/story-ui 1.7.1 → 2.0.1

package/dist/story-generator/componentBlacklist.js

@@ -0,0 +1,181 @@
+/**
+ * Blacklist of component names that AI commonly mistakes for real components
+ * These are often story export names or made-up components that don't exist
+ */
+import { isDeprecatedComponent, getComponentReplacement } from './documentation-sources.js';
+export const BLACKLISTED_COMPONENTS = [
+    // Story UI interface components (not design system components)
+    'StoryUIPanel',
+    // Common mistaken imports
+    'GitHubStyleRepoCard',
+    'GitHubHeader',
+    'CustomCard',
+    'StyledCard',
+    'LayoutWrapper',
+    'ContentWrapper',
+    'StoryCard',
+    'UICard',
+    'ComponentCard',
+    // Patterns that indicate story exports
+    /^.*Story$/,
+    /^.*Example$/,
+    /^.*Demo$/,
+    /^Custom.*/,
+    /^Styled.*/,
+    /^.*Layout$/,
+    /^.*Wrapper$/,
+    /^.*Container$/,
+    /^GitHub.*/,
+    /^.*Header$/, // Except for 'Header' itself
+    /^.*Card$/, // Except for specific known card components
+];
+// Generic deprecated components (can be extended per design system)
+const DEPRECATED_COMPONENTS = {
+// Add deprecated components for supported design systems as needed
+};
+export function isBlacklistedComponent(componentName, validComponents, importPath) {
+    // Check if it's a known deprecated component from documentation
+    if (importPath && isDeprecatedComponent(importPath, componentName)) {
+        return true;
+    }
+    // Check for deprecated components for specific design systems
+    if (importPath) {
+        for (const [systemPath, deprecatedList] of Object.entries(DEPRECATED_COMPONENTS)) {
+            if (importPath.includes(systemPath) && deprecatedList.includes(componentName)) {
+                return true;
+            }
+        }
+    }
+    // First check if it's in the allowed list - if so, it's not blacklisted
+    if (validComponents.has(componentName)) {
+        return false;
+    }
+    // Check exact matches
+    if (BLACKLISTED_COMPONENTS.includes(componentName)) {
+        return true;
+    }
+    // Check regex patterns
+    for (const pattern of BLACKLISTED_COMPONENTS) {
+        if (pattern instanceof RegExp && pattern.test(componentName)) {
+            // Special cases - these are allowed even if they match patterns
+            if (componentName === 'Header' || componentName === 'Card') {
+                return false;
+            }
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Common icon name mistakes - maps incorrect names to correct ones
+ */
+export const ICON_CORRECTIONS = {
+    'CommitIcon': 'GitCommitIcon',
+    'BranchIcon': 'GitBranchIcon',
+    'MergeIcon': 'GitMergeIcon',
+    'PullRequestIcon': 'GitPullRequestIcon',
+    'RepoForkedIcon': 'RepoForkedIcon',
+    'IssueIcon': 'IssueOpenedIcon',
+    'PullIcon': 'GitPullRequestIcon',
+    'ForkIcon': 'RepoForkedIcon',
+    'CloseIcon': 'XIcon',
+    'CheckmarkIcon': 'CheckIcon',
+    'CrossIcon': 'XIcon',
+    'EditIcon': 'PencilIcon',
+    'DeleteIcon': 'TrashIcon',
+    'SettingsIcon': 'GearIcon',
+    'UserIcon': 'PersonIcon',
+    'EmailIcon': 'MailIcon',
+    'TimeIcon': 'ClockIcon',
+    'CodeReviewIcon': 'CodeIcon',
+    'CommentDiscussionIcon': 'CommentIcon',
+};
+export function isBlacklistedIcon(iconName, allowedIcons) {
+    // First check if it's in the allowed list - if so, it's not blacklisted
+    if (allowedIcons.has(iconName)) {
+        return false;
+    }
+    // Check if it's a known incorrect name
+    if (ICON_CORRECTIONS[iconName]) {
+        return true;
+    }
+    // Check if it follows incorrect patterns
+    const incorrectPatterns = [
+        // Icons that are missing the 'Git' prefix
+        /^(Commit|Branch|Merge|PullRequest)Icon$/,
+        // Icons with wrong suffixes
+        /Icon[0-9]+$/,
+        // Made up icon names
+        /^Custom.*Icon$/,
+        /^.*IconStyle$/,
+    ];
+    return incorrectPatterns.some(pattern => pattern.test(iconName));
+}
+export function validateImports(imports, allowedComponents) {
+    const valid = [];
+    const invalid = [];
+    const suggestions = new Map();
+    for (const importName of imports) {
+        if (isBlacklistedComponent(importName, allowedComponents)) {
+            invalid.push(importName);
+            // Suggest alternatives
+            const suggested = suggestAlternatives(importName, allowedComponents);
+            if (suggested.length > 0) {
+                suggestions.set(importName, suggested);
+            }
+        }
+        else if (!allowedComponents.has(importName)) {
+            invalid.push(importName);
+        }
+        else {
+            valid.push(importName);
+        }
+    }
+    return { valid, invalid, suggestions };
+}
+function suggestAlternatives(invalidComponent, allowedComponents) {
+    const suggestions = [];
+    // Specific mappings for common mistakes
+    const mappings = {
+        'StoryUIPanel': ['Box', 'Card', 'Stack'],
+        'GitHubStyleRepoCard': ['Box', 'Card'],
+        'GitHubHeader': ['Header'],
+        'CustomCard': ['Box', 'Card'],
+        'StyledCard': ['Box', 'Card'],
+        'LayoutWrapper': ['Box', 'Stack', 'PageLayout'],
+        'ContentWrapper': ['Box', 'Stack'],
+    };
+    if (mappings[invalidComponent]) {
+        return mappings[invalidComponent].filter(comp => allowedComponents.has(comp));
+    }
+    // Generic suggestions based on patterns
+    if (invalidComponent.includes('Card')) {
+        suggestions.push('Box', 'Card');
+    }
+    if (invalidComponent.includes('Header')) {
+        suggestions.push('Header', 'Pagehead');
+    }
+    if (invalidComponent.includes('Layout') || invalidComponent.includes('Wrapper')) {
+        suggestions.push('Box', 'Stack', 'PageLayout');
+    }
+    return suggestions.filter(comp => allowedComponents.has(comp));
+}
+/**
+ * Get helpful error message for blacklisted component
+ */
+export function getBlacklistErrorMessage(componentName, importPath) {
+    if (importPath) {
+        const replacement = getComponentReplacement(importPath, componentName);
+        if (replacement) {
+            return `"${componentName}" is deprecated. Use ${replacement} instead.`;
+        }
+    }
+    // Existing error messages
+    if (componentName.endsWith('Icon') && !componentName.includes('Icon')) {
+        return `"${componentName}" looks like an icon but may not exist. Check the available icons list.`;
+    }
+    if (BLACKLISTED_COMPONENTS.some(pattern => pattern instanceof RegExp && pattern.test(componentName))) {
+        return `"${componentName}" appears to be invalid. Use standard component names.`;
+    }
+    return `"${componentName}" is not a valid component.`;
+}

package/dist/story-generator/componentDiscovery.js

@@ -10,10 +10,14 @@ export function discoverComponentsFromDirectory(componentsPath, componentPrefix
     }
     const components = [];
     const dirs = fs.readdirSync(componentsPath, { withFileTypes: true })
-        .filter(d => d.isDirectory() && d.name !== 'generated' && !d.name.startsWith('.'));
+        .filter(d => d.isDirectory() && d.name !== 'generated' && !d.name.startsWith('.') && d.name !== 'StoryUI');
     for (const dir of dirs) {
         const componentName = componentPrefix + dir.name;
         const componentPath = path.join(componentsPath, dir.name);
+        // Skip Story UI components
+        if (componentName === 'StoryUIPanel' || componentName.startsWith('StoryUI')) {
+            continue;
+        }
         // Look for story files to extract component information
         const storyFile = path.join(componentPath, `${dir.name}.stories.tsx`);
         const componentFile = path.join(componentPath, `${dir.name}.tsx`);
@@ -201,8 +205,11 @@ function extractSlotsFromComponent(content) {
     return [];
 }
 function categorizeComponent(name, description) {
+    if (!name || typeof name !== 'string') {
+        return 'other';
+    }
     const lowerName = name.toLowerCase();
-    const lowerDesc = description.toLowerCase();
+    const lowerDesc = (description && typeof description === 'string') ? description.toLowerCase() : '';
     if (lowerName.includes('layout') || lowerName.includes('grid') || lowerName.includes('container') || lowerName.includes('section')) {
         return 'layout';
     }

package/dist/story-generator/configLoader.js

@@ -42,6 +42,20 @@ export function loadUserConfig() {
                     eval(evalContent);
                     const userConfig = module.exports;
                     const config = createStoryUIConfig(userConfig.default || userConfig);
+                    // Detect Storybook framework if not already specified
+                    if (!config.storybookFramework) {
+                        const packageJsonPath = path.join(process.cwd(), 'package.json');
+                        if (fs.existsSync(packageJsonPath)) {
+                            try {
+                                const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+                                const dependencies = { ...packageJson.dependencies, ...packageJson.devDependencies };
+                                config.storybookFramework = detectStorybookFramework(dependencies);
+                            }
+                            catch (error) {
+                                console.warn('Failed to detect Storybook framework:', error);
+                            }
+                        }
+                    }
                     // Cache the loaded config
                     cachedConfig = config;
                     configLoadTime = now;
@@ -58,10 +72,24 @@ export function loadUserConfig() {
         console.warn('No story-ui.config.js found. Using default configuration.');
         console.warn('Please create a story-ui.config.js file in your project root to configure Story UI for your design system.');
     }
+    // Create default config with detected framework
+    const defaultConfig = { ...DEFAULT_CONFIG };
+    // Detect Storybook framework for default config
+    const packageJsonPath = path.join(process.cwd(), 'package.json');
+    if (fs.existsSync(packageJsonPath)) {
+        try {
+            const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+            const dependencies = { ...packageJson.dependencies, ...packageJson.devDependencies };
+            defaultConfig.storybookFramework = detectStorybookFramework(dependencies);
+        }
+        catch (error) {
+            console.warn('Failed to detect Storybook framework:', error);
+        }
+    }
     // Cache the default config
-    cachedConfig = DEFAULT_CONFIG;
+    cachedConfig = defaultConfig;
     configLoadTime = now;
-    return DEFAULT_CONFIG;
+    return defaultConfig;
 }
 /**
  * Validates that the configuration has the necessary paths and components
@@ -83,7 +111,7 @@ export function validateConfig(config) {
             }
         }
     }
-    // Determine if we're using an external package (like antd, @mui/material, etc.)
+    // Determine if we're using an external package (like antd, @chakra-ui/react, etc.)
     const isExternalPackage = config.importPath &&
         !config.importPath.startsWith('.') &&
         !config.importPath.startsWith('/') &&
@@ -100,15 +128,69 @@ export function validateConfig(config) {
     if (config.componentsMetadataPath && !fs.existsSync(config.componentsMetadataPath)) {
         errors.push(`Components metadata path does not exist: ${config.componentsMetadataPath}`);
     }
-    // Check import path - but allow actual library names like 'antd'
-    if (!config.importPath || config.importPath === 'your-component-library' || config.importPath.trim() === '') {
-        errors.push('importPath must be configured to point to your component library');
+    // Check import path - but allow it to be optional if auto-discovery will find local components
+    const hasManualImportPath = config.importPath &&
+        config.importPath !== 'your-component-library' &&
+        config.importPath.trim() !== '';
+    const hasLocalComponents = checkForLocalComponents(config);
+    const hasManualComponents = config.components && config.components.length > 0;
+    if (!hasManualImportPath && !hasLocalComponents && !hasManualComponents) {
+        errors.push('Either importPath must be configured, or local components must be available for auto-discovery');
     }
     return {
         isValid: errors.length === 0,
         errors
     };
 }
+/**
+ * Check if local components are available for auto-discovery
+ */
+function checkForLocalComponents(config) {
+    // Get project root from generated stories path
+    let projectRoot = process.cwd();
+    if (config.generatedStoriesPath) {
+        let currentPath = path.resolve(config.generatedStoriesPath);
+        while (currentPath !== path.dirname(currentPath)) {
+            if (fs.existsSync(path.join(currentPath, 'package.json'))) {
+                projectRoot = currentPath;
+                break;
+            }
+            currentPath = path.dirname(currentPath);
+        }
+    }
+    // Check for manually configured components path
+    if (config.componentsPath && fs.existsSync(config.componentsPath)) {
+        return true;
+    }
+    // Check for common React component directories
+    const commonComponentDirs = [
+        'src/components',
+        'src/ui',
+        'components',
+        'ui',
+        'src/lib/components',
+        'lib/components',
+        'src/shared/components',
+        'shared/components'
+    ];
+    for (const dir of commonComponentDirs) {
+        const fullPath = path.join(projectRoot, dir);
+        if (fs.existsSync(fullPath)) {
+            // Check if it contains React component files
+            try {
+                const files = fs.readdirSync(fullPath);
+                const hasComponents = files.some(file => file.endsWith('.tsx') || file.endsWith('.jsx'));
+                if (hasComponents) {
+                    return true;
+                }
+            }
+            catch (error) {
+                // Ignore errors and continue checking
+            }
+        }
+    }
+    return false;
+}
 /**
  * Analyzes existing Storybook files to detect design system patterns
  */
@@ -203,6 +285,23 @@ export function analyzeExistingStories(projectRoot = process.cwd()) {
         layoutPatterns
     };
 }
+/**
+ * Detects the Storybook framework being used
+ */
+export function detectStorybookFramework(dependencies) {
+    // Check for Vite-based Storybook
+    if (dependencies['@storybook/react-vite']) {
+        return '@storybook/react-vite';
+    }
+    else if (dependencies['@storybook/react-webpack5']) {
+        return '@storybook/react-webpack5';
+    }
+    else if (dependencies['@storybook/nextjs']) {
+        return '@storybook/nextjs';
+    }
+    // Default to generic React
+    return '@storybook/react';
+}
 /**
  * Auto-detects design system configuration by analyzing the project structure
  */
@@ -237,12 +336,15 @@ export function autoDetectDesignSystem() {
         const componentPrefix = findMostLikelyPrefix(analysis.componentPrefixes);
         // Determine layout patterns
         const layoutRules = detectLayoutPatterns(analysis.layoutPatterns, componentPrefix);
+        // Detect Storybook framework
+        const storybookFramework = detectStorybookFramework(dependencies);
         // Build configuration
         const config = {
             generatedStoriesPath: path.join(cwd, 'src/stories/generated/'),
             importPath: importPath,
             componentPrefix: componentPrefix,
-            layoutRules: layoutRules
+            layoutRules: layoutRules,
+            storybookFramework: storybookFramework
         };
         // Only set componentsPath for local component libraries
         if (componentPath && !isExternalPackage) {
@@ -263,38 +365,6 @@ export function autoDetectDesignSystem() {
  * Detects known design systems from package.json dependencies
  */
 function detectKnownDesignSystems(dependencies) {
-    // Material-UI detection
-    if (dependencies['@mui/material']) {
-        return {
-            importPath: '@mui/material',
-            componentPrefix: '',
-            layoutRules: {
-                multiColumnWrapper: 'Grid',
-                columnComponent: 'Grid',
-                containerComponent: 'Container',
-                layoutExamples: {
-                    twoColumn: `<Grid container spacing={2}>
-  <Grid item xs={6}>
-    <Card>
-      <CardContent>
-        <Typography variant="h5">Left Card</Typography>
-        <Typography>Left content</Typography>
-      </CardContent>
-    </Card>
-  </Grid>
-  <Grid item xs={6}>
-    <Card>
-      <CardContent>
-        <Typography variant="h5">Right Card</Typography>
-        <Typography>Right content</Typography>
-      </CardContent>
-    </Card>
-  </Grid>
-</Grid>`
-                }
-            }
-        };
-    }
     // Chakra UI detection
     if (dependencies['@chakra-ui/react']) {
         return {

package/dist/story-generator/considerationsLoader.js

@@ -0,0 +1,204 @@
+import fs from 'fs';
+import path from 'path';
+/**
+ * Loads AI considerations from a markdown or JSON file
+ */
+export function loadConsiderations(considerationsPath) {
+    if (!considerationsPath) {
+        // Try to find considerations file in common locations
+        const possiblePaths = [
+            path.join(process.cwd(), 'story-ui-considerations.json'),
+            path.join(process.cwd(), 'story-ui-considerations.md'),
+            path.join(process.cwd(), '.storybook', 'story-ui-considerations.json'),
+            path.join(process.cwd(), '.storybook', 'story-ui-considerations.md'),
+        ];
+        for (const possiblePath of possiblePaths) {
+            if (fs.existsSync(possiblePath)) {
+                considerationsPath = possiblePath;
+                console.log(`Found considerations file at: ${considerationsPath}`);
+                break;
+            }
+        }
+    }
+    if (!considerationsPath || !fs.existsSync(considerationsPath)) {
+        return null;
+    }
+    try {
+        const content = fs.readFileSync(considerationsPath, 'utf-8');
+        const ext = path.extname(considerationsPath).toLowerCase();
+        if (ext === '.json') {
+            return JSON.parse(content);
+        }
+        else if (ext === '.md') {
+            return parseMarkdownConsiderations(content);
+        }
+    }
+    catch (error) {
+        console.warn(`Failed to load considerations from ${considerationsPath}:`, error);
+    }
+    return null;
+}
+/**
+ * Parses markdown content to extract AI considerations
+ */
+function parseMarkdownConsiderations(content) {
+    const considerations = {};
+    // Extract library name and import path from frontmatter or headers
+    const libraryMatch = content.match(/\*\*Library Name\*\*:\s*(.+)/);
+    if (libraryMatch) {
+        considerations.libraryName = libraryMatch[1].trim();
+    }
+    const importMatch = content.match(/\*\*Import Path\*\*:\s*`(.+)`/);
+    if (importMatch) {
+        considerations.importPath = importMatch[1].trim();
+    }
+    // Extract sections
+    const sections = content.split(/^##\s+/m);
+    for (const section of sections) {
+        const lines = section.split('\n');
+        const title = lines[0]?.trim().toLowerCase();
+        if (title.includes('core principles')) {
+            considerations.corePrinciples = extractListItems(section);
+        }
+        else if (title.includes("do's and don'ts")) {
+            const doSection = section.match(/###\s*✅\s*DO\s*([\s\S]*?)(?=###|$)/);
+            const dontSection = section.match(/###\s*❌\s*DON'T\s*([\s\S]*?)(?=###|$)/);
+            if (doSection) {
+                considerations.dos = extractListItems(doSection[1]);
+            }
+            if (dontSection) {
+                considerations.donts = extractListItems(dontSection[1]);
+            }
+        }
+        else if (title.includes('special considerations')) {
+            considerations.specialConsiderations = extractListItems(section);
+        }
+        else if (title.includes('error patterns')) {
+            considerations.commonMistakes = extractErrorPatterns(section);
+        }
+    }
+    // Extract AI instructions from the entire content
+    considerations.aiInstructions = {
+        general: extractAIInstructions(content)
+    };
+    return considerations;
+}
+/**
+ * Extracts list items from a markdown section
+ */
+function extractListItems(section) {
+    const items = [];
+    const lines = section.split('\n');
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith('- ') || trimmed.startsWith('* ') || trimmed.match(/^\d+\.\s+/)) {
+            const item = trimmed.replace(/^[-*]\s+/, '').replace(/^\d+\.\s+/, '').trim();
+            if (item && !item.startsWith('<!--')) {
+                items.push(item);
+            }
+        }
+    }
+    return items;
+}
+/**
+ * Extracts error patterns from markdown
+ */
+function extractErrorPatterns(section) {
+    const patterns = [];
+    const errorBlocks = section.match(/\d+\.\s*\*\*Wrong\*\*:[\s\S]*?(?=\d+\.\s*\*\*Wrong\*\*:|$)/g);
+    if (errorBlocks) {
+        for (const block of errorBlocks) {
+            const wrongMatch = block.match(/\*\*Wrong\*\*:\s*`([^`]+)`/);
+            const rightMatch = block.match(/\*\*Right\*\*:\s*`([^`]+)`/);
+            const whyMatch = block.match(/\*\*Why\*\*:\s*(.+)/);
+            const issueMatch = block.match(/^\d+\.\s*(.+?)\s*\n/);
+            if (wrongMatch && rightMatch) {
+                patterns.push({
+                    issue: issueMatch ? issueMatch[1].replace(/\*\*/g, '').trim() : 'Pattern',
+                    wrong: wrongMatch[1],
+                    correct: rightMatch[1],
+                    explanation: whyMatch ? whyMatch[1].trim() : ''
+                });
+            }
+        }
+    }
+    return patterns;
+}
+/**
+ * Extracts AI-specific instructions from the content
+ */
+function extractAIInstructions(content) {
+    const instructions = [];
+    // Look for specific instruction patterns
+    const instructionPatterns = [
+        /(?:always|never|must|should|ensure|remember|important)(?:\s+\w+)*[:.]?\s*(.+)/gi,
+        /(?:use|prefer|avoid|don't)(?:\s+\w+)*[:.]?\s*(.+)/gi
+    ];
+    for (const pattern of instructionPatterns) {
+        const matches = content.matchAll(pattern);
+        for (const match of matches) {
+            const instruction = match[1].trim();
+            if (instruction.length > 10 && instruction.length < 200 && !instruction.includes('<!--')) {
+                instructions.push(instruction);
+            }
+        }
+    }
+    // Remove duplicates
+    return [...new Set(instructions)];
+}
+/**
+ * Converts considerations to prompt additions
+ */
+export function considerationsToPrompt(considerations) {
+    const promptParts = [];
+    if (considerations.libraryName) {
+        promptParts.push(`LIBRARY: ${considerations.libraryName}`);
+    }
+    if (considerations.description) {
+        promptParts.push(`\n${considerations.description}`);
+    }
+    if (considerations.corePrinciples && considerations.corePrinciples.length > 0) {
+        promptParts.push('\nCORE PRINCIPLES:');
+        considerations.corePrinciples.forEach(principle => {
+            promptParts.push(`- ${principle}`);
+        });
+    }
+    if (considerations.dos && considerations.dos.length > 0) {
+        promptParts.push('\nIMPORTANT - ALWAYS DO:');
+        considerations.dos.forEach(rule => {
+            promptParts.push(`- ${rule}`);
+        });
+    }
+    if (considerations.donts && considerations.donts.length > 0) {
+        promptParts.push('\nIMPORTANT - NEVER DO:');
+        considerations.donts.forEach(rule => {
+            promptParts.push(`- ${rule}`);
+        });
+    }
+    if (considerations.commonMistakes && considerations.commonMistakes.length > 0) {
+        promptParts.push('\nCOMMON MISTAKES TO AVOID:');
+        considerations.commonMistakes.forEach(mistake => {
+            promptParts.push(`- ${mistake.issue}`);
+            promptParts.push(`  WRONG: ${mistake.wrong}`);
+            promptParts.push(`  CORRECT: ${mistake.correct}`);
+            if (mistake.explanation) {
+                promptParts.push(`  WHY: ${mistake.explanation}`);
+            }
+        });
+    }
+    if (considerations.specialConsiderations && considerations.specialConsiderations.length > 0) {
+        promptParts.push('\nSPECIAL CONSIDERATIONS:');
+        considerations.specialConsiderations.forEach(consideration => {
+            promptParts.push(`- ${consideration}`);
+        });
+    }
+    if (considerations.aiInstructions) {
+        if (considerations.aiInstructions.general && considerations.aiInstructions.general.length > 0) {
+            promptParts.push('\nAI INSTRUCTIONS:');
+            considerations.aiInstructions.general.forEach(instruction => {
+                promptParts.push(`- ${instruction}`);
+            });
+        }
+    }
+    return promptParts.join('\n');
+}

package/dist/story-generator/documentation-sources.js

@@ -0,0 +1,36 @@
+/**
+ * Documentation sources for design systems
+ * Provides fallback documentation when custom docs aren't available
+ */
+/**
+ * Pre-bundled documentation for popular design systems
+ * Users should provide their own documentation in story-ui-docs/ directory for best results
+ */
+export const BUNDLED_DOCUMENTATION = {
+// Currently empty - users should provide their own documentation
+// in story-ui-docs/ directory for best AI story generation
+};
+/**
+ * Get documentation for a design system
+ * Falls back to bundled docs if no scraped docs exist
+ */
+export function getDocumentation(importPath) {
+    // First check for scraped documentation
+    const cacheFile = `.story-ui-cache/${importPath.replace(/[@\/]/g, '-')}-docs.json`;
+    // For now, just return bundled docs if available
+    return BUNDLED_DOCUMENTATION[importPath] || null;
+}
+/**
+ * Check if a component is deprecated for a given design system
+ */
+export function isDeprecatedComponent(importPath, componentName) {
+    const docs = getDocumentation(importPath);
+    return docs?.deprecations && docs.deprecations[componentName];
+}
+/**
+ * Get replacement suggestion for a deprecated component
+ */
+export function getComponentReplacement(importPath, componentName) {
+    const docs = getDocumentation(importPath);
+    return docs?.deprecations?.[componentName] || null;
+}