generate_wordpress_plugin
Create a production-ready WordPress plugin structure with essential files, tests, and documentation. Customize features, admin interfaces, REST API endpoints, and Gutenberg blocks. Streamline plugin development with iterative, locally generated code for review.
Instructions
Generate a complete WordPress plugin structure with all necessary files and best practices
WORKFLOW: Ideal for creating production-ready code, tests, and documentation TIP: Generate unlimited iterations locally, then review with Claude SAVES: Claude context for strategic decisions
Input Schema
TableJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| analysisDepth | No | Level of plugin generation detail | comprehensive |
| analysisType | No | Type of plugin generation to perform | comprehensive |
| code | No | Existing plugin code to analyze (for single-file analysis) | |
| description | Yes | Plugin description | |
| features | Yes | List of features to include | |
| filePath | No | Path to existing plugin file to analyze | |
| files | No | Array of specific plugin files to analyze (for multi-file analysis) | |
| includeAdmin | No | Include admin interface | |
| includeAjax | No | Include AJAX handlers | |
| includeDatabase | No | Include database tables | |
| includeGutenberg | No | Include Gutenberg blocks | |
| includeRest | No | Include REST API endpoints | |
| language | No | Programming language (PHP for WordPress) | php |
| maxDepth | No | Maximum directory depth for plugin analysis (1-5) | |
| name | Yes | Plugin name | |
| phpVersion | No | Minimum PHP version | 7.4 |
| prefix | Yes | Plugin prefix for functions and classes (e.g., "wp_my_plugin") | |
| projectPath | No | Path to existing plugin project root (for multi-file analysis) | |
| textDomain | No | Text domain for internationalization | |
| wpVersion | No | Minimum WordPress version | 6.0 |
Implementation Reference
- Core handler implementation in WordPressPluginGenerator class. Defines tool name, parameters, and execute method which orchestrates security, validation, model setup, prompt staging, and execution using ThreeStagePromptManager for context-aware generation.export class WordPressPluginGenerator extends BasePlugin implements IPromptPlugin { name = 'generate_wordpress_plugin'; category = 'generate' as const; description = 'Generate a complete WordPress plugin structure with all necessary files and best practices'; // Universal parameter set - supports both single and multi-file scenarios parameters = { // WordPress plugin specific parameters name: { type: 'string' as const, description: 'Plugin name', required: true }, description: { type: 'string' as const, description: 'Plugin description', required: true }, features: { type: 'array' as const, description: 'List of features to include', required: true, items: { type: 'string' as const } }, prefix: { type: 'string' as const, description: 'Plugin prefix for functions and classes (e.g., "wp_my_plugin")', required: true }, // Optional WordPress parameters wpVersion: { type: 'string' as const, description: 'Minimum WordPress version', required: false, default: '6.0' }, phpVersion: { type: 'string' as const, description: 'Minimum PHP version', required: false, default: '7.4' }, textDomain: { type: 'string' as const, description: 'Text domain for internationalization', required: false }, // Feature flags includeAdmin: { type: 'boolean' as const, description: 'Include admin interface', required: false, default: true }, includeDatabase: { type: 'boolean' as const, description: 'Include database tables', required: false, default: false }, includeAjax: { type: 'boolean' as const, description: 'Include AJAX handlers', required: false, default: false }, includeRest: { type: 'boolean' as const, description: 'Include REST API endpoints', required: false, default: false }, includeGutenberg: { type: 'boolean' as const, description: 'Include Gutenberg blocks', required: false, default: false }, // Template compatibility parameters (for future flexibility) code: { type: 'string' as const, description: 'Existing plugin code to analyze (for single-file analysis)', required: false }, filePath: { type: 'string' as const, description: 'Path to existing plugin file to analyze', required: false }, projectPath: { type: 'string' as const, description: 'Path to existing plugin project root (for multi-file analysis)', required: false }, files: { type: 'array' as const, description: 'Array of specific plugin files to analyze (for multi-file analysis)', required: false, items: { type: 'string' as const } }, maxDepth: { type: 'number' as const, description: 'Maximum directory depth for plugin analysis (1-5)', required: false, default: 3 }, // Universal parameters language: { type: 'string' as const, description: 'Programming language (PHP for WordPress)', required: false, default: 'php' }, analysisDepth: { type: 'string' as const, description: 'Level of plugin generation detail', enum: ['basic', 'detailed', 'comprehensive'], default: 'comprehensive', required: false }, analysisType: { type: 'string' as const, description: 'Type of plugin generation to perform', enum: ['simple', 'advanced', 'comprehensive'], default: 'comprehensive', required: false } }; private analysisCache = getAnalysisCache(); private multiFileAnalysis = new MultiFileAnalysis(); constructor() { super(); // Cache and analysis utilities are initialized above } async execute(params: any, llmClient: any) { 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: any) { 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 */ private detectAnalysisMode(params: any): 'single-file' | 'multi-file' { // 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 */ private validateParameters(params: any, mode: 'single-file' | 'multi-file'): void { 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) */ private async executeSingleFileAnalysis(params: any, model: any, contextLength: number) { // 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) */ private async executeMultiFileAnalysis(params: any, model: any, contextLength: number) { // Discover files let filesToAnalyze: string[] = 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 */ private getSingleFilePromptStages(params: any): PromptStages { 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: string; let dataPayload: string; let outputInstructions: string; 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 */ private getMultiFilePromptStages(params: any): PromptStages { 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: any): PromptStages { const mode = this.detectAnalysisMode(params); if (mode === 'single-file') { return this.getSingleFilePromptStages(params); } else { return this.getMultiFilePromptStages(params); } } // Multi-file helper methods private async discoverRelevantFiles( projectPath: string, maxDepth: number, analysisType: string ): Promise<string[]> { const extensions = this.getFileExtensions(analysisType); return await this.multiFileAnalysis.discoverFiles(projectPath, extensions, maxDepth); } private async performMultiFileAnalysis( files: string[], params: any, model: any, contextLength: number ): Promise<any> { 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: string) => 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: number, result: any) => 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; } private async analyzeIndividualFile(file: string, params: any, model: any): Promise<any> { 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) }; } private categorizeWordPressFile(filePath: string, content: string): string { 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'; } private analyzePluginStructure(fileResults: any[]): any { 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; } private getFileExtensions(analysisType: string): string[] { const extensionMap: Record<string, string[]> = { '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; } private generateCacheKey(files: string[], params: any): string { const fileHash = files.join('|'); const paramHash = JSON.stringify(params); return `${fileHash}_${paramHash}`.substring(0, 64); } }
- src/validation/schemas.ts:238-263 (schema)Output schema definition for generate_wordpress_plugin tool response, specifying structure for generated plugin files, features, and instructions.export interface GenerateWordpressPluginResponse extends BaseResponse { data: { files: Array<{ path: string; content: string; description: string; }>; structure: { mainFile: string; directories: string[]; totalFiles: number; }; features: { implemented: string[]; hooks: string[]; shortcodes?: string[]; blocks?: string[]; endpoints?: string[]; }; instructions: { installation: string; configuration: string; usage: string; }; }; }
- src/plugins/index.ts:108-122 (registration)PluginLoader.registerPlugin method that registers the tool by its name 'generate_wordpress_plugin' after dynamic loading from prompts/generate directory.registerPlugin(plugin: IPromptPlugin): void { // Validate plugin has required properties if (!plugin.name || !plugin.category || !plugin.execute) { throw new Error('Invalid plugin: missing required properties'); } // Register in main map this.plugins.set(plugin.name, plugin); // Register in category map const categoryPlugins = this.categories.get(plugin.category) || []; categoryPlugins.push(plugin); this.categories.set(plugin.category, categoryPlugins); }
- src/validation/schemas.ts:529-529 (schema)Response type mapping in FunctionResponseMap for generate_wordpress_plugin.'generate_wordpress_plugin': GenerateWordpressPluginResponse;
- Output parser maps 'generate_wordpress_plugin' to 'plugin-code' type for generation response handling.'generate_wordpress_plugin': 'plugin-code', 'generate_responsive_component': 'component-code', 'convert_to_typescript': 'typescript-code', 'suggest_refactoring': 'refactored-code' }; return typeMap[functionName] || 'generated-content'; }