@juspay/yama 1.3.0 → 1.4.0

package/dist/features/CodeReviewer.js

@@ -4,8 +4,11 @@
  */
 // NeuroLink will be dynamically imported
 import { ProviderError, } from "../types/index.js";
+import { createMultiInstanceProcessor, } from "./MultiInstanceProcessor.js";
 import { logger } from "../utils/Logger.js";
 import { getProviderTokenLimit } from "../utils/ProviderLimits.js";
+import { Semaphore, TokenBudgetManager, calculateOptimalConcurrency, } from "../utils/ParallelProcessing.js";
+import { createExactDuplicateRemover } from "../utils/ExactDuplicateRemover.js";
 export class CodeReviewer {
     neurolink;
     bitbucketProvider;
@@ -17,37 +20,46 @@ export class CodeReviewer {
         this.reviewConfig = reviewConfig;
     }
     /**
-     * Review code using pre-gathered unified context (OPTIMIZED with Batch Processing)
+     * Review code using pre-gathered unified context (OPTIMIZED with Multi-Instance and Batch Processing)
      */
-    async reviewCodeWithContext(context, options) {
+    async reviewCodeWithContext(context, options, multiInstanceConfig) {
         const startTime = Date.now();
         try {
             logger.phase("🧪 Conducting AI-powered code analysis...");
             logger.info(`Analyzing ${context.diffStrategy.fileCount} files using ${context.diffStrategy.strategy} strategy`);
-            // Determine if we should use batch processing
-            const batchConfig = this.getBatchProcessingConfig();
-            const shouldUseBatchProcessing = this.shouldUseBatchProcessing(context, batchConfig);
             let violations;
             let processingStrategy;
-            if (shouldUseBatchProcessing) {
-                logger.info("🔄 Using batch processing for large PR analysis");
-                const batchResult = await this.reviewWithBatchProcessing(context, options, batchConfig);
-                violations = batchResult.violations;
-                processingStrategy = "batch-processing";
+            // Check if multi-instance processing is enabled and configured
+            if (multiInstanceConfig?.enabled &&
+                multiInstanceConfig.instances?.length > 1) {
+                logger.info("🚀 Using multi-instance processing for enhanced analysis");
+                const multiInstanceResult = await this.reviewWithMultipleInstances(context, options, multiInstanceConfig);
+                violations = multiInstanceResult.finalViolations;
+                processingStrategy = "multi-instance";
             }
             else {
-                logger.info("⚡ Using single-request analysis for small PR");
-                const analysisPrompt = this.buildAnalysisPrompt(context, options);
-                violations = await this.analyzeWithAI(analysisPrompt, context);
-                processingStrategy = "single-request";
+                // Determine if we should use batch processing
+                const batchConfig = this.getBatchProcessingConfig();
+                const shouldUseBatchProcessing = this.shouldUseBatchProcessing(context, batchConfig);
+                if (shouldUseBatchProcessing) {
+                    logger.info("🔄 Using batch processing for large PR analysis");
+                    const batchResult = await this.reviewWithBatchProcessing(context, options, batchConfig);
+                    violations = batchResult.violations;
+                    processingStrategy = "batch-processing";
+                }
+                else {
+                    logger.info("⚡ Using single-request analysis for small PR");
+                    const analysisPrompt = this.buildAnalysisPrompt(context, options);
+                    violations = await this.analyzeWithAI(analysisPrompt, context);
+                    processingStrategy = "single-request";
+                }
             }
-            const validatedViolations = this.validateViolations(violations, context);
-            if (!options.dryRun && validatedViolations.length > 0) {
-                await this.postComments(context, validatedViolations, options);
+            if (!options.dryRun && violations.length > 0) {
+                violations = await this.postComments(context, violations, options);
             }
             const duration = Math.round((Date.now() - startTime) / 1000);
-            const result = this.generateReviewResult(validatedViolations, duration, context, processingStrategy);
-            logger.success(`Code review completed in ${duration}s: ${validatedViolations.length} violations found (${processingStrategy})`);
+            const result = this.generateReviewResult(violations, duration, context, processingStrategy);
+            logger.success(`Code review completed in ${duration}s: ${violations.length} violations found (${processingStrategy})`);
             return result;
         }
         catch (error) {
@@ -56,153 +68,20 @@ export class CodeReviewer {
         }
     }
     /**
-     * Validate violations to ensure code snippets exist in diff
+     * Review code using multiple instances for enhanced analysis
      */
-    validateViolations(violations, context) {
-        const validatedViolations = [];
-        const diffContent = this.extractDiffContent(context);
-        for (const violation of violations) {
-            if (violation.type === "inline" &&
-                violation.code_snippet &&
-                violation.file) {
-                // Check if the code snippet exists in the diff
-                if (diffContent.includes(violation.code_snippet)) {
-                    validatedViolations.push(violation);
-                }
-                else {
-                    // Try to find a close match and fix the snippet
-                    const fixedViolation = this.tryFixCodeSnippet(violation, context);
-                    if (fixedViolation) {
-                        validatedViolations.push(fixedViolation);
-                    }
-                    else {
-                        logger.debug(`⚠️ Skipping violation - snippet not found in diff: ${violation.file}`);
-                        logger.debug(`   Original snippet: "${violation.code_snippet}"`);
-                    }
-                }
-            }
-            else {
-                // Non-inline violations are always valid
-                validatedViolations.push(violation);
-            }
-        }
-        logger.debug(`Validated ${validatedViolations.length} out of ${violations.length} violations`);
-        return validatedViolations;
-    }
-    /**
-     * Try to fix code snippet by finding it in the actual diff
-     */
-    tryFixCodeSnippet(violation, context) {
-        if (!violation.file || !violation.code_snippet) {
-            return null;
-        }
+    async reviewWithMultipleInstances(context, options, multiInstanceConfig) {
         try {
-            // Get the diff for this specific file
-            let fileDiff;
-            if (context.diffStrategy.strategy === "whole" && context.prDiff) {
-                // Extract file diff from whole diff - handle different path formats
-                const diffLines = context.prDiff.diff.split("\n");
-                let fileStartIndex = -1;
-                // Generate all possible path variations
-                const pathVariations = this.generatePathVariations(violation.file);
-                // Try to find the file in the diff with various path formats
-                for (let i = 0; i < diffLines.length; i++) {
-                    const line = diffLines[i];
-                    if (line.startsWith("diff --git") || line.startsWith("Index:")) {
-                        for (const pathVariation of pathVariations) {
-                            if (line.includes(pathVariation)) {
-                                fileStartIndex = i;
-                                break;
-                            }
-                        }
-                        if (fileStartIndex >= 0) {
-                            break;
-                        }
-                    }
-                }
-                if (fileStartIndex >= 0) {
-                    const nextFileIndex = diffLines.findIndex((line, idx) => idx > fileStartIndex &&
-                        (line.startsWith("diff --git") || line.startsWith("Index:")));
-                    fileDiff = diffLines
-                        .slice(fileStartIndex, nextFileIndex > 0 ? nextFileIndex : diffLines.length)
-                        .join("\n");
-                }
-            }
-            else if (context.diffStrategy.strategy === "file-by-file" &&
-                context.fileDiffs) {
-                // Try all path variations
-                const pathVariations = this.generatePathVariations(violation.file);
-                for (const path of pathVariations) {
-                    fileDiff = context.fileDiffs.get(path);
-                    if (fileDiff) {
-                        logger.debug(`Found diff for ${violation.file} using variation: ${path}`);
-                        break;
-                    }
-                }
-                // If still not found, try partial matching
-                if (!fileDiff) {
-                    for (const [key, value] of context.fileDiffs.entries()) {
-                        if (key.endsWith(violation.file) || violation.file.endsWith(key)) {
-                            fileDiff = value;
-                            logger.debug(`Found diff for ${violation.file} using partial match: ${key}`);
-                            break;
-                        }
-                    }
-                }
-            }
-            if (!fileDiff) {
-                logger.debug(`❌ Could not find diff for file: ${violation.file}`);
-                return null;
-            }
-            // First, try to find the exact line with line number extraction
-            const lineInfo = this.extractLineNumberFromDiff(fileDiff, violation.code_snippet);
-            if (lineInfo) {
-                const fixedViolation = { ...violation };
-                fixedViolation.line_type = lineInfo.lineType;
-                // Extract search context from the diff
-                const diffLines = fileDiff.split("\n");
-                const snippetIndex = diffLines.findIndex((line) => line === violation.code_snippet);
-                if (snippetIndex > 0 && snippetIndex < diffLines.length - 1) {
-                    fixedViolation.search_context = {
-                        before: [diffLines[snippetIndex - 1]],
-                        after: [diffLines[snippetIndex + 1]],
-                    };
-                }
-                logger.debug(`✅ Found exact match with line number for ${violation.file}`);
-                return fixedViolation;
-            }
-            // Fallback: Clean the snippet and try fuzzy matching
-            const cleanSnippet = violation.code_snippet
-                .trim()
-                .replace(/^[+\-\s]/, ""); // Remove diff prefix for searching
-            // Look for the clean snippet in the diff
-            const diffLines = fileDiff.split("\n");
-            for (let i = 0; i < diffLines.length; i++) {
-                const line = diffLines[i];
-                const cleanLine = line.replace(/^[+\-\s]/, "").trim();
-                if (cleanLine.includes(cleanSnippet) ||
-                    cleanSnippet.includes(cleanLine)) {
-                    // Found a match! Update the violation with the correct snippet
-                    const fixedViolation = { ...violation };
-                    fixedViolation.code_snippet = line; // Use the full line with diff prefix
-                    // Update search context if needed
-                    if (i > 0 && i < diffLines.length - 1) {
-                        fixedViolation.search_context = {
-                            before: [diffLines[i - 1]],
-                            after: [diffLines[i + 1]],
-                        };
-                    }
-                    logger.debug(`✅ Fixed code snippet for ${violation.file} using fuzzy match`);
-                    return fixedViolation;
-                }
-            }
-            logger.debug(`❌ Could not find snippet in diff for ${violation.file}`);
-            logger.debug(`   Looking for: "${violation.code_snippet}"`);
+            // Create multi-instance processor
+            const multiInstanceProcessor = createMultiInstanceProcessor(this.bitbucketProvider, this.reviewConfig);
+            // Execute multi-instance processing
+            const result = await multiInstanceProcessor.processWithMultipleInstances(context, options, multiInstanceConfig);
+            return result;
         }
         catch (error) {
-            logger.debug(`Error fixing code snippet: ${error.message}`);
+            logger.error(`Multi-instance processing failed: ${error.message}`);
+            throw error;
         }
-        return null;
     }
     /**
      * Get system prompt for security-focused code review
@@ -512,11 +391,27 @@ Return ONLY valid JSON:
      */
     async postComments(context, violations, _options) {
         logger.phase("📝 Posting review comments...");
+        // NEW: Apply semantic comment deduplication before posting
+        const duplicateRemover = createExactDuplicateRemover();
+        const deduplicationResult = await duplicateRemover.removeAgainstExistingComments(violations, context.pr.comments || [], this.aiConfig, 85);
+        logger.info(`🔍 Semantic deduplication: ${violations.length} → ${deduplicationResult.uniqueViolations.length} violations ` +
+            `(${deduplicationResult.duplicatesRemoved} duplicates removed)`);
+        // Log deduplication details if any duplicates were found
+        if (deduplicationResult.duplicatesRemoved > 0) {
+            logger.info(duplicateRemover.getCommentDeduplicationStats(deduplicationResult));
+            // Log details of semantic matches
+            deduplicationResult.semanticMatches.forEach((match, index) => {
+                logger.debug(`🎯 Semantic match ${index + 1}: "${match.violation}" matches ${match.comment} ` +
+                    `(${match.similarityScore}% similarity)${match.reasoning ? ` - ${match.reasoning}` : ""}`);
+            });
+        }
+        // Use deduplicated violations for posting
+        const uniqueViolations = deduplicationResult.uniqueViolations;
         let commentsPosted = 0;
         let commentsFailed = 0;
         const failedComments = [];
         // Post inline comments
-        const inlineViolations = violations.filter((v) => v.type === "inline" && v.file && v.code_snippet);
+        const inlineViolations = uniqueViolations.filter((v) => v.type === "inline" && v.file && v.code_snippet);
         for (const violation of inlineViolations) {
             try {
                 // Clean file path - remove protocol prefixes ONLY (keep a/ and b/ prefixes)
@@ -571,9 +466,9 @@ Return ONLY valid JSON:
             }
         }
         // Post summary comment (include failed comments info if any)
-        if (violations.length > 0) {
+        if (uniqueViolations.length > 0) {
             try {
-                const summaryComment = this.generateSummaryComment(violations, context, failedComments);
+                const summaryComment = this.generateSummaryComment(uniqueViolations, context, failedComments);
                 await this.bitbucketProvider.addComment(context.identifier, summaryComment);
                 commentsPosted++;
                 logger.debug("✅ Posted summary comment");
@@ -586,6 +481,7 @@ Return ONLY valid JSON:
         if (commentsFailed > 0) {
             logger.warn(`⚠️ Failed to post ${commentsFailed} inline comments`);
         }
+        return uniqueViolations;
     }
     /**
      * Format inline comment for specific violation
@@ -933,14 +829,33 @@ ${recommendation}
             enabled: true,
             maxFilesPerBatch: 3,
             prioritizeSecurityFiles: true,
-            parallelBatches: false, // Sequential for better reliability
+            parallelBatches: false, // Keep for backward compatibility
             batchDelayMs: 1000,
             singleRequestThreshold: 5, // Use single request for ≤5 files
+            // NEW: Parallel processing defaults
+            parallel: {
+                enabled: true, // Enable parallel processing by default
+                maxConcurrentBatches: 3,
+                rateLimitStrategy: "fixed",
+                tokenBudgetDistribution: "equal",
+                failureHandling: "continue",
+            },
         };
-        return {
+        const mergedConfig = {
             ...defaultConfig,
             ...this.reviewConfig.batchProcessing,
         };
+        // Merge parallel config separately to handle nested object properly
+        if (mergedConfig.parallel && this.reviewConfig.batchProcessing?.parallel) {
+            mergedConfig.parallel = {
+                ...defaultConfig.parallel,
+                ...this.reviewConfig.batchProcessing.parallel,
+            };
+        }
+        else if (!mergedConfig.parallel) {
+            mergedConfig.parallel = defaultConfig.parallel;
+        }
+        return mergedConfig;
     }
     /**
      * Determine if batch processing should be used
@@ -964,56 +879,152 @@ ${recommendation}
         return true;
     }
     /**
-     * Main batch processing method
+     * Main batch processing method with parallel processing support
      */
     async reviewWithBatchProcessing(context, options, batchConfig) {
         const startTime = Date.now();
         try {
             // Step 1: Prioritize and organize files
             const prioritizedFiles = await this.prioritizeFiles(context, batchConfig);
-            logger.info(`📋 Prioritized ${prioritizedFiles.length} files: ${prioritizedFiles.filter(f => f.priority === "high").length} high, ${prioritizedFiles.filter(f => f.priority === "medium").length} medium, ${prioritizedFiles.filter(f => f.priority === "low").length} low priority`);
+            logger.info(`📋 Prioritized ${prioritizedFiles.length} files: ${prioritizedFiles.filter((f) => f.priority === "high").length} high, ${prioritizedFiles.filter((f) => f.priority === "medium").length} medium, ${prioritizedFiles.filter((f) => f.priority === "low").length} low priority`);
             // Step 2: Create batches
             const batches = this.createBatches(prioritizedFiles, batchConfig);
             logger.info(`📦 Created ${batches.length} batches (max ${batchConfig.maxFilesPerBatch} files per batch)`);
-            // Step 3: Process batches
-            const batchResults = [];
-            const allViolations = [];
-            for (let i = 0; i < batches.length; i++) {
-                const batch = batches[i];
-                logger.info(`🔄 Processing batch ${i + 1}/${batches.length} (${batch.files.length} files, ${batch.priority} priority)`);
-                try {
-                    const batchResult = await this.processBatch(batch, context, options);
-                    batchResults.push(batchResult);
-                    allViolations.push(...batchResult.violations);
-                    logger.info(`✅ Batch ${i + 1} completed: ${batchResult.violations.length} violations found in ${Math.round(batchResult.processingTime / 1000)}s`);
-                    // Add delay between batches if configured
-                    if (i < batches.length - 1 && batchConfig.batchDelayMs > 0) {
-                        logger.debug(`⏳ Waiting ${batchConfig.batchDelayMs}ms before next batch`);
-                        await new Promise(resolve => setTimeout(resolve, batchConfig.batchDelayMs));
-                    }
-                }
-                catch (error) {
-                    logger.error(`❌ Batch ${i + 1} failed: ${error.message}`);
-                    // Record failed batch
-                    batchResults.push({
-                        batchIndex: i,
-                        files: batch.files,
-                        violations: [],
-                        processingTime: Date.now() - startTime,
-                        error: error.message,
-                    });
-                }
+            // Step 3: Determine processing strategy
+            const useParallel = batchConfig.parallel?.enabled && batches.length > 1;
+            if (useParallel) {
+                logger.info(`🚀 Using parallel processing: ${batches.length} batches, max ${batchConfig.parallel?.maxConcurrentBatches} concurrent`);
+                return await this.processInParallel(batches, context, options, batchConfig);
+            }
+            else {
+                logger.info(`🔄 Using serial processing: ${batches.length} batches`);
+                return await this.processSerially(batches, context, options, batchConfig);
             }
-            const totalTime = Date.now() - startTime;
-            const avgBatchSize = batches.reduce((sum, b) => sum + b.files.length, 0) / batches.length;
-            logger.success(`🎯 Batch processing completed: ${allViolations.length} total violations from ${batches.length} batches in ${Math.round(totalTime / 1000)}s (avg ${avgBatchSize.toFixed(1)} files/batch)`);
-            return { violations: allViolations, batchResults };
         }
         catch (error) {
             logger.error(`Batch processing failed: ${error.message}`);
             throw error;
         }
     }
+    /**
+     * Process batches in parallel with concurrency control
+     */
+    async processInParallel(batches, context, options, batchConfig) {
+        const startTime = Date.now();
+        const parallelConfig = batchConfig.parallel;
+        // Calculate optimal concurrency
+        const avgTokensPerBatch = batches.reduce((sum, b) => sum + b.estimatedTokens, 0) / batches.length;
+        const optimalConcurrency = calculateOptimalConcurrency(batches.length, parallelConfig.maxConcurrentBatches, avgTokensPerBatch, this.getSafeTokenLimit());
+        // Initialize concurrency control
+        const semaphore = new Semaphore(optimalConcurrency);
+        const tokenBudget = new TokenBudgetManager(this.getSafeTokenLimit() * 0.8); // 80% for safety
+        logger.info(`🎯 Parallel processing: ${optimalConcurrency} concurrent batches, ${tokenBudget.getTotalBudget()} token budget`);
+        const batchResults = new Array(batches.length);
+        const allViolations = [];
+        const processingPromises = [];
+        // Process batches with controlled concurrency
+        for (let i = 0; i < batches.length; i++) {
+            const batch = batches[i];
+            const processingPromise = this.processBatchWithConcurrency(batch, context, options, semaphore, tokenBudget, i, batches.length)
+                .then((result) => {
+                batchResults[i] = result; // Maintain order
+                if (result.violations) {
+                    allViolations.push(...result.violations);
+                }
+            })
+                .catch((error) => {
+                logger.error(`❌ Batch ${i + 1} failed: ${error.message}`);
+                batchResults[i] = {
+                    batchIndex: i,
+                    files: batch.files,
+                    violations: [],
+                    processingTime: 0,
+                    error: error.message,
+                };
+                // Handle failure strategy
+                if (parallelConfig.failureHandling === "stop-all") {
+                    throw error;
+                }
+            });
+            processingPromises.push(processingPromise);
+            // Add small delay between batch starts to avoid overwhelming
+            if (i < batches.length - 1) {
+                await new Promise((resolve) => setTimeout(resolve, 200));
+            }
+        }
+        // Wait for all batches to complete
+        await Promise.allSettled(processingPromises);
+        // Filter out undefined results and sort by batch index
+        const validResults = batchResults
+            .filter((r) => r !== undefined)
+            .sort((a, b) => a.batchIndex - b.batchIndex);
+        const totalTime = Date.now() - startTime;
+        const avgBatchSize = batches.reduce((sum, b) => sum + b.files.length, 0) / batches.length;
+        const budgetStatus = tokenBudget.getBudgetStatus();
+        logger.success(`🎯 Parallel processing completed: ${allViolations.length} total violations from ${batches.length} batches in ${Math.round(totalTime / 1000)}s (avg ${avgBatchSize.toFixed(1)} files/batch, ${budgetStatus.utilizationPercent}% token usage)`);
+        return { violations: allViolations, batchResults: validResults };
+    }
+    /**
+     * Process batches serially (original implementation)
+     */
+    async processSerially(batches, context, options, batchConfig) {
+        const startTime = Date.now();
+        const batchResults = [];
+        const allViolations = [];
+        for (let i = 0; i < batches.length; i++) {
+            const batch = batches[i];
+            logger.info(`🔄 Processing batch ${i + 1}/${batches.length} (${batch.files.length} files, ${batch.priority} priority, serial)`);
+            try {
+                const batchResult = await this.processBatch(batch, context, options);
+                batchResults.push(batchResult);
+                allViolations.push(...batchResult.violations);
+                logger.info(`✅ Batch ${i + 1} completed: ${batchResult.violations.length} violations found in ${Math.round(batchResult.processingTime / 1000)}s`);
+                // Add delay between batches if configured
+                if (i < batches.length - 1 && batchConfig.batchDelayMs > 0) {
+                    logger.debug(`⏳ Waiting ${batchConfig.batchDelayMs}ms before next batch`);
+                    await new Promise((resolve) => setTimeout(resolve, batchConfig.batchDelayMs));
+                }
+            }
+            catch (error) {
+                logger.error(`❌ Batch ${i + 1} failed: ${error.message}`);
+                // Record failed batch
+                batchResults.push({
+                    batchIndex: i,
+                    files: batch.files,
+                    violations: [],
+                    processingTime: Date.now() - startTime,
+                    error: error.message,
+                });
+            }
+        }
+        const totalTime = Date.now() - startTime;
+        const avgBatchSize = batches.reduce((sum, b) => sum + b.files.length, 0) / batches.length;
+        logger.success(`🎯 Serial processing completed: ${allViolations.length} total violations from ${batches.length} batches in ${Math.round(totalTime / 1000)}s (avg ${avgBatchSize.toFixed(1)} files/batch)`);
+        return { violations: allViolations, batchResults };
+    }
+    /**
+     * Process a single batch with concurrency control
+     */
+    async processBatchWithConcurrency(batch, context, options, semaphore, tokenBudget, batchIndex, totalBatches) {
+        // Acquire semaphore permit
+        await semaphore.acquire();
+        try {
+            // Check token budget
+            if (!tokenBudget.allocateForBatch(batchIndex, batch.estimatedTokens)) {
+                throw new Error(`Insufficient token budget for batch ${batchIndex + 1}`);
+            }
+            logger.info(`🔄 Processing batch ${batchIndex + 1}/${totalBatches} (${batch.files.length} files, parallel)`);
+            // Process the batch (existing logic)
+            const result = await this.processBatch(batch, context, options);
+            logger.info(`✅ Batch ${batchIndex + 1} completed: ${result.violations.length} violations in ${Math.round(result.processingTime / 1000)}s`);
+            return result;
+        }
+        finally {
+            // Always release resources
+            tokenBudget.releaseBatch(batchIndex);
+            semaphore.release();
+        }
+    }
     /**
      * Prioritize files based on security importance and file type
      */
@@ -1051,26 +1062,73 @@ ${recommendation}
         const path = filePath.toLowerCase();
         // High priority: Security-sensitive files
         const highPriorityPatterns = [
-            /auth/i, /login/i, /password/i, /token/i, /jwt/i, /oauth/i,
-            /crypto/i, /encrypt/i, /decrypt/i, /hash/i, /security/i,
-            /payment/i, /billing/i, /transaction/i, /money/i, /wallet/i,
-            /admin/i, /privilege/i, /permission/i, /role/i, /access/i,
-            /config/i, /env/i, /secret/i, /key/i, /credential/i,
-            /api/i, /endpoint/i, /route/i, /controller/i, /middleware/i,
+            /auth/i,
+            /login/i,
+            /password/i,
+            /token/i,
+            /jwt/i,
+            /oauth/i,
+            /crypto/i,
+            /encrypt/i,
+            /decrypt/i,
+            /hash/i,
+            /security/i,
+            /payment/i,
+            /billing/i,
+            /transaction/i,
+            /money/i,
+            /wallet/i,
+            /admin/i,
+            /privilege/i,
+            /permission/i,
+            /role/i,
+            /access/i,
+            /config/i,
+            /env/i,
+            /secret/i,
+            /key/i,
+            /credential/i,
+            /api/i,
+            /endpoint/i,
+            /route/i,
+            /controller/i,
+            /middleware/i,
         ];
-        if (highPriorityPatterns.some(pattern => pattern.test(path))) {
+        if (highPriorityPatterns.some((pattern) => pattern.test(path))) {
             return "high";
         }
         // Low priority: Documentation, tests, config files
         const lowPriorityPatterns = [
-            /\.md$/i, /\.txt$/i, /readme/i, /changelog/i, /license/i,
-            /test/i, /spec/i, /\.test\./i, /\.spec\./i, /__tests__/i,
-            /\.json$/i, /\.yaml$/i, /\.yml$/i, /\.toml$/i, /\.ini$/i,
-            /\.lock$/i, /package-lock/i, /yarn\.lock/i, /pnpm-lock/i,
-            /\.gitignore/i, /\.eslint/i, /\.prettier/i, /tsconfig/i,
-            /\.svg$/i, /\.png$/i, /\.jpg$/i, /\.jpeg$/i, /\.gif$/i,
+            /\.md$/i,
+            /\.txt$/i,
+            /readme/i,
+            /changelog/i,
+            /license/i,
+            /test/i,
+            /spec/i,
+            /\.test\./i,
+            /\.spec\./i,
+            /__tests__/i,
+            /\.json$/i,
+            /\.yaml$/i,
+            /\.yml$/i,
+            /\.toml$/i,
+            /\.ini$/i,
+            /\.lock$/i,
+            /package-lock/i,
+            /yarn\.lock/i,
+            /pnpm-lock/i,
+            /\.gitignore/i,
+            /\.eslint/i,
+            /\.prettier/i,
+            /tsconfig/i,
+            /\.svg$/i,
+            /\.png$/i,
+            /\.jpg$/i,
+            /\.jpeg$/i,
+            /\.gif$/i,
         ];
-        if (lowPriorityPatterns.some(pattern => pattern.test(path))) {
+        if (lowPriorityPatterns.some((pattern) => pattern.test(path))) {
             return "low";
         }
         // Medium priority: Everything else
@@ -1128,7 +1186,8 @@ ${recommendation}
         for (const file of prioritizedFiles) {
             const wouldExceedTokens = currentBatch.estimatedTokens + file.estimatedTokens > maxTokensPerBatch;
             const wouldExceedFileCount = currentBatch.files.length >= batchConfig.maxFilesPerBatch;
-            if ((wouldExceedTokens || wouldExceedFileCount) && currentBatch.files.length > 0) {
+            if ((wouldExceedTokens || wouldExceedFileCount) &&
+                currentBatch.files.length > 0) {
                 // Finalize current batch
                 batches.push(currentBatch);
                 // Start new batch