@houtini/lm 1.0.0

package/dist/prompts/generate/wordpress-plugin.js

@@ -0,0 +1,763 @@
+/**
+ * WordPress Plugin Generator - Modern v4.3 Universal Template
+ *
+ * Generates complete WordPress plugin structures with all necessary files and best practices
+ * Intelligently handles plugin requirements and generates production-ready code
+ */
+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 WordPressPluginGenerator extends BasePlugin {
+    constructor() {
+        super();
+        this.name = 'generate_wordpress_plugin';
+        this.category = 'generate';
+        this.description = 'Generate a complete WordPress plugin structure with all necessary files and best practices';
+        // Universal parameter set - supports both single and multi-file scenarios
+        this.parameters = {
+            // WordPress plugin specific parameters
+            name: {
+                type: 'string',
+                description: 'Plugin name',
+                required: true
+            },
+            description: {
+                type: 'string',
+                description: 'Plugin description',
+                required: true
+            },
+            features: {
+                type: 'array',
+                description: 'List of features to include',
+                required: true,
+                items: { type: 'string' }
+            },
+            prefix: {
+                type: 'string',
+                description: 'Plugin prefix for functions and classes (e.g., "wp_my_plugin")',
+                required: true
+            },
+            // Optional WordPress parameters
+            wpVersion: {
+                type: 'string',
+                description: 'Minimum WordPress version',
+                required: false,
+                default: '6.0'
+            },
+            phpVersion: {
+                type: 'string',
+                description: 'Minimum PHP version',
+                required: false,
+                default: '7.4'
+            },
+            textDomain: {
+                type: 'string',
+                description: 'Text domain for internationalization',
+                required: false
+            },
+            // Feature flags
+            includeAdmin: {
+                type: 'boolean',
+                description: 'Include admin interface',
+                required: false,
+                default: true
+            },
+            includeDatabase: {
+                type: 'boolean',
+                description: 'Include database tables',
+                required: false,
+                default: false
+            },
+            includeAjax: {
+                type: 'boolean',
+                description: 'Include AJAX handlers',
+                required: false,
+                default: false
+            },
+            includeRest: {
+                type: 'boolean',
+                description: 'Include REST API endpoints',
+                required: false,
+                default: false
+            },
+            includeGutenberg: {
+                type: 'boolean',
+                description: 'Include Gutenberg blocks',
+                required: false,
+                default: false
+            },
+            // Template compatibility parameters (for future flexibility)
+            code: {
+                type: 'string',
+                description: 'Existing plugin code to analyze (for single-file analysis)',
+                required: false
+            },
+            filePath: {
+                type: 'string',
+                description: 'Path to existing plugin file to analyze',
+                required: false
+            },
+            projectPath: {
+                type: 'string',
+                description: 'Path to existing plugin project root (for multi-file analysis)',
+                required: false
+            },
+            files: {
+                type: 'array',
+                description: 'Array of specific plugin files to analyze (for multi-file analysis)',
+                required: false,
+                items: { type: 'string' }
+            },
+            maxDepth: {
+                type: 'number',
+                description: 'Maximum directory depth for plugin analysis (1-5)',
+                required: false,
+                default: 3
+            },
+            // Universal parameters
+            language: {
+                type: 'string',
+                description: 'Programming language (PHP for WordPress)',
+                required: false,
+                default: 'php'
+            },
+            analysisDepth: {
+                type: 'string',
+                description: 'Level of plugin generation detail',
+                enum: ['basic', 'detailed', 'comprehensive'],
+                default: 'comprehensive',
+                required: false
+            },
+            analysisType: {
+                type: 'string',
+                description: 'Type of plugin generation to perform',
+                enum: ['simple', 'advanced', '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('generate_wordpress_plugin', error);
+            }
+        });
+    }
+    /**
+     * Auto-detect whether this is plugin generation or plugin analysis
+     *
+     * For WordPress plugins, we default to generation (single-file mode) unless
+     * existing plugin files are provided for analysis
+     */
+    detectAnalysisMode(params) {
+        // Multi-file mode: when analyzing existing plugin projects
+        if (params.projectPath || params.files) {
+            return 'multi-file';
+        }
+        // Single-file mode: when analyzing individual plugin files or generating new plugins
+        if (params.code || params.filePath) {
+            return 'single-file';
+        }
+        // Default to single-file for plugin generation (most common use case)
+        return 'single-file';
+    }
+    /**
+     * Validate parameters based on detected analysis mode
+     */
+    validateParameters(params, mode) {
+        if (mode === 'single-file') {
+            // For plugin generation, require plugin-specific parameters
+            if (!params.code && !params.filePath) {
+                // This is plugin generation - validate required fields
+                if (!params.name || !params.description || !params.features || !params.prefix) {
+                    throw new Error('For plugin generation: name, description, features, and prefix are required');
+                }
+            }
+            else {
+                // This is plugin analysis - use standard validation
+                ParameterValidator.validateCodeOrFile(params);
+            }
+        }
+        else {
+            ParameterValidator.validateProjectPath(params);
+            ParameterValidator.validateDepth(params);
+        }
+        // Universal validations
+        ParameterValidator.validateEnum(params, 'analysisType', ['simple', 'advanced', 'comprehensive']);
+        ParameterValidator.validateEnum(params, 'analysisDepth', ['basic', 'detailed', 'comprehensive']);
+    }
+    /**
+     * Execute single-file analysis (plugin generation or single file analysis)
+     */
+    async executeSingleFileAnalysis(params, model, contextLength) {
+        // Process single file input if provided, otherwise this is plugin generation
+        let codeToAnalyze = params.code;
+        if (params.filePath) {
+            codeToAnalyze = await readFileContent(params.filePath);
+        }
+        // Generate prompt stages for single file (generation or analysis)
+        const promptStages = this.getSingleFilePromptStages({
+            ...params,
+            code: codeToAnalyze
+        });
+        // 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, 'generate_wordpress_plugin', 'single');
+        }
+        else {
+            return await ResponseProcessor.executeDirect(promptStages, model, contextLength, 'generate_wordpress_plugin');
+        }
+    }
+    /**
+     * Execute multi-file analysis (existing plugin project analysis)
+     */
+    async executeMultiFileAnalysis(params, model, contextLength) {
+        // Discover files
+        let filesToAnalyze = params.files ||
+            await this.discoverRelevantFiles(params.projectPath, params.maxDepth, params.analysisType);
+        // Perform multi-file analysis with caching
+        const analysisResult = await this.performMultiFileAnalysis(filesToAnalyze, params, model, contextLength);
+        // Generate prompt stages for multi-file
+        const promptStages = this.getMultiFilePromptStages({
+            ...params,
+            analysisResult,
+            fileCount: filesToAnalyze.length
+        });
+        // 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, 'generate_wordpress_plugin', 'multifile');
+    }
+    /**
+     * Single-file prompt stages - WordPress plugin generation or single file analysis
+     */
+    getSingleFilePromptStages(params) {
+        const { code, analysisDepth, analysisType, name, description, features, prefix } = params;
+        // Determine if this is generation or analysis
+        const isGeneration = !code && name && description && features && prefix;
+        let systemAndContext;
+        let dataPayload;
+        let outputInstructions;
+        if (isGeneration) {
+            // Plugin Generation Mode
+            systemAndContext = `You are an expert WordPress plugin developer specializing in ${analysisDepth} ${analysisType} plugin development.
+
+WordPress Plugin Development Expertise:
+- WordPress Standards: Follow WordPress Coding Standards (WPCS) meticulously
+- Security Best Practices: Implement proper nonces, capabilities, escaping, and sanitization
+- Modern PHP Architecture: Use namespaces, dependency injection, and design patterns
+- Compatibility: WordPress ${params.wpVersion || '6.0'}+ and PHP ${params.phpVersion || '7.4'}+
+- Internationalization: Ready for translation with proper text domains
+- Performance: Optimize for speed, lazy loading, and minimal footprint
+- Accessibility: WCAG compliant admin interfaces
+- Code Quality: Clean, maintainable, well-documented code
+
+Generation Context:
+- Plugin Generation Mode: Creating complete, production-ready plugin structure
+- Analysis Depth: ${analysisDepth}
+- Plugin Complexity: ${analysisType}
+
+Your task is to generate a complete, professional WordPress plugin that developers can immediately use in production.`;
+            dataPayload = `WordPress Plugin Requirements:
+
+**Core Details:**
+- Plugin Name: ${name}
+- Description: ${description}
+- Features Required: ${features.join(', ')}
+- Function Prefix: ${prefix}
+- Text Domain: ${params.textDomain || prefix}
+
+**Technical Requirements:**
+- Minimum WordPress Version: ${params.wpVersion || '6.0'}
+- Minimum PHP Version: ${params.phpVersion || '7.4'}
+- Include Admin Interface: ${params.includeAdmin !== false}
+- Include Database Tables: ${params.includeDatabase || false}
+- Include AJAX Handlers: ${params.includeAjax || false}
+- Include REST API Endpoints: ${params.includeRest || false}
+- Include Gutenberg Blocks: ${params.includeGutenberg || false}
+
+**Quality Standards Required:**
+- WordPress Coding Standards (WPCS) compliance
+- Security-first approach with proper sanitization
+- Internationalization ready
+- Performance optimized
+- Accessibility compliant admin interfaces
+- Comprehensive documentation`;
+            outputInstructions = `Generate a complete WordPress plugin structure with production-ready code, comprehensive QA analysis, and deployment package preparation:
+
+## Part 1: Complete Plugin Architecture
+
+### 1. Main Plugin File (${prefix}.php)
+- Complete plugin header with all metadata
+- Namespace: ${prefix.charAt(0).toUpperCase() + prefix.slice(1)}
+- Main plugin class with singleton pattern
+- Proper activation/deactivation hooks with error handling
+- Security checks and early exits
+- **CRITICAL**: Include activation safety checks to prevent fatal errors
+
+### 2. Core Plugin Structure
+- **Includes Directory**: Core functionality classes
+  - Main plugin class (${prefix}-core.php)
+  - Activation/deactivation handlers with rollback capability
+  - Security and validation utilities
+
+${params.includeAdmin !== false ? `
+### 3. Admin Interface (admin/)
+- Admin menu registration with proper capabilities
+- Settings API implementation with sections and fields
+- Form handling with nonces and validation
+- Admin notices system with dismissible functionality
+- Dashboard widgets (if relevant)` : ''}
+
+${params.includeDatabase ? `
+### 4. Database Layer (includes/database/)
+- Custom table schema with proper indexes and rollback
+- Database abstraction layer with $wpdb
+- Migration system with version checking
+- Data validation and sanitization layers with error recovery` : ''}
+
+${params.includeAjax ? `
+### 5. AJAX System (includes/ajax/)
+- Nonce verification for all AJAX calls
+- Capability checks and user permissions
+- Structured response formatting with error codes
+- Error handling and logging with graceful degradation` : ''}
+
+${params.includeRest ? `
+### 6. REST API (includes/rest/)
+- Custom endpoint registration with permission callbacks
+- Authentication and authorization layers
+- Request/response schema definitions with validation
+- API versioning and backward compatibility` : ''}
+
+${params.includeGutenberg ? `
+### 7. Gutenberg Integration (blocks/)
+- Block registration with fallback for older WordPress
+- JavaScript/CSS asset management with dependency checking
+- Block attributes and server-side rendering
+- Editor and frontend styles with theme compatibility` : ''}
+
+## Part 2: Essential WordPress Standards Implementation
+
+### Security Requirements (MANDATORY):
+- Nonce verification: wp_verify_nonce() for ALL forms and AJAX
+- Capability checks: current_user_can() for ALL admin functions
+- Data escaping: esc_html(), esc_attr(), esc_url() for ALL output
+- Input sanitization: sanitize_text_field(), sanitize_email(), etc.
+- SQL injection prevention: $wpdb prepared statements ONLY
+- File inclusion security: Absolute paths and existence checks
+
+### Activation Safety Requirements (CRITICAL):
+- PHP version compatibility checks before class definitions
+- WordPress version compatibility verification
+- Required function/class existence checks
+- Database connection verification (if database features used)
+- Write permission checks for required directories
+- Memory limit and execution time considerations
+- Graceful failure with informative error messages
+
+### Code Quality Requirements:
+- WordPress hooks: Properly registered actions and filters
+- Error handling: Try-catch blocks with wp_die() for user-facing errors
+- Logging: error_log() for debugging with conditional logging
+- Documentation: PHPDoc blocks for ALL functions and classes
+- Coding standards: WordPress-VIP-Go standards compliance
+
+### Performance Requirements:
+- Lazy loading: Load heavy resources only when needed
+- Caching: Implement transients with expiration and cleanup
+- Database optimization: Proper indexes and optimized queries
+- Asset optimization: Minification and concatenation strategies
+
+## Part 3: QA Analysis and Validation
+
+### Pre-Activation Checklist Analysis:
+Provide a comprehensive QA analysis covering:
+
+1. **Fatal Error Prevention:**
+   - All class names unique and properly namespaced
+   - All function names prefixed to avoid conflicts
+   - All required files exist and are properly included
+   - All WordPress functions have availability checks
+   - All third-party dependencies properly loaded
+
+2. **Security Vulnerability Assessment:**
+   - All user inputs properly sanitized
+   - All outputs properly escaped
+   - All nonces implemented correctly
+   - All capability checks in place
+   - All SQL queries use prepared statements
+
+3. **WordPress Compatibility Verification:**
+   - Minimum WordPress version requirements met
+   - Hooks and filters properly registered
+   - Admin interfaces follow WordPress UI guidelines
+   - Internationalization properly implemented
+   - Settings API correctly utilized
+
+4. **Performance Impact Assessment:**
+   - Database queries optimized and indexed
+   - Assets properly enqueued with dependencies
+   - Caching implemented where beneficial
+   - Memory usage considerations addressed
+
+## Part 4: Deployment Package Preparation
+
+### ZIP Package Instructions:
+1. **File Structure for ZIP**: Complete directory listing for packaging
+2. **README.txt Creation**: WordPress.org standard readme with installation steps
+3. **Version Management**: Clear version numbering and changelog
+4. **Asset Optimization**: Minified CSS/JS for production
+5. **Permission Settings**: Correct file permissions (644 for files, 755 for directories)
+
+### Installation Testing Checklist:
+1. **Upload Test**: ZIP file uploads successfully via WordPress admin
+2. **Activation Test**: Plugin activates without fatal errors
+3. **Functionality Test**: All features work as expected
+4. **Deactivation Test**: Plugin deactivates cleanly without orphaned data
+5. **Reactivation Test**: Plugin reactivates properly with saved settings
+
+## Part 5: Output Format Requirements
+
+Provide your response in exactly this structure:
+
+### A. Complete Plugin Code
+[All plugin files with full, production-ready code]
+
+### B. QA Analysis Report
+\`\`\`
+# Plugin QA Analysis Report
+
+## Fatal Error Prevention: ✅ PASS / ⚠️ WARNING / ❌ FAIL
+- Class naming conflicts: [assessment]
+- Function naming conflicts: [assessment]
+- File inclusion safety: [assessment]
+- WordPress function availability: [assessment]
+
+## Security Assessment: ✅ PASS / ⚠️ WARNING / ❌ FAIL
+- Input sanitization: [assessment]
+- Output escaping: [assessment]
+- Nonce implementation: [assessment]
+- Capability checks: [assessment]
+- SQL injection prevention: [assessment]
+
+## WordPress Compatibility: ✅ PASS / ⚠️ WARNING / ❌ FAIL
+- Version requirements: [assessment]
+- Hook implementation: [assessment]
+- Admin UI compliance: [assessment]
+- Internationalization: [assessment]
+
+## Performance Assessment: ✅ PASS / ⚠️ WARNING / ❌ FAIL
+- Database optimization: [assessment]
+- Asset management: [assessment]
+- Caching implementation: [assessment]
+- Memory usage: [assessment]
+
+## Overall Plugin Grade: A / B / C / D / F
+[Summary of plugin quality and readiness]
+\`\`\`
+
+### C. ZIP Package Creation Guide
+\`\`\`
+# Plugin ZIP Package Instructions
+
+1. **Create ZIP Structure:**
+   - Include all plugin files in folder named: ${prefix}
+   - Maintain exact directory structure shown above
+   - Include README.txt with WordPress.org format
+
+2. **File Permissions:**
+   - PHP files: 644
+   - CSS/JS files: 644
+   - Directories: 755
+
+3. **ZIP Creation Command:**
+   [Provide command-line or manual ZIP creation steps]
+
+4. **Upload Instructions:**
+   - Navigate to WordPress Admin → Plugins → Add New → Upload Plugin
+   - Select the created ZIP file
+   - Click "Install Now"
+   - Activate the plugin
+\`\`\`
+
+### D. Testing Checklist
+\`\`\`
+# Pre-Deployment Testing
+
+□ ZIP file uploads successfully
+□ Plugin activates without errors
+□ Admin menu appears correctly
+□ Settings page functions properly
+□ All features work as designed
+□ No PHP errors in debug log
+□ Plugin deactivates cleanly
+□ Reactivation works properly
+□ No database orphans after deactivation
+\`\`\`
+
+Provide complete, functional, production-ready code that has been thoroughly analyzed for activation safety, security vulnerabilities, and WordPress compatibility. Include comprehensive QA analysis, deployment preparation, and testing procedures.`;
+        }
+        else {
+            // Plugin Analysis Mode
+            systemAndContext = `You are an expert WordPress plugin analyst specializing in ${analysisDepth} ${analysisType} analysis.
+
+Analysis Context:
+- Language: PHP (WordPress)
+- Analysis Depth: ${analysisDepth}
+- Analysis Type: ${analysisType}
+- Mode: Single WordPress Plugin File Analysis
+
+Your task is to provide actionable insights and recommendations for this individual WordPress plugin file.`;
+            dataPayload = `WordPress plugin code to analyze:
+
+\`\`\`php
+${code}
+\`\`\``;
+            outputInstructions = `Provide comprehensive WordPress plugin analysis in the following structured format:
+
+{
+  "summary": "Brief overview of this plugin file's purpose and functionality",
+  "analysis": {
+    "wordpressCompliance": {
+      "codingStandards": "assessment of WPCS compliance",
+      "hooksUsage": "evaluation of actions and filters usage",
+      "apiUsage": "assessment of WordPress API usage"
+    },
+    "security": {
+      "nonceUsage": "evaluation of nonce implementation",
+      "sanitization": "input sanitization assessment",
+      "escaping": "output escaping assessment",
+      "capabilities": "user capability checks assessment"
+    },
+    "functionality": {
+      "coreFeatures": ["list of main features identified"],
+      "integrations": ["WordPress integrations detected"],
+      "dependencies": ["external dependencies identified"]
+    },
+    "codeQuality": {
+      "structure": "code organization assessment",
+      "documentation": "code documentation quality",
+      "errorHandling": "error handling implementation"
+    }
+  },
+  "recommendations": [
+    "specific WordPress-focused recommendations for improvement"
+  ],
+  "securityConcerns": [
+    "identified security issues with suggested fixes"
+  ],
+  "confidence": 0.85
+}`;
+        }
+        return { systemAndContext, dataPayload, outputInstructions };
+    }
+    /**
+     * Multi-file prompt stages - WordPress plugin project analysis
+     */
+    getMultiFilePromptStages(params) {
+        const { analysisResult, analysisType, analysisDepth, fileCount } = params;
+        const systemAndContext = `You are an expert WordPress plugin architect specializing in ${analysisDepth} ${analysisType} analysis.
+
+WordPress Plugin Project Analysis Context:
+- Analysis Type: ${analysisType}
+- Analysis Depth: ${analysisDepth}  
+- Files Analyzed: ${fileCount}
+- Mode: Multi-File WordPress Plugin Project Analysis
+
+Your task is to provide comprehensive architectural insights and recommendations for this WordPress plugin project.`;
+        const dataPayload = `WordPress plugin project analysis results:
+
+${JSON.stringify(analysisResult, null, 2)}`;
+        const outputInstructions = `Provide comprehensive WordPress plugin project analysis in the following structured format:
+
+{
+  "summary": "Overall WordPress plugin project assessment",
+  "architecture": {
+    "pluginStructure": "evaluation of plugin organization and structure",
+    "namespacing": "assessment of PHP namespacing and class organization",
+    "hookSystem": "evaluation of WordPress hooks implementation across files"
+  },
+  "crossFileFindings": [
+    {
+      "type": "security|performance|compatibility|standards",
+      "severity": "high|medium|low",
+      "description": "Cross-file issue description in WordPress context", 
+      "affectedFiles": ["file1.php", "file2.php"],
+      "recommendation": "WordPress-specific fix recommendation"
+    }
+  ],
+  "wordpressCompliance": {
+    "codingStandards": "overall WPCS compliance assessment",
+    "securityImplementation": "security best practices implementation",
+    "performanceOptimization": "performance optimization assessment",
+    "accessibilityCompliance": "accessibility standards compliance"
+  },
+  "recommendations": [
+    "project-wide WordPress plugin improvement recommendations"
+  ],
+  "migrationPath": "suggestions for modernizing the plugin architecture"
+}`;
+        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('generate_wordpress_plugin', 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 proper analysis result format
+        const aggregatedResult = {
+            summary: `WordPress plugin project analysis of ${files.length} files`,
+            findings: fileAnalysisResults,
+            data: {
+                fileCount: files.length,
+                totalSize: fileAnalysisResults.reduce((sum, result) => sum + (result.size || 0), 0),
+                pluginStructure: this.analyzePluginStructure(fileAnalysisResults),
+                phpFiles: fileAnalysisResults.filter(f => f.extension === '.php').length,
+                jsFiles: fileAnalysisResults.filter(f => f.extension === '.js').length,
+                cssFiles: fileAnalysisResults.filter(f => f.extension === '.css').length
+            }
+        };
+        await this.analysisCache.cacheAnalysis(cacheKey, aggregatedResult, {
+            modelUsed: model.identifier || 'unknown',
+            executionTime: Date.now() - Date.now(), // TODO: Track actual execution time
+            timestamp: new Date().toISOString()
+        });
+        return aggregatedResult;
+    }
+    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));
+        // WordPress-specific file analysis
+        const isMainPluginFile = basename(file).endsWith('.php') && content.includes('Plugin Name:');
+        const hasWordPressHooks = content.includes('add_action') || content.includes('add_filter');
+        const hasSecurityChecks = content.includes('wp_verify_nonce') || content.includes('current_user_can');
+        return {
+            filePath: file,
+            fileName: basename(file),
+            size: content.length,
+            lines: content.split('\n').length,
+            extension: extname(file),
+            relativePath: relative(params.projectPath || '', file),
+            isMainPluginFile,
+            hasWordPressHooks,
+            hasSecurityChecks,
+            fileType: this.categorizeWordPressFile(file, content)
+        };
+    }
+    categorizeWordPressFile(filePath, content) {
+        const fileName = basename(filePath).toLowerCase();
+        const fileContent = content.toLowerCase();
+        if (fileName.endsWith('.php')) {
+            if (fileContent.includes('plugin name:'))
+                return 'main-plugin-file';
+            if (fileName.includes('admin'))
+                return 'admin-file';
+            if (fileName.includes('ajax'))
+                return 'ajax-handler';
+            if (fileName.includes('rest') || fileName.includes('api'))
+                return 'rest-api';
+            if (fileName.includes('block'))
+                return 'gutenberg-block';
+            if (fileName.includes('widget'))
+                return 'widget';
+            if (fileName.includes('shortcode'))
+                return 'shortcode';
+            return 'php-file';
+        }
+        if (fileName.endsWith('.js')) {
+            if (fileContent.includes('wp.blocks'))
+                return 'gutenberg-script';
+            if (fileContent.includes('jquery'))
+                return 'jquery-script';
+            return 'javascript-file';
+        }
+        if (fileName.endsWith('.css')) {
+            if (fileName.includes('admin'))
+                return 'admin-styles';
+            return 'stylesheet';
+        }
+        return 'other-file';
+    }
+    analyzePluginStructure(fileResults) {
+        const structure = {
+            hasMainFile: fileResults.some(f => f.isMainPluginFile),
+            hasAdminInterface: fileResults.some(f => f.fileType === 'admin-file'),
+            hasAjaxHandlers: fileResults.some(f => f.fileType === 'ajax-handler'),
+            hasRestAPI: fileResults.some(f => f.fileType === 'rest-api'),
+            hasGutenbergBlocks: fileResults.some(f => f.fileType === 'gutenberg-block' || f.fileType === 'gutenberg-script'),
+            securityImplementation: fileResults.filter(f => f.hasSecurityChecks).length / fileResults.length
+        };
+        return structure;
+    }
+    getFileExtensions(analysisType) {
+        const extensionMap = {
+            'simple': ['.php', '.js', '.css'],
+            'advanced': ['.php', '.js', '.css', '.json', '.md', '.txt'],
+            'comprehensive': ['.php', '.js', '.css', '.json', '.md', '.txt', '.xml', '.yml', '.yaml', '.po', '.pot']
+        };
+        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 WordPressPluginGenerator;
+//# sourceMappingURL=wordpress-plugin.js.map