@juspay/yama 1.0.0

package/dist/features/CodeReviewer.js

@@ -0,0 +1,1041 @@
+"use strict";
+/**
+ * Enhanced Code Reviewer - Optimized to work with Unified Context
+ * Preserves all original functionality from pr-police.js but optimized
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeReviewer = void 0;
+exports.createCodeReviewer = createCodeReviewer;
+// NeuroLink will be dynamically imported
+const types_1 = require("../types");
+const Logger_1 = require("../utils/Logger");
+class CodeReviewer {
+    constructor(bitbucketProvider, aiConfig, reviewConfig) {
+        this.bitbucketProvider = bitbucketProvider;
+        this.aiConfig = aiConfig;
+        this.reviewConfig = reviewConfig;
+    }
+    /**
+     * Review code using pre-gathered unified context (OPTIMIZED)
+     */
+    async reviewCodeWithContext(context, options) {
+        const startTime = Date.now();
+        try {
+            Logger_1.logger.phase("🧪 Conducting AI-powered code analysis...");
+            Logger_1.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);
+            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_1.logger.success(`Code review completed in ${duration}s: ${validatedViolations.length} violations found`);
+            return result;
+        }
+        catch (error) {
+            Logger_1.logger.error(`Code review failed: ${error.message}`);
+            throw new types_1.ProviderError(`Code review failed: ${error.message}`);
+        }
+    }
+    /**
+     * Validate violations to ensure code snippets exist in diff
+     */
+    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_1.logger.debug(`⚠️ Skipping violation - snippet not found in diff: ${violation.file}`);
+                        Logger_1.logger.debug(`   Original snippet: "${violation.code_snippet}"`);
+                    }
+                }
+            }
+            else {
+                // Non-inline violations are always valid
+                validatedViolations.push(violation);
+            }
+        }
+        Logger_1.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;
+        }
+        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_1.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_1.logger.debug(`Found diff for ${violation.file} using partial match: ${key}`);
+                            break;
+                        }
+                    }
+                }
+            }
+            if (!fileDiff) {
+                Logger_1.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_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_1.logger.debug(`✅ Fixed code snippet for ${violation.file} using fuzzy match`);
+                    return fixedViolation;
+                }
+            }
+            Logger_1.logger.debug(`❌ Could not find snippet in diff for ${violation.file}`);
+            Logger_1.logger.debug(`   Looking for: "${violation.code_snippet}"`);
+        }
+        catch (error) {
+            Logger_1.logger.debug(`Error fixing code snippet: ${error.message}`);
+        }
+        return null;
+    }
+    /**
+     * Get system prompt for security-focused code review
+     */
+    getSecurityReviewSystemPrompt() {
+        return (this.reviewConfig.systemPrompt ||
+            `You are an Expert Security Code Reviewer for enterprise applications. Your role is to:
+
+🔒 SECURITY FIRST: Prioritize security vulnerabilities and data protection
+⚡ PERFORMANCE AWARE: Identify performance bottlenecks and optimization opportunities  
+🏗️ QUALITY FOCUSED: Ensure maintainable, readable, and robust code
+🛡️ ERROR RESILIENT: Verify comprehensive error handling and edge cases
+
+You provide actionable, educational feedback with specific examples and solutions.
+Focus on critical issues that could impact production systems.
+
+CRITICAL INSTRUCTION: When identifying issues, you MUST copy the EXACT line from the diff, including the diff prefix (+, -, or space). Do not modify or clean the line in any way.`);
+    }
+    /**
+     * Get analysis requirements from config or defaults
+     */
+    getAnalysisRequirements() {
+        if (this.reviewConfig.focusAreas &&
+            this.reviewConfig.focusAreas.length > 0) {
+            return this.reviewConfig.focusAreas
+                .map((area) => `### ${area}`)
+                .join("\n\n");
+        }
+        // Default analysis requirements
+        return `### 🔒 Security Analysis (CRITICAL PRIORITY)
+- SQL/XSS/Command injection vulnerabilities
+- Authentication/authorization flaws
+- Input validation and sanitization
+- Hardcoded secrets or credentials
+- Data exposure and privacy concerns
+
+### ⚡ Performance Review
+- Algorithm efficiency and complexity
+- Database query optimization
+- Memory management and resource leaks
+- Caching opportunities
+
+### 🏗️ Code Quality
+- SOLID principles compliance
+- Error handling robustness
+- Code organization and readability
+- Test coverage considerations`;
+    }
+    /**
+     * Build focused analysis prompt separated from context
+     */
+    buildCoreAnalysisPrompt(context) {
+        const diffContent = this.extractDiffContent(context);
+        return `Conduct a comprehensive security and quality analysis of this ${context.diffStrategy.strategy === "whole" ? "pull request" : "code changeset"}.
+
+## COMPLETE PR CONTEXT:
+**Title**: ${context.pr.title}
+**Author**: ${context.pr.author}  
+**Description**: ${context.pr.description}
+**Files Changed**: ${context.pr.fileChanges?.length || 0}
+**Existing Comments**: ${JSON.stringify(context.pr.comments || [], null, 2)}
+**Branch**: ${context.identifier.branch}
+**Repository**: ${context.identifier.workspace}/${context.identifier.repository}
+
+## DIFF STRATEGY (${context.diffStrategy.strategy.toUpperCase()}):
+**Reason**: ${context.diffStrategy.reason}
+**File Count**: ${context.diffStrategy.fileCount}
+**Estimated Size**: ${context.diffStrategy.estimatedSize}
+
+## COMPLETE PROJECT CONTEXT:
+${context.projectContext.memoryBank.projectContext || context.projectContext.memoryBank.summary}
+
+## PROJECT RULES & STANDARDS:
+${context.projectContext.clinerules || "No specific rules defined"}
+
+## COMPLETE CODE CHANGES (NO TRUNCATION):
+${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
+
+Example of CORRECT snippet format:
+- For added lines: "+    const password = 'hardcoded123';"
+- For removed lines: "-    return userData;"  
+- For context lines: "     function processPayment() {"
+
+Example of INCORRECT snippet format (DO NOT DO THIS):
+- "const password = 'hardcoded123';" (missing the + prefix)
+- "return userData" (missing the - prefix and semicolon)
+
+## 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": "Analysis summary",
+  "positiveObservations": ["Good practices found"],
+  "statistics": {
+    "filesReviewed": ${context.diffStrategy.fileCount},
+    "totalIssues": 0,
+    "criticalCount": 0,
+    "majorCount": 0,
+    "minorCount": 0,
+    "suggestionCount": 0
+  }
+}`;
+    }
+    /**
+     * Extract diff content based on strategy
+     */
+    extractDiffContent(context) {
+        if (context.diffStrategy.strategy === "whole" && context.prDiff) {
+            return context.prDiff.diff || JSON.stringify(context.prDiff, null, 2);
+        }
+        else if (context.diffStrategy.strategy === "file-by-file" &&
+            context.fileDiffs) {
+            const fileDiffArray = Array.from(context.fileDiffs.entries()).map(([file, diff]) => ({
+                file,
+                diff,
+            }));
+            return JSON.stringify(fileDiffArray, null, 2);
+        }
+        return "No diff content available";
+    }
+    /**
+     * Detect project type for better context
+     */
+    detectProjectType(context) {
+        const fileExtensions = new Set();
+        // Extract file extensions from changes
+        if (context.pr.fileChanges) {
+            context.pr.fileChanges.forEach((file) => {
+                const ext = file.split(".").pop()?.toLowerCase();
+                if (ext) {
+                    fileExtensions.add(ext);
+                }
+            });
+        }
+        if (fileExtensions.has("rs") || fileExtensions.has("res")) {
+            return "rescript";
+        }
+        if (fileExtensions.has("ts") || fileExtensions.has("tsx")) {
+            return "typescript";
+        }
+        if (fileExtensions.has("js") || fileExtensions.has("jsx")) {
+            return "javascript";
+        }
+        if (fileExtensions.has("py")) {
+            return "python";
+        }
+        if (fileExtensions.has("go")) {
+            return "golang";
+        }
+        if (fileExtensions.has("java")) {
+            return "java";
+        }
+        if (fileExtensions.has("cpp") || fileExtensions.has("c")) {
+            return "cpp";
+        }
+        return "mixed";
+    }
+    /**
+     * Assess complexity level for better AI context
+     */
+    assessComplexity(context) {
+        const fileCount = context.diffStrategy.fileCount;
+        const hasLargeFiles = context.diffStrategy.estimatedSize.includes("Large");
+        const hasComments = (context.pr.comments?.length || 0) > 0;
+        if (fileCount > 50) {
+            return "very-high";
+        }
+        if (fileCount > 20 || hasLargeFiles) {
+            return "high";
+        }
+        if (fileCount > 10 || hasComments) {
+            return "medium";
+        }
+        return "low";
+    }
+    /**
+     * Legacy method - kept for compatibility but simplified
+     */
+    buildAnalysisPrompt(context, _options) {
+        // Legacy method - now delegates to new structure
+        return this.buildCoreAnalysisPrompt(context);
+    }
+    /**
+     * Analyze code with AI using the enhanced prompt
+     */
+    async analyzeWithAI(prompt, context) {
+        try {
+            Logger_1.logger.debug("Starting AI analysis...");
+            // Initialize NeuroLink with eval-based dynamic import
+            if (!this.neurolink) {
+                const dynamicImport = eval("(specifier) => import(specifier)");
+                const { NeuroLink } = await dynamicImport("@juspay/neurolink");
+                this.neurolink = new NeuroLink();
+            }
+            // Extract context from unified context for better AI understanding
+            const aiContext = {
+                operation: "code-review",
+                repository: `${context.identifier.workspace}/${context.identifier.repository}`,
+                branch: context.identifier.branch,
+                prId: context.identifier.pullRequestId,
+                prTitle: context.pr.title,
+                prAuthor: context.pr.author,
+                fileCount: context.diffStrategy.fileCount,
+                diffStrategy: context.diffStrategy.strategy,
+                analysisType: context.diffStrategy.strategy === "whole"
+                    ? "comprehensive"
+                    : "file-by-file",
+                projectType: this.detectProjectType(context),
+                hasExistingComments: (context.pr.comments?.length || 0) > 0,
+                complexity: this.assessComplexity(context),
+            };
+            // Simplified, focused prompt without context pollution
+            const corePrompt = this.buildCoreAnalysisPrompt(context);
+            const result = await this.neurolink.generate({
+                input: { text: corePrompt },
+                systemPrompt: this.getSecurityReviewSystemPrompt(),
+                provider: this.aiConfig.provider || "auto", // Auto-select best provider
+                model: this.aiConfig.model || "best", // Use most capable model
+                temperature: this.aiConfig.temperature || 0.3, // Lower for more focused analysis
+                maxTokens: Math.max(this.aiConfig.maxTokens || 0, 2000000), // Quality first - always use higher limit
+                timeout: "15m", // Allow plenty of time for thorough analysis
+                context: aiContext,
+                enableAnalytics: this.aiConfig.enableAnalytics || true,
+                enableEvaluation: false, // Disabled to prevent evaluation warnings
+            });
+            // Log analytics if available
+            if (result.analytics) {
+                Logger_1.logger.debug(`AI Analytics - Provider: ${result.provider}, Response Time: ${result.responseTime}ms, Quality Score: ${result.evaluation?.overallScore}`);
+            }
+            Logger_1.logger.debug("AI analysis completed, parsing response...");
+            // Modern NeuroLink returns { content: string }
+            const analysisData = this.parseAIResponse(result);
+            // Display AI response for debugging
+            if (Logger_1.logger.getConfig().verbose) {
+                Logger_1.logger.debug("AI Analysis Response:");
+                Logger_1.logger.debug("═".repeat(80));
+                Logger_1.logger.debug(JSON.stringify(analysisData, null, 2));
+                Logger_1.logger.debug("═".repeat(80));
+            }
+            if (!analysisData.violations || !Array.isArray(analysisData.violations)) {
+                Logger_1.logger.debug("No violations array found in AI response");
+                return [];
+            }
+            Logger_1.logger.debug(`AI analysis found ${analysisData.violations.length} violations`);
+            return analysisData.violations;
+        }
+        catch (error) {
+            if (error.message?.includes("timeout")) {
+                Logger_1.logger.error("⏰ AI analysis timed out after 15 minutes");
+                throw new Error("Analysis timeout - try reducing diff size or adjusting timeout");
+            }
+            Logger_1.logger.error(`AI analysis failed: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * Post comments to PR using unified context - matching pr-police.js exactly
+     */
+    async postComments(context, violations, _options) {
+        Logger_1.logger.phase("📝 Posting review comments...");
+        let commentsPosted = 0;
+        let commentsFailed = 0;
+        const failedComments = [];
+        // Post inline comments
+        const inlineViolations = violations.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)
+                let cleanFilePath = violation.file;
+                if (cleanFilePath.startsWith("src://")) {
+                    cleanFilePath = cleanFilePath.replace("src://", "");
+                }
+                if (cleanFilePath.startsWith("dst://")) {
+                    cleanFilePath = cleanFilePath.replace("dst://", "");
+                }
+                // Clean code snippet and fix search context - EXACTLY like pr-police.js
+                const processedViolation = this.cleanCodeSnippet(violation);
+                if (!processedViolation) {
+                    Logger_1.logger.debug(`⚠️ Skipping invalid violation for ${cleanFilePath}`);
+                    continue;
+                }
+                const formattedComment = this.formatInlineComment(processedViolation);
+                // Debug logging
+                Logger_1.logger.debug(`🔍 Posting inline comment:`);
+                Logger_1.logger.debug(`   File: ${cleanFilePath}`);
+                Logger_1.logger.debug(`   Issue: ${processedViolation.issue}`);
+                Logger_1.logger.debug(`   Original snippet: ${violation.code_snippet}`);
+                Logger_1.logger.debug(`   Processed snippet: ${processedViolation.code_snippet}`);
+                if (processedViolation.search_context) {
+                    Logger_1.logger.debug(`   Search context before: ${JSON.stringify(processedViolation.search_context.before)}`);
+                    Logger_1.logger.debug(`   Search context after: ${JSON.stringify(processedViolation.search_context.after)}`);
+                }
+                // Use new code snippet approach - EXACTLY like pr-police.js
+                await this.bitbucketProvider.addComment(context.identifier, formattedComment, {
+                    filePath: cleanFilePath,
+                    lineNumber: undefined, // No line number needed - use pure snippet matching
+                    lineType: processedViolation.line_type || "ADDED", // Default to ADDED if not specified
+                    codeSnippet: processedViolation.code_snippet,
+                    searchContext: processedViolation.search_context,
+                    matchStrategy: "best", // Use best match strategy instead of strict for flexibility
+                    suggestion: processedViolation.suggestion, // Pass the suggestion for inline code suggestions
+                });
+                commentsPosted++;
+                Logger_1.logger.debug(`✅ Posted inline comment: ${cleanFilePath} (${processedViolation.issue})`);
+            }
+            catch (error) {
+                commentsFailed++;
+                const errorMsg = error.message;
+                Logger_1.logger.debug(`❌ Failed to post inline comment: ${errorMsg}`);
+                Logger_1.logger.debug(`   File: ${violation.file}, Issue: ${violation.issue}`);
+                Logger_1.logger.debug(`   Code snippet: ${violation.code_snippet}`);
+                failedComments.push({
+                    file: violation.file,
+                    issue: violation.issue,
+                    error: errorMsg,
+                });
+            }
+        }
+        // Post summary comment (include failed comments info if any)
+        if (violations.length > 0) {
+            try {
+                const summaryComment = this.generateSummaryComment(violations, context, failedComments);
+                await this.bitbucketProvider.addComment(context.identifier, summaryComment);
+                commentsPosted++;
+                Logger_1.logger.debug("✅ Posted summary comment");
+            }
+            catch (error) {
+                Logger_1.logger.debug(`❌ Failed to post summary comment: ${error.message}`);
+            }
+        }
+        Logger_1.logger.success(`✅ Posted ${commentsPosted} comments successfully`);
+        if (commentsFailed > 0) {
+            Logger_1.logger.warn(`⚠️ Failed to post ${commentsFailed} inline comments`);
+        }
+    }
+    /**
+     * Format inline comment for specific violation
+     */
+    formatInlineComment(violation) {
+        const severityConfig = {
+            CRITICAL: {
+                emoji: "🚨",
+                badge: "**🚨 CRITICAL SECURITY ISSUE**",
+                color: "red",
+            },
+            MAJOR: { emoji: "⚠️", badge: "**⚠️ MAJOR ISSUE**", color: "orange" },
+            MINOR: { emoji: "📝", badge: "**📝 MINOR IMPROVEMENT**", color: "blue" },
+            SUGGESTION: { emoji: "💡", badge: "**💡 SUGGESTION**", color: "green" },
+        };
+        const categoryIcons = {
+            security: "🔒",
+            performance: "⚡",
+            maintainability: "🏗️",
+            functionality: "⚙️",
+            error_handling: "🛡️",
+            testing: "🧪",
+            general: "📋",
+        };
+        const config = severityConfig[violation.severity] || severityConfig.MINOR;
+        const categoryIcon = categoryIcons[violation.category] || categoryIcons.general;
+        let comment = `${config.badge}
+
+**${categoryIcon} ${violation.issue}**
+
+**Category**: ${violation.category.replace(/_/g, " ").replace(/\b\w/g, (l) => l.toUpperCase())}
+
+**Issue**: ${violation.message}`;
+        if (violation.impact) {
+            comment += `\n\n**Impact**: ${violation.impact}`;
+        }
+        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
+            const escapedCodeBlock = this.escapeMarkdownCodeBlock(violation.suggestion, language);
+            comment += `\n\n**💡 Suggested Fix**:\n${escapedCodeBlock}`;
+        }
+        comment += `\n\n---\n*🛡️ Automated review by **Yama** • Powered by AI*`;
+        return comment;
+    }
+    /**
+     * Generate comprehensive summary comment with failed comments info
+     */
+    generateSummaryComment(violations, context, failedComments = []) {
+        const stats = this.calculateStats(violations);
+        const statusEmoji = stats.criticalCount > 0
+            ? "🚨"
+            : stats.majorCount > 0
+                ? "⚠️ "
+                : stats.minorCount > 0
+                    ? "📝"
+                    : "✅";
+        const statusText = stats.criticalCount > 0
+            ? "CRITICAL ISSUES FOUND"
+            : stats.majorCount > 0
+                ? "ISSUES DETECTED"
+                : stats.minorCount > 0
+                    ? "IMPROVEMENTS SUGGESTED"
+                    : "CODE QUALITY APPROVED";
+        let comment = `
+╭─────────────────────────────────────────────────────────────╮
+│                    ⚔️ **YAMA REVIEW REPORT** ⚔️               │
+╰─────────────────────────────────────────────────────────────╯
+
+## ${statusEmoji} **${statusText}**
+
+### 📊 **Security & Quality Analysis**
+| **Severity** | **Count** | **Status** |
+|--------------|-----------|------------|
+| 🚨 Critical | ${stats.criticalCount} | ${stats.criticalCount > 0 ? "⛔ Must Fix" : "✅ Clear"} |
+| ⚠️ Major | ${stats.majorCount} | ${stats.majorCount > 0 ? "⚠️ Should Fix" : "✅ Clear"} |
+| 📝 Minor | ${stats.minorCount} | ${stats.minorCount > 0 ? "📝 Consider Fixing" : "✅ Clear"} |
+| 💡 Suggestions | ${stats.suggestionCount} | ${stats.suggestionCount > 0 ? "💡 Optional" : "✅ Clear"} |
+
+### 🔍 **Analysis Summary**
+- **📁 Files Analyzed**: ${context.diffStrategy.fileCount}
+- **📊 Strategy Used**: ${context.diffStrategy.strategy} (${context.diffStrategy.reason})
+- **🎯 Total Issues**: ${stats.totalIssues}
+- **🏷️ PR**: #${context.pr.id} - "${context.pr.title}"`;
+        // Add category breakdown if there are violations
+        const violationsByCategory = this.groupViolationsByCategory(violations);
+        if (Object.keys(violationsByCategory).length > 0) {
+            comment += `\n\n### 📍 **Issues by Category**\n`;
+            for (const [category, categoryViolations] of Object.entries(violationsByCategory)) {
+                const categoryIcons = {
+                    security: "🔒",
+                    performance: "⚡",
+                    maintainability: "🏗️",
+                    functionality: "⚙️",
+                    error_handling: "🛡️",
+                    testing: "🧪",
+                    general: "📋",
+                };
+                const icon = categoryIcons[category] || "📋";
+                const name = category
+                    .replace(/_/g, " ")
+                    .replace(/\b\w/g, (l) => l.toUpperCase());
+                comment += `**${icon} ${name}**: ${categoryViolations.length} issue${categoryViolations.length !== 1 ? "s" : ""}\n`;
+            }
+        }
+        // Add failed comments section if any
+        if (failedComments.length > 0) {
+            comment += `\n\n### ⚠️ **Note on Inline Comments**\n`;
+            comment += `Some inline comments could not be posted due to code matching issues. `;
+            comment += `Please review the following issues manually:\n\n`;
+            for (const failed of failedComments) {
+                comment += `- **${failed.issue}** in \`${failed.file || "unknown file"}\`\n`;
+            }
+        }
+        // Add recommendation
+        const recommendation = stats.criticalCount > 0
+            ? "🚨 **URGENT**: Critical security issues must be resolved before merge"
+            : stats.majorCount > 0
+                ? "⚠️ **RECOMMENDED**: Address major issues before merge"
+                : stats.minorCount > 0
+                    ? "📝 **OPTIONAL**: Consider addressing minor improvements"
+                    : "✅ **APPROVED**: Code meets security and quality standards";
+        comment += `\n\n### 💡 **Recommendation**
+${recommendation}
+
+---
+**🛡️ Automated Security & Quality Review**  
+*Powered by Yama AI • Keeping your code secure and maintainable* 🚀`;
+        return comment;
+    }
+    /**
+     * Helper methods for processing violations
+     */
+    cleanFilePath(filePath) {
+        // Clean the file path but preserve the structure - EXACTLY like pr-police.js
+        // Only clean src:// and dst:// prefixes, keep a/ and b/ prefixes
+        const cleaned = filePath.replace(/^(src|dst):\/\//, "");
+        // Log the cleaning for debugging
+        if (cleaned !== filePath) {
+            Logger_1.logger.debug(`Cleaned file path: ${filePath} -> ${cleaned}`);
+        }
+        return cleaned;
+    }
+    /**
+     * Extract exact file path from diff
+     */
+    extractFilePathFromDiff(diff, fileName) {
+        const lines = diff.split("\n");
+        for (const line of lines) {
+            if (line.startsWith("diff --git")) {
+                // Extract both paths: a/path/to/file b/path/to/file
+                const match = line.match(/diff --git a\/(.*?) b\/(.*?)$/);
+                if (match &&
+                    (match[1].includes(fileName) || match[2].includes(fileName))) {
+                    return match[2]; // Return the 'b/' path (destination)
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * Extract line number from diff for a specific code snippet
+     */
+    extractLineNumberFromDiff(fileDiff, codeSnippet) {
+        const lines = fileDiff.split("\n");
+        let currentNewLine = 0;
+        let currentOldLine = 0;
+        let inHunk = false;
+        // Debug logging
+        Logger_1.logger.debug(`Looking for snippet: "${codeSnippet}"`);
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            // Parse hunk headers (e.g., @@ -10,6 +10,8 @@)
+            const hunkMatch = line.match(/@@ -(\d+),?\d* \+(\d+),?\d* @@/);
+            if (hunkMatch) {
+                // Hunk headers show the starting line numbers (1-based)
+                currentOldLine = parseInt(hunkMatch[1]);
+                currentNewLine = parseInt(hunkMatch[2]);
+                inHunk = true;
+                Logger_1.logger.debug(`Found hunk header: old=${currentOldLine}, new=${currentNewLine}`);
+                continue;
+            }
+            // Skip lines that aren't part of the diff content
+            if (!inHunk ||
+                (!line.startsWith("+") &&
+                    !line.startsWith("-") &&
+                    !line.startsWith(" "))) {
+                continue;
+            }
+            // Check if this line matches our snippet
+            if (line === codeSnippet) {
+                let resultLine;
+                let lineType;
+                if (line.startsWith("+")) {
+                    resultLine = currentNewLine;
+                    lineType = "ADDED";
+                }
+                else if (line.startsWith("-")) {
+                    resultLine = currentOldLine;
+                    lineType = "REMOVED";
+                }
+                else {
+                    resultLine = currentNewLine;
+                    lineType = "CONTEXT";
+                }
+                Logger_1.logger.debug(`Found match at line ${resultLine} (${lineType})`);
+                return { lineNumber: resultLine, lineType };
+            }
+            // Update line counters AFTER checking for match
+            // For added lines: only increment new line counter
+            // For removed lines: only increment old line counter
+            // For context lines: increment both counters
+            if (line.startsWith("+")) {
+                currentNewLine++;
+            }
+            else if (line.startsWith("-")) {
+                currentOldLine++;
+            }
+            else if (line.startsWith(" ")) {
+                currentNewLine++;
+                currentOldLine++;
+            }
+        }
+        Logger_1.logger.debug(`Snippet not found in diff`);
+        return null;
+    }
+    /**
+     * Escape markdown code blocks properly
+     */
+    escapeMarkdownCodeBlock(code, language) {
+        // If code contains triple backticks, use quadruple backticks
+        if (code.includes("```")) {
+            return `\`\`\`\`${language}\n${code}\n\`\`\`\``;
+        }
+        return `\`\`\`${language}\n${code}\n\`\`\``;
+    }
+    cleanCodeSnippet(violation) {
+        try {
+            // Clone the violation to avoid modifying the original - EXACTLY like pr-police.js
+            const fixed = JSON.parse(JSON.stringify(violation));
+            // Fix search_context arrays if they contain embedded newlines
+            if (fixed.search_context) {
+                if (fixed.search_context.before &&
+                    Array.isArray(fixed.search_context.before)) {
+                    fixed.search_context.before = this.splitArrayLines(fixed.search_context.before);
+                }
+                if (fixed.search_context.after &&
+                    Array.isArray(fixed.search_context.after)) {
+                    fixed.search_context.after = this.splitArrayLines(fixed.search_context.after);
+                }
+            }
+            // Ensure line_type is set based on code snippet prefix BEFORE cleaning
+            if (!fixed.line_type && fixed.code_snippet) {
+                if (fixed.code_snippet.startsWith("+")) {
+                    fixed.line_type = "ADDED";
+                }
+                else if (fixed.code_snippet.startsWith("-")) {
+                    fixed.line_type = "REMOVED";
+                }
+                else {
+                    fixed.line_type = "CONTEXT";
+                }
+            }
+            // Clean the code_snippet field to remove diff symbols - EXACTLY like pr-police.js
+            if (fixed.code_snippet) {
+                fixed.code_snippet = fixed.code_snippet.replace(/^[+\-\s]/, "").trim();
+            }
+            // Clean the suggestion field to remove any diff symbols
+            if (fixed.suggestion) {
+                fixed.suggestion = fixed.suggestion
+                    .split("\n")
+                    .map((line) => line.replace(/^[+\-\s]/, "")) // Remove diff symbols at start of each line
+                    .join("\n")
+                    .trim();
+            }
+            return fixed;
+        }
+        catch (error) {
+            Logger_1.logger.debug(`❌ Error cleaning code snippet: ${error.message}`);
+            return null;
+        }
+    }
+    splitArrayLines(arr) {
+        const result = [];
+        for (const item of arr) {
+            if (typeof item === "string" && item.includes("\n")) {
+                result.push(...item.split("\n").filter((line) => line.length > 0));
+            }
+            else {
+                result.push(item);
+            }
+        }
+        return result;
+    }
+    groupViolationsByCategory(violations) {
+        const grouped = {};
+        violations.forEach((v) => {
+            const category = v.category || "general";
+            if (!grouped[category]) {
+                grouped[category] = [];
+            }
+            grouped[category].push(v);
+        });
+        return grouped;
+    }
+    calculateStats(violations) {
+        return {
+            criticalCount: violations.filter((v) => v.severity === "CRITICAL").length,
+            majorCount: violations.filter((v) => v.severity === "MAJOR").length,
+            minorCount: violations.filter((v) => v.severity === "MINOR").length,
+            suggestionCount: violations.filter((v) => v.severity === "SUGGESTION")
+                .length,
+            totalIssues: violations.length,
+            filesReviewed: new Set(violations.filter((v) => v.file).map((v) => v.file)).size || 1,
+        };
+    }
+    generateReviewResult(violations, _duration, _context) {
+        const stats = this.calculateStats(violations);
+        return {
+            violations,
+            summary: `Review found ${stats.criticalCount} critical, ${stats.majorCount} major, ${stats.minorCount} minor issues, and ${stats.suggestionCount} suggestions`,
+            statistics: {
+                filesReviewed: stats.filesReviewed,
+                totalIssues: stats.totalIssues,
+                criticalCount: stats.criticalCount,
+                majorCount: stats.majorCount,
+                minorCount: stats.minorCount,
+                suggestionCount: stats.suggestionCount,
+            },
+            positiveObservations: [], // Could be extracted from AI response
+        };
+    }
+    /**
+     * Utility methods
+     */
+    parseAIResponse(result) {
+        try {
+            const responseText = result.content || result.text || result.response || "";
+            if (!responseText) {
+                return { violations: [] };
+            }
+            // Extract JSON from response
+            const jsonMatch = responseText.match(/\{[\s\S]*\}/);
+            if (jsonMatch) {
+                return JSON.parse(jsonMatch[0]);
+            }
+            return { violations: [] };
+        }
+        catch (error) {
+            Logger_1.logger.debug(`Failed to parse AI response: ${error.message}`);
+            return { violations: [] };
+        }
+    }
+    /**
+     * Extract line information for comment from context
+     */
+    extractLineInfoForComment(violation, context) {
+        if (!violation.file || !violation.code_snippet) {
+            return null;
+        }
+        try {
+            // Get the diff for this specific file
+            let fileDiff;
+            if (context.diffStrategy.strategy === "whole" && context.prDiff) {
+                // Extract file diff from whole diff
+                const diffLines = context.prDiff.diff.split("\n");
+                let fileStartIndex = -1;
+                // Create all possible path variations for matching
+                const filePathVariations = this.generatePathVariations(violation.file);
+                for (let i = 0; i < diffLines.length; i++) {
+                    const line = diffLines[i];
+                    if (line.startsWith("diff --git")) {
+                        // Check if any variation matches
+                        for (const pathVariation of filePathVariations) {
+                            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"));
+                    fileDiff = diffLines
+                        .slice(fileStartIndex, nextFileIndex > 0 ? nextFileIndex : diffLines.length)
+                        .join("\n");
+                }
+            }
+            else if (context.diffStrategy.strategy === "file-by-file" &&
+                context.fileDiffs) {
+                // Try all possible path variations
+                const pathVariations = this.generatePathVariations(violation.file);
+                for (const path of pathVariations) {
+                    fileDiff = context.fileDiffs.get(path);
+                    if (fileDiff) {
+                        Logger_1.logger.debug(`Found diff for ${violation.file} using variation: ${path}`);
+                        break;
+                    }
+                }
+                // If still not found, try to find by partial match
+                if (!fileDiff) {
+                    for (const [key, value] of context.fileDiffs.entries()) {
+                        if (key.endsWith(violation.file) || violation.file.endsWith(key)) {
+                            fileDiff = value;
+                            Logger_1.logger.debug(`Found diff for ${violation.file} using partial match: ${key}`);
+                            break;
+                        }
+                    }
+                }
+            }
+            if (fileDiff) {
+                const lineInfo = this.extractLineNumberFromDiff(fileDiff, violation.code_snippet);
+                if (lineInfo) {
+                    Logger_1.logger.debug(`Extracted line info for ${violation.file}: line ${lineInfo.lineNumber}, type ${lineInfo.lineType}`);
+                }
+                return lineInfo;
+            }
+            else {
+                Logger_1.logger.debug(`No diff found for file: ${violation.file}`);
+            }
+        }
+        catch (error) {
+            Logger_1.logger.debug(`Error extracting line info: ${error.message}`);
+        }
+        return null;
+    }
+    /**
+     * Generate all possible path variations for a file
+     */
+    generatePathVariations(filePath) {
+        const variations = new Set();
+        // Add original path
+        variations.add(filePath);
+        // Add with a/ and b/ prefixes
+        variations.add(`a/${filePath}`);
+        variations.add(`b/${filePath}`);
+        // Handle nested paths
+        if (filePath.includes("/")) {
+            const parts = filePath.split("/");
+            // Try removing first directory
+            if (parts.length > 1) {
+                variations.add(parts.slice(1).join("/"));
+            }
+            // Try removing first two directories
+            if (parts.length > 2) {
+                variations.add(parts.slice(2).join("/"));
+            }
+            // Try with just the filename
+            variations.add(parts[parts.length - 1]);
+        }
+        // Remove app/ prefix variations
+        if (filePath.startsWith("app/")) {
+            const withoutApp = filePath.substring(4);
+            variations.add(withoutApp);
+            variations.add(`a/${withoutApp}`);
+            variations.add(`b/${withoutApp}`);
+        }
+        // Add app/ prefix variations
+        if (!filePath.startsWith("app/")) {
+            variations.add(`app/${filePath}`);
+            variations.add(`a/app/${filePath}`);
+            variations.add(`b/app/${filePath}`);
+        }
+        return Array.from(variations);
+    }
+}
+exports.CodeReviewer = CodeReviewer;
+function createCodeReviewer(bitbucketProvider, aiConfig, reviewConfig) {
+    return new CodeReviewer(bitbucketProvider, aiConfig, reviewConfig);
+}
+//# sourceMappingURL=CodeReviewer.js.map