@juspay/yama 1.0.0

package/dist/core/providers/BitbucketProvider.js

@@ -0,0 +1,444 @@
+"use strict";
+/**
+ * Enhanced Bitbucket Provider - Optimized from both pr-police.js and pr-describe.js
+ * Provides unified, cached, and optimized Bitbucket operations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BitbucketProvider = void 0;
+exports.createBitbucketProvider = createBitbucketProvider;
+const types_1 = require("../../types");
+const Logger_1 = require("../../utils/Logger");
+const Cache_1 = require("../../utils/Cache");
+class BitbucketProvider {
+    constructor(credentials) {
+        this.initialized = false;
+        this.credentials = credentials;
+        this.baseUrl = credentials.baseUrl || "https://your-bitbucket-server.com";
+    }
+    /**
+     * Initialize MCP handlers with lazy loading and connection reuse
+     */
+    async initialize() {
+        if (this.initialized) {
+            return;
+        }
+        try {
+            Logger_1.logger.debug("Initializing Bitbucket MCP handlers...");
+            const dynamicImport = eval("(specifier) => 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"),
+                dynamicImport("@nexus2520/bitbucket-mcp-server/build/handlers/pull-request-handlers.js"),
+                dynamicImport("@nexus2520/bitbucket-mcp-server/build/handlers/review-handlers.js"),
+                dynamicImport("@nexus2520/bitbucket-mcp-server/build/handlers/file-handlers.js"),
+            ]);
+            this.apiClient = new BitbucketApiClient(this.baseUrl, this.credentials.username, undefined, this.credentials.token);
+            this.branchHandlers = new BranchHandlers(this.apiClient, this.baseUrl);
+            this.pullRequestHandlers = new PullRequestHandlers(this.apiClient, this.baseUrl, this.credentials.username);
+            this.reviewHandlers = new ReviewHandlers(this.apiClient, this.credentials.username);
+            this.fileHandlers = new FileHandlers(this.apiClient, this.baseUrl);
+            this.initialized = true;
+            Logger_1.logger.debug("Bitbucket MCP handlers initialized successfully");
+        }
+        catch (error) {
+            throw new types_1.ProviderError(`Failed to initialize Bitbucket provider: ${error.message}`);
+        }
+    }
+    /**
+     * Parse MCP response - exactly matching the working pr-police.js implementation
+     */
+    parseMCPResponse(result) {
+        // Handle error responses
+        if (result.error) {
+            throw new Error(result.error);
+        }
+        // Check if result has MCP format (content array) or direct data - EXACTLY like pr-police.js
+        if (result.content && result.content[0] && result.content[0].text) {
+            const text = result.content[0].text;
+            // Check if it's an error message
+            if (typeof text === "string" && text.startsWith("Error:")) {
+                throw new Error(text);
+            }
+            try {
+                return JSON.parse(text);
+            }
+            catch (error) {
+                // If parsing fails, return the text as-is for simple responses
+                return text;
+            }
+        }
+        else {
+            // Direct data format - return as-is
+            return result;
+        }
+    }
+    /**
+     * Find PR for branch with intelligent caching
+     */
+    async findPRForBranch(identifier) {
+        await this.initialize();
+        const { workspace, repository, branch } = identifier;
+        if (!branch) {
+            throw new types_1.ProviderError("Branch name is required");
+        }
+        const cacheKey = Cache_1.Cache.keys.branchInfo(workspace, repository, branch);
+        return Cache_1.cache.getOrSet(cacheKey, async () => {
+            Logger_1.logger.debug(`Finding PR for branch: ${workspace}/${repository}@${branch}`);
+            const rawBranchData = await this.branchHandlers.handleGetBranch({
+                workspace,
+                repository,
+                branch_name: branch,
+                include_merged_prs: false,
+            });
+            const branchData = this.parseMCPResponse(rawBranchData);
+            // Direct data extraction
+            if (branchData.open_pull_requests &&
+                branchData.open_pull_requests.length > 0) {
+                const firstPR = branchData.open_pull_requests[0];
+                // Debug author data structure
+                Logger_1.logger.debug(`Author data structure: ${JSON.stringify(firstPR.author, null, 2)}`);
+                Logger_1.logger.debug(`Raw firstPR keys: ${Object.keys(firstPR).join(", ")}`);
+                return {
+                    id: firstPR.id,
+                    title: firstPR.title,
+                    description: firstPR.description || "",
+                    author: firstPR.author?.displayName ||
+                        firstPR.author?.name ||
+                        firstPR.author ||
+                        "Unknown",
+                    state: "OPEN",
+                    sourceRef: branch,
+                    targetRef: firstPR.destination?.branch?.name || "main",
+                    createdDate: firstPR.createdDate || new Date().toISOString(),
+                    updatedDate: firstPR.updatedDate || new Date().toISOString(),
+                    reviewers: firstPR.reviewers || [],
+                    fileChanges: firstPR.file_changes || [],
+                };
+            }
+            throw new types_1.ProviderError(`No open PR found for branch: ${branch}`);
+        }, 3600);
+    }
+    /**
+     * Get PR details with enhanced caching
+     */
+    async getPRDetails(identifier) {
+        await this.initialize();
+        const { workspace, repository, pullRequestId } = identifier;
+        if (!pullRequestId) {
+            throw new types_1.ProviderError("Pull request ID is required");
+        }
+        const cacheKey = Cache_1.Cache.keys.prInfo(workspace, repository, pullRequestId);
+        return Cache_1.cache.getOrSet(cacheKey, async () => {
+            Logger_1.logger.debug(`Getting PR details: ${workspace}/${repository}#${pullRequestId}`);
+            const rawPRDetails = await this.pullRequestHandlers.handleGetPullRequest({
+                workspace,
+                repository,
+                pull_request_id: pullRequestId,
+            });
+            const prData = this.parseMCPResponse(rawPRDetails);
+            // Debug author data structure
+            Logger_1.logger.debug(`PR Details author data structure: ${JSON.stringify(prData.author, null, 2)}`);
+            Logger_1.logger.debug(`PR Details raw keys: ${Object.keys(prData).join(", ")}`);
+            return {
+                id: prData.id,
+                title: prData.title,
+                description: prData.description || "",
+                author: prData.author?.displayName ||
+                    prData.author?.name ||
+                    prData.author ||
+                    "Unknown",
+                state: prData.state || "OPEN",
+                sourceRef: prData.source?.branch?.name || "",
+                targetRef: prData.destination?.branch?.name || "",
+                createdDate: prData.createdDate || new Date().toISOString(),
+                updatedDate: prData.updatedDate || new Date().toISOString(),
+                reviewers: prData.reviewers || [],
+                comments: prData.active_comments || [],
+                fileChanges: prData.file_changes?.map((f) => f.path || f.file) ||
+                    [],
+            };
+        }, 1800);
+    }
+    /**
+     * Get PR diff with smart caching and filtering
+     */
+    async getPRDiff(identifier, contextLines = 3, excludePatterns = ["*.lock", "*.svg"], includePatterns) {
+        await this.initialize();
+        const { workspace, repository, pullRequestId } = identifier;
+        if (!pullRequestId) {
+            throw new types_1.ProviderError("Pull request ID is required");
+        }
+        // Create a cache key that includes include patterns if specified
+        const cacheKey = includePatterns && includePatterns.length === 1
+            ? `file-diff:${workspace}:${repository}:${pullRequestId}:${includePatterns[0]}`
+            : Cache_1.Cache.keys.prDiff(workspace, repository, pullRequestId);
+        return Cache_1.cache.getOrSet(cacheKey, async () => {
+            Logger_1.logger.debug(`Getting PR diff: ${workspace}/${repository}#${pullRequestId}`);
+            if (includePatterns) {
+                Logger_1.logger.debug(`Include patterns: ${includePatterns.join(", ")}`);
+            }
+            const args = {
+                workspace,
+                repository,
+                pull_request_id: pullRequestId,
+                context_lines: contextLines,
+                exclude_patterns: excludePatterns,
+            };
+            // Add include_patterns if specified
+            if (includePatterns) {
+                args.include_patterns = includePatterns;
+            }
+            const rawDiff = await this.reviewHandlers.handleGetPullRequestDiff(args);
+            const diffData = this.parseMCPResponse(rawDiff);
+            return {
+                diff: diffData.diff || "",
+                fileChanges: diffData.file_changes || [],
+                totalAdditions: diffData.total_additions || 0,
+                totalDeletions: diffData.total_deletions || 0,
+            };
+        }, 1800);
+    }
+    /**
+     * Get file content with caching
+     */
+    async getFileContent(workspace, repository, filePath, branch) {
+        await this.initialize();
+        const cacheKey = Cache_1.Cache.keys.fileContent(workspace, repository, filePath, branch);
+        return Cache_1.cache.getOrSet(cacheKey, async () => {
+            Logger_1.logger.debug(`Getting file content: ${workspace}/${repository}/${filePath}@${branch}`);
+            const result = await this.fileHandlers.handleGetFileContent({
+                workspace,
+                repository,
+                file_path: filePath,
+                branch,
+            });
+            // Handle file content response directly (don't JSON parse)
+            if (result.content && result.content[0] && result.content[0].text) {
+                const fileResponse = JSON.parse(result.content[0].text);
+                return fileResponse.content || "";
+            }
+            // Handle direct response format
+            return result.content || "";
+        }, 7200);
+    }
+    /**
+     * List directory content with caching
+     */
+    async listDirectoryContent(workspace, repository, path, branch) {
+        await this.initialize();
+        const cacheKey = Cache_1.Cache.keys.directoryContent(workspace, repository, path, branch);
+        return Cache_1.cache.getOrSet(cacheKey, async () => {
+            Logger_1.logger.debug(`Listing directory: ${workspace}/${repository}/${path}@${branch}`);
+            const result = await this.fileHandlers.handleListDirectoryContent({
+                workspace,
+                repository,
+                path,
+                branch,
+            });
+            const dirData = this.parseMCPResponse(result);
+            return dirData.contents || [];
+        }, 3600);
+    }
+    /**
+     * Update PR description with reviewer preservation
+     */
+    async updatePRDescription(identifier, description) {
+        await this.initialize();
+        const { workspace, repository, pullRequestId } = identifier;
+        if (!pullRequestId) {
+            throw new types_1.ProviderError("Pull request ID is required");
+        }
+        try {
+            Logger_1.logger.debug(`Updating PR description: ${workspace}/${repository}#${pullRequestId}`);
+            Logger_1.logger.debug(`Description length: ${description.length} characters`);
+            const result = await this.pullRequestHandlers.handleUpdatePullRequest({
+                workspace,
+                repository,
+                pull_request_id: pullRequestId,
+                description: description,
+            });
+            // Log the raw MCP response
+            Logger_1.logger.debug(`Raw MCP update response: ${JSON.stringify(result, null, 2)}`);
+            const updateData = this.parseMCPResponse(result);
+            // Log the parsed response
+            Logger_1.logger.debug(`Parsed update response: ${JSON.stringify(updateData, null, 2)}`);
+            // Invalidate related cache entries
+            Cache_1.cache.del(Cache_1.Cache.keys.prInfo(workspace, repository, pullRequestId));
+            // Check if the response indicates actual success
+            if (typeof updateData === "string" && updateData.includes("Error")) {
+                Logger_1.logger.error(`Update response contains error: ${updateData}`);
+                return {
+                    success: false,
+                    message: updateData,
+                };
+            }
+            return {
+                success: true,
+                message: updateData.message || "PR description updated successfully",
+            };
+        }
+        catch (error) {
+            Logger_1.logger.error(`Failed to update PR description: ${error.message}`);
+            throw new types_1.ProviderError(`Update failed: ${error.message}`);
+        }
+    }
+    /**
+     * Add comment to PR with smart positioning
+     */
+    async addComment(identifier, commentText, options = {}) {
+        await this.initialize();
+        const { workspace, repository, pullRequestId } = identifier;
+        if (!pullRequestId) {
+            throw new types_1.ProviderError("Pull request ID is required");
+        }
+        try {
+            Logger_1.logger.debug(`Adding comment to PR: ${workspace}/${repository}#${pullRequestId}`);
+            const args = {
+                workspace,
+                repository,
+                pull_request_id: pullRequestId,
+                comment_text: commentText,
+            };
+            // Add inline comment parameters if provided
+            if (options.filePath && options.codeSnippet) {
+                args.file_path = options.filePath;
+                args.code_snippet = options.codeSnippet;
+                if (options.searchContext) {
+                    args.search_context = options.searchContext;
+                }
+                if (options.matchStrategy) {
+                    args.match_strategy = options.matchStrategy;
+                }
+                if (options.suggestion) {
+                    args.suggestion = options.suggestion;
+                }
+                Logger_1.logger.debug(`🔍 Inline comment details:`);
+                Logger_1.logger.debug(`   File: ${options.filePath}`);
+                Logger_1.logger.debug(`   Code snippet: "${options.codeSnippet}"`);
+                Logger_1.logger.debug(`   Match strategy: ${options.matchStrategy}`);
+                if (options.searchContext) {
+                    Logger_1.logger.debug(`   Search context before: ${JSON.stringify(options.searchContext.before)}`);
+                    Logger_1.logger.debug(`   Search context after: ${JSON.stringify(options.searchContext.after)}`);
+                }
+            }
+            else if (options.filePath && options.lineNumber) {
+                // Fallback to line number if no code snippet
+                args.file_path = options.filePath;
+                args.line_number = options.lineNumber;
+                args.line_type = options.lineType || "CONTEXT";
+                Logger_1.logger.debug(`🔍 Line-based comment details:`);
+                Logger_1.logger.debug(`   File: ${options.filePath}`);
+                Logger_1.logger.debug(`   Line: ${options.lineNumber}`);
+                Logger_1.logger.debug(`   Type: ${options.lineType || "CONTEXT"}`);
+            }
+            Logger_1.logger.debug(`🔍 MCP addComment args: ${JSON.stringify(args, null, 2)}`);
+            const result = await this.pullRequestHandlers.handleAddComment(args);
+            // Parse response exactly like pr-police.js
+            let commentData;
+            if (result.content && result.content[0] && result.content[0].text) {
+                commentData = JSON.parse(result.content[0].text);
+            }
+            else {
+                commentData = result;
+            }
+            return {
+                success: true,
+                commentId: commentData.id || commentData.comment_id,
+            };
+        }
+        catch (error) {
+            Logger_1.logger.error(`Failed to add comment: ${error.message}`);
+            throw new types_1.ProviderError(`Comment failed: ${error.message}`);
+        }
+    }
+    /**
+     * Batch operation support for multiple API calls
+     */
+    async batchOperations(operations, options = {}) {
+        const { maxConcurrent = 5, delayBetween = 1000, continueOnError = true, } = options;
+        const results = [];
+        // Process operations in batches
+        for (let i = 0; i < operations.length; i += maxConcurrent) {
+            const batch = operations.slice(i, i + maxConcurrent);
+            const batchPromises = batch.map(async (operation) => {
+                try {
+                    const data = await operation();
+                    return { success: true, data };
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    if (!continueOnError) {
+                        throw error;
+                    }
+                    return { success: false, error: errorMessage };
+                }
+            });
+            const batchResults = await Promise.all(batchPromises);
+            results.push(...batchResults);
+            // Add delay between batches (except for the last batch)
+            if (i + maxConcurrent < operations.length && delayBetween > 0) {
+                await new Promise((resolve) => setTimeout(resolve, delayBetween));
+            }
+        }
+        return results;
+    }
+    /**
+     * Health check for the provider
+     */
+    async healthCheck() {
+        try {
+            await this.initialize();
+            // Try a simple API call to verify connectivity
+            const testResult = await this.branchHandlers.handleGetBranch({
+                workspace: "test",
+                repository: "test",
+                branch_name: "test",
+                include_merged_prs: false,
+            });
+            return {
+                healthy: true,
+                details: {
+                    initialized: this.initialized,
+                    baseUrl: this.baseUrl,
+                    username: this.credentials.username,
+                    apiConnected: !!testResult,
+                },
+            };
+        }
+        catch (error) {
+            return {
+                healthy: false,
+                details: {
+                    initialized: this.initialized,
+                    error: error.message,
+                },
+            };
+        }
+    }
+    /**
+     * Get provider statistics and cache metrics
+     */
+    getStats() {
+        return {
+            provider: "bitbucket",
+            initialized: this.initialized,
+            baseUrl: this.baseUrl,
+            cacheStats: Cache_1.cache.stats(),
+            cacheHitRatio: Cache_1.cache.getHitRatio(),
+        };
+    }
+    /**
+     * Clear provider-related cache entries
+     */
+    clearCache() {
+        // Clear all cache entries (could be made more specific)
+        Cache_1.cache.clear();
+        Logger_1.logger.debug("BitbucketProvider cache cleared");
+    }
+}
+exports.BitbucketProvider = BitbucketProvider;
+// Export factory function
+function createBitbucketProvider(credentials) {
+    return new BitbucketProvider(credentials);
+}
+//# sourceMappingURL=BitbucketProvider.js.map

package/dist/features/CodeReviewer.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Enhanced Code Reviewer - Optimized to work with Unified Context
+ * Preserves all original functionality from pr-police.js but optimized
+ */
+import { ReviewResult, ReviewOptions, AIProviderConfig, CodeReviewConfig } from "../types";
+import { UnifiedContext } from "../core/ContextGatherer";
+import { BitbucketProvider } from "../core/providers/BitbucketProvider";
+export declare class CodeReviewer {
+    private neurolink;
+    private bitbucketProvider;
+    private aiConfig;
+    private reviewConfig;
+    constructor(bitbucketProvider: BitbucketProvider, aiConfig: AIProviderConfig, reviewConfig: CodeReviewConfig);
+    /**
+     * Review code using pre-gathered unified context (OPTIMIZED)
+     */
+    reviewCodeWithContext(context: UnifiedContext, options: ReviewOptions): Promise<ReviewResult>;
+    /**
+     * Validate violations to ensure code snippets exist in diff
+     */
+    private validateViolations;
+    /**
+     * Try to fix code snippet by finding it in the actual diff
+     */
+    private tryFixCodeSnippet;
+    /**
+     * Get system prompt for security-focused code review
+     */
+    private getSecurityReviewSystemPrompt;
+    /**
+     * Get analysis requirements from config or defaults
+     */
+    private getAnalysisRequirements;
+    /**
+     * Build focused analysis prompt separated from context
+     */
+    private buildCoreAnalysisPrompt;
+    /**
+     * Extract diff content based on strategy
+     */
+    private extractDiffContent;
+    /**
+     * Detect project type for better context
+     */
+    private detectProjectType;
+    /**
+     * Assess complexity level for better AI context
+     */
+    private assessComplexity;
+    /**
+     * Legacy method - kept for compatibility but simplified
+     */
+    private buildAnalysisPrompt;
+    /**
+     * Analyze code with AI using the enhanced prompt
+     */
+    private analyzeWithAI;
+    /**
+     * Post comments to PR using unified context - matching pr-police.js exactly
+     */
+    private postComments;
+    /**
+     * Format inline comment for specific violation
+     */
+    private formatInlineComment;
+    /**
+     * Generate comprehensive summary comment with failed comments info
+     */
+    private generateSummaryComment;
+    /**
+     * Helper methods for processing violations
+     */
+    private cleanFilePath;
+    /**
+     * Extract exact file path from diff
+     */
+    private extractFilePathFromDiff;
+    /**
+     * Extract line number from diff for a specific code snippet
+     */
+    private extractLineNumberFromDiff;
+    /**
+     * Escape markdown code blocks properly
+     */
+    private escapeMarkdownCodeBlock;
+    private cleanCodeSnippet;
+    private splitArrayLines;
+    private groupViolationsByCategory;
+    private calculateStats;
+    private generateReviewResult;
+    /**
+     * Utility methods
+     */
+    private parseAIResponse;
+    /**
+     * Extract line information for comment from context
+     */
+    private extractLineInfoForComment;
+    /**
+     * Generate all possible path variations for a file
+     */
+    private generatePathVariations;
+}
+export declare function createCodeReviewer(bitbucketProvider: BitbucketProvider, aiConfig: AIProviderConfig, reviewConfig: CodeReviewConfig): CodeReviewer;
+//# sourceMappingURL=CodeReviewer.d.ts.map