@tpitre/story-ui 2.2.0 → 2.3.0

package/dist/story-generator/framework-adapters/base-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-adapter.d.ts","sourceRoot":"","sources":["../../../story-generator/framework-adapters/base-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,aAAa,EACb,cAAc,EACd,gBAAgB,EAChB,sBAAsB,EACvB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAG/D;;GAEG;AACH,8BAAsB,oBAAqB,YAAW,gBAAgB;IACpE,QAAQ,CAAC,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IACtC,QAAQ,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,QAAQ,CAAC,wBAAwB,EAAE,cAAc,EAAE,CAAC;IAC7D,QAAQ,CAAC,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAE3C;;OAEG;IACH,QAAQ,CAAC,oBAAoB,CAC3B,MAAM,EAAE,aAAa,EACrB,OAAO,CAAC,EAAE,sBAAsB,GAC/B,MAAM;IAET;;OAEG;IACH,0BAA0B,CACxB,UAAU,EAAE,mBAAmB,EAAE,EACjC,MAAM,EAAE,aAAa,GACpB,MAAM;IAmBT;;OAEG;IACH,SAAS,CAAC,oBAAoB,CAC5B,SAAS,EAAE,mBAAmB,EAC9B,MAAM,EAAE,aAAa,GACpB,MAAM;IAkBT;;OAEG;IACH,SAAS,CAAC,aAAa,CACrB,SAAS,EAAE,mBAAmB,EAC9B,MAAM,EAAE,aAAa,GACpB,MAAM;IAUT;;OAEG;IACH,SAAS,CAAC,wBAAwB,CAChC,UAAU,EAAE,mBAAmB,EAAE,GAChC,MAAM,CAAC,MAAM,EAAE,mBAAmB,EAAE,CAAC;IAcxC;;OAEG;IACH,QAAQ,CAAC,gBAAgB,CAAC,MAAM,EAAE,aAAa,GAAG,MAAM;IAExD;;OAEG;IACH,QAAQ,CAAC,mBAAmB,CAC1B,MAAM,EAAE,aAAa,EACrB,UAAU,EAAE,mBAAmB,EAAE,GAChC,MAAM;IAET;;OAEG;IACH,eAAe,CACb,UAAU,EAAE,mBAAmB,EAAE,EACjC,MAAM,EAAE,aAAa,GACpB,MAAM;IAoBT;;OAEG;IACH,WAAW,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM;IAQzC;;OAEG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG;QAAE,KAAK,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAA;KAAE;IAkBpE;;OAEG;IACH,QAAQ,CAAC,gBAAgB,CAAC,OAAO,CAAC,EAAE,sBAAsB,GAAG,MAAM;IAEnE;;OAEG;IACH,SAAS,CAAC,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAIpE;;OAEG;IACH,SAAS,CAAC,cAAc,IAAI,MAAM;CAoBnC"}

package/dist/story-generator/framework-adapters/base-adapter.js

@@ -0,0 +1,147 @@
+/**
+ * Base Framework Adapter
+ *
+ * Abstract base class that provides common functionality for all
+ * framework-specific adapters. Subclasses implement framework-specific
+ * prompt generation and story templates.
+ */
+import { logger } from '../logger.js';
+/**
+ * Abstract Base Framework Adapter
+ */
+export class BaseFrameworkAdapter {
+    /**
+     * Generate component reference documentation
+     */
+    generateComponentReference(components, config) {
+        if (components.length === 0) {
+            return 'No components discovered.';
+        }
+        const groupedComponents = this.groupComponentsByPackage(components);
+        const sections = [];
+        for (const [packageName, pkgComponents] of Object.entries(groupedComponents)) {
+            const componentList = pkgComponents
+                .map(comp => this.formatComponentEntry(comp, config))
+                .join('\n');
+            sections.push(`## ${packageName}\n${componentList}`);
+        }
+        return `# Available Components\n\n${sections.join('\n\n')}`;
+    }
+    /**
+     * Format a single component entry
+     */
+    formatComponentEntry(component, config) {
+        const importPath = this.getImportPath(component, config);
+        let entry = `- **${component.name}** (import from '${importPath}')`;
+        if (component.props && component.props.length > 0) {
+            const propsList = component.props
+                .slice(0, 5) // Limit to first 5 props
+                .join(', ');
+            entry += `\n  Props: ${propsList}${component.props.length > 5 ? '...' : ''}`;
+        }
+        if (component.description) {
+            entry += `\n  ${component.description}`;
+        }
+        return entry;
+    }
+    /**
+     * Get the import path for a component
+     */
+    getImportPath(component, config) {
+        // Use component's __componentPath if available
+        if (component.__componentPath) {
+            return component.__componentPath;
+        }
+        // Fall back to import path from config
+        return config.importPath || 'unknown';
+    }
+    /**
+     * Group components by their category
+     */
+    groupComponentsByPackage(components) {
+        const grouped = {};
+        for (const component of components) {
+            const category = component.category || 'other';
+            if (!grouped[category]) {
+                grouped[category] = [];
+            }
+            grouped[category].push(component);
+        }
+        return grouped;
+    }
+    /**
+     * Generate import statements for components
+     */
+    generateImports(components, config) {
+        const importsByPath = new Map();
+        for (const component of components) {
+            const importPath = this.getImportPath(component, config);
+            if (!importsByPath.has(importPath)) {
+                importsByPath.set(importPath, new Set());
+            }
+            importsByPath.get(importPath).add(component.name);
+        }
+        const imports = [];
+        for (const [path, names] of importsByPath) {
+            const namedImports = Array.from(names).sort().join(', ');
+            imports.push(`import { ${namedImports} } from '${path}';`);
+        }
+        return imports.join('\n');
+    }
+    /**
+     * Post-process generated story content
+     */
+    postProcess(storyContent) {
+        // Default implementation - can be overridden by subclasses
+        return storyContent
+            .trim()
+            .replace(/\r\n/g, '\n')
+            .replace(/\n{3,}/g, '\n\n');
+    }
+    /**
+     * Validate generated story syntax
+     */
+    validate(storyContent) {
+        const errors = [];
+        if (!storyContent || storyContent.trim().length === 0) {
+            errors.push('Story content is empty');
+        }
+        // Check for common issues
+        if (!storyContent.includes('export')) {
+            errors.push('Story missing exports');
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+        };
+    }
+    /**
+     * Log adapter activity
+     */
+    log(message, data) {
+        logger.debug(`[${this.name}Adapter] ${message}`, data);
+    }
+    /**
+     * Get common story structure rules
+     */
+    getCommonRules() {
+        return `
+GENERAL RULES:
+- Follow the component library's design patterns
+- Use meaningful story names that describe the variant
+- Include multiple stories showing different states/variants
+- Ensure accessibility by using proper ARIA attributes
+- Use realistic placeholder content
+
+IMAGE RULES:
+- Use Lorem Picsum for placeholder images: https://picsum.photos/[width]/[height]
+- Always include alt text for images
+- Example: https://picsum.photos/400/300?random=1
+
+SPACING RULES:
+- Use the design system's spacing tokens when available
+- Maintain consistent margins and padding
+- Follow the layout grid system if present
+`;
+    }
+}

package/dist/story-generator/framework-adapters/framework-detector.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Framework Detection System
+ *
+ * Automatically detects the component framework and story framework
+ * used in a project by analyzing package.json, config files, and
+ * file patterns.
+ */
+import { FrameworkType, FrameworkDetectionResult } from './types.js';
+/**
+ * Framework Detector Class
+ */
+export declare class FrameworkDetector {
+    private projectRoot;
+    private packageJson;
+    private dependencies;
+    private detectedConfigFiles;
+    constructor(projectRoot?: string);
+    /**
+     * Detect frameworks used in the project
+     */
+    detect(): Promise<FrameworkDetectionResult>;
+    /**
+     * Load and parse package.json
+     */
+    private loadPackageJson;
+    /**
+     * Scan for framework configuration files
+     */
+    private scanConfigFiles;
+    /**
+     * Score each framework pattern based on evidence
+     */
+    private scoreFrameworks;
+    /**
+     * Get framework version from dependencies
+     */
+    private getFrameworkVersion;
+    /**
+     * Get framework-specific configuration
+     */
+    private getFrameworkConfig;
+    /**
+     * Quick check for a specific framework
+     */
+    hasFramework(framework: FrameworkType): boolean;
+}
+/**
+ * Factory function for framework detection
+ */
+export declare function detectFramework(projectRoot?: string): Promise<FrameworkDetectionResult>;
+/**
+ * Get framework detector instance
+ */
+export declare function getFrameworkDetector(projectRoot?: string): FrameworkDetector;
+//# sourceMappingURL=framework-detector.d.ts.map

package/dist/story-generator/framework-adapters/framework-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"framework-detector.d.ts","sourceRoot":"","sources":["../../../story-generator/framework-adapters/framework-detector.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,OAAO,EACL,aAAa,EAGb,wBAAwB,EAEzB,MAAM,YAAY,CAAC;AAmGpB;;GAEG;AACH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,WAAW,CAAwC;IAC3D,OAAO,CAAC,YAAY,CAA8B;IAClD,OAAO,CAAC,mBAAmB,CAAgB;gBAE/B,WAAW,GAAE,MAAsB;IAI/C;;OAEG;IACG,MAAM,IAAI,OAAO,CAAC,wBAAwB,CAAC;IAkDjD;;OAEG;YACW,eAAe;IAwB7B;;OAEG;IACH,OAAO,CAAC,eAAe;IAqBvB;;OAEG;IACH,OAAO,CAAC,eAAe;IA2BvB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAoB3B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAwD1B;;OAEG;IACH,YAAY,CAAC,SAAS,EAAE,aAAa,GAAG,OAAO;CAchD;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAGvF;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,iBAAiB,CAE5E"}

package/dist/story-generator/framework-adapters/framework-detector.js

@@ -0,0 +1,323 @@
+/**
+ * Framework Detection System
+ *
+ * Automatically detects the component framework and story framework
+ * used in a project by analyzing package.json, config files, and
+ * file patterns.
+ */
+import fs from 'fs';
+import path from 'path';
+import { logger } from '../logger.js';
+const FRAMEWORK_PATTERNS = [
+    // React
+    {
+        framework: 'react',
+        storyFramework: 'storybook-react',
+        packageIndicators: ['react', 'react-dom', '@storybook/react', '@storybook/react-vite', '@storybook/react-webpack5'],
+        configFiles: ['.storybook/main.js', '.storybook/main.ts', '.storybook/preview.js'],
+        filePatterns: ['*.jsx', '*.tsx', '*.stories.tsx', '*.stories.jsx'],
+        weight: 10,
+    },
+    // Vue 3
+    {
+        framework: 'vue',
+        storyFramework: 'storybook-vue3',
+        packageIndicators: ['vue', '@vue/runtime-core', '@storybook/vue3', '@storybook/vue3-vite'],
+        configFiles: ['vite.config.ts', 'vue.config.js', 'nuxt.config.ts'],
+        filePatterns: ['*.vue', '*.stories.ts'],
+        weight: 10,
+    },
+    // Angular
+    {
+        framework: 'angular',
+        storyFramework: 'storybook-angular',
+        packageIndicators: ['@angular/core', '@angular/common', '@storybook/angular'],
+        configFiles: ['angular.json', 'ng-package.json'],
+        filePatterns: ['*.component.ts', '*.stories.ts'],
+        weight: 10,
+    },
+    // Svelte
+    {
+        framework: 'svelte',
+        storyFramework: 'storybook-svelte',
+        packageIndicators: ['svelte', '@sveltejs/kit', '@storybook/svelte', '@storybook/svelte-vite'],
+        configFiles: ['svelte.config.js', 'svelte.config.ts'],
+        filePatterns: ['*.svelte', '*.stories.svelte'],
+        weight: 10,
+    },
+    // Web Components
+    {
+        framework: 'web-components',
+        storyFramework: 'storybook-web-components',
+        packageIndicators: ['lit', 'lit-element', 'lit-html', '@storybook/web-components', '@open-wc/testing'],
+        configFiles: ['web-dev-server.config.js', 'custom-elements.json'],
+        filePatterns: ['*.element.ts', '*.element.js'],
+        weight: 10,
+    },
+    // Solid
+    {
+        framework: 'solid',
+        storyFramework: 'storybook-react', // Uses React adapter with solid-js
+        packageIndicators: ['solid-js', '@solidjs/router'],
+        configFiles: ['vite.config.ts'],
+        filePatterns: ['*.tsx', '*.jsx'],
+        weight: 8,
+    },
+    // Qwik
+    {
+        framework: 'qwik',
+        storyFramework: 'custom',
+        packageIndicators: ['@builder.io/qwik', '@builder.io/qwik-city'],
+        configFiles: ['qwik.config.ts'],
+        filePatterns: ['*.tsx'],
+        weight: 8,
+    },
+    // Histoire (Vue alternative)
+    {
+        framework: 'vue',
+        storyFramework: 'histoire',
+        packageIndicators: ['histoire', '@histoire/plugin-vue'],
+        configFiles: ['histoire.config.ts', 'histoire.config.js'],
+        filePatterns: ['*.story.vue'],
+        weight: 12,
+    },
+    // Ladle (React alternative)
+    {
+        framework: 'react',
+        storyFramework: 'ladle',
+        packageIndicators: ['@ladle/react'],
+        configFiles: ['.ladle/config.mjs'],
+        filePatterns: ['*.stories.tsx'],
+        weight: 12,
+    },
+];
+/**
+ * Framework Detector Class
+ */
+export class FrameworkDetector {
+    constructor(projectRoot = process.cwd()) {
+        this.packageJson = null;
+        this.dependencies = {};
+        this.detectedConfigFiles = [];
+        this.projectRoot = projectRoot;
+    }
+    /**
+     * Detect frameworks used in the project
+     */
+    async detect() {
+        logger.debug('Starting framework detection', { projectRoot: this.projectRoot });
+        // Load package.json
+        await this.loadPackageJson();
+        // Scan for config files
+        this.scanConfigFiles();
+        // Score each framework pattern
+        const frameworkScores = this.scoreFrameworks();
+        // Sort by score descending
+        const sortedFrameworks = frameworkScores
+            .filter(f => f.score > 0)
+            .sort((a, b) => b.score - a.score);
+        // Convert to DetectedFramework objects
+        const detectedFrameworks = sortedFrameworks.map(f => ({
+            componentFramework: f.pattern.framework,
+            storyFramework: f.pattern.storyFramework,
+            version: this.getFrameworkVersion(f.pattern.framework),
+            config: this.getFrameworkConfig(f.pattern.framework),
+            confidence: Math.min(f.score / 30, 1), // Normalize to 0-1
+        }));
+        // Default to React if nothing detected
+        const defaultFramework = {
+            componentFramework: 'react',
+            storyFramework: 'storybook-react',
+            config: this.getFrameworkConfig('react'),
+            confidence: 0.5,
+        };
+        const primary = detectedFrameworks[0] || defaultFramework;
+        logger.info('Framework detection complete', {
+            primary: primary.componentFramework,
+            storyFramework: primary.storyFramework,
+            confidence: primary.confidence,
+        });
+        return {
+            frameworks: detectedFrameworks.length > 0 ? detectedFrameworks : [defaultFramework],
+            primary,
+            dependencies: this.dependencies,
+            configFiles: this.detectedConfigFiles,
+        };
+    }
+    /**
+     * Load and parse package.json
+     */
+    async loadPackageJson() {
+        const packagePath = path.join(this.projectRoot, 'package.json');
+        try {
+            if (fs.existsSync(packagePath)) {
+                const content = fs.readFileSync(packagePath, 'utf-8');
+                this.packageJson = JSON.parse(content);
+                // Merge all dependencies
+                this.dependencies = {
+                    ...(this.packageJson?.dependencies || {}),
+                    ...(this.packageJson?.devDependencies || {}),
+                    ...(this.packageJson?.peerDependencies || {}),
+                };
+                logger.debug('Loaded package.json', {
+                    dependencyCount: Object.keys(this.dependencies).length,
+                });
+            }
+        }
+        catch (error) {
+            logger.warn('Failed to load package.json', { error });
+        }
+    }
+    /**
+     * Scan for framework configuration files
+     */
+    scanConfigFiles() {
+        const allConfigFiles = new Set();
+        for (const pattern of FRAMEWORK_PATTERNS) {
+            for (const configFile of pattern.configFiles) {
+                allConfigFiles.add(configFile);
+            }
+        }
+        for (const configFile of allConfigFiles) {
+            const fullPath = path.join(this.projectRoot, configFile);
+            if (fs.existsSync(fullPath)) {
+                this.detectedConfigFiles.push(configFile);
+            }
+        }
+        logger.debug('Config files detected', {
+            configFiles: this.detectedConfigFiles,
+        });
+    }
+    /**
+     * Score each framework pattern based on evidence
+     */
+    scoreFrameworks() {
+        return FRAMEWORK_PATTERNS.map(pattern => {
+            let score = 0;
+            // Check package indicators
+            for (const pkg of pattern.packageIndicators) {
+                if (this.dependencies[pkg]) {
+                    score += pattern.weight;
+                    // Extra weight for Storybook packages
+                    if (pkg.startsWith('@storybook/')) {
+                        score += 5;
+                    }
+                }
+            }
+            // Check config files
+            for (const configFile of pattern.configFiles) {
+                if (this.detectedConfigFiles.includes(configFile)) {
+                    score += pattern.weight / 2;
+                }
+            }
+            return { pattern, score };
+        });
+    }
+    /**
+     * Get framework version from dependencies
+     */
+    getFrameworkVersion(framework) {
+        const versionMap = {
+            'react': ['react'],
+            'vue': ['vue'],
+            'angular': ['@angular/core'],
+            'svelte': ['svelte'],
+            'web-components': ['lit', 'lit-element'],
+            'solid': ['solid-js'],
+            'qwik': ['@builder.io/qwik'],
+        };
+        const packages = versionMap[framework] || [];
+        for (const pkg of packages) {
+            if (this.dependencies[pkg]) {
+                return this.dependencies[pkg].replace(/[\^~]/, '');
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Get framework-specific configuration
+     */
+    getFrameworkConfig(framework) {
+        const configs = {
+            'react': {
+                importStyle: 'named',
+                storyExtension: '.stories.tsx',
+                typescript: true,
+                jsx: true,
+                componentExtension: '.tsx',
+            },
+            'vue': {
+                importStyle: 'default',
+                storyExtension: '.stories.ts',
+                typescript: true,
+                jsx: false,
+                componentExtension: '.vue',
+            },
+            'angular': {
+                importStyle: 'named',
+                storyExtension: '.stories.ts',
+                typescript: true,
+                jsx: false,
+                componentExtension: '.component.ts',
+            },
+            'svelte': {
+                importStyle: 'default',
+                storyExtension: '.stories.svelte',
+                typescript: true,
+                jsx: false,
+                componentExtension: '.svelte',
+            },
+            'web-components': {
+                importStyle: 'named',
+                storyExtension: '.stories.ts',
+                typescript: true,
+                jsx: false,
+                componentExtension: '.ts',
+            },
+            'solid': {
+                importStyle: 'named',
+                storyExtension: '.stories.tsx',
+                typescript: true,
+                jsx: true,
+                componentExtension: '.tsx',
+            },
+            'qwik': {
+                importStyle: 'named',
+                storyExtension: '.stories.tsx',
+                typescript: true,
+                jsx: true,
+                componentExtension: '.tsx',
+            },
+        };
+        return configs[framework] || configs['react'];
+    }
+    /**
+     * Quick check for a specific framework
+     */
+    hasFramework(framework) {
+        const packageMap = {
+            'react': ['react', 'react-dom'],
+            'vue': ['vue'],
+            'angular': ['@angular/core'],
+            'svelte': ['svelte'],
+            'web-components': ['lit', 'lit-element', '@open-wc/testing'],
+            'solid': ['solid-js'],
+            'qwik': ['@builder.io/qwik'],
+        };
+        const packages = packageMap[framework] || [];
+        return packages.some(pkg => !!this.dependencies[pkg]);
+    }
+}
+/**
+ * Factory function for framework detection
+ */
+export function detectFramework(projectRoot) {
+    const detector = new FrameworkDetector(projectRoot);
+    return detector.detect();
+}
+/**
+ * Get framework detector instance
+ */
+export function getFrameworkDetector(projectRoot) {
+    return new FrameworkDetector(projectRoot);
+}

package/dist/story-generator/framework-adapters/index.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Framework Adapters Module
+ *
+ * Exports framework detection, adapters, and the adapter registry.
+ */
+export * from './types.js';
+export { FrameworkDetector, detectFramework, getFrameworkDetector, } from './framework-detector.js';
+export { BaseFrameworkAdapter } from './base-adapter.js';
+export { ReactAdapter, createReactAdapter } from './react-adapter.js';
+export { WebComponentsAdapter, createWebComponentsAdapter } from './web-components-adapter.js';
+export { VueAdapter, createVueAdapter } from './vue-adapter.js';
+export { AngularAdapter, createAngularAdapter } from './angular-adapter.js';
+export { SvelteAdapter, createSvelteAdapter } from './svelte-adapter.js';
+import { FrameworkType, FrameworkAdapter, DetectedFramework, FrameworkPrompt, StoryGenerationOptions } from './types.js';
+import { StoryUIConfig } from '../../story-ui.config.js';
+import { DiscoveredComponent } from '../componentDiscovery.js';
+/**
+ * Framework Adapter Registry
+ *
+ * Manages available framework adapters and provides
+ * automatic framework detection and adapter selection.
+ */
+declare class AdapterRegistry {
+    private adapters;
+    private defaultAdapter;
+    private detectedFramework;
+    constructor();
+    /**
+     * Register built-in framework adapters
+     */
+    private registerBuiltInAdapters;
+    /**
+     * Register a framework adapter
+     */
+    register(adapter: FrameworkAdapter): void;
+    /**
+     * Get adapter by framework type
+     */
+    get(type: FrameworkType): FrameworkAdapter | undefined;
+    /**
+     * Get all registered adapters
+     */
+    getAll(): FrameworkAdapter[];
+    /**
+     * Get available framework types
+     */
+    getAvailableTypes(): FrameworkType[];
+    /**
+     * Get available framework types (alias for getAvailableTypes)
+     */
+    getAvailableFrameworks(): FrameworkType[];
+    /**
+     * Get adapter by framework type (alias for get with default fallback)
+     */
+    getAdapter(type: FrameworkType): FrameworkAdapter;
+    /**
+     * Get the default adapter
+     */
+    getDefault(): FrameworkAdapter;
+    /**
+     * Set the default adapter
+     */
+    setDefault(type: FrameworkType): void;
+    /**
+     * Auto-detect framework and return appropriate adapter
+     */
+    autoDetect(projectRoot?: string): Promise<FrameworkAdapter>;
+    /**
+     * Get the last detected framework info
+     */
+    getDetectedFramework(): DetectedFramework | null;
+    /**
+     * Generate prompt using the appropriate adapter
+     */
+    generatePrompt(config: StoryUIConfig, components: DiscoveredComponent[], options?: StoryGenerationOptions): Promise<FrameworkPrompt>;
+}
+/**
+ * Get the global adapter registry instance
+ */
+export declare function getAdapterRegistry(): AdapterRegistry;
+/**
+ * Get adapter for a specific framework
+ */
+export declare function getAdapter(type: FrameworkType): FrameworkAdapter | undefined;
+/**
+ * Get the default adapter
+ */
+export declare function getDefaultAdapter(): FrameworkAdapter;
+/**
+ * Auto-detect framework and get appropriate adapter
+ */
+export declare function autoDetectAdapter(projectRoot?: string): Promise<FrameworkAdapter>;
+/**
+ * Generate framework-specific prompt
+ */
+export declare function generateFrameworkPrompt(config: StoryUIConfig, components: DiscoveredComponent[], options?: StoryGenerationOptions): Promise<FrameworkPrompt>;
+//# sourceMappingURL=index.d.ts.map

package/dist/story-generator/framework-adapters/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../story-generator/framework-adapters/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,cAAc,YAAY,CAAC;AAG3B,OAAO,EACL,iBAAiB,EACjB,eAAe,EACf,oBAAoB,GACrB,MAAM,yBAAyB,CAAC;AAGjC,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAGzD,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACtE,OAAO,EAAE,oBAAoB,EAAE,0BAA0B,EAAE,MAAM,6BAA6B,CAAC;AAC/F,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAChE,OAAO,EAAE,cAAc,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAC5E,OAAO,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAGzE,OAAO,EACL,aAAa,EACb,gBAAgB,EAChB,iBAAiB,EACjB,eAAe,EACf,sBAAsB,EACvB,MAAM,YAAY,CAAC;AAOpB,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAG/D;;;;;GAKG;AACH,cAAM,eAAe;IACnB,OAAO,CAAC,QAAQ,CAAmD;IACnE,OAAO,CAAC,cAAc,CAAmB;IACzC,OAAO,CAAC,iBAAiB,CAAkC;;IAU3D;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAY/B;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,gBAAgB,GAAG,IAAI;IAIzC;;OAEG;IACH,GAAG,CAAC,IAAI,EAAE,aAAa,GAAG,gBAAgB,GAAG,SAAS;IAItD;;OAEG;IACH,MAAM,IAAI,gBAAgB,EAAE;IAI5B;;OAEG;IACH,iBAAiB,IAAI,aAAa,EAAE;IAIpC;;OAEG;IACH,sBAAsB,IAAI,aAAa,EAAE;IAIzC;;OAEG;IACH,UAAU,CAAC,IAAI,EAAE,aAAa,GAAG,gBAAgB;IAIjD;;OAEG;IACH,UAAU,IAAI,gBAAgB;IAI9B;;OAEG;IACH,UAAU,CAAC,IAAI,EAAE,aAAa,GAAG,IAAI;IAQrC;;OAEG;IACG,UAAU,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAoBjE;;OAEG;IACH,oBAAoB,IAAI,iBAAiB,GAAG,IAAI;IAIhD;;OAEG;IACG,cAAc,CAClB,MAAM,EAAE,aAAa,EACrB,UAAU,EAAE,mBAAmB,EAAE,EACjC,OAAO,CAAC,EAAE,sBAAsB,GAC/B,OAAO,CAAC,eAAe,CAAC;CA8B5B;AAKD;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,eAAe,CAKpD;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,aAAa,GAAG,gBAAgB,GAAG,SAAS,CAE5E;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,gBAAgB,CAEpD;AAED;;GAEG;AACH,wBAAsB,iBAAiB,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAEvF;AAED;;GAEG;AACH,wBAAsB,uBAAuB,CAC3C,MAAM,EAAE,aAAa,EACrB,UAAU,EAAE,mBAAmB,EAAE,EACjC,OAAO,CAAC,EAAE,sBAAsB,GAC/B,OAAO,CAAC,eAAe,CAAC,CAE1B"}