@juspay/yama 1.6.0 → 2.0.0

package/dist/core/providers/BitbucketProvider.js

@@ -1,489 +0,0 @@
-/**
- * Enhanced Bitbucket Provider - Optimized from both pr-police.js and pr-describe.js
- * Provides unified, cached, and optimized Bitbucket operations
- */
-import { ProviderError, } from "../../types/index.js";
-import { logger } from "../../utils/Logger.js";
-import { cache, Cache } from "../../utils/Cache.js";
-import { RetryManager } from "../../utils/RetryManager.js";
-export class BitbucketProvider {
-    apiClient;
-    branchHandlers;
-    pullRequestHandlers;
-    reviewHandlers;
-    fileHandlers;
-    initialized = false;
-    baseUrl;
-    credentials;
-    constructor(credentials) {
-        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.debug("Initializing Bitbucket MCP handlers...");
-            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"),
-                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.debug("Bitbucket MCP handlers initialized successfully");
-        }
-        catch (error) {
-            throw new 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 ProviderError("Branch name is required");
-        }
-        const cacheKey = Cache.keys.branchInfo(workspace, repository, branch);
-        return cache.getOrSetResilient(cacheKey, async () => {
-            logger.debug(`Finding PR for branch: ${workspace}/${repository}@${branch}`);
-            const rawBranchData = await RetryManager.withRetry(() => this.branchHandlers.handleGetBranch({
-                workspace,
-                repository,
-                branch_name: branch,
-                include_merged_prs: false,
-            }), `Find PR for branch ${workspace}/${repository}@${branch}`);
-            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.debug(`Author data structure: ${JSON.stringify(firstPR.author, null, 2)}`);
-                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 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 ProviderError("Pull request ID is required");
-        }
-        const cacheKey = Cache.keys.prInfo(workspace, repository, pullRequestId);
-        return cache.getOrSetResilient(cacheKey, async () => {
-            logger.debug(`Getting PR details: ${workspace}/${repository}#${pullRequestId}`);
-            const rawPRDetails = await RetryManager.withRetry(() => this.pullRequestHandlers.handleGetPullRequest({
-                workspace,
-                repository,
-                pull_request_id: pullRequestId,
-            }), `Get PR details ${workspace}/${repository}#${pullRequestId}`);
-            const prData = this.parseMCPResponse(rawPRDetails);
-            // Debug author data structure
-            logger.debug(`PR Details author data structure: ${JSON.stringify(prData.author, null, 2)}`);
-            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 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.keys.prDiff(workspace, repository, pullRequestId);
-        return cache.getOrSetResilient(cacheKey, async () => {
-            logger.debug(`Getting PR diff: ${workspace}/${repository}#${pullRequestId}`);
-            if (includePatterns) {
-                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 RetryManager.withRetry(() => this.reviewHandlers.handleGetPullRequestDiff(args), `Get PR diff ${workspace}/${repository}#${pullRequestId}`);
-            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.keys.fileContent(workspace, repository, filePath, branch);
-        return cache.getOrSetResilient(cacheKey, async () => {
-            logger.debug(`Getting file content: ${workspace}/${repository}/${filePath}@${branch}`);
-            const result = await RetryManager.withRetry(() => this.fileHandlers.handleGetFileContent({
-                workspace,
-                repository,
-                file_path: filePath,
-                branch,
-            }), `Get file content ${workspace}/${repository}/${filePath}@${branch}`);
-            // Handle file content response with proper error handling for plain text files
-            if (result.content &&
-                result.content[0] &&
-                result.content[0].text) {
-                try {
-                    const fileResponse = JSON.parse(result.content[0].text);
-                    return fileResponse.content || "";
-                }
-                catch (parseError) {
-                    // If JSON parsing fails, the content might be plain text (like .clinerules)
-                    // Return the text content directly
-                    logger.debug(`JSON parsing failed for ${filePath}, treating as plain text: ${parseError.message}`);
-                    return result.content[0].text || "";
-                }
-            }
-            // 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.keys.directoryContent(workspace, repository, path, branch);
-        return cache.getOrSetResilient(cacheKey, async () => {
-            logger.debug(`Listing directory: ${workspace}/${repository}/${path}@${branch}`);
-            const result = await RetryManager.withRetry(() => this.fileHandlers.handleListDirectoryContent({
-                workspace,
-                repository,
-                path,
-                branch,
-            }), `List directory ${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 ProviderError("Pull request ID is required");
-        }
-        try {
-            logger.debug(`Updating PR description: ${workspace}/${repository}#${pullRequestId}`);
-            logger.debug(`Description length: ${description.length} characters`);
-            const result = await RetryManager.withRetry(() => this.pullRequestHandlers.handleUpdatePullRequest({
-                workspace,
-                repository,
-                pull_request_id: pullRequestId,
-                description: description,
-            }), `Update PR description ${workspace}/${repository}#${pullRequestId}`);
-            // Log the raw MCP response
-            logger.debug(`Raw MCP update response: ${JSON.stringify(result, null, 2)}`);
-            const updateData = this.parseMCPResponse(result);
-            // Log the parsed response
-            logger.debug(`Parsed update response: ${JSON.stringify(updateData, null, 2)}`);
-            // Invalidate related cache entries
-            cache.del(Cache.keys.prInfo(workspace, repository, pullRequestId));
-            // Check if the response indicates actual success
-            if (typeof updateData === "string" && updateData.includes("Error")) {
-                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.error(`Failed to update PR description: ${error.message}`);
-            throw new ProviderError(`Update failed: ${error.message}`);
-        }
-    }
-    /**
-     * Add comment to PR with smart positioning and validation
-     */
-    async addComment(identifier, commentText, options = {}) {
-        await this.initialize();
-        const { workspace, repository, pullRequestId } = identifier;
-        if (!pullRequestId) {
-            throw new ProviderError("Pull request ID is required");
-        }
-        try {
-            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.debug(`🔍 Inline comment details:`);
-                logger.debug(`   File: ${options.filePath}`);
-                logger.debug(`   Code snippet: "${options.codeSnippet}"`);
-                logger.debug(`   Match strategy: ${options.matchStrategy}`);
-                if (options.searchContext) {
-                    logger.debug(`   Search context before: ${JSON.stringify(options.searchContext.before)}`);
-                    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.debug(`🔍 Line-based comment details:`);
-                logger.debug(`   File: ${options.filePath}`);
-                logger.debug(`   Line: ${options.lineNumber}`);
-                logger.debug(`   Type: ${options.lineType || "CONTEXT"}`);
-            }
-            logger.debug(`🔍 MCP addComment args: ${JSON.stringify(args, null, 2)}`);
-            const result = await RetryManager.withRetry(() => this.pullRequestHandlers.handleAddComment(args), `Add comment to PR ${workspace}/${repository}#${pullRequestId}`);
-            // 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.error(`Failed to add comment: ${error.message}`);
-            // If inline comment fails, try posting as general comment
-            if (options.filePath && options.codeSnippet) {
-                logger.debug(`Attempting fallback to general comment...`);
-                try {
-                    const fallbackArgs = {
-                        workspace,
-                        repository,
-                        pull_request_id: pullRequestId,
-                        comment_text: `**File: ${options.filePath}**\n\n${commentText}`,
-                    };
-                    const fallbackResult = await RetryManager.withRetry(() => this.pullRequestHandlers.handleAddComment(fallbackArgs), `Add fallback comment to PR ${workspace}/${repository}#${pullRequestId}`);
-                    let fallbackData;
-                    if (fallbackResult.content &&
-                        fallbackResult.content[0] &&
-                        fallbackResult.content[0].text) {
-                        fallbackData = JSON.parse(fallbackResult.content[0].text);
-                    }
-                    else {
-                        fallbackData = fallbackResult;
-                    }
-                    logger.debug(`Fallback comment posted successfully`);
-                    return {
-                        success: true,
-                        commentId: fallbackData.id || fallbackData.comment_id,
-                    };
-                }
-                catch (fallbackError) {
-                    logger.error(`Fallback comment also failed: ${fallbackError.message}`);
-                }
-            }
-            throw new 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.stats(),
-            cacheHitRatio: cache.getHitRatio(),
-        };
-    }
-    /**
-     * Clear provider-related cache entries
-     */
-    clearCache() {
-        // Clear all cache entries (could be made more specific)
-        cache.clear();
-        logger.debug("BitbucketProvider cache cleared");
-    }
-}
-// Export factory function
-export function createBitbucketProvider(credentials) {
-    return new BitbucketProvider(credentials);
-}
-//# sourceMappingURL=BitbucketProvider.js.map

package/dist/features/CodeReviewer.d.ts

@@ -1,173 +0,0 @@
-/**
- * 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/index.js";
-import { UnifiedContext } from "../core/ContextGatherer.js";
-import { BitbucketProvider } from "../core/providers/BitbucketProvider.js";
-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 with Multi-Instance and Batch Processing)
-     */
-    reviewCodeWithContext(context: UnifiedContext, options: ReviewOptions, multiInstanceConfig?: any): Promise<ReviewResult>;
-    /**
-     * Review code using multiple instances for enhanced analysis
-     */
-    reviewWithMultipleInstances(context: UnifiedContext, options: ReviewOptions, multiInstanceConfig: any): Promise<any>;
-    /**
-     * 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;
-    /**
-     * Get safe token limit based on AI provider using shared utility
-     */
-    private getSafeTokenLimit;
-    /**
-     * 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;
-    /**
-     * Get batch processing configuration with defaults
-     */
-    private getBatchProcessingConfig;
-    /**
-     * Determine if batch processing should be used
-     */
-    private shouldUseBatchProcessing;
-    /**
-     * Main batch processing method with parallel processing support
-     */
-    private reviewWithBatchProcessing;
-    /**
-     * Process batches in parallel with concurrency control
-     */
-    private processInParallel;
-    /**
-     * Process batches serially (original implementation)
-     */
-    private processSerially;
-    /**
-     * Pre-allocate tokens based on distribution strategy with proper integer arithmetic
-     */
-    private preAllocateTokens;
-    /**
-     * Try weighted allocation for batches
-     */
-    private tryWeightedAllocation;
-    /**
-     * Try equal allocation for batches
-     */
-    private tryEqualAllocation;
-    /**
-     * Process a single batch with concurrency control
-     */
-    private processBatchWithConcurrency;
-    /**
-     * 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
-     */
-    private parseAIResponse;
-    /**
-     * 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
-     */
-    private generatePathVariations;
-}
-export declare function createCodeReviewer(bitbucketProvider: BitbucketProvider, aiConfig: AIProviderConfig, reviewConfig: CodeReviewConfig): CodeReviewer;
-//# sourceMappingURL=CodeReviewer.d.ts.map