@juspay/yama 1.2.0 → 1.3.0

package/CHANGELOG.md

@@ -1,31 +1,33 @@
-# [1.2.0](https://github.com/juspay/yama/compare/v1.1.1...v1.2.0) (2025-08-08)
+# [1.3.0](https://github.com/juspay/yama/compare/v1.2.0...v1.3.0) (2025-09-01)
+
+### Features
+
+- **github:** implement comprehensive automation with proper Yama branding ([a03cb7f](https://github.com/juspay/yama/commit/a03cb7f499ea7793d626686beebde907551035d0))
 
+# [1.2.0](https://github.com/juspay/yama/compare/v1.1.1...v1.2.0) (2025-08-08)
 
 ### Features
 
-* **Memory:** support memory bank path and maxToken from config file ([1bc69d5](https://github.com/juspay/yama/commit/1bc69d5bda3ac5868d7537b881007beaf6916476))
+- **Memory:** support memory bank path and maxToken from config file ([1bc69d5](https://github.com/juspay/yama/commit/1bc69d5bda3ac5868d7537b881007beaf6916476))
 
 ## [1.1.1](https://github.com/juspay/yama/compare/v1.1.0...v1.1.1) (2025-07-28)
 
-
 ### Bug Fixes
 
-* bump version to 1.2.1 ([8964645](https://github.com/juspay/yama/commit/89646450a7dec6ffcc3ad7fb745e1414fc751d4f))
+- bump version to 1.2.1 ([8964645](https://github.com/juspay/yama/commit/89646450a7dec6ffcc3ad7fb745e1414fc751d4f))
 
 # [1.1.0](https://github.com/juspay/yama/compare/v1.0.0...v1.1.0) (2025-07-28)
 
-
 ### Features
 
-* migrate from CommonJS to ESM modules ([b45559f](https://github.com/juspay/yama/commit/b45559f86d37ab3516079becfa56a9f73ff8f062))
+- migrate from CommonJS to ESM modules ([b45559f](https://github.com/juspay/yama/commit/b45559f86d37ab3516079becfa56a9f73ff8f062))
 
 # 1.0.0 (2025-07-25)
 
-
 ### Features
 
-* add enterprise-grade CI/CD pipeline and release automation ([e385d69](https://github.com/juspay/yama/commit/e385d69d135bee72f51ac4462adcfc9a4a4be17b))
-* v1.1.0 - Enhanced AI configuration and performance improvements ([e763e93](https://github.com/juspay/yama/commit/e763e9341c2869433097b7a6bcc9080028934e1b))
+- add enterprise-grade CI/CD pipeline and release automation ([e385d69](https://github.com/juspay/yama/commit/e385d69d135bee72f51ac4462adcfc9a4a4be17b))
+- v1.1.0 - Enhanced AI configuration and performance improvements ([e763e93](https://github.com/juspay/yama/commit/e763e9341c2869433097b7a6bcc9080028934e1b))
 
 # Changelog
 

package/dist/core/providers/BitbucketProvider.js

@@ -27,7 +27,7 @@ export class BitbucketProvider {
         }
         try {
             logger.debug("Initializing Bitbucket MCP handlers...");
-            const dynamicImport = eval("(specifier) => import(specifier)");
+            const dynamicImport = new Function("specifier", "return import(specifier)");
             const [{ BitbucketApiClient }, { BranchHandlers }, { PullRequestHandlers }, { ReviewHandlers }, { FileHandlers },] = await Promise.all([
                 dynamicImport("@nexus2520/bitbucket-mcp-server/build/utils/api-client.js"),
                 dynamicImport("@nexus2520/bitbucket-mcp-server/build/handlers/branch-handlers.js"),

package/dist/features/CodeReviewer.d.ts

@@ -12,7 +12,7 @@ export declare class CodeReviewer {
     private reviewConfig;
     constructor(bitbucketProvider: BitbucketProvider, aiConfig: AIProviderConfig, reviewConfig: CodeReviewConfig);
     /**
-     * Review code using pre-gathered unified context (OPTIMIZED)
+     * Review code using pre-gathered unified context (OPTIMIZED with Batch Processing)
      */
     reviewCodeWithContext(context: UnifiedContext, options: ReviewOptions): Promise<ReviewResult>;
     /**
@@ -92,6 +92,46 @@ export declare class CodeReviewer {
     private groupViolationsByCategory;
     private calculateStats;
     private generateReviewResult;
+    /**
+     * Get batch processing configuration with defaults
+     */
+    private getBatchProcessingConfig;
+    /**
+     * Determine if batch processing should be used
+     */
+    private shouldUseBatchProcessing;
+    /**
+     * Main batch processing method
+     */
+    private reviewWithBatchProcessing;
+    /**
+     * Prioritize files based on security importance and file type
+     */
+    private prioritizeFiles;
+    /**
+     * Calculate file priority based on path and content
+     */
+    private calculateFilePriority;
+    /**
+     * Estimate token count for a file
+     */
+    private estimateFileTokens;
+    /**
+     * Create batches from prioritized files
+     */
+    private createBatches;
+    /**
+     * Process a single batch of files
+     */
+    private processBatch;
+    /**
+     * Create context for a specific batch
+     */
+    private createBatchContext;
+    /**
+     * Build analysis prompt for a specific batch
+     */
+    private buildBatchAnalysisPrompt;
     /**
      * Utility methods
      */
@@ -100,6 +140,10 @@ export declare class CodeReviewer {
      * Extract line information for comment from context
      */
     private extractLineInfoForComment;
+    /**
+     * Detect programming language from file extension
+     */
+    private detectLanguageFromFile;
     /**
      * Generate all possible path variations for a file
      */

package/dist/features/CodeReviewer.js

@@ -17,22 +17,37 @@ export class CodeReviewer {
         this.reviewConfig = reviewConfig;
     }
     /**
-     * Review code using pre-gathered unified context (OPTIMIZED)
+     * Review code using pre-gathered unified context (OPTIMIZED with Batch Processing)
      */
     async reviewCodeWithContext(context, options) {
         const startTime = Date.now();
         try {
             logger.phase("🧪 Conducting AI-powered code analysis...");
             logger.info(`Analyzing ${context.diffStrategy.fileCount} files using ${context.diffStrategy.strategy} strategy`);
-            const analysisPrompt = this.buildAnalysisPrompt(context, options);
-            const violations = await this.analyzeWithAI(analysisPrompt, context);
+            // 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";
+            }
+            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);
             }
             const duration = Math.round((Date.now() - startTime) / 1000);
-            const result = this.generateReviewResult(validatedViolations, duration, context);
-            logger.success(`Code review completed in ${duration}s: ${validatedViolations.length} violations found`);
+            const result = this.generateReviewResult(validatedViolations, duration, context, processingStrategy);
+            logger.success(`Code review completed in ${duration}s: ${validatedViolations.length} violations found (${processingStrategy})`);
             return result;
         }
         catch (error) {
@@ -607,27 +622,14 @@ Return ONLY valid JSON:
         if (violation.impact) {
             comment += `\n\n**Impact**: ${violation.impact}`;
         }
+        // Add suggested fix section if suggestion is provided
         if (violation.suggestion) {
-            const fileExt = violation.file?.split(".").pop() || "text";
-            const langMap = {
-                js: "javascript",
-                jsx: "javascript",
-                ts: "typescript",
-                tsx: "typescript",
-                res: "rescript",
-                resi: "rescript",
-                py: "python",
-                java: "java",
-                go: "go",
-                rb: "ruby",
-                php: "php",
-                sql: "sql",
-                json: "json",
-            };
-            const language = langMap[fileExt] || "text";
-            // Use the escape method for code blocks
+            comment += `\n\n**Suggested Fix**:\n`;
+            // Detect the language for syntax highlighting
+            const language = this.detectLanguageFromFile(violation.file || "");
+            // Use proper markdown escaping for code blocks
             const escapedCodeBlock = this.escapeMarkdownCodeBlock(violation.suggestion, language);
-            comment += `\n\n**💡 Suggested Fix**:\n${escapedCodeBlock}`;
+            comment += escapedCodeBlock;
         }
         comment += `\n\n---\n*🛡️ Automated review by **Yama** • Powered by AI*`;
         return comment;
@@ -903,7 +905,7 @@ ${recommendation}
             filesReviewed: new Set(violations.filter((v) => v.file).map((v) => v.file)).size || 1,
         };
     }
-    generateReviewResult(violations, _duration, _context) {
+    generateReviewResult(violations, _duration, _context, processingStrategy) {
         const stats = this.calculateStats(violations);
         return {
             violations,
@@ -915,10 +917,374 @@ ${recommendation}
                 majorCount: stats.majorCount,
                 minorCount: stats.minorCount,
                 suggestionCount: stats.suggestionCount,
+                processingStrategy,
             },
             positiveObservations: [], // Could be extracted from AI response
         };
     }
+    // ============================================================================
+    // BATCH PROCESSING METHODS
+    // ============================================================================
+    /**
+     * Get batch processing configuration with defaults
+     */
+    getBatchProcessingConfig() {
+        const defaultConfig = {
+            enabled: true,
+            maxFilesPerBatch: 3,
+            prioritizeSecurityFiles: true,
+            parallelBatches: false, // Sequential for better reliability
+            batchDelayMs: 1000,
+            singleRequestThreshold: 5, // Use single request for ≤5 files
+        };
+        return {
+            ...defaultConfig,
+            ...this.reviewConfig.batchProcessing,
+        };
+    }
+    /**
+     * Determine if batch processing should be used
+     */
+    shouldUseBatchProcessing(context, batchConfig) {
+        if (!batchConfig.enabled) {
+            logger.debug("Batch processing disabled in config");
+            return false;
+        }
+        const fileCount = context.diffStrategy.fileCount;
+        if (fileCount <= batchConfig.singleRequestThreshold) {
+            logger.debug(`File count (${fileCount}) ≤ threshold (${batchConfig.singleRequestThreshold}), using single request`);
+            return false;
+        }
+        // Force batch processing for file-by-file strategy with many files
+        if (context.diffStrategy.strategy === "file-by-file" && fileCount > 10) {
+            logger.debug(`File-by-file strategy with ${fileCount} files, forcing batch processing`);
+            return true;
+        }
+        logger.debug(`File count (${fileCount}) > threshold (${batchConfig.singleRequestThreshold}), using batch processing`);
+        return true;
+    }
+    /**
+     * Main batch processing method
+     */
+    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`);
+            // 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,
+                    });
+                }
+            }
+            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;
+        }
+    }
+    /**
+     * Prioritize files based on security importance and file type
+     */
+    async prioritizeFiles(context, batchConfig) {
+        const files = context.pr.fileChanges || [];
+        const prioritizedFiles = [];
+        for (const filePath of files) {
+            const priority = this.calculateFilePriority(filePath, batchConfig);
+            const estimatedTokens = await this.estimateFileTokens(filePath, context);
+            prioritizedFiles.push({
+                path: filePath,
+                priority,
+                estimatedTokens,
+                diff: context.fileDiffs?.get(filePath),
+            });
+        }
+        // Sort by priority (high -> medium -> low) then by estimated tokens (smaller first)
+        prioritizedFiles.sort((a, b) => {
+            const priorityOrder = { high: 0, medium: 1, low: 2 };
+            const priorityDiff = priorityOrder[a.priority] - priorityOrder[b.priority];
+            if (priorityDiff !== 0) {
+                return priorityDiff;
+            }
+            return a.estimatedTokens - b.estimatedTokens;
+        });
+        return prioritizedFiles;
+    }
+    /**
+     * Calculate file priority based on path and content
+     */
+    calculateFilePriority(filePath, batchConfig) {
+        if (!batchConfig.prioritizeSecurityFiles) {
+            return "medium"; // All files same priority if not prioritizing
+        }
+        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,
+        ];
+        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,
+        ];
+        if (lowPriorityPatterns.some(pattern => pattern.test(path))) {
+            return "low";
+        }
+        // Medium priority: Everything else
+        return "medium";
+    }
+    /**
+     * Estimate token count for a file
+     */
+    async estimateFileTokens(filePath, context) {
+        try {
+            let content = "";
+            if (context.fileDiffs?.has(filePath)) {
+                content = context.fileDiffs.get(filePath) || "";
+            }
+            else if (context.prDiff) {
+                // Extract file content from whole diff
+                const diffLines = context.prDiff.diff.split("\n");
+                let inFile = false;
+                for (const line of diffLines) {
+                    if (line.startsWith("diff --git") && line.includes(filePath)) {
+                        inFile = true;
+                        continue;
+                    }
+                    if (inFile && line.startsWith("diff --git")) {
+                        break;
+                    }
+                    if (inFile) {
+                        content += line + "\n";
+                    }
+                }
+            }
+            // Rough estimation: ~4 characters per token
+            const estimatedTokens = Math.ceil(content.length / 4);
+            // Add base overhead for context and prompts
+            const baseOverhead = 1000;
+            return estimatedTokens + baseOverhead;
+        }
+        catch (error) {
+            logger.debug(`Error estimating tokens for ${filePath}: ${error.message}`);
+            return 2000; // Default estimate
+        }
+    }
+    /**
+     * Create batches from prioritized files
+     */
+    createBatches(prioritizedFiles, batchConfig) {
+        const batches = [];
+        const maxTokensPerBatch = this.getSafeTokenLimit() * 0.7; // Use 70% of limit for safety
+        let currentBatch = {
+            files: [],
+            priority: "medium",
+            estimatedTokens: 0,
+            batchIndex: 0,
+        };
+        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) {
+                // Finalize current batch
+                batches.push(currentBatch);
+                // Start new batch
+                currentBatch = {
+                    files: [],
+                    priority: file.priority,
+                    estimatedTokens: 0,
+                    batchIndex: batches.length,
+                };
+            }
+            // Add file to current batch
+            currentBatch.files.push(file.path);
+            currentBatch.estimatedTokens += file.estimatedTokens;
+            // Update batch priority to highest priority file in batch
+            if (file.priority === "high" ||
+                (file.priority === "medium" && currentBatch.priority === "low")) {
+                currentBatch.priority = file.priority;
+            }
+        }
+        // Add final batch if it has files
+        if (currentBatch.files.length > 0) {
+            batches.push(currentBatch);
+        }
+        return batches;
+    }
+    /**
+     * Process a single batch of files
+     */
+    async processBatch(batch, context, options) {
+        const startTime = Date.now();
+        try {
+            // Create batch-specific context
+            const batchContext = this.createBatchContext(batch, context);
+            // Build batch-specific prompt
+            const batchPrompt = this.buildBatchAnalysisPrompt(batchContext, batch, options);
+            // Analyze with AI
+            const violations = await this.analyzeWithAI(batchPrompt, batchContext);
+            const processingTime = Date.now() - startTime;
+            return {
+                batchIndex: batch.batchIndex,
+                files: batch.files,
+                violations,
+                processingTime,
+            };
+        }
+        catch (error) {
+            const processingTime = Date.now() - startTime;
+            return {
+                batchIndex: batch.batchIndex,
+                files: batch.files,
+                violations: [],
+                processingTime,
+                error: error.message,
+            };
+        }
+    }
+    /**
+     * Create context for a specific batch
+     */
+    createBatchContext(batch, originalContext) {
+        // Create a filtered context containing only the files in this batch
+        const batchFileDiffs = new Map();
+        if (originalContext.fileDiffs) {
+            for (const filePath of batch.files) {
+                const diff = originalContext.fileDiffs.get(filePath);
+                if (diff) {
+                    batchFileDiffs.set(filePath, diff);
+                }
+            }
+        }
+        return {
+            ...originalContext,
+            fileDiffs: batchFileDiffs,
+            diffStrategy: {
+                ...originalContext.diffStrategy,
+                fileCount: batch.files.length,
+                strategy: "file-by-file", // Always use file-by-file for batches
+                reason: `Batch processing ${batch.files.length} files`,
+            },
+            pr: {
+                ...originalContext.pr,
+                fileChanges: batch.files,
+            },
+        };
+    }
+    /**
+     * Build analysis prompt for a specific batch
+     */
+    buildBatchAnalysisPrompt(batchContext, batch, options) {
+        const diffContent = this.extractDiffContent(batchContext);
+        return `Conduct a focused security and quality analysis of this batch of ${batch.files.length} files (${batch.priority} priority).
+
+## BATCH CONTEXT:
+**Batch**: ${batch.batchIndex + 1}
+**Files**: ${batch.files.length}
+**Priority**: ${batch.priority}
+**Files in batch**: ${batch.files.join(", ")}
+
+## PR CONTEXT:
+**Title**: ${batchContext.pr.title}
+**Author**: ${batchContext.pr.author}
+**Repository**: ${batchContext.identifier.workspace}/${batchContext.identifier.repository}
+
+## PROJECT CONTEXT:
+${batchContext.projectContext.memoryBank.projectContext || batchContext.projectContext.memoryBank.summary}
+
+## PROJECT RULES & STANDARDS:
+${batchContext.projectContext.clinerules || "No specific rules defined"}
+
+## BATCH CODE CHANGES:
+${diffContent}
+
+## CRITICAL INSTRUCTIONS FOR CODE SNIPPETS:
+
+When you identify an issue in the code, you MUST:
+1. Copy the EXACT line from the diff above, including the diff prefix (+, -, or space at the beginning)
+2. Do NOT modify, clean, or reformat the line
+3. Include the complete line as it appears in the diff
+4. If the issue spans multiple lines, choose the most relevant single line
+
+## ANALYSIS REQUIREMENTS:
+
+${this.getAnalysisRequirements()}
+
+### 📋 OUTPUT FORMAT
+Return ONLY valid JSON:
+{
+  "violations": [
+    {
+      "type": "inline",
+      "file": "exact/file/path.ext",
+      "code_snippet": "EXACT line from diff INCLUDING the +/- prefix",
+      "search_context": {
+        "before": ["line before from diff with prefix"],
+        "after": ["line after from diff with prefix"]
+      },
+      "severity": "CRITICAL|MAJOR|MINOR|SUGGESTION",
+      "category": "security|performance|maintainability|functionality",
+      "issue": "Brief issue title",
+      "message": "Detailed explanation",
+      "impact": "Potential impact description",
+      "suggestion": "Clean, executable code fix (no diff symbols)"
+    }
+  ],
+  "summary": "Batch analysis summary",
+  "positiveObservations": ["Good practices found"],
+  "statistics": {
+    "filesReviewed": ${batch.files.length},
+    "totalIssues": 0,
+    "criticalCount": 0,
+    "majorCount": 0,
+    "minorCount": 0,
+    "suggestionCount": 0
+  }
+}`;
+    }
     /**
      * Utility methods
      */
@@ -1016,6 +1382,43 @@ ${recommendation}
         }
         return null;
     }
+    /**
+     * Detect programming language from file extension
+     */
+    detectLanguageFromFile(filePath) {
+        const ext = filePath.split(".").pop()?.toLowerCase();
+        const languageMap = {
+            js: "javascript",
+            jsx: "javascript",
+            ts: "typescript",
+            tsx: "typescript",
+            py: "python",
+            java: "java",
+            cpp: "cpp",
+            c: "c",
+            cs: "csharp",
+            php: "php",
+            rb: "ruby",
+            go: "go",
+            rs: "rust",
+            res: "rescript",
+            kt: "kotlin",
+            swift: "swift",
+            scala: "scala",
+            sh: "bash",
+            sql: "sql",
+            json: "json",
+            yaml: "yaml",
+            yml: "yaml",
+            xml: "xml",
+            html: "html",
+            css: "css",
+            scss: "scss",
+            sass: "sass",
+            md: "markdown",
+        };
+        return languageMap[ext || ""] || "text";
+    }
     /**
      * Generate all possible path variations for a file
      */

package/dist/types/index.d.ts

@@ -162,6 +162,35 @@ export interface ReviewStatistics {
     majorCount: number;
     minorCount: number;
     suggestionCount: number;
+    batchCount?: number;
+    processingStrategy?: "single-request" | "batch-processing";
+    averageBatchSize?: number;
+    totalProcessingTime?: number;
+}
+export interface FileBatch {
+    files: string[];
+    priority: "high" | "medium" | "low";
+    estimatedTokens: number;
+    batchIndex: number;
+}
+export interface BatchResult {
+    batchIndex: number;
+    files: string[];
+    violations: Violation[];
+    processingTime: number;
+    tokenUsage?: {
+        input: number;
+        output: number;
+        total: number;
+    };
+    error?: string;
+}
+export type FilePriority = "high" | "medium" | "low";
+export interface PrioritizedFile {
+    path: string;
+    priority: FilePriority;
+    estimatedTokens: number;
+    diff?: string;
 }
 export interface ReviewOptions {
     workspace: string;
@@ -250,6 +279,15 @@ export interface CodeReviewConfig {
     systemPrompt?: string;
     analysisTemplate?: string;
     focusAreas?: string[];
+    batchProcessing?: BatchProcessingConfig;
+}
+export interface BatchProcessingConfig {
+    enabled: boolean;
+    maxFilesPerBatch: number;
+    prioritizeSecurityFiles: boolean;
+    parallelBatches: boolean;
+    batchDelayMs: number;
+    singleRequestThreshold: number;
 }
 export interface DescriptionEnhancementConfig {
     enabled: boolean;

package/dist/utils/Cache.js

@@ -229,7 +229,7 @@ export class Cache {
         }
         // Clean up tag associations for deleted keys
         this.tags.forEach((keys, tag) => {
-            const validKeys = new Set([...keys].filter((key) => this.cache.has(key)));
+            const validKeys = new Set(Array.from(keys).filter((key) => this.cache.has(key)));
             if (validKeys.size !== keys.size) {
                 this.tags.set(tag, validKeys);
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/yama",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Enterprise-grade Pull Request automation toolkit with AI-powered code review and description enhancement",
   "keywords": [
     "pr",
@@ -54,12 +54,12 @@
     "test": "jest",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
-    "type-check": "tsc --noEmit",
+    "type-check": "tsc --noEmit --skipLibCheck",
     "format": "prettier --write .",
     "format:check": "prettier --check .",
     "docs": "typedoc src",
     "clean": "rimraf dist",
-    "prepare": "npm run build",
+    "prepare": "husky install",
     "prepack": "npm run build && npm run test",
     "changeset": "changeset",
     "changeset:version": "changeset version && git add --all",
@@ -67,7 +67,20 @@
     "release:dry": "npm publish --dry-run",
     "release:github": "npm publish --registry https://npm.pkg.github.com",
     "version:check": "npm version --no-git-tag-version",
-    "pack:verify": "npm pack && tar -tzf *.tgz | head -20"
+    "pack:verify": "npm pack && tar -tzf *.tgz | head -20",
+    "validate": "npm run validate:env && npm run validate:security",
+    "validate:all": "npm run lint && npm run type-check && npm run validate",
+    "validate:env": "node scripts/validate-env.cjs",
+    "validate:security": "node scripts/validate-security.cjs",
+    "validate:commit": "node scripts/commit-validation.cjs \"$(git log -1 --pretty=format:'%s')\"",
+    "validate:build": "node scripts/build-validations.cjs",
+    "commit:validate": "node scripts/commit-validation.cjs",
+    "pre-commit": "lint-staged",
+    "pre-push": "npm run validate && npm run test",
+    "quality:all": "npm run lint && npm run format && npm run test",
+    "quality:metrics": "node scripts/quality-metrics.cjs",
+    "quality:report": "npm run quality:metrics && echo 'Quality metrics saved to quality-metrics.json'",
+    "check:all": "npm run lint && npm run format --check && npm run validate && npm run validate:commit"
   },
   "dependencies": {
     "@juspay/neurolink": "^5.1.0",
@@ -111,7 +124,9 @@
     "@semantic-release/release-notes-generator": "^14.0.1",
     "semantic-release": "^24.0.0",
     "prettier": "^3.0.0",
-    "publint": "^0.3.0"
+    "publint": "^0.3.0",
+    "husky": "^9.0.0",
+    "lint-staged": "^15.0.0"
   },
   "peerDependencies": {
     "typescript": ">=4.5.0"
@@ -134,5 +149,15 @@
     "onlyBuiltDependencies": [
       "esbuild"
     ]
+  },
+  "lint-staged": {
+    "*.{ts,tsx,js,jsx}": [
+      "eslint --fix",
+      "prettier --write"
+    ],
+    "*.{json,md,yml,yaml}": [
+      "prettier --write"
+    ],
+    "*.ts": []
   }
 }

package/yama.config.example.yaml

@@ -51,6 +51,15 @@ features:
       - "Performance bottlenecks"
       - "Error handling"
       - "Code quality"
+    
+    # NEW: Batch Processing Configuration
+    batchProcessing:
+      enabled: true # Enable batch processing for large PRs
+      maxFilesPerBatch: 3 # Maximum files to process in each batch
+      prioritizeSecurityFiles: true # Process security-sensitive files first
+      parallelBatches: false # Process batches sequentially for reliability
+      batchDelayMs: 1000 # Delay between batches in milliseconds
+      singleRequestThreshold: 5 # Use single request for PRs with ≤5 files
 
   # Description Enhancement Configuration
   descriptionEnhancement:
@@ -149,4 +158,4 @@ memoryBank:
   fallbackPaths:       # Optional fallback paths if primary doesn't exist
     - "docs/memory-bank"
     - ".memory-bank"
-    - "project-docs/context"
+    - "project-docs/context"