@tpitre/story-ui 3.6.2 → 3.8.0

package/dist/story-generator/runtimeValidator.js

@@ -0,0 +1,356 @@
+/**
+ * Runtime Validator for Story UI
+ *
+ * Validates that generated stories actually load and render in Storybook
+ * by making HTTP requests to the running Storybook instance after HMR processes
+ * the new story file.
+ *
+ * This catches runtime errors that static validation cannot detect, such as:
+ * - "importers[path] is not a function" - Storybook CSF loader errors
+ * - Module resolution failures
+ * - Runtime component errors
+ */
+import { logger } from './logger.js';
+// Known Storybook runtime error patterns
+const RUNTIME_ERROR_PATTERNS = [
+    { pattern: /importers\[.*?\] is not a function/i, type: 'module_error', description: 'CSF module loader error' },
+    { pattern: /Cannot read propert.*of undefined/i, type: 'render_error', description: 'Component render error' },
+    { pattern: /is not defined/i, type: 'render_error', description: 'Undefined variable error' },
+    { pattern: /Module not found/i, type: 'module_error', description: 'Module resolution error' },
+    { pattern: /Failed to resolve import/i, type: 'module_error', description: 'Import resolution error' },
+    { pattern: /SyntaxError/i, type: 'module_error', description: 'Runtime syntax error' },
+    { pattern: /Unexpected token/i, type: 'module_error', description: 'Parse error' },
+    { pattern: /ReferenceError/i, type: 'render_error', description: 'Reference error' },
+    { pattern: /TypeError/i, type: 'render_error', description: 'Type error' },
+];
+/**
+ * Get the Storybook URL based on environment configuration
+ */
+export function getStorybookUrl() {
+    // Priority 1: Explicit storybookUrl in environment
+    if (process.env.STORYBOOK_URL) {
+        return process.env.STORYBOOK_URL;
+    }
+    // Priority 2: Proxy mode - use internal Storybook port
+    if (process.env.STORYBOOK_PROXY_ENABLED === 'true') {
+        const proxyPort = process.env.STORYBOOK_PROXY_PORT || '6006';
+        return `http://localhost:${proxyPort}`;
+    }
+    // Priority 3: Explicit Storybook port
+    if (process.env.STORYBOOK_PORT) {
+        return `http://localhost:${process.env.STORYBOOK_PORT}`;
+    }
+    // Priority 4: Default local Storybook
+    return 'http://localhost:6006';
+}
+/**
+ * Check if runtime validation is enabled
+ */
+export function isRuntimeValidationEnabled() {
+    // Enabled by default if we can determine a Storybook URL
+    // Can be explicitly disabled with STORYBOOK_RUNTIME_VALIDATION=false
+    if (process.env.STORYBOOK_RUNTIME_VALIDATION === 'false') {
+        return false;
+    }
+    // In proxy mode, always enable since we know Storybook is accessible
+    if (process.env.STORYBOOK_PROXY_ENABLED === 'true') {
+        return true;
+    }
+    // Otherwise, enable if explicitly set to true
+    return process.env.STORYBOOK_RUNTIME_VALIDATION === 'true';
+}
+/**
+ * Convert a story title to the Storybook story ID prefix format
+ * e.g., "Simple Card" with prefix "Generated/" -> "generated-simple-card"
+ * Note: This returns the prefix only, without the story export name
+ */
+export function titleToStoryIdPrefix(title, storyPrefix = 'Generated/') {
+    // Remove prefix and convert to kebab case
+    const fullTitle = storyPrefix + title;
+    const kebabTitle = fullTitle
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-|-$/g, '');
+    return kebabTitle;
+}
+/**
+ * Extract the actual title from generated story content
+ * Looks for: title: 'Generated/Something' or title: "Generated/Something"
+ */
+export function extractTitleFromStory(storyContent) {
+    const titleMatch = storyContent.match(/title:\s*['"]([^'"]+)['"]/);
+    if (titleMatch) {
+        // Return the full title (including prefix like "Generated/")
+        return titleMatch[1];
+    }
+    return null;
+}
+/**
+ * Convert a full story title (like "Generated/Button Click Counter") to story ID prefix
+ */
+export function fullTitleToStoryIdPrefix(fullTitle) {
+    return fullTitle
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-|-$/g, '');
+}
+/**
+ * Sleep utility
+ */
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+/**
+ * Fetch with timeout
+ */
+async function fetchWithTimeout(url, timeoutMs) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const response = await fetch(url, { signal: controller.signal });
+        clearTimeout(timeoutId);
+        return response;
+    }
+    catch (error) {
+        clearTimeout(timeoutId);
+        if (error.name === 'AbortError') {
+            throw new Error(`Request timed out after ${timeoutMs}ms`);
+        }
+        throw error;
+    }
+}
+/**
+ * Check if stories exist in Storybook's index that match the given title prefix
+ * Returns the first matching story ID for iframe validation
+ */
+async function checkStoryInIndex(storyIdPrefix, storybookUrl, config) {
+    const indexUrl = `${storybookUrl}/index.json`;
+    const timeout = config.fetchTimeoutMs || 5000;
+    try {
+        const response = await fetchWithTimeout(indexUrl, timeout);
+        if (!response.ok) {
+            return { exists: false, error: `Index returned ${response.status}` };
+        }
+        const index = await response.json();
+        // Storybook 7+ uses 'entries', older versions use 'stories'
+        const stories = index.entries || index.stories || {};
+        // Find story IDs that match our prefix (not docs entries)
+        const matchingIds = Object.keys(stories).filter(id => {
+            // Skip docs entries - we want actual story entries
+            if (id.endsWith('--docs'))
+                return false;
+            // Check if the ID starts with our prefix
+            return id.startsWith(storyIdPrefix + '--');
+        });
+        if (matchingIds.length > 0) {
+            return { exists: true, matchingStoryId: matchingIds[0] };
+        }
+        return { exists: false };
+    }
+    catch (error) {
+        return { exists: false, error: error.message };
+    }
+}
+/**
+ * Check the story iframe for runtime errors
+ */
+async function checkStoryIframe(storyId, storybookUrl, config) {
+    const iframeUrl = `${storybookUrl}/iframe.html?id=${storyId}&viewMode=story`;
+    const timeout = config.fetchTimeoutMs || 5000;
+    try {
+        const response = await fetchWithTimeout(iframeUrl, timeout);
+        if (!response.ok) {
+            return {
+                success: false,
+                error: `Story iframe returned ${response.status}`,
+                errorType: 'not_found'
+            };
+        }
+        const html = await response.text();
+        // Check for known error patterns in the HTML response
+        for (const { pattern, type, description } of RUNTIME_ERROR_PATTERNS) {
+            if (pattern.test(html)) {
+                // Extract the actual error message if possible
+                const match = html.match(/<pre[^>]*>([\s\S]*?)<\/pre>/i) ||
+                    html.match(/Error:?\s*([^\n<]+)/i);
+                const errorDetail = match ? match[1].trim().substring(0, 200) : description;
+                return {
+                    success: false,
+                    error: errorDetail,
+                    errorType: type
+                };
+            }
+        }
+        // Check for Storybook error boundary markers
+        // Note: We need to check for VISIBLE errors, not just the error display template
+        // The 'sb-show-errordisplay' class is added to body when an error is actually shown
+        // IMPORTANT: Must use regex to check for class attribute, not just includes()
+        // because ':not(.sb-show-errordisplay)' exists in CSS selectors
+        const hasVisibleError = /class="[^"]*sb-show-errordisplay[^"]*"/i.test(html);
+        // Check for actual error content in the error display elements (non-empty)
+        const hasErrorContent = /<h1[^>]*id="error-message"[^>]*>[^<]+<\/h1>/i.test(html) ||
+            /<code[^>]*id="error-stack"[^>]*>[^<]+<\/code>/i.test(html);
+        // Check for specific error text (not in CSS context)
+        const hasDocsError = />\s*DocsRenderer error/i.test(html);
+        const hasStoryError = /class="[^"]*story-error[^"]*"/i.test(html);
+        if (hasVisibleError || hasErrorContent || hasDocsError || hasStoryError) {
+            // Try to extract the actual error message
+            const errorMsgMatch = html.match(/<h1[^>]*id="error-message"[^>]*>([^<]+)<\/h1>/i);
+            const errorDetail = errorMsgMatch ? errorMsgMatch[1].trim() : 'Storybook error boundary triggered';
+            return {
+                success: false,
+                error: errorDetail,
+                errorType: 'render_error'
+            };
+        }
+        return { success: true };
+    }
+    catch (error) {
+        if (error.message.includes('timed out')) {
+            return { success: false, error: error.message, errorType: 'timeout' };
+        }
+        return { success: false, error: error.message, errorType: 'connection_error' };
+    }
+}
+/**
+ * Validate that a story loads and renders correctly in Storybook
+ *
+ * @param storyContent - The generated story content (used to extract the actual title)
+ * @param fallbackTitle - Fallback title if extraction fails (e.g., "Simple Card")
+ * @param storyPrefix - The story prefix from config (e.g., "Generated/")
+ * @param customConfig - Runtime validator configuration
+ * @returns Validation result with success status and any errors
+ */
+export async function validateStoryRuntime(storyContent, fallbackTitle, storyPrefix = 'Generated/', customConfig) {
+    // Check if runtime validation is enabled
+    if (!isRuntimeValidationEnabled()) {
+        logger.debug('Runtime validation disabled, skipping');
+        return { success: true, storyExists: true };
+    }
+    const storybookUrl = getStorybookUrl();
+    if (!storybookUrl) {
+        logger.warn('Could not determine Storybook URL for runtime validation');
+        return { success: true, storyExists: true, details: 'Storybook URL not configured' };
+    }
+    const config = {
+        storybookUrl,
+        hmrWaitMs: 3000,
+        fetchTimeoutMs: 5000,
+        retryAttempts: 3,
+        retryDelayMs: 1000,
+        ...customConfig
+    };
+    // Extract the actual title from the story content, or use fallback
+    const extractedTitle = extractTitleFromStory(storyContent);
+    let storyIdPrefix;
+    if (extractedTitle) {
+        // Use the exact title from the generated code
+        storyIdPrefix = fullTitleToStoryIdPrefix(extractedTitle);
+        logger.debug(`Extracted title from story: "${extractedTitle}" -> prefix: "${storyIdPrefix}"`);
+    }
+    else {
+        // Fall back to constructing from the provided title
+        storyIdPrefix = titleToStoryIdPrefix(fallbackTitle, storyPrefix);
+        logger.debug(`Using fallback title: "${fallbackTitle}" -> prefix: "${storyIdPrefix}"`);
+    }
+    logger.info(`Runtime validation: checking stories with prefix "${storyIdPrefix}" at ${storybookUrl}`);
+    // Wait for HMR to process the new file
+    logger.debug(`Waiting ${config.hmrWaitMs}ms for HMR to process...`);
+    await sleep(config.hmrWaitMs);
+    // Step 1: Check if story appears in the index (with retries for HMR timing)
+    let matchingStoryId;
+    let lastIndexError;
+    for (let attempt = 1; attempt <= config.retryAttempts; attempt++) {
+        const indexResult = await checkStoryInIndex(storyIdPrefix, storybookUrl, config);
+        if (indexResult.exists && indexResult.matchingStoryId) {
+            matchingStoryId = indexResult.matchingStoryId;
+            logger.debug(`Found matching story: "${matchingStoryId}"`);
+            break;
+        }
+        lastIndexError = indexResult.error;
+        if (attempt < config.retryAttempts) {
+            logger.debug(`Story not found in index (attempt ${attempt}/${config.retryAttempts}), waiting...`);
+            await sleep(config.retryDelayMs);
+        }
+    }
+    if (!matchingStoryId) {
+        logger.warn(`Stories with prefix "${storyIdPrefix}" not found in Storybook index after ${config.retryAttempts} attempts`);
+        return {
+            success: false,
+            storyExists: false,
+            errorType: 'not_found',
+            renderError: lastIndexError || 'Story not found in Storybook index - HMR may not have processed the file',
+            details: `Story ID prefix: ${storyIdPrefix}`
+        };
+    }
+    // Step 2: Load the story iframe and check for runtime errors
+    const iframeResult = await checkStoryIframe(matchingStoryId, storybookUrl, config);
+    if (!iframeResult.success) {
+        logger.error(`Runtime error detected in story "${matchingStoryId}": ${iframeResult.error}`);
+        return {
+            success: false,
+            storyExists: true,
+            renderError: iframeResult.error,
+            errorType: iframeResult.errorType,
+            details: `Story ID: ${matchingStoryId}, URL: ${storybookUrl}/iframe.html?id=${matchingStoryId}`
+        };
+    }
+    logger.info(`Runtime validation passed for story "${matchingStoryId}"`);
+    return {
+        success: true,
+        storyExists: true
+    };
+}
+/**
+ * Format runtime validation errors for the self-healing prompt
+ */
+export function formatRuntimeErrorForHealing(result) {
+    if (result.success)
+        return '';
+    const parts = [];
+    parts.push(`RUNTIME ERROR: The generated story failed to load in Storybook.`);
+    if (result.renderError) {
+        parts.push(`Error: ${result.renderError}`);
+    }
+    if (result.errorType === 'module_error') {
+        parts.push(`This is a module/import error. Common causes:`);
+        parts.push(`- Invalid CSF (Component Story Format) structure`);
+        parts.push(`- Missing or malformed default export (meta)`);
+        parts.push(`- Story exports that conflict with Storybook internals`);
+        parts.push(`- Invalid import statements`);
+        parts.push(`\nEnsure the story follows this exact structure:`);
+        parts.push(`\`\`\`tsx`);
+        parts.push(`import type { Meta, StoryObj } from '@storybook/react';`);
+        parts.push(`import { Component } from '@design-system/core';`);
+        parts.push(``);
+        parts.push(`const meta: Meta<typeof Component> = {`);
+        parts.push(`  title: 'Generated/Story Title',`);
+        parts.push(`  component: Component,`);
+        parts.push(`};`);
+        parts.push(``);
+        parts.push(`export default meta;`);
+        parts.push(`type Story = StoryObj<typeof meta>;`);
+        parts.push(``);
+        parts.push(`export const Default: Story = {`);
+        parts.push(`  render: () => <Component />,`);
+        parts.push(`};`);
+        parts.push(`\`\`\``);
+    }
+    else if (result.errorType === 'render_error') {
+        parts.push(`This is a component render error. Common causes:`);
+        parts.push(`- Using undefined variables or components`);
+        parts.push(`- Invalid props passed to components`);
+        parts.push(`- Missing required props`);
+        parts.push(`- Incorrect component composition`);
+    }
+    else if (result.errorType === 'not_found') {
+        parts.push(`The story was not found in Storybook's index. This usually means:`);
+        parts.push(`- The file has syntax errors that prevent Storybook from parsing it`);
+        parts.push(`- The story title/path doesn't match expected format`);
+        parts.push(`- The default export is missing or invalid`);
+    }
+    if (result.details) {
+        parts.push(`\nDetails: ${result.details}`);
+    }
+    return parts.join('\n');
+}

package/dist/story-generator/selfHealingLoop.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Self-Healing Loop for Story Generation
+ *
+ * Provides LLM-assisted error correction when validation fails
+ * and auto-fix cannot repair the code.
+ *
+ * Design-system agnostic - uses discovered components from the user's project.
+ */
+import { ValidationResult } from './validateStory.js';
+import { ValidationError } from './storyValidator.js';
+/**
+ * Aggregated validation errors from all validation systems
+ */
+export interface ValidationErrors {
+    /** TypeScript AST syntax errors */
+    syntaxErrors: string[];
+    /** Forbidden pattern violations (e.g., UNSAFE_style) */
+    patternErrors: string[];
+    /** Invalid component import errors */
+    importErrors: string[];
+}
+/**
+ * Options for self-healing prompt generation
+ */
+export interface SelfHealingOptions {
+    /** Maximum retry attempts */
+    maxAttempts: number;
+    /** List of available component names from discovery */
+    availableComponents: string[];
+    /** Framework being used (react, vue, angular, etc.) */
+    framework: string;
+    /** Import path for the component library */
+    importPath: string;
+}
+/**
+ * Result of a self-healing attempt
+ */
+export interface SelfHealingResult {
+    /** Whether the code was successfully healed */
+    success: boolean;
+    /** The final code (healed or best attempt) */
+    code: string;
+    /** Number of attempts made */
+    attempts: number;
+    /** History of errors from each attempt */
+    errorHistory: ValidationErrors[];
+    /** Final remaining errors (if any) */
+    finalErrors: ValidationErrors;
+    /** Whether self-healing was actually used */
+    selfHealingUsed: boolean;
+}
+/**
+ * Metrics for generation response
+ */
+export interface GenerationMetrics {
+    attempts: number;
+    selfHealingUsed: boolean;
+    validationHistory: Array<{
+        attempt: number;
+        syntaxErrors: number;
+        patternErrors: number;
+        importErrors: number;
+        autoFixApplied: boolean;
+    }>;
+}
+/**
+ * Check if validation errors object is empty (no errors)
+ */
+export declare function hasNoErrors(errors: ValidationErrors): boolean;
+/**
+ * Get total error count
+ */
+export declare function getTotalErrorCount(errors: ValidationErrors): number;
+/**
+ * Create empty validation errors object
+ */
+export declare function createEmptyErrors(): ValidationErrors;
+/**
+ * Aggregate validation errors from different validation systems
+ */
+export declare function aggregateValidationErrors(astResult: ValidationResult | null, patternErrors: ValidationError[] | null, importErrors: string[] | null): ValidationErrors;
+/**
+ * Determine if we should continue retrying based on error history
+ */
+export declare function shouldContinueRetrying(attempts: number, maxAttempts: number, errorHistory: ValidationErrors[]): {
+    shouldRetry: boolean;
+    reason: string;
+};
+/**
+ * Build the self-healing prompt to send to the LLM
+ * Design-system agnostic - uses discovered components
+ */
+export declare function buildSelfHealingPrompt(originalCode: string, errors: ValidationErrors, attempt: number, options: SelfHealingOptions): string;
+/**
+ * Format errors for logging
+ */
+export declare function formatErrorsForLog(errors: ValidationErrors): string;
+/**
+ * Create generation metrics from error history
+ */
+export declare function createGenerationMetrics(attempts: number, errorHistory: ValidationErrors[], autoFixApplied: boolean[]): GenerationMetrics;
+/**
+ * Select the best code from multiple attempts based on error count
+ */
+export declare function selectBestAttempt(attempts: Array<{
+    code: string;
+    errors: ValidationErrors;
+}>): {
+    code: string;
+    errors: ValidationErrors;
+} | null;
+//# sourceMappingURL=selfHealingLoop.d.ts.map

package/dist/story-generator/selfHealingLoop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selfHealingLoop.d.ts","sourceRoot":"","sources":["../../story-generator/selfHealingLoop.ts"],"names":[],"mappings":"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"}

package/dist/story-generator/selfHealingLoop.js

@@ -0,0 +1,202 @@
+/**
+ * Self-Healing Loop for Story Generation
+ *
+ * Provides LLM-assisted error correction when validation fails
+ * and auto-fix cannot repair the code.
+ *
+ * Design-system agnostic - uses discovered components from the user's project.
+ */
+/**
+ * Check if validation errors object is empty (no errors)
+ */
+export function hasNoErrors(errors) {
+    return (errors.syntaxErrors.length === 0 &&
+        errors.patternErrors.length === 0 &&
+        errors.importErrors.length === 0);
+}
+/**
+ * Get total error count
+ */
+export function getTotalErrorCount(errors) {
+    return (errors.syntaxErrors.length +
+        errors.patternErrors.length +
+        errors.importErrors.length);
+}
+/**
+ * Create empty validation errors object
+ */
+export function createEmptyErrors() {
+    return {
+        syntaxErrors: [],
+        patternErrors: [],
+        importErrors: [],
+    };
+}
+/**
+ * Aggregate validation errors from different validation systems
+ */
+export function aggregateValidationErrors(astResult, patternErrors, importErrors) {
+    const errors = createEmptyErrors();
+    // Add AST validation errors
+    if (astResult && !astResult.isValid) {
+        errors.syntaxErrors = [...astResult.errors];
+    }
+    // Add pattern validation errors
+    if (patternErrors && patternErrors.length > 0) {
+        errors.patternErrors = patternErrors.map((e) => `Line ${e.line}: ${e.message}`);
+    }
+    // Add import validation errors
+    if (importErrors && importErrors.length > 0) {
+        errors.importErrors = [...importErrors];
+    }
+    return errors;
+}
+/**
+ * Determine if we should continue retrying based on error history
+ */
+export function shouldContinueRetrying(attempts, maxAttempts, errorHistory) {
+    // Don't exceed max attempts
+    if (attempts >= maxAttempts) {
+        return { shouldRetry: false, reason: 'Maximum retry attempts reached' };
+    }
+    // If we have at least 2 attempts, check if errors are repeating
+    if (errorHistory.length >= 2) {
+        const currentErrors = errorHistory[errorHistory.length - 1];
+        const previousErrors = errorHistory[errorHistory.length - 2];
+        // Convert to sets for comparison
+        const currentSet = new Set([
+            ...currentErrors.syntaxErrors,
+            ...currentErrors.patternErrors,
+            ...currentErrors.importErrors,
+        ]);
+        const previousSet = new Set([
+            ...previousErrors.syntaxErrors,
+            ...previousErrors.patternErrors,
+            ...previousErrors.importErrors,
+        ]);
+        // Check if same errors are repeating (LLM is stuck)
+        if (currentSet.size === previousSet.size) {
+            let allSame = true;
+            for (const error of currentSet) {
+                if (!previousSet.has(error)) {
+                    allSame = false;
+                    break;
+                }
+            }
+            if (allSame && currentSet.size > 0) {
+                return {
+                    shouldRetry: false,
+                    reason: 'Same errors repeating - LLM appears stuck',
+                };
+            }
+        }
+    }
+    return { shouldRetry: true, reason: '' };
+}
+/**
+ * Build the self-healing prompt to send to the LLM
+ * Design-system agnostic - uses discovered components
+ */
+export function buildSelfHealingPrompt(originalCode, errors, attempt, options) {
+    const sections = [];
+    sections.push(`## CODE CORRECTION REQUIRED (Attempt ${attempt} of ${options.maxAttempts})`);
+    sections.push('');
+    sections.push('Your previous code contained errors. Please fix them while preserving the original intent.');
+    sections.push('');
+    // Syntax errors section
+    if (errors.syntaxErrors.length > 0) {
+        sections.push('### TypeScript Syntax Errors');
+        sections.push('These prevent the code from compiling:');
+        errors.syntaxErrors.forEach((e) => sections.push(`- ${e}`));
+        sections.push('');
+    }
+    // Pattern errors section
+    if (errors.patternErrors.length > 0) {
+        sections.push('### Forbidden Patterns');
+        sections.push('These patterns are not allowed in this codebase:');
+        errors.patternErrors.forEach((e) => sections.push(`- ${e}`));
+        sections.push('');
+    }
+    // Import errors section
+    if (errors.importErrors.length > 0) {
+        sections.push('### Import Errors');
+        sections.push(`These components do not exist in "${options.importPath}":`);
+        errors.importErrors.forEach((e) => sections.push(`- ${e}`));
+        sections.push('');
+        // Show available components (design-system agnostic)
+        if (options.availableComponents.length > 0) {
+            sections.push('**Available components include:**');
+            const displayComponents = options.availableComponents.slice(0, 20);
+            sections.push(displayComponents.join(', '));
+            if (options.availableComponents.length > 20) {
+                sections.push(`... and ${options.availableComponents.length - 20} more`);
+            }
+            sections.push('');
+        }
+    }
+    // Original code section
+    sections.push('### Original Code (with errors)');
+    sections.push('```tsx');
+    sections.push(originalCode);
+    sections.push('```');
+    sections.push('');
+    // Correction instructions
+    sections.push('### Correction Instructions');
+    sections.push('1. Fix ALL errors listed above');
+    sections.push('2. Keep the same component structure and layout');
+    sections.push('3. Do NOT add new features - only fix the errors');
+    sections.push('4. Ensure all JSX elements are properly opened and closed');
+    sections.push(`5. Only import components that exist in "${options.importPath}"`);
+    sections.push('6. Return the COMPLETE corrected code in a ```tsx code block');
+    sections.push('7. Do NOT include any explanation - just the corrected code block');
+    return sections.join('\n');
+}
+/**
+ * Format errors for logging
+ */
+export function formatErrorsForLog(errors) {
+    const parts = [];
+    if (errors.syntaxErrors.length > 0) {
+        parts.push(`Syntax(${errors.syntaxErrors.length})`);
+    }
+    if (errors.patternErrors.length > 0) {
+        parts.push(`Pattern(${errors.patternErrors.length})`);
+    }
+    if (errors.importErrors.length > 0) {
+        parts.push(`Import(${errors.importErrors.length})`);
+    }
+    return parts.length > 0 ? parts.join(', ') : 'None';
+}
+/**
+ * Create generation metrics from error history
+ */
+export function createGenerationMetrics(attempts, errorHistory, autoFixApplied) {
+    return {
+        attempts,
+        selfHealingUsed: attempts > 1,
+        validationHistory: errorHistory.map((errors, index) => ({
+            attempt: index + 1,
+            syntaxErrors: errors.syntaxErrors.length,
+            patternErrors: errors.patternErrors.length,
+            importErrors: errors.importErrors.length,
+            autoFixApplied: autoFixApplied[index] || false,
+        })),
+    };
+}
+/**
+ * Select the best code from multiple attempts based on error count
+ */
+export function selectBestAttempt(attempts) {
+    if (attempts.length === 0)
+        return null;
+    let best = attempts[0];
+    let bestErrorCount = getTotalErrorCount(best.errors);
+    for (const attempt of attempts) {
+        const errorCount = getTotalErrorCount(attempt.errors);
+        if (errorCount < bestErrorCount) {
+            best = attempt;
+            bestErrorCount = errorCount;
+        }
+    }
+    return best;
+}

package/dist/story-generator/validateStory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validateStory.d.ts","sourceRoot":"","sources":["../../story-generator/validateStory.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAoB,EAAE,MAAM,CAAC,EAAE,GAAG,GAAG,gBAAgB,CAgG9G;AAoYD;;GAEG;AACH,wBAAgB,2BAA2B,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,GAAG,GAAG,gBAAgB,CAqC9F;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,GAAG,MAAM,CA+BvE"}
+{"version":3,"file":"validateStory.d.ts","sourceRoot":"","sources":["../../story-generator/validateStory.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAoB,EAAE,MAAM,CAAC,EAAE,GAAG,GAAG,gBAAgB,CA+G9G;AAqcD;;GAEG;AACH,wBAAgB,2BAA2B,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,GAAG,GAAG,gBAAgB,CAqC9F;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,GAAG,MAAM,CA+BvE"}