@houtini/lm 1.0.0

package/dist/prompts/analyze/single-file.js

@@ -0,0 +1,665 @@
+/**
+ * Plugin Template - Modern v4.2 (Single Source of Truth)
+ *
+ * Universal template that intelligently handles both single-file and multi-file analysis
+ * Automatically detects analysis type based on provided parameters
+ *
+ * Copy this template for creating any new plugin - it adapts to your needs
+ */
+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';
+import { readFile, stat } from 'fs/promises';
+export class CodeStructureAnalyzer extends BasePlugin {
+    constructor() {
+        super();
+        this.name = 'analyze_single_file';
+        this.category = 'analyze';
+        this.description = 'Analyze code structure, quality, patterns, and provide actionable recommendations for individual files or entire projects';
+        // Universal parameter set - supports both single and multi-file scenarios
+        this.parameters = {
+            // Single-file parameters
+            code: {
+                type: 'string',
+                description: 'The code to analyze (for single-file analysis)',
+                required: false
+            },
+            filePath: {
+                type: 'string',
+                description: 'Path to single file to analyze',
+                required: false
+            },
+            // Multi-file parameters  
+            projectPath: {
+                type: 'string',
+                description: 'Path to project root (for multi-file analysis)',
+                required: false
+            },
+            files: {
+                type: 'array',
+                description: 'Array of specific file paths (for multi-file analysis)',
+                required: false,
+                items: { type: 'string' }
+            },
+            maxDepth: {
+                type: 'number',
+                description: 'Maximum directory depth for multi-file discovery (1-5)',
+                required: false,
+                default: 3
+            },
+            // Universal parameters
+            language: {
+                type: 'string',
+                description: 'Programming language',
+                required: false,
+                default: 'javascript'
+            },
+            analysisDepth: {
+                type: 'string',
+                description: 'Level of analysis detail',
+                enum: ['basic', 'detailed', 'comprehensive'],
+                default: 'detailed',
+                required: false
+            },
+            analysisType: {
+                type: 'string',
+                description: 'Type of analysis to perform',
+                enum: ['structure', 'quality', 'security', 'performance', 'comprehensive'],
+                default: 'comprehensive',
+                required: false
+            },
+            // Enhanced context parameter
+            context: {
+                type: 'object',
+                description: 'Optional context for framework-specific analysis',
+                required: false,
+                properties: {
+                    projectType: {
+                        type: 'string',
+                        enum: ['wordpress-plugin', 'wordpress-theme', 'react-app', 'react-component', 'n8n-node', 'node-api', 'html-component', 'generic'],
+                        description: 'Type of project for specialized analysis'
+                    },
+                    framework: {
+                        type: 'string',
+                        description: 'Framework being used (e.g., WordPress, React, Express)'
+                    },
+                    frameworkVersion: {
+                        type: 'string',
+                        description: 'Framework version for version-specific recommendations'
+                    },
+                    standards: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'Coding standards to validate against'
+                    },
+                    environment: {
+                        type: 'string',
+                        enum: ['browser', 'node', 'wordpress', 'hybrid'],
+                        description: 'Runtime environment for context-aware analysis'
+                    }
+                }
+            }
+        };
+        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('analyze_single_file', error);
+            }
+        });
+    }
+    /**
+     * Auto-detect whether this is single-file or multi-file analysis
+     *
+     * DETECTION GUIDE:
+     * Single-file: code, filePath provided → analyze individual file
+     * Multi-file: projectPath, files provided → analyze project/multiple files
+     * Default: single-file (this plugin's primary use case)
+     */
+    detectAnalysisMode(params) {
+        // Single-file indicators take priority (avoids default parameter issues)
+        if (params.code || params.filePath) {
+            return 'single-file';
+        }
+        // Multi-file indicators
+        if (params.projectPath || params.files) {
+            return 'multi-file';
+        }
+        // Default to single-file for code analysis
+        return 'single-file';
+    }
+    /**
+     * Validate parameters based on detected analysis mode
+     */
+    validateParameters(params, mode) {
+        if (mode === 'single-file') {
+            ParameterValidator.validateCodeOrFile(params);
+        }
+        else {
+            ParameterValidator.validateProjectPath(params);
+            ParameterValidator.validateDepth(params);
+        }
+        // Universal validations
+        ParameterValidator.validateEnum(params, 'analysisType', ['structure', 'quality', 'security', 'performance', 'comprehensive']);
+        ParameterValidator.validateEnum(params, 'analysisDepth', ['basic', 'detailed', 'comprehensive']);
+    }
+    /**
+     * Execute single-file analysis
+     */
+    async executeSingleFileAnalysis(params, model, contextLength) {
+        // Process single file input
+        let codeToAnalyze = params.code;
+        if (params.filePath) {
+            codeToAnalyze = await readFileContent(params.filePath);
+        }
+        // Generate prompt stages for single file
+        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, 'analyze_single_file', 'single');
+        }
+        else {
+            return await ResponseProcessor.executeDirect(promptStages, model, contextLength, 'analyze_single_file');
+        }
+    }
+    /**
+     * Execute multi-file 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, 'analyze_single_file', 'multifile');
+    }
+    /**
+     * Implement single-file prompt stages - OPTIMIZED FOR POWERFUL CODE ANALYSIS
+     */
+    getSingleFilePromptStages(params) {
+        const { code, language, analysisDepth, analysisType, filePath, context = {} } = params;
+        const projectType = context.projectType || 'generic';
+        const framework = context.framework || 'none specified';
+        const standards = context.standards?.join(', ') || 'clean code principles';
+        const systemAndContext = `You are a world-class senior software architect and code quality expert with deep expertise in ${language} and ${analysisDepth} code analysis.
+
+**ANALYSIS CONTEXT:**
+- Programming Language: ${language}
+- Analysis Depth: ${analysisDepth}
+- Analysis Type: ${analysisType}
+- Project Type: ${projectType}
+- Framework: ${framework} ${context.frameworkVersion ? `v${context.frameworkVersion}` : ''}
+- Coding Standards: ${standards}
+- Runtime Environment: ${context.environment || 'not specified'}
+- File: ${filePath ? basename(filePath) : 'inline code'}
+
+**YOUR EXPERTISE:**
+You have 20+ years of experience in software development, code review, and architectural design. You understand:
+- Design patterns and anti-patterns
+- Performance optimization techniques
+- Security vulnerabilities and best practices
+- Framework-specific conventions and idioms
+- Code maintainability and testability principles
+- Industry best practices for ${language} development
+
+${this.getProjectSpecificInstructions(projectType)}
+
+**ANALYSIS APPROACH:**
+1. **Structure Analysis**: Examine code organization, modularity, and architectural patterns
+2. **Quality Assessment**: Evaluate maintainability, readability, and adherence to best practices
+3. **Security Review**: Identify potential vulnerabilities and security concerns
+4. **Performance Analysis**: Spot performance bottlenecks and optimization opportunities
+5. **Actionable Recommendations**: Provide specific, implementable improvements with examples
+
+You are thorough, insightful, and provide actionable feedback that helps developers grow and improve their code quality.`;
+        const dataPayload = `**CODE TO ANALYZE:**
+
+\`\`\`${language}
+${code}
+\`\`\`
+
+${filePath ? `\n**File Path:** ${filePath}` : ''}`;
+        const outputInstructions = `Provide a comprehensive code analysis covering all aspects of the ${language} code:
+
+**Code Overview & Purpose:**
+Provide a 2-3 sentence summary of what this code does, its overall quality level, and the main areas that need attention.
+
+**Structural Analysis:**
+- **Architecture**: Describe the code's architectural approach and organization
+- **Components**: List key classes, functions, modules, and their roles
+- **Dependencies**: Identify imports, exports, and external dependencies
+- **Design Patterns**: Note any design patterns or architectural patterns used
+
+**Quality Assessment:**
+- **Lines of Code**: Estimate total lines and assess if appropriate for functionality
+- **Complexity**: Evaluate cyclomatic complexity (low/medium/high) and maintainability
+- **Code Quality**: Rate maintainability, testability, and reusability (high/medium/low)
+- **Standards Adherence**: How well it follows ${language} and ${framework} best practices
+
+**Issues & Findings:**
+For each issue found, provide:
+- **Type**: issue, improvement, security concern, or performance problem
+- **Severity**: critical, high, medium, or low priority
+- **Location**: Specific line numbers where possible
+- **Description**: Clear explanation of the problem
+- **Impact**: How this affects the code's functionality or quality
+- **Recommendation**: Specific steps to fix or improve
+- **Code Example**: Show before/after code where helpful
+
+**Security Assessment:**
+- **Vulnerability Analysis**: Identify potential security issues
+- **Risk Level**: Overall security risk (critical/high/medium/low/none)  
+- **Security Recommendations**: Specific security improvements needed
+- **Best Practices**: Security practices being followed or missing
+
+**Performance Analysis:**
+- **Bottlenecks**: Identify performance issues or inefficiencies
+- **Optimization Opportunities**: Suggest specific performance improvements
+- **Impact Assessment**: Estimate the performance impact of suggested changes
+
+**Actionable Recommendations:**
+Organize suggestions by priority:
+- **Immediate Actions**: Critical fixes needed right away
+- **Short-term Improvements**: Quality enhancements for next iteration
+- **Long-term Enhancements**: Architectural or major structural improvements
+
+**Code Examples:**
+Where applicable, provide before/after code examples showing:
+- Current problematic code
+- Improved version with fix applied
+- Clear explanation of why the improvement helps
+
+**Best Practices Assessment:**
+- Highlight coding practices being done well
+- Identify areas where ${language}/${framework} best practices should be adopted
+- Consider ${projectType} specific requirements and conventions
+
+**Implementation Guidance:**
+- Prioritize recommendations by impact and effort required
+- Provide specific, actionable steps that can be implemented immediately
+- Consider the existing codebase context and constraints
+- Balance perfectionism with practical improvement steps
+
+Focus on being constructive, specific, and actionable. Include line numbers where possible, and ensure all recommendations are implementable within the project's context.`;
+        return { systemAndContext, dataPayload, outputInstructions };
+    }
+    /**
+     * Implement multi-file prompt stages for project-wide analysis
+     */
+    getMultiFilePromptStages(params) {
+        const { analysisResult, analysisType, analysisDepth, fileCount, context = {} } = params;
+        const projectType = context.projectType || 'generic';
+        const systemAndContext = `You are a senior software architect specializing in ${analysisDepth} multi-file project analysis.
+
+**PROJECT ANALYSIS CONTEXT:**
+- Analysis Type: ${analysisType}
+- Analysis Depth: ${analysisDepth}  
+- Files Analyzed: ${fileCount}
+- Project Type: ${projectType}
+- Mode: Multi-File Architecture Analysis
+
+**YOUR EXPERTISE:**
+You excel at identifying cross-file patterns, architectural issues, and system-wide improvements. You understand how files interact, dependencies flow, and architectural patterns emerge across codebases.
+
+**FOCUS AREAS:**
+- Cross-file dependencies and coupling
+- Architectural patterns and violations  
+- Code duplication and reuse opportunities
+- Consistency across modules
+- System-wide security and performance concerns`;
+        const dataPayload = `**PROJECT ANALYSIS RESULTS:**
+
+${JSON.stringify(analysisResult, null, 2)}`;
+        const outputInstructions = `**PROVIDE PROJECT-WIDE ANALYSIS:**
+
+## Executive Summary
+Overall architectural assessment and key findings across the entire project.
+
+## Architecture Analysis
+- **Architectural Patterns**: Patterns identified across the codebase
+- **Architecture Violations**: Areas where architectural principles are violated
+- **Architectural Strengths**: What the project does well architecturally  
+- **Architectural Weaknesses**: Areas needing architectural improvement
+
+## Cross-File Analysis
+For each cross-file issue identified:
+- **Issue Type**: Duplication, coupling, inconsistency, security, or performance
+- **Severity Level**: Critical, high, medium, or low impact
+- **Issue Title**: Descriptive name for the cross-file issue
+- **Description**: Detailed explanation of the cross-file problem
+- **Affected Files**: List of files involved in this issue
+- **System Impact**: How this affects the overall system
+- **Resolution Strategy**: Specific steps to resolve across files
+
+## Dependency Analysis
+- **Coupling Assessment**: Overall coupling level (high/medium/low)
+- **Circular Dependencies**: Any circular dependency issues found
+- **Unused Dependencies**: Dependencies that can be removed
+- **Dependency Recommendations**: Improvements to dependency management
+
+## Code Consistency Analysis
+- **Naming Conventions**: Consistency assessment (consistent/inconsistent/mixed)
+- **Code Style**: Style consistency across files (consistent/inconsistent/mixed)
+- **Pattern Usage**: Pattern consistency across the codebase
+- **Consistency Improvements**: Recommendations for better consistency
+
+## System-Wide Recommendations
+- **Architectural Improvements**: High-level architectural enhancements needed for better system design
+- **Refactoring Opportunities**: Major refactoring opportunities across files to improve maintainability
+- **Development Standards**: Coding standards and best practices that should be adopted project-wide
+- **Tooling Recommendations**: Development tools and automation that would benefit the project
+- **Quality Improvements**: Long-term quality enhancement strategies for sustainable development
+
+Focus on providing strategic, actionable insights that improve overall project quality, team productivity, and long-term maintainability across the entire codebase.`;
+        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('analyze_single_file', 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 for cross-file analysis
+        const aggregatedResult = {
+            summary: `Multi-file code analysis of ${files.length} files`,
+            findings: fileAnalysisResults,
+            architecture: this.analyzeArchitecture(fileAnalysisResults),
+            dependencies: this.analyzeDependencies(fileAnalysisResults),
+            patterns: this.identifyPatterns(fileAnalysisResults),
+            data: {
+                fileCount: files.length,
+                totalSize: fileAnalysisResults.reduce((sum, result) => sum + (result.size || 0), 0),
+                languages: this.getLanguageDistribution(fileAnalysisResults),
+                complexity: this.calculateProjectComplexity(fileAnalysisResults)
+            }
+        };
+        await this.analysisCache.cacheAnalysis(cacheKey, aggregatedResult, {
+            modelUsed: model.identifier || 'unknown',
+            executionTime: Date.now() - Date.now(),
+            timestamp: new Date().toISOString()
+        });
+        return aggregatedResult;
+    }
+    async analyzeIndividualFile(file, params, model) {
+        const content = await readFile(file, 'utf-8');
+        const stats = await stat(file);
+        return {
+            filePath: file,
+            fileName: basename(file),
+            size: content.length,
+            lines: content.split('\n').length,
+            extension: extname(file),
+            relativePath: relative(params.projectPath || '', file),
+            // Basic code analysis
+            functions: this.extractFunctions(content),
+            imports: this.extractImports(content),
+            exports: this.extractExports(content),
+            complexity: this.estimateComplexity(content),
+            modified: stats.mtime
+        };
+    }
+    // Enhanced analysis helper methods
+    analyzeArchitecture(results) {
+        return {
+            fileTypes: this.groupByType(results),
+            modularity: this.assessModularity(results),
+            layering: this.identifyLayers(results)
+        };
+    }
+    analyzeDependencies(results) {
+        return {
+            internal: this.findInternalDependencies(results),
+            external: this.findExternalDependencies(results),
+            circular: this.detectCircularDependencies(results)
+        };
+    }
+    identifyPatterns(results) {
+        // Simple pattern identification
+        const patterns = [];
+        if (results.some(r => r.fileName.includes('Controller')))
+            patterns.push('MVC Pattern');
+        if (results.some(r => r.fileName.includes('Service')))
+            patterns.push('Service Layer');
+        if (results.some(r => r.fileName.includes('Factory')))
+            patterns.push('Factory Pattern');
+        return patterns;
+    }
+    getLanguageDistribution(results) {
+        const distribution = {};
+        results.forEach(result => {
+            const ext = result.extension || 'unknown';
+            distribution[ext] = (distribution[ext] || 0) + 1;
+        });
+        return distribution;
+    }
+    calculateProjectComplexity(results) {
+        const avgComplexity = results.reduce((sum, r) => sum + (r.complexity || 0), 0) / results.length;
+        if (avgComplexity > 10)
+            return 'high';
+        if (avgComplexity > 5)
+            return 'medium';
+        return 'low';
+    }
+    // Simple code extraction methods
+    extractFunctions(content) {
+        const functionPattern = /function\s+([a-zA-Z_$][a-zA-Z0-9_$]*)|const\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=\s*\(/g;
+        const functions = [];
+        let match;
+        while ((match = functionPattern.exec(content)) !== null) {
+            functions.push(match[1] || match[2]);
+        }
+        return functions;
+    }
+    extractImports(content) {
+        const importPattern = /import.*?from\s+['"]([^'"]+)['"]/g;
+        const imports = [];
+        let match;
+        while ((match = importPattern.exec(content)) !== null) {
+            imports.push(match[1]);
+        }
+        return imports;
+    }
+    extractExports(content) {
+        const exportPattern = /export\s+(?:default\s+)?(?:class|function|const|let|var)?\s*([a-zA-Z_$][a-zA-Z0-9_$]*)/g;
+        const exports = [];
+        let match;
+        while ((match = exportPattern.exec(content)) !== null) {
+            exports.push(match[1]);
+        }
+        return exports;
+    }
+    estimateComplexity(content) {
+        // Simple complexity estimation based on control flow keywords
+        const complexityKeywords = /\b(if|else|for|while|switch|case|catch|&&|\|\|)\b/g;
+        const matches = content.match(complexityKeywords) || [];
+        return matches.length;
+    }
+    // Placeholder methods for more advanced analysis
+    groupByType(results) {
+        return results.reduce((acc, r) => {
+            const ext = r.extension || 'unknown';
+            acc[ext] = (acc[ext] || 0) + 1;
+            return acc;
+        }, {});
+    }
+    assessModularity(results) {
+        // Simple modularity assessment
+        const avgFunctions = results.reduce((sum, r) => sum + (r.functions?.length || 0), 0) / results.length;
+        return avgFunctions > 10 ? 'low' : avgFunctions > 5 ? 'medium' : 'high';
+    }
+    identifyLayers(results) {
+        const layers = [];
+        if (results.some(r => r.relativePath.includes('controller')))
+            layers.push('Controller Layer');
+        if (results.some(r => r.relativePath.includes('service')))
+            layers.push('Service Layer');
+        if (results.some(r => r.relativePath.includes('model')))
+            layers.push('Data Layer');
+        return layers;
+    }
+    findInternalDependencies(results) {
+        return results.flatMap(r => r.imports?.filter((imp) => imp.startsWith('.')) || []);
+    }
+    findExternalDependencies(results) {
+        return results.flatMap(r => r.imports?.filter((imp) => !imp.startsWith('.')) || []);
+    }
+    detectCircularDependencies(results) {
+        // Simplified circular dependency detection
+        return []; // Placeholder for more complex analysis
+    }
+    getFileExtensions(analysisType) {
+        const extensionMap = {
+            'structure': ['.js', '.ts', '.jsx', '.tsx', '.py', '.php', '.java', '.cs', '.rb', '.html', '.css', '.scss', '.sass', '.less'],
+            'quality': ['.js', '.ts', '.jsx', '.tsx', '.py', '.php', '.java', '.cs', '.rb', '.html', '.css', '.scss', '.sass', '.less', '.json', '.yml', '.yaml'],
+            'security': ['.js', '.ts', '.jsx', '.tsx', '.py', '.php', '.java', '.cs', '.html'],
+            'performance': ['.js', '.ts', '.jsx', '.tsx', '.py', '.php', '.java', '.html', '.css', '.scss', '.sass'],
+            'comprehensive': ['.js', '.ts', '.jsx', '.tsx', '.py', '.php', '.java', '.cs', '.rb', '.go', '.cpp', '.c', '.h', '.html', '.css', '.scss', '.sass', '.less', '.json', '.yml', '.yaml', '.md', '.txt', '.xml']
+        };
+        return extensionMap[analysisType] || extensionMap.comprehensive;
+    }
+    /**
+     * Project-specific analysis instructions
+     */
+    getProjectSpecificInstructions(projectType) {
+        const instructions = {
+            'wordpress-plugin': `
+**WORDPRESS PLUGIN EXPERTISE:**
+- Hook system: action/filter usage, priority settings, timing
+- Database operations: $wpdb practices, custom tables, option API
+- Admin interfaces: menu structure, settings API, meta boxes
+- Security: nonces, capability checks, data sanitization, SQL injection prevention
+- Multisite compatibility and network admin considerations
+- Internationalization: text domains, translation functions
+- Plugin architecture: activation/deactivation hooks, uninstall procedures`,
+            'wordpress-theme': `
+**WORDPRESS THEME EXPERTISE:**
+- Template hierarchy and conditional tags
+- Custom post types, taxonomies, and meta fields
+- Customizer API and theme supports
+- Widget areas, navigation menus, and custom widgets
+- Asset enqueueing and dependency management
+- Child theme compatibility and parent theme integration
+- Performance: lazy loading, critical CSS, image optimization`,
+            'react-app': `
+**REACT APPLICATION EXPERTISE:**
+- Component architecture: composition vs inheritance
+- State management: Context, Redux, Zustand patterns
+- Performance optimization: React.memo, useMemo, useCallback
+- Side effects: useEffect best practices, cleanup functions
+- Routing: React Router patterns, code splitting
+- Testing: component testing, integration testing strategies
+- Build optimization: bundle splitting, tree shaking`,
+            'react-component': `
+**REACT COMPONENT EXPERTISE:**
+- Props design: interface clarity, default values, validation
+- Hook patterns: custom hooks, dependency arrays
+- Render performance: preventing unnecessary re-renders
+- Accessibility: ARIA attributes, keyboard navigation, screen readers
+- Styling approaches: CSS modules, styled-components, Tailwind
+- Component patterns: controlled vs uncontrolled, compound components
+- Testing: unit tests, snapshot tests, user interaction tests`,
+            'n8n-node': `
+**N8N NODE EXPERTISE:**
+- Node structure: properties, credentials, resource locators
+- Execute method: input processing, output formatting
+- Error handling: user-friendly messages, retry strategies
+- API integration: authentication, rate limiting, pagination
+- Resource optimization: memory usage, execution time
+- Testing: node testing framework, mock data patterns`,
+            'node-api': `
+**NODE.JS API EXPERTISE:**
+- Express patterns: middleware design, route organization
+- Authentication: JWT, sessions, OAuth implementations
+- Database patterns: connection pooling, query optimization
+- Error handling: async/await patterns, global error handlers
+- Security: helmet, rate limiting, input validation
+- Performance: caching strategies, response compression
+- API design: RESTful principles, versioning, documentation`,
+            'html-component': `
+**HTML COMPONENT EXPERTISE:**
+- Semantic HTML: proper element usage, document outline
+- Accessibility: WCAG guidelines, ARIA attributes, keyboard navigation
+- Progressive enhancement: baseline functionality, JavaScript enhancement
+- CSS architecture: BEM methodology, component isolation
+- Performance: critical path optimization, resource hints
+- Browser compatibility: graceful degradation, polyfills
+- Web standards: HTML5 validation, microdata, structured data`,
+            'generic': `
+**GENERAL CODE EXPERTISE:**
+Focus on universal software engineering principles: SOLID principles, design patterns, code organization, error handling, testing strategies, performance optimization, and maintainability practices applicable across languages and frameworks.`
+        };
+        return instructions[projectType] || instructions.generic;
+    }
+    generateCacheKey(files, params) {
+        const fileHash = files.join('|');
+        const paramHash = JSON.stringify(params);
+        return `${fileHash}_${paramHash}`.substring(0, 64);
+    }
+}
+export default CodeStructureAnalyzer;
+//# sourceMappingURL=single-file.js.map