@houtini/lm 1.0.0

package/dist/prompts/generate/wordpress-theme-from-static.js

@@ -0,0 +1,695 @@
+/**
+ * WordPress Theme from Static Site Generator - Modern v4.3 Universal Template
+ *
+ * Converts static HTML/CSS/JS sites into fully functional WordPress themes
+ * Supports both URL analysis and local file directory conversion
+ * Intelligently handles multiple pages to understand site structure and styling
+ */
+import { BasePlugin } from '../../plugins/base-plugin.js';
+import { ThreeStagePromptManager } from '../../core/ThreeStagePromptManager.js';
+import { withSecurity } from '../../security/integration-helpers.js';
+import { readFileContent } from '../shared/helpers.js';
+import { ModelSetup, ResponseProcessor, ParameterValidator, ErrorHandler, MultiFileAnalysis } from '../../utils/plugin-utilities.js';
+import { getAnalysisCache } from '../../cache/index.js';
+// Common Node.js modules - Use these instead of require()
+import { basename, extname, relative } from 'path';
+export class WordPressThemeFromStaticGenerator extends BasePlugin {
+    constructor() {
+        super();
+        this.name = 'wordpress_theme_from_static';
+        this.category = 'generate';
+        this.description = 'Convert static HTML/CSS/JS sites into fully functional WordPress themes with smart template detection';
+        // Universal parameter set - supports both single and multi-file scenarios
+        this.parameters = {
+            // Static site source parameters
+            urls: {
+                type: 'array',
+                description: 'Array of URLs to analyze for theme conversion (e.g., home, blog, about pages)',
+                required: false,
+                items: { type: 'string' }
+            },
+            url: {
+                type: 'string',
+                description: 'Single URL to analyze for theme conversion',
+                required: false
+            },
+            // WordPress theme parameters
+            themeName: {
+                type: 'string',
+                description: 'WordPress theme name',
+                required: false,
+                default: 'Custom Static Theme'
+            },
+            themeDescription: {
+                type: 'string',
+                description: 'Theme description',
+                required: false,
+                default: 'WordPress theme generated from static site'
+            },
+            themeAuthor: {
+                type: 'string',
+                description: 'Theme author name',
+                required: false,
+                default: 'Theme Generator'
+            },
+            themeVersion: {
+                type: 'string',
+                description: 'Theme version',
+                required: false,
+                default: '1.0.0'
+            },
+            // Template compatibility parameters
+            code: {
+                type: 'string',
+                description: 'HTML content to convert (for single-file analysis)',
+                required: false
+            },
+            filePath: {
+                type: 'string',
+                description: 'Path to HTML file to convert',
+                required: false
+            },
+            projectPath: {
+                type: 'string',
+                description: 'Path to static site directory (for multi-file analysis)',
+                required: false
+            },
+            files: {
+                type: 'array',
+                description: 'Array of specific static site files to analyze',
+                required: false,
+                items: { type: 'string' }
+            },
+            maxDepth: {
+                type: 'number',
+                description: 'Maximum directory depth for static site discovery (1-5)',
+                required: false,
+                default: 3
+            },
+            // Theme generation options
+            includeGutenberg: {
+                type: 'boolean',
+                description: 'Include Gutenberg block support',
+                required: false,
+                default: true
+            },
+            includeWooCommerce: {
+                type: 'boolean',
+                description: 'Include WooCommerce template support',
+                required: false,
+                default: false
+            },
+            includeCustomizer: {
+                type: 'boolean',
+                description: 'Include WordPress Customizer options',
+                required: false,
+                default: true
+            },
+            includeMenus: {
+                type: 'boolean',
+                description: 'Include dynamic WordPress menus',
+                required: false,
+                default: true
+            },
+            includeSidebars: {
+                type: 'boolean',
+                description: 'Include WordPress sidebar/widget areas',
+                required: false,
+                default: true
+            },
+            // Universal parameters
+            language: {
+                type: 'string',
+                description: 'Primary language (HTML/PHP for WordPress themes)',
+                required: false,
+                default: 'html'
+            },
+            analysisDepth: {
+                type: 'string',
+                description: 'Level of analysis detail for theme conversion',
+                enum: ['basic', 'detailed', 'comprehensive'],
+                default: 'comprehensive',
+                required: false
+            },
+            analysisType: {
+                type: 'string',
+                description: 'Type of theme conversion to perform',
+                enum: ['simple', 'responsive', 'comprehensive'],
+                default: 'comprehensive',
+                required: false
+            }
+        };
+        this.analysisCache = getAnalysisCache();
+        this.multiFileAnalysis = new MultiFileAnalysis();
+        // Cache and analysis utilities are initialized above
+    }
+    async execute(params, llmClient) {
+        return await withSecurity(this, params, llmClient, async (secureParams) => {
+            try {
+                // 1. Auto-detect analysis mode based on parameters
+                const analysisMode = this.detectAnalysisMode(secureParams);
+                // 2. Validate parameters based on detected mode
+                this.validateParameters(secureParams, analysisMode);
+                // 3. Setup model
+                const { model, contextLength } = await ModelSetup.getReadyModel(llmClient);
+                // 4. Route to appropriate analysis method
+                if (analysisMode === 'single-file') {
+                    return await this.executeSingleFileAnalysis(secureParams, model, contextLength);
+                }
+                else {
+                    return await this.executeMultiFileAnalysis(secureParams, model, contextLength);
+                }
+            }
+            catch (error) {
+                return ErrorHandler.createExecutionError('wordpress_theme_from_static', error);
+            }
+        });
+    }
+    /**
+     * Auto-detect whether this is single-page or multi-page/directory conversion
+     */
+    detectAnalysisMode(params) {
+        // Single-file indicators: single URL, HTML content, or single file path
+        if (params.url || params.code || params.filePath) {
+            return 'single-file';
+        }
+        // Multi-file indicators: multiple URLs, directory paths, or file arrays
+        if (params.urls && params.urls.length > 1) {
+            return 'multi-file';
+        }
+        if (params.projectPath || params.files) {
+            return 'multi-file';
+        }
+        // Default to single-file for simple conversions
+        return 'single-file';
+    }
+    /**
+     * Validate parameters based on detected analysis mode
+     */
+    validateParameters(params, mode) {
+        if (mode === 'single-file') {
+            // Validate single source input
+            if (!params.url && !params.code && !params.filePath && (!params.urls || params.urls.length === 0)) {
+                throw new Error('For theme conversion: url, urls, code, or filePath is required');
+            }
+        }
+        else {
+            // Validate multi-source input
+            if (params.projectPath) {
+                ParameterValidator.validateProjectPath(params);
+                ParameterValidator.validateDepth(params);
+            }
+            else if (!params.urls || params.urls.length === 0) {
+                throw new Error('For multi-file conversion: urls array or projectPath is required');
+            }
+        }
+        // Universal validations
+        ParameterValidator.validateEnum(params, 'analysisType', ['simple', 'responsive', 'comprehensive']);
+        ParameterValidator.validateEnum(params, 'analysisDepth', ['basic', 'detailed', 'comprehensive']);
+    }
+    /**
+     * Execute single-file analysis (single page/URL conversion)
+     */
+    async executeSingleFileAnalysis(params, model, contextLength) {
+        // Process single source input
+        let contentToAnalyze = params.code;
+        let sourceUrl = params.url;
+        if (params.filePath) {
+            contentToAnalyze = await readFileContent(params.filePath);
+        }
+        else if (params.urls && params.urls.length === 1) {
+            sourceUrl = params.urls[0];
+        }
+        // Generate prompt stages for single source conversion
+        const promptStages = this.getSingleFilePromptStages({
+            ...params,
+            content: contentToAnalyze,
+            sourceUrl
+        });
+        // Execute with appropriate method
+        const promptManager = new ThreeStagePromptManager(contextLength);
+        const needsChunking = promptManager.needsChunking(promptStages);
+        if (needsChunking) {
+            const conversation = promptManager.createChunkedConversation(promptStages);
+            const messages = [
+                conversation.systemMessage,
+                ...conversation.dataMessages,
+                conversation.analysisMessage
+            ];
+            return await ResponseProcessor.executeChunked(messages, model, contextLength, 'wordpress_theme_from_static', 'single');
+        }
+        else {
+            return await ResponseProcessor.executeDirect(promptStages, model, contextLength, 'wordpress_theme_from_static');
+        }
+    }
+    /**
+     * Execute multi-file analysis (multiple pages/URLs or directory conversion)
+     */
+    async executeMultiFileAnalysis(params, model, contextLength) {
+        let analysisResult;
+        if (params.projectPath) {
+            // Directory-based conversion
+            const filesToAnalyze = await this.discoverRelevantFiles(params.projectPath, params.maxDepth, params.analysisType);
+            analysisResult = await this.performMultiFileAnalysis(filesToAnalyze, params, model, contextLength);
+        }
+        else if (params.urls) {
+            // URL-based conversion
+            analysisResult = await this.performMultiUrlAnalysis(params.urls, params, model, contextLength);
+        }
+        // Generate prompt stages for multi-source conversion
+        const promptStages = this.getMultiFilePromptStages({
+            ...params,
+            analysisResult,
+            sourceCount: params.urls?.length || analysisResult?.findings?.length || 0
+        });
+        // Always use chunking for multi-file
+        const promptManager = new ThreeStagePromptManager(contextLength);
+        const conversation = promptManager.createChunkedConversation(promptStages);
+        const messages = [
+            conversation.systemMessage,
+            ...conversation.dataMessages,
+            conversation.analysisMessage
+        ];
+        return await ResponseProcessor.executeChunked(messages, model, contextLength, 'wordpress_theme_from_static', 'multifile');
+    }
+    /**
+     * Single-file prompt stages - Single page/URL to WordPress theme conversion
+     */
+    getSingleFilePromptStages(params) {
+        const { content, sourceUrl, analysisDepth, analysisType, themeName, themeDescription } = params;
+        const systemAndContext = `You are an expert WordPress theme developer specializing in converting static sites to ${analysisDepth} ${analysisType} WordPress themes.
+
+WordPress Theme Development Expertise:
+- Static to Dynamic Conversion: Transform HTML/CSS/JS into PHP template hierarchy
+- WordPress Standards: Follow WordPress Theme Review Guidelines and coding standards
+- Template Hierarchy: Master WordPress template hierarchy (index, home, single, page, archive, etc.)
+- Dynamic Content Integration: Replace static content with WordPress functions and loops
+- Responsive Design: Maintain original responsiveness while adding WordPress functionality
+- Performance Optimization: Enqueue scripts/styles properly, optimize images, minimize HTTP requests
+- Accessibility: Maintain WCAG compliance throughout conversion process
+- Cross-browser Compatibility: Ensure theme works across all major browsers
+- SEO Best Practices: Implement proper meta tags, structured data, and SEO-friendly markup
+
+Conversion Context:
+- Analysis Depth: ${analysisDepth}
+- Theme Complexity: ${analysisType}
+- Source Type: ${sourceUrl ? 'URL-based conversion' : 'File-based conversion'}
+- WordPress Features: Gutenberg ${params.includeGutenberg ? 'enabled' : 'disabled'}, WooCommerce ${params.includeWooCommerce ? 'enabled' : 'disabled'}
+
+Your task is to create a complete, professional WordPress theme that preserves the original design while adding full WordPress functionality.`;
+        const dataPayload = `Static Site Conversion Requirements:
+
+**Theme Details:**
+- Theme Name: ${themeName || 'Custom Static Theme'}
+- Description: ${themeDescription || 'WordPress theme generated from static site'}
+- Author: ${params.themeAuthor || 'Theme Generator'}
+- Version: ${params.themeVersion || '1.0.0'}
+${sourceUrl ? `- Source URL: ${sourceUrl}` : ''}
+
+**WordPress Features to Include:**
+- Gutenberg Block Editor Support: ${params.includeGutenberg !== false}
+- WooCommerce Template Support: ${params.includeWooCommerce || false}
+- WordPress Customizer Integration: ${params.includeCustomizer !== false}
+- Dynamic Navigation Menus: ${params.includeMenus !== false}
+- Sidebar/Widget Areas: ${params.includeSidebars !== false}
+
+**Static Site Content to Convert:**
+${content ? `
+HTML Content:
+\`\`\`html
+${content}
+\`\`\`
+` : `
+Source URL: ${sourceUrl}
+Note: Analyze the provided URL to understand the site structure, design patterns, and styling approach.
+`}
+
+**Conversion Requirements:**
+- Preserve exact visual design and layout
+- Maintain responsive behavior and animations
+- Convert static navigation to WordPress menus
+- Transform static content areas into dynamic WordPress content
+- Implement proper WordPress template hierarchy
+- Add WordPress admin customization options`;
+        const outputInstructions = `Generate a complete WordPress theme structure that perfectly replicates the static site design:
+
+## Required WordPress Theme Structure:
+
+### 1. Theme Root Files
+- **style.css**: Main stylesheet with proper WordPress theme header
+- **index.php**: Default template with WordPress loop
+- **functions.php**: Theme functions, enqueues, and WordPress feature support
+- **screenshot.png**: Theme screenshot (1200x900px description)
+
+### 2. Template Hierarchy Files
+Based on detected page types, include relevant templates:
+- **home.php** / **front-page.php**: Homepage template
+- **single.php**: Single post template
+- **page.php**: Static page template
+- **archive.php**: Archive pages template
+- **search.php**: Search results template
+- **404.php**: Error page template
+- **header.php**: Header template with WordPress head functions
+- **footer.php**: Footer template with WordPress footer functions
+- **sidebar.php**: Sidebar with widget areas (if applicable)
+
+### 3. Asset Management
+- **js/**: JavaScript files with proper WordPress enqueuing
+- **css/**: Additional stylesheets organized by purpose
+- **images/**: Theme images and assets
+- **fonts/**: Custom fonts (if used)
+
+### 4. WordPress Integration Features
+- **Template Parts**: Modular template components
+- **Custom Post Types**: If needed for content structure
+- **Customizer Options**: Theme customization panel
+- **Widget Areas**: Dynamic sidebar/footer widget areas
+- **Navigation Menus**: Dynamic menu locations
+
+${params.includeGutenberg ? `
+### 5. Gutenberg Block Support
+- **blocks/**: Custom block styles and templates
+- **theme.json**: Global theme settings for block editor
+- **Block patterns**: Custom block patterns matching original design
+` : ''}
+
+${params.includeWooCommerce ? `
+### 6. WooCommerce Integration
+- **woocommerce/**: WooCommerce template overrides
+- **WooCommerce styling**: Product page styling matching theme design
+- **Cart/checkout**: Styled cart and checkout pages
+` : ''}
+
+## WordPress Standards Implementation:
+
+### Theme Header Requirements (style.css):
+\`\`\`css
+/*
+Theme Name: ${themeName || 'Custom Static Theme'}
+Description: ${themeDescription || 'WordPress theme generated from static site'}
+Author: ${params.themeAuthor || 'Theme Generator'}
+Version: ${params.themeVersion || '1.0.0'}
+Requires at least: 6.0
+Tested up to: 6.4
+Requires PHP: 7.4
+License: GPL v2 or later
+Text Domain: [theme-slug]
+Tags: responsive, custom-design, static-conversion
+*/
+\`\`\`
+
+### Functions.php Requirements:
+- Proper theme setup with add_theme_support()
+- Script/style enqueuing with wp_enqueue_script/style()
+- Navigation menu registration
+- Widget area registration
+- Custom post type registration (if needed)
+- Theme customizer options
+- Gutenberg block support (if enabled)
+
+### Template Requirements:
+- WordPress head/footer functions: wp_head(), wp_footer()
+- Proper WordPress loops with get_template_part()
+- Conditional template loading
+- Escape all output: esc_html(), esc_url(), esc_attr()
+- Internationalization: __(), _e(), _x() functions
+- WordPress body classes: body_class()
+
+### Performance & SEO:
+- Optimized CSS/JS loading
+- Proper image handling with wp_get_attachment_image()
+- Meta tags and structured data
+- Page speed optimization
+- Mobile-first responsive design
+
+Provide complete, production-ready WordPress theme files that exactly replicate the original static site design while adding full WordPress functionality. Include detailed setup instructions and customization documentation.`;
+        return { systemAndContext, dataPayload, outputInstructions };
+    }
+    /**
+     * Multi-file prompt stages - Multiple pages/URLs or directory conversion
+     */
+    getMultiFilePromptStages(params) {
+        const { analysisResult, analysisType, analysisDepth, sourceCount } = params;
+        const systemAndContext = `You are an expert WordPress theme architect specializing in ${analysisDepth} ${analysisType} static site to WordPress conversions.
+
+Multi-Source WordPress Theme Conversion Context:
+- Analysis Type: ${analysisType}
+- Analysis Depth: ${analysisDepth}  
+- Sources Analyzed: ${sourceCount}
+- Mode: Multi-Page/Multi-File WordPress Theme Generation
+
+Your task is to create a comprehensive WordPress theme that unifies multiple pages/sections while maintaining design consistency and adding full WordPress functionality.`;
+        const dataPayload = `Multi-source static site analysis results:
+
+${JSON.stringify(analysisResult, null, 2)}`;
+        const outputInstructions = `Generate a comprehensive WordPress theme from multiple static sources:
+
+## Multi-Source Theme Architecture:
+
+### 1. Unified Design System Analysis
+- **Design Patterns**: Common elements across all analyzed sources
+- **Color Schemes**: Consistent color palette extraction
+- **Typography**: Font families and sizing scales used
+- **Layout Grids**: Responsive grid systems identified
+- **Component Library**: Reusable UI components found
+
+### 2. Template Hierarchy Strategy
+Based on analyzed sources, create appropriate templates:
+- **Page Templates**: Custom templates for different page types found
+- **Content Variations**: Handle different content structures
+- **Layout Variations**: Multiple layout options for different sections
+- **Component Templates**: Reusable template parts
+
+### 3. WordPress Theme Structure
+Generate complete theme with:
+- **Unified style.css**: Combining all CSS while maintaining organization
+- **Template files**: Appropriate templates for all page types discovered
+- **functions.php**: Comprehensive theme setup with all required features
+- **Asset organization**: Properly structured JS/CSS/image assets
+
+### 4. Multi-Source Integration Features
+- **Content Type Detection**: Identify different content structures across sources
+- **Navigation Synthesis**: Combine navigation patterns into cohesive menu system
+- **Widget Area Strategy**: Determine optimal sidebar/widget placements
+- **Customizer Options**: Theme options covering variations found in sources
+
+### 5. Cross-Page Consistency
+- **Design System**: Unified component system across all templates
+- **Performance**: Optimized asset loading for multi-template theme
+- **Accessibility**: Consistent accessibility implementation across all templates
+- **Responsive Behavior**: Unified responsive design strategy
+
+## Multi-Source Conversion Output:
+
+{
+  "themeOverview": {
+    "detectedPageTypes": ["list of page types found"],
+    "commonDesignElements": ["shared design patterns"],
+    "uniqueFeatures": ["special features requiring custom implementation"],
+    "recommendedTemplates": ["WordPress templates to create"]
+  },
+  "unifiedDesignSystem": {
+    "colorPalette": ["primary colors extracted"],
+    "typography": ["font systems identified"],
+    "componentLibrary": ["reusable components found"],
+    "layoutSystems": ["grid and layout patterns"]
+  },
+  "themeFiles": [
+    {
+      "filename": "style.css",
+      "purpose": "Main stylesheet with unified design system",
+      "content": "Complete CSS code"
+    },
+    {
+      "filename": "index.php", 
+      "purpose": "Default template with WordPress loop",
+      "content": "Complete PHP template code"
+    }
+    // ... additional theme files
+  ],
+  "implementationGuide": {
+    "setupInstructions": ["step-by-step theme setup"],
+    "customizationOptions": ["available theme customizer options"],
+    "maintenanceNotes": ["ongoing maintenance considerations"]
+  }
+}
+
+Provide a complete, unified WordPress theme that successfully combines all analyzed sources into a cohesive, professional theme with full WordPress functionality.`;
+        return { systemAndContext, dataPayload, outputInstructions };
+    }
+    /**
+     * Backwards compatibility method
+     */
+    getPromptStages(params) {
+        const mode = this.detectAnalysisMode(params);
+        if (mode === 'single-file') {
+            return this.getSingleFilePromptStages(params);
+        }
+        else {
+            return this.getMultiFilePromptStages(params);
+        }
+    }
+    // Multi-file helper methods
+    async discoverRelevantFiles(projectPath, maxDepth, analysisType) {
+        const extensions = this.getFileExtensions(analysisType);
+        return await this.multiFileAnalysis.discoverFiles(projectPath, extensions, maxDepth);
+    }
+    async performMultiFileAnalysis(files, params, model, contextLength) {
+        const cacheKey = this.analysisCache.generateKey('wordpress_theme_from_static', params, files);
+        const cached = await this.analysisCache.get(cacheKey);
+        if (cached)
+            return cached;
+        const fileAnalysisResults = await this.multiFileAnalysis.analyzeBatch(files, (file) => this.analyzeIndividualFile(file, params, model), contextLength);
+        // Aggregate results into theme-specific analysis format
+        const aggregatedResult = {
+            summary: `Static site directory analysis of ${files.length} files`,
+            findings: fileAnalysisResults,
+            data: {
+                fileCount: files.length,
+                totalSize: fileAnalysisResults.reduce((sum, result) => sum + (result.size || 0), 0),
+                htmlFiles: fileAnalysisResults.filter(f => f.extension === '.html').length,
+                cssFiles: fileAnalysisResults.filter(f => f.extension === '.css').length,
+                jsFiles: fileAnalysisResults.filter(f => f.extension === '.js').length,
+                imageFiles: fileAnalysisResults.filter(f => ['.jpg', '.jpeg', '.png', '.gif', '.svg', '.webp'].includes(f.extension)).length,
+                designPatterns: this.extractDesignPatterns(fileAnalysisResults),
+                pageTypes: this.identifyPageTypes(fileAnalysisResults)
+            }
+        };
+        await this.analysisCache.cacheAnalysis(cacheKey, aggregatedResult, {
+            modelUsed: model.identifier || 'unknown',
+            executionTime: Date.now() - Date.now(),
+            timestamp: new Date().toISOString()
+        });
+        return aggregatedResult;
+    }
+    async performMultiUrlAnalysis(urls, params, model, contextLength) {
+        // For URL analysis, we'll create a structured analysis result
+        // Note: Actual URL fetching would require additional implementation
+        const analysisResult = {
+            summary: `Multi-URL static site analysis of ${urls.length} pages`,
+            findings: urls.map(url => ({
+                url,
+                pageType: this.guessPageTypeFromUrl(url),
+                analysisNote: `URL analysis - would require fetch implementation for actual content`
+            })),
+            data: {
+                urlCount: urls.length,
+                estimatedPageTypes: urls.map(url => this.guessPageTypeFromUrl(url)),
+                conversionComplexity: urls.length > 5 ? 'high' : urls.length > 2 ? 'medium' : 'low'
+            }
+        };
+        return analysisResult;
+    }
+    async analyzeIndividualFile(file, params, model) {
+        const content = await import('fs/promises').then(fs => fs.readFile(file, 'utf-8'));
+        const stats = await import('fs/promises').then(fs => fs.stat(file));
+        // Static site specific analysis
+        const isHtmlFile = extname(file).toLowerCase() === '.html';
+        const isCssFile = extname(file).toLowerCase() === '.css';
+        const isJsFile = extname(file).toLowerCase() === '.js';
+        let pageType = 'unknown';
+        if (isHtmlFile) {
+            pageType = this.identifyHtmlPageType(basename(file), content);
+        }
+        return {
+            filePath: file,
+            fileName: basename(file),
+            size: content.length,
+            lines: content.split('\n').length,
+            extension: extname(file),
+            relativePath: relative(params.projectPath || '', file),
+            isHtmlFile,
+            isCssFile,
+            isJsFile,
+            pageType,
+            hasBootstrap: content.includes('bootstrap'),
+            hasJQuery: content.includes('jquery'),
+            hasResponsiveDesign: content.includes('@media'),
+            hasCustomFonts: content.includes('@font-face') || content.includes('googleapis.com/css')
+        };
+    }
+    identifyHtmlPageType(filename, content) {
+        const lowerName = filename.toLowerCase();
+        const lowerContent = content.toLowerCase();
+        if (lowerName.includes('index') || lowerName.includes('home'))
+            return 'homepage';
+        if (lowerName.includes('about'))
+            return 'about-page';
+        if (lowerName.includes('contact'))
+            return 'contact-page';
+        if (lowerName.includes('blog'))
+            return 'blog-page';
+        if (lowerName.includes('service'))
+            return 'services-page';
+        if (lowerName.includes('portfolio') || lowerName.includes('work'))
+            return 'portfolio-page';
+        if (lowerName.includes('product'))
+            return 'product-page';
+        if (lowerName.includes('news'))
+            return 'news-page';
+        // Content-based detection
+        if (lowerContent.includes('blog') && lowerContent.includes('post'))
+            return 'blog-page';
+        if (lowerContent.includes('contact') && lowerContent.includes('form'))
+            return 'contact-page';
+        if (lowerContent.includes('portfolio') || lowerContent.includes('gallery'))
+            return 'portfolio-page';
+        return 'content-page';
+    }
+    guessPageTypeFromUrl(url) {
+        const lowerUrl = url.toLowerCase();
+        if (lowerUrl.includes('/blog') || lowerUrl.includes('/news'))
+            return 'blog-page';
+        if (lowerUrl.includes('/about'))
+            return 'about-page';
+        if (lowerUrl.includes('/contact'))
+            return 'contact-page';
+        if (lowerUrl.includes('/services'))
+            return 'services-page';
+        if (lowerUrl.includes('/portfolio') || lowerUrl.includes('/work'))
+            return 'portfolio-page';
+        if (lowerUrl.includes('/products'))
+            return 'product-page';
+        if (lowerUrl.endsWith('/') || lowerUrl.includes('index'))
+            return 'homepage';
+        return 'content-page';
+    }
+    extractDesignPatterns(results) {
+        const patterns = {
+            hasBootstrap: results.some(f => f.hasBootstrap),
+            hasJQuery: results.some(f => f.hasJQuery),
+            hasResponsiveDesign: results.some(f => f.hasResponsiveDesign),
+            hasCustomFonts: results.some(f => f.hasCustomFonts),
+            commonFrameworks: []
+        };
+        if (patterns.hasBootstrap)
+            patterns.commonFrameworks.push('Bootstrap');
+        if (patterns.hasJQuery)
+            patterns.commonFrameworks.push('jQuery');
+        return patterns;
+    }
+    identifyPageTypes(results) {
+        const pageTypes = new Set();
+        results.forEach(result => {
+            if (result.pageType && result.pageType !== 'unknown') {
+                pageTypes.add(result.pageType);
+            }
+        });
+        return Array.from(pageTypes);
+    }
+    getFileExtensions(analysisType) {
+        const extensionMap = {
+            'simple': ['.html', '.css', '.js'],
+            'responsive': ['.html', '.css', '.js', '.scss', '.sass', '.less'],
+            'comprehensive': ['.html', '.htm', '.css', '.js', '.scss', '.sass', '.less', '.json', '.xml', '.svg', '.jpg', '.jpeg', '.png', '.gif', '.webp', '.woff', '.woff2', '.ttf', '.eot']
+        };
+        return extensionMap[analysisType] || extensionMap.comprehensive;
+    }
+    generateCacheKey(files, params) {
+        const fileHash = files.join('|');
+        const paramHash = JSON.stringify(params);
+        return `${fileHash}_${paramHash}`.substring(0, 64);
+    }
+}
+export default WordPressThemeFromStaticGenerator;
+//# sourceMappingURL=wordpress-theme-from-static.js.map