@houtini/lm 1.0.13 → 2.0.1

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

@@ -1,767 +0,0 @@
-/**
- * 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, TokenCalculator } 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();
-        const needsChunking = TokenCalculator.needsChunking(promptStages, contextLength);
-        if (needsChunking) {
-            const chunkSize = TokenCalculator.calculateOptimalChunkSize(promptStages, contextLength);
-            const dataChunks = promptManager.chunkDataPayload(promptStages.dataPayload, chunkSize);
-            const conversation = promptManager.createChunkedConversation(promptStages, dataChunks);
-            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();
-        const chunkSize = TokenCalculator.calculateOptimalChunkSize(promptStages, contextLength);
-        const dataChunks = promptManager.chunkDataPayload(promptStages.dataPayload, chunkSize);
-        const conversation = promptManager.createChunkedConversation(promptStages, dataChunks);
-        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