@houtini/lm 1.0.12 → 2.0.0

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

@@ -1,763 +0,0 @@
-/**
- * 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, TokenCalculator } from '../../utils/plugin-utilities.js';
-import { getAnalysisCache } from '../../cache/index.js';
-// Common Node.js modules - Use these instead of require()
-import { basename, extname, relative } from 'path';
-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();
-        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, '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();
-        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, '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