@houtini/lm 1.0.0

package/dist/prompts/analyze/database-queries.js

@@ -0,0 +1,759 @@
+/**
+ * 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 DatabaseQueryAnalyzer extends BasePlugin {
+    constructor() {
+        super();
+        this.name = 'analyze_database_queries';
+        this.category = 'analyze';
+        this.description = 'Analyze database queries for performance, security, and best practices in code 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 database queries (for single-file analysis)',
+                required: false
+            },
+            filePath: {
+                type: 'string',
+                description: 'Path to single file to analyze for database queries',
+                required: false
+            },
+            // Multi-file parameters  
+            projectPath: {
+                type: 'string',
+                description: 'Path to project root (for multi-file database 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: 'php'
+            },
+            analysisDepth: {
+                type: 'string',
+                description: 'Level of analysis detail',
+                enum: ['basic', 'detailed', 'comprehensive'],
+                default: 'detailed',
+                required: false
+            },
+            analysisType: {
+                type: 'string',
+                description: 'Type of database analysis to perform',
+                enum: ['security', 'performance', 'best-practices', 'comprehensive'],
+                default: 'comprehensive',
+                required: false
+            },
+            // Database-specific parameters
+            context: {
+                type: 'object',
+                description: 'Database and framework context for specialized analysis',
+                required: false,
+                properties: {
+                    database: {
+                        type: 'string',
+                        enum: ['mysql', 'postgresql', 'sqlite', 'mongodb', 'generic'],
+                        description: 'Database engine for engine-specific optimizations'
+                    },
+                    framework: {
+                        type: 'string',
+                        enum: ['wordpress', 'laravel', 'symfony', 'django', 'rails', 'express', 'generic'],
+                        description: 'Framework for framework-specific query patterns'
+                    },
+                    orm: {
+                        type: 'string',
+                        enum: ['eloquent', 'doctrine', 'sequelize', 'mongoose', 'activerecord', 'none'],
+                        description: 'ORM/Query builder being used'
+                    },
+                    environment: {
+                        type: 'string',
+                        enum: ['development', 'staging', 'production'],
+                        description: 'Environment context for performance recommendations'
+                    }
+                }
+            }
+        };
+        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_database_queries', error);
+            }
+        });
+    }
+    /**
+     * Auto-detect whether this is single-file or multi-file analysis
+     */
+    detectAnalysisMode(params) {
+        // Single-file indicators take priority
+        if (params.code || params.filePath) {
+            return 'single-file';
+        }
+        // Multi-file indicators
+        if (params.projectPath || params.files) {
+            return 'multi-file';
+        }
+        // Default to single-file for focused query 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', ['security', 'performance', 'best-practices', '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);
+        }
+        // Extract database queries from the code
+        const extractedQueries = this.extractDatabaseQueries(codeToAnalyze, params.language, params.context);
+        // Generate prompt stages for single file
+        const promptStages = this.getSingleFilePromptStages({
+            ...params,
+            code: codeToAnalyze,
+            extractedQueries
+        });
+        // 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_database_queries', 'single');
+        }
+        else {
+            return await ResponseProcessor.executeDirect(promptStages, model, contextLength, 'analyze_database_queries');
+        }
+    }
+    /**
+     * 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_database_queries', 'multifile');
+    }
+    /**
+     * Database Query Analysis - Single File Expert Analysis
+     */
+    getSingleFilePromptStages(params) {
+        const { code, language, analysisDepth, analysisType, extractedQueries, filePath, context = {} } = params;
+        const database = context.database || 'generic';
+        const framework = context.framework || 'generic';
+        const orm = context.orm || 'none';
+        const environment = context.environment || 'production';
+        const systemAndContext = `You are a world-class database performance expert and security specialist with 20+ years of experience optimizing database queries across all major platforms.
+
+**DATABASE ANALYSIS CONTEXT:**
+- Database Engine: ${database}
+- Framework: ${framework}
+- ORM/Query Builder: ${orm}
+- Programming Language: ${language}
+- Environment: ${environment}
+- Analysis Focus: ${analysisType}
+- Analysis Depth: ${analysisDepth}
+- File: ${filePath ? basename(filePath) : 'inline code'}
+
+**YOUR EXPERTISE:**
+You are recognized as a leading expert in:
+- SQL query optimization and execution plan analysis
+- Database security and injection prevention
+- Framework-specific query patterns (WordPress $wpdb, Laravel Eloquent, etc.)
+- Performance bottleneck identification and resolution
+- Index strategy and database schema optimization
+- N+1 query problem detection and solutions
+- Query caching strategies and implementation
+- Database-specific optimization techniques for ${database}
+
+${this.getDatabaseSpecificInstructions(database, framework, orm)}
+
+**ANALYSIS APPROACH:**
+1. **Query Detection**: Identify all database queries in the code
+2. **Security Assessment**: Evaluate for SQL injection vulnerabilities
+3. **Performance Analysis**: Identify bottlenecks, N+1 problems, and optimization opportunities
+4. **Best Practices Review**: Check against framework and database best practices
+5. **Actionable Recommendations**: Provide specific, implementable improvements with examples
+
+You provide expert-level analysis that helps developers write secure, performant database code.`;
+        const dataPayload = `**CODE WITH DATABASE QUERIES:**
+
+\`\`\`${language}
+${code}
+\`\`\`
+
+**EXTRACTED DATABASE QUERIES:**
+${extractedQueries.length > 0 ?
+            extractedQueries.map((query, index) => `**Query ${index + 1}** (Line ${query.line}):\n\`\`\`sql\n${query.query}\n\`\`\`\nContext: ${query.context}\n`).join('\n') :
+            'No explicit database queries detected. Analyzing for potential query patterns and ORM usage.'}
+
+${filePath ? `\n**File Path:** ${filePath}` : ''}`;
+        const outputInstructions = `**PROVIDE COMPREHENSIVE DATABASE QUERY ANALYSIS:**
+
+## Executive Summary
+Provide a 2-3 sentence overview of database usage, query patterns, and main security/performance concerns found in this file.
+
+## Query Analysis Overview
+- **Total Queries Found**: Count of database queries identified in the code
+- **Query Types**: Breakdown of query types (SELECT, INSERT, UPDATE, DELETE, etc.)
+- **Complex Queries**: Identification of complex queries that need attention
+- **Dynamic Queries**: Queries built dynamically at runtime
+
+## Security Analysis
+For each security finding:
+- **Vulnerability Type**: SQL injection, prepared statements, input validation, etc.
+- **Severity Level**: Critical, high, medium, or low priority
+- **Vulnerable Query**: The specific problematic query
+- **Location**: Line number and context
+- **Security Risk**: Detailed description of the security issue
+- **Exploit Scenario**: How this vulnerability could be exploited
+- **Fix Recommendation**: Specific fix with secure code example
+- **Implementation**: Example of secure implementation
+
+## Performance Analysis  
+For each performance issue:
+- **Performance Problem**: N+1 queries, missing indexes, inefficient queries, excessive joins
+- **Impact Level**: Critical, high, medium, or low performance impact
+- **Problematic Query**: The query causing performance issues
+- **Location**: Line number and context
+      "issue": "Detailed performance issue description",
+      "impact": "Performance impact (queries/second, memory usage)",
+      "optimization": "Specific optimization strategy",
+      "optimizedQuery": "Improved query example"
+    }
+  ],
+  
+  "bestPracticeViolations": [
+    {
+      "practice": "Best practice being violated",
+      "line": 78,
+      "current": "Current implementation",
+      "recommended": "Recommended implementation",
+      "benefit": "Why this improvement matters"
+    }
+  ],
+  
+  "recommendations": {
+    "immediate": [
+      "Critical security fix 1",
+      "Critical performance fix 1"
+    ],
+    "shortTerm": [
+      "Performance optimization 1",
+      "Code quality improvement 1"
+    ],
+    "longTerm": [
+      "Architectural improvement 1",
+      "Scalability enhancement 1"
+    ]
+  },
+  
+  "codeExamples": {
+    "before": "// Current problematic database code",
+    "after": "// Optimized and secure version",
+    "explanation": "Why this improvement enhances security and performance"
+  },
+  
+  "indexRecommendations": [
+    {
+      "table": "table_name",
+      "columns": ["column1", "column2"],
+      "type": "btree|hash|partial",
+      "reasoning": "Why this index improves performance"
+    }
+  ],
+  
+  "metrics": {
+    "estimatedQueriesPerRequest": 5,
+    "potentialBottlenecks": 2,
+    "securityRiskLevel": "high|medium|low",
+    "optimizationPotential": "high|medium|low"
+  },
+  
+  "confidence": 0.92
+}
+
+**CRITICAL REQUIREMENTS:**
+- Focus on real, exploitable security vulnerabilities
+- Provide specific query optimizations with measurable impact
+- Include framework-specific best practices for ${framework}
+- Consider ${database}-specific optimization techniques
+- Prioritize fixes by impact and implementation difficulty`;
+        return { systemAndContext, dataPayload, outputInstructions };
+    }
+    /**
+     * Multi-file database analysis for project-wide query patterns
+     */
+    getMultiFilePromptStages(params) {
+        const { analysisResult, analysisType, analysisDepth, fileCount, context = {} } = params;
+        const database = context.database || 'generic';
+        const framework = context.framework || 'generic';
+        const systemAndContext = `You are a senior database architect specializing in ${analysisDepth} multi-file database analysis and optimization.
+
+**PROJECT DATABASE ANALYSIS CONTEXT:**
+- Database Engine: ${database}
+- Framework: ${framework}
+- Analysis Type: ${analysisType}
+- Analysis Depth: ${analysisDepth}  
+- Files Analyzed: ${fileCount}
+- Mode: Multi-File Database Architecture Analysis
+
+**YOUR EXPERTISE:**
+You excel at identifying cross-file database patterns, architectural issues, and system-wide database optimization opportunities. You understand how queries interact across modules, transaction boundaries, and data consistency patterns.
+
+**FOCUS AREAS:**
+- Cross-file query patterns and duplication
+- Database transaction boundaries and consistency
+- Query performance across the application
+- Security patterns and vulnerabilities at scale
+- Database schema utilization and optimization opportunities`;
+        const dataPayload = `**PROJECT DATABASE ANALYSIS RESULTS:**
+
+${JSON.stringify(analysisResult, null, 2)}`;
+        const outputInstructions = `**PROVIDE PROJECT-WIDE DATABASE ANALYSIS:**
+
+## Executive Summary
+Overall assessment of database usage patterns, architecture quality, and system-wide security/performance concerns across the project.
+
+## Database Architecture Analysis
+- **Query Patterns**: Common patterns used throughout the project
+- **Data Access Layers**: How database access is organized across files
+- **Transaction Boundaries**: Transaction management patterns across the system
+- **Consistency Approach**: Eventual, strong, or mixed consistency patterns
+
+## Cross-File Analysis
+For each system-wide issue identified:
+- **Issue Type**: Query duplication, transaction issues, N+1 patterns, security patterns
+- **Severity Impact**: Critical, high, medium, or low system impact  
+- **Issue Title**: Descriptive name for the cross-file issue
+- **Description**: Detailed explanation of the system-wide problem
+- **Affected Files**: List of files involved in this issue
+- **System Impact**: How this affects overall performance/security
+- **Resolution Strategy**: System-wide fix approach
+
+## Performance Architecture
+- **Query Distribution**: How database queries are distributed across the codebase
+- **Bottleneck Patterns**: Common performance bottlenecks across files
+- **Caching Strategy**: Current approach to database result caching
+- **Optimization Opportunities**: System-wide performance improvements
+
+## Security Architecture  
+- **Input Validation Patterns**: Consistency of input validation (consistent/inconsistent/missing)
+- **Prepared Statement Usage**: Overall usage of prepared statements (high/medium/low)
+- **Privilege Patterns**: Common privilege and access control patterns
+- **High Risk Areas**: Areas requiring immediate security attention
+
+## System-Wide Recommendations
+- **Architecture Improvements**: Database architecture enhancements
+- **Performance Optimizations**: System-wide performance improvements
+- **Security Enhancements**: Security strengthening recommendations
+- **Maintainability Improvements**: Long-term maintenance considerations
+
+Focus on actionable recommendations that improve overall database architecture, performance, and security across the entire project.`;
+        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_database_queries', 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 database-specific results
+        const aggregatedResult = {
+            summary: `Multi-file database analysis of ${files.length} files`,
+            findings: fileAnalysisResults,
+            database: this.analyzeDatabasePatterns(fileAnalysisResults),
+            queries: this.aggregateQueryAnalysis(fileAnalysisResults),
+            security: this.aggregateSecurityFindings(fileAnalysisResults),
+            performance: this.aggregatePerformanceFindings(fileAnalysisResults),
+            data: {
+                fileCount: files.length,
+                totalQueries: fileAnalysisResults.reduce((sum, result) => sum + (result.queryCount || 0), 0),
+                riskLevel: this.calculateRiskLevel(fileAnalysisResults),
+                frameworks: this.identifyDatabaseFrameworks(fileAnalysisResults)
+            }
+        };
+        await this.analysisCache.cacheAnalysis(cacheKey, aggregatedResult, {
+            modelUsed: model.identifier || 'unknown',
+            executionTime: 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);
+        const queries = this.extractDatabaseQueries(content, params.language, params.context);
+        return {
+            filePath: file,
+            fileName: basename(file),
+            size: content.length,
+            lines: content.split('\n').length,
+            extension: extname(file),
+            relativePath: relative(params.projectPath || '', file),
+            // Database-specific analysis
+            queryCount: queries.length,
+            queries: queries,
+            databaseCalls: this.countDatabaseCalls(content),
+            securityRisks: this.identifySecurityRisks(queries),
+            performanceIssues: this.identifyPerformanceIssues(queries),
+            modified: stats.mtime
+        };
+    }
+    /**
+     * Extract database queries from code using patterns for different languages/frameworks
+     */
+    extractDatabaseQueries(code, language = 'php', context = {}) {
+        const queries = [];
+        const lines = code.split('\n');
+        // WordPress $wpdb patterns
+        const wpdbPatterns = [
+            /\$wpdb->query\s*\(\s*['"](.*?)['"].*?\)/gi,
+            /\$wpdb->get_results\s*\(\s*['"](.*?)['"].*?\)/gi,
+            /\$wpdb->get_var\s*\(\s*['"](.*?)['"].*?\)/gi,
+            /\$wpdb->get_row\s*\(\s*['"](.*?)['"].*?\)/gi,
+            /\$wpdb->prepare\s*\(\s*['"](.*?)['"].*?\)/gi
+        ];
+        // Raw SQL patterns
+        const sqlPatterns = [
+            /(SELECT\s+.*?FROM\s+.*?)(?=;|\s*$|\s*\))/gis,
+            /(INSERT\s+INTO\s+.*?)(?=;|\s*$|\s*\))/gis,
+            /(UPDATE\s+.*?SET\s+.*?)(?=;|\s*$|\s*\))/gis,
+            /(DELETE\s+FROM\s+.*?)(?=;|\s*$|\s*\))/gis
+        ];
+        // Laravel Eloquent patterns
+        const eloquentPatterns = [
+            /DB::select\s*\(\s*['"](.*?)['"].*?\)/gi,
+            /DB::insert\s*\(\s*['"](.*?)['"].*?\)/gi,
+            /DB::update\s*\(\s*['"](.*?)['"].*?\)/gi,
+            /DB::delete\s*\(\s*['"](.*?)['"].*?\)/gi
+        ];
+        const patterns = [...wpdbPatterns, ...sqlPatterns, ...eloquentPatterns];
+        lines.forEach((line, index) => {
+            patterns.forEach(pattern => {
+                let match;
+                pattern.lastIndex = 0; // Reset regex
+                while ((match = pattern.exec(line)) !== null) {
+                    queries.push({
+                        query: match[1] || match[0],
+                        line: index + 1,
+                        context: this.getQueryContext(line),
+                        type: this.getQueryType(match[1] || match[0]),
+                        framework: this.detectQueryFramework(line)
+                    });
+                }
+            });
+        });
+        return queries;
+    }
+    getQueryContext(line) {
+        if (line.includes('$wpdb'))
+            return 'WordPress';
+        if (line.includes('DB::'))
+            return 'Laravel';
+        if (line.includes('query(') || line.includes('execute('))
+            return 'Direct SQL';
+        return 'Unknown';
+    }
+    getQueryType(query) {
+        if (/^SELECT/i.test(query.trim()))
+            return 'SELECT';
+        if (/^INSERT/i.test(query.trim()))
+            return 'INSERT';
+        if (/^UPDATE/i.test(query.trim()))
+            return 'UPDATE';
+        if (/^DELETE/i.test(query.trim()))
+            return 'DELETE';
+        return 'OTHER';
+    }
+    detectQueryFramework(line) {
+        if (line.includes('$wpdb'))
+            return 'WordPress';
+        if (line.includes('DB::'))
+            return 'Laravel';
+        if (line.includes('PDO'))
+            return 'PDO';
+        return 'Generic';
+    }
+    countDatabaseCalls(content) {
+        const dbCallPatterns = [
+            /\$wpdb->/g,
+            /DB::/g,
+            /->query\(/g,
+            /->execute\(/g,
+            /mysqli_/g,
+            /pg_query/g
+        ];
+        return dbCallPatterns.reduce((count, pattern) => {
+            const matches = content.match(pattern) || [];
+            return count + matches.length;
+        }, 0);
+    }
+    identifySecurityRisks(queries) {
+        const risks = [];
+        queries.forEach(query => {
+            // Check for potential SQL injection
+            if (query.query.includes('$') && !query.query.includes('prepare')) {
+                risks.push('Potential SQL injection vulnerability');
+            }
+            // Check for dynamic query construction
+            if (query.query.includes('{') || query.query.includes('}')) {
+                risks.push('Dynamic query construction detected');
+            }
+            // Check for missing prepared statements
+            if (query.framework === 'WordPress' && !query.context.includes('prepare')) {
+                risks.push('Unprepared WordPress query');
+            }
+        });
+        return [...new Set(risks)]; // Remove duplicates
+    }
+    identifyPerformanceIssues(queries) {
+        const issues = [];
+        queries.forEach(query => {
+            // Check for SELECT *
+            if (query.query.includes('SELECT *')) {
+                issues.push('SELECT * usage detected');
+            }
+            // Check for missing WHERE clauses in UPDATE/DELETE
+            if ((query.type === 'UPDATE' || query.type === 'DELETE') && !query.query.includes('WHERE')) {
+                issues.push('Missing WHERE clause in destructive operation');
+            }
+            // Check for potential N+1 queries (simple heuristic)
+            if (query.context.includes('foreach') || query.context.includes('for (')) {
+                issues.push('Potential N+1 query pattern');
+            }
+        });
+        return [...new Set(issues)];
+    }
+    // Database-specific aggregation methods
+    analyzeDatabasePatterns(results) {
+        return {
+            totalQueries: results.reduce((sum, r) => sum + (r.queryCount || 0), 0),
+            frameworks: this.identifyDatabaseFrameworks(results),
+            queryTypes: this.aggregateQueryTypes(results)
+        };
+    }
+    aggregateQueryAnalysis(results) {
+        const allQueries = results.flatMap(r => r.queries || []);
+        return {
+            total: allQueries.length,
+            byType: this.groupBy(allQueries, 'type'),
+            byFramework: this.groupBy(allQueries, 'framework')
+        };
+    }
+    aggregateSecurityFindings(results) {
+        const allRisks = results.flatMap(r => r.securityRisks || []);
+        return {
+            totalRisks: allRisks.length,
+            riskTypes: this.countOccurrences(allRisks)
+        };
+    }
+    aggregatePerformanceFindings(results) {
+        const allIssues = results.flatMap(r => r.performanceIssues || []);
+        return {
+            totalIssues: allIssues.length,
+            issueTypes: this.countOccurrences(allIssues)
+        };
+    }
+    calculateRiskLevel(results) {
+        const totalRisks = results.reduce((sum, r) => sum + (r.securityRisks?.length || 0), 0);
+        if (totalRisks > 10)
+            return 'high';
+        if (totalRisks > 5)
+            return 'medium';
+        return 'low';
+    }
+    identifyDatabaseFrameworks(results) {
+        const frameworks = new Set();
+        results.forEach(result => {
+            if (result.queries) {
+                result.queries.forEach((query) => {
+                    frameworks.add(query.framework);
+                });
+            }
+        });
+        return Array.from(frameworks);
+    }
+    aggregateQueryTypes(results) {
+        const types = {};
+        results.forEach(result => {
+            if (result.queries) {
+                result.queries.forEach((query) => {
+                    types[query.type] = (types[query.type] || 0) + 1;
+                });
+            }
+        });
+        return types;
+    }
+    groupBy(array, key) {
+        return array.reduce((groups, item) => {
+            const group = item[key] || 'unknown';
+            groups[group] = (groups[group] || 0) + 1;
+            return groups;
+        }, {});
+    }
+    countOccurrences(array) {
+        return array.reduce((counts, item) => {
+            counts[item] = (counts[item] || 0) + 1;
+            return counts;
+        }, {});
+    }
+    getFileExtensions(analysisType) {
+        const extensionMap = {
+            'security': ['.php', '.js', '.ts', '.py', '.rb', '.java', '.cs', '.sql'],
+            'performance': ['.php', '.js', '.ts', '.py', '.rb', '.java', '.cs', '.sql'],
+            'best-practices': ['.php', '.js', '.ts', '.py', '.rb', '.java', '.cs', '.sql'],
+            'comprehensive': ['.php', '.js', '.ts', '.py', '.rb', '.java', '.cs', '.sql', '.jsp', '.asp', '.aspx']
+        };
+        return extensionMap[analysisType] || extensionMap.comprehensive;
+    }
+    /**
+     * Database and framework-specific expert instructions
+     */
+    getDatabaseSpecificInstructions(database, framework, orm) {
+        const instructions = {
+            'wordpress': `
+**WORDPRESS DATABASE EXPERTISE:**
+- $wpdb best practices: Always use $wpdb->prepare() for dynamic queries
+- WordPress query functions: get_results(), get_var(), get_row(), get_col()
+- Custom table naming: Use $wpdb->prefix for table prefixes
+- Caching integration: wp_cache_* functions for query result caching
+- Security: Validate and sanitize all input, use wpdb::esc_like() for LIKE queries
+- Performance: Avoid queries in loops, use WP_Query efficiently, leverage object caching
+- Schema: Follow WordPress database schema conventions, use dbDelta() for table creation`,
+            'laravel': `
+**LARAVEL DATABASE EXPERTISE:**
+- Eloquent ORM: Use relationships to avoid N+1 queries, eager loading with with()
+- Query Builder: DB::table() with proper parameter binding
+- Raw queries: Always use DB::select() with parameter binding, never string concatenation
+- Migrations: Use Schema builder for database changes, maintain rollback capability
+- Performance: Query scopes, database indexes, query caching with Redis/Memcached
+- Security: Always use parameter binding, validate inputs with Form Requests
+- Transactions: Use DB::transaction() for data consistency`,
+            'django': `
+**DJANGO DATABASE EXPERTISE:**
+- ORM QuerySets: Use select_related() and prefetch_related() to minimize queries
+- Raw SQL: Always use parameterized queries, never string formatting
+- Migrations: Use Django migrations for schema changes
+- Performance: Database indexes, QuerySet optimization, database connection pooling
+- Security: Django ORM provides SQL injection protection by default
+- Caching: Use Django's cache framework for query result caching`,
+            'generic': `
+**GENERAL DATABASE EXPERTISE:**
+- Always use prepared statements or parameterized queries
+- Validate and sanitize all user inputs before database operations
+- Use appropriate indexes for query performance
+- Avoid SELECT * and fetch only required columns
+- Implement proper error handling and logging
+- Use transactions for data consistency
+- Consider connection pooling for high-traffic applications`
+        };
+        return instructions[framework] || instructions[database] || instructions.generic;
+    }
+    generateCacheKey(files, params) {
+        const fileHash = files.join('|');
+        const paramHash = JSON.stringify(params);
+        return `${fileHash}_${paramHash}`.substring(0, 64);
+    }
+}
+export default DatabaseQueryAnalyzer;
+//# sourceMappingURL=database-queries.js.map