@juspay/yama 1.5.1 → 2.0.0

package/dist/core/Guardian.js

@@ -1,474 +0,0 @@
-/**
- * Yama - Unified orchestrator class
- * The main class that coordinates all operations using shared context
- */
-import { GuardianError, } from "../types/index.js";
-import { BitbucketProvider } from "./providers/BitbucketProvider.js";
-import { ContextGatherer } from "./ContextGatherer.js";
-import { CodeReviewer } from "../features/CodeReviewer.js";
-import { DescriptionEnhancer } from "../features/DescriptionEnhancer.js";
-import { logger, createLogger } from "../utils/Logger.js";
-import { configManager } from "../utils/ConfigManager.js";
-import { cache } from "../utils/Cache.js";
-export class Guardian {
-    config;
-    bitbucketProvider;
-    contextGatherer;
-    codeReviewer;
-    descriptionEnhancer;
-    neurolink;
-    initialized = false;
-    logger = logger; // Default logger, will be updated after config load
-    constructor(config) {
-        this.config = {};
-        if (config) {
-            this.config = { ...this.config, ...config };
-        }
-    }
-    /**
-     * Initialize Guardian with configuration
-     */
-    async initialize(configPath) {
-        if (this.initialized) {
-            return;
-        }
-        try {
-            // Load configuration first
-            const loaded = await configManager.loadConfig(configPath);
-            // Loaded file first, then in-memory overrides last
-            this.config = { ...loaded, ...this.config };
-            // Create logger with banner configuration if needed
-            const showBanner = this.config.display?.showBanner ?? true;
-            if (showBanner !== true) {
-                // Only create a new logger if we need to change the banner setting
-                this.logger = createLogger(logger.getConfig(), showBanner);
-            }
-            // Otherwise, keep using the default logger
-            this.logger.badge();
-            this.logger.phase("🚀 Initializing Yama...");
-            // Initialize providers
-            this.bitbucketProvider = new BitbucketProvider(this.config.providers.git.credentials);
-            await this.bitbucketProvider.initialize();
-            // Initialize NeuroLink with native ESM dynamic import
-            const { NeuroLink } = await import("@juspay/neurolink");
-            this.neurolink = new NeuroLink();
-            // Initialize core components
-            this.contextGatherer = new ContextGatherer(this.bitbucketProvider, this.config.providers.ai, this.config.memoryBank || {
-                enabled: true,
-                path: "memory-bank",
-                fallbackPaths: ["docs/memory-bank", ".memory-bank"],
-            });
-            this.codeReviewer = new CodeReviewer(this.bitbucketProvider, this.config.providers.ai, this.config.features.codeReview);
-            this.descriptionEnhancer = new DescriptionEnhancer(this.bitbucketProvider, this.config.providers.ai);
-            this.initialized = true;
-            logger.success("✅ Yama initialized successfully");
-        }
-        catch (error) {
-            logger.error(`Failed to initialize Yama: ${error.message}`);
-            throw new GuardianError("INITIALIZATION_ERROR", `Initialization failed: ${error.message}`);
-        }
-    }
-    /**
-     * Main method: Process PR with multiple operations using unified context
-     */
-    async processPR(options) {
-        await this.ensureInitialized();
-        const startTime = Date.now();
-        const operations = [];
-        try {
-            logger.operation("PR Processing", "started");
-            logger.info(`Target: ${options.workspace}/${options.repository}`);
-            logger.info(`Operations: ${options.operations.join(", ")}`);
-            logger.info(`Mode: ${options.dryRun ? "DRY RUN" : "LIVE"}`);
-            // Step 1: Gather unified context ONCE for all operations
-            logger.phase("📋 Gathering unified context...");
-            const context = await this.gatherUnifiedContext(options);
-            logger.success(`Context ready: PR #${context.pr.id} - "${context.pr.title}"`);
-            logger.info(`Files: ${context.diffStrategy.fileCount}, Strategy: ${context.diffStrategy.strategy}`);
-            // Step 2: Execute requested operations using shared context
-            for (const operation of options.operations) {
-                if (operation === "all") {
-                    // Execute all available operations
-                    operations.push(await this.executeOperation("review", context, options));
-                    operations.push(await this.executeOperation("enhance-description", context, options));
-                }
-                else {
-                    operations.push(await this.executeOperation(operation, context, options));
-                }
-            }
-            const duration = Date.now() - startTime;
-            const successCount = operations.filter((op) => op.status === "success").length;
-            const errorCount = operations.filter((op) => op.status === "error").length;
-            const skippedCount = operations.filter((op) => op.status === "skipped").length;
-            const result = {
-                pullRequest: context.pr,
-                operations,
-                summary: {
-                    totalOperations: operations.length,
-                    successCount,
-                    errorCount,
-                    skippedCount,
-                    totalDuration: duration,
-                },
-            };
-            logger.operation("PR Processing", "completed");
-            logger.success(`✅ Processing completed in ${Math.round(duration / 1000)}s: ` +
-                `${successCount} success, ${errorCount} errors, ${skippedCount} skipped`);
-            return result;
-        }
-        catch (error) {
-            logger.operation("PR Processing", "failed");
-            logger.error(`Processing failed: ${error.message}`);
-            throw error;
-        }
-    }
-    /**
-     * Streaming version of processPR for real-time updates
-     */
-    async *processPRStream(options, _streamOptions) {
-        await this.ensureInitialized();
-        const startTime = Date.now();
-        try {
-            // Initial update
-            yield {
-                operation: "all",
-                status: "started",
-                message: "Yama processing initiated",
-                timestamp: new Date().toISOString(),
-            };
-            // Context gathering phase
-            yield {
-                operation: "all",
-                status: "progress",
-                progress: 10,
-                message: "Gathering unified context...",
-                timestamp: new Date().toISOString(),
-            };
-            const context = await this.gatherUnifiedContext(options);
-            yield {
-                operation: "all",
-                status: "progress",
-                progress: 30,
-                message: `Context ready: PR #${context.pr.id}`,
-                data: { prId: context.pr.id, title: context.pr.title },
-                timestamp: new Date().toISOString(),
-            };
-            // Execute operations with progress updates
-            const totalOps = options.operations.length;
-            let completedOps = 0;
-            for (const operation of options.operations) {
-                yield {
-                    operation,
-                    status: "started",
-                    message: `Starting ${operation}...`,
-                    timestamp: new Date().toISOString(),
-                };
-                try {
-                    const result = await this.executeOperation(operation, context, options);
-                    if (result.status === "error") {
-                        yield {
-                            operation,
-                            status: "error",
-                            message: `${operation} failed: ${result.error}`,
-                            timestamp: new Date().toISOString(),
-                        };
-                    }
-                    else {
-                        completedOps++;
-                        yield {
-                            operation,
-                            status: "completed",
-                            progress: 30 + Math.round((completedOps / totalOps) * 60),
-                            message: `${operation} completed`,
-                            data: result,
-                            timestamp: new Date().toISOString(),
-                        };
-                    }
-                }
-                catch (error) {
-                    // This catch is for unexpected errors that bypass executeOperation's own error handling
-                    yield {
-                        operation,
-                        status: "error",
-                        message: `${operation} failed: ${error.message}`,
-                        timestamp: new Date().toISOString(),
-                    };
-                }
-            }
-            // Final completion
-            const duration = Date.now() - startTime;
-            yield {
-                operation: "all",
-                status: "completed",
-                progress: 100,
-                message: `Processing completed in ${Math.round(duration / 1000)}s`,
-                timestamp: new Date().toISOString(),
-            };
-        }
-        catch (error) {
-            yield {
-                operation: "all",
-                status: "error",
-                message: `Processing failed: ${error.message}`,
-                timestamp: new Date().toISOString(),
-            };
-        }
-    }
-    /**
-     * Gather unified context (cached and reusable)
-     */
-    async gatherUnifiedContext(options) {
-        const identifier = {
-            workspace: options.workspace,
-            repository: options.repository,
-            branch: options.branch,
-            pullRequestId: options.pullRequestId,
-        };
-        // Check if we have cached context first
-        const cachedContext = await this.contextGatherer.getCachedContext(identifier);
-        if (cachedContext && options.config?.cache?.enabled !== false) {
-            logger.debug("✓ Using cached context");
-            return cachedContext;
-        }
-        // Determine what operations need diff data
-        const needsDiff = options.operations.some((op) => op === "review" || op === "security-scan" || op === "all");
-        const contextOptions = {
-            excludePatterns: this.config.features.codeReview.excludePatterns,
-            contextLines: this.config.features.codeReview.contextLines,
-            forceRefresh: false,
-            includeDiff: needsDiff,
-            diffStrategyConfig: this.config.features.diffStrategy,
-        };
-        return await this.contextGatherer.gatherContext(identifier, contextOptions);
-    }
-    /**
-     * Execute individual operation using shared context
-     */
-    async executeOperation(operation, context, options) {
-        const startTime = Date.now();
-        try {
-            let data;
-            switch (operation) {
-                case "review":
-                    data = await this.executeCodeReview(context, options);
-                    break;
-                case "enhance-description":
-                    data = await this.executeDescriptionEnhancement(context, options);
-                    break;
-                case "security-scan":
-                    // TODO: Implement in future phases
-                    throw new Error("Security scan not implemented in Phase 1");
-                case "analytics":
-                    // TODO: Implement in future phases
-                    throw new Error("Analytics not implemented in Phase 1");
-                default:
-                    throw new Error(`Unknown operation: ${operation}`);
-            }
-            return {
-                operation,
-                status: "success",
-                data,
-                duration: Date.now() - startTime,
-                timestamp: new Date().toISOString(),
-            };
-        }
-        catch (error) {
-            logger.error(`Operation ${operation} failed: ${error.message}`);
-            return {
-                operation,
-                status: "error",
-                error: error.message,
-                duration: Date.now() - startTime,
-                timestamp: new Date().toISOString(),
-            };
-        }
-    }
-    /**
-     * Execute code review using shared context
-     */
-    async executeCodeReview(context, options) {
-        if (!this.config.features.codeReview.enabled) {
-            logger.info("Code review is disabled in configuration");
-            return { skipped: true, reason: "disabled in config" };
-        }
-        const reviewOptions = {
-            workspace: context.identifier.workspace,
-            repository: context.identifier.repository,
-            pullRequestId: context.identifier.pullRequestId,
-            dryRun: options.dryRun,
-            verbose: logger.getConfig().verbose,
-            excludePatterns: this.config.features.codeReview.excludePatterns,
-            contextLines: this.config.features.codeReview.contextLines,
-        };
-        logger.phase("🔍 Executing code review...");
-        // Check if multi-instance processing is configured
-        const multiInstanceConfig = this.config.features?.codeReview
-            ?.multiInstance;
-        // Use code review with multi-instance support
-        return await this.codeReviewer.reviewCodeWithContext(context, reviewOptions, multiInstanceConfig);
-    }
-    /**
-     * Execute description enhancement using shared context
-     */
-    async executeDescriptionEnhancement(context, options) {
-        if (!this.config.features.descriptionEnhancement.enabled) {
-            logger.info("Description enhancement is disabled in configuration");
-            return { skipped: true, reason: "disabled in config" };
-        }
-        logger.phase("📝 Executing description enhancement...");
-        const enhancementOptions = {
-            workspace: context.identifier.workspace,
-            repository: context.identifier.repository,
-            pullRequestId: context.identifier.pullRequestId,
-            dryRun: options.dryRun,
-            verbose: logger.getConfig().verbose,
-            preserveContent: this.config.features.descriptionEnhancement.preserveContent,
-            ensureRequiredSections: true,
-            customSections: this.config.features.descriptionEnhancement.requiredSections,
-        };
-        // Use the already gathered context instead of gathering again
-        return await this.descriptionEnhancer.enhanceWithContext(context, enhancementOptions);
-    }
-    /**
-     * Individual operation methods for backwards compatibility
-     */
-    /**
-     * Code review operation (standalone)
-     */
-    async reviewCode(options) {
-        await this.ensureInitialized();
-        const identifier = {
-            workspace: options.workspace,
-            repository: options.repository,
-            branch: options.branch,
-            pullRequestId: options.pullRequestId,
-        };
-        logger.operation("Code Review", "started");
-        try {
-            // Gather context specifically for code review
-            const context = await this.contextGatherer.gatherContext(identifier, {
-                excludePatterns: options.excludePatterns,
-                contextLines: options.contextLines,
-                includeDiff: true,
-            });
-            const result = await this.codeReviewer.reviewCodeWithContext(context, options);
-            logger.operation("Code Review", "completed");
-            return result;
-        }
-        catch (error) {
-            logger.operation("Code Review", "failed");
-            throw error;
-        }
-    }
-    /**
-     * Description enhancement operation (standalone)
-     */
-    async enhanceDescription(options) {
-        await this.ensureInitialized();
-        const identifier = {
-            workspace: options.workspace,
-            repository: options.repository,
-            branch: options.branch,
-            pullRequestId: options.pullRequestId,
-        };
-        logger.operation("Description Enhancement", "started");
-        try {
-            // Gather context specifically for description enhancement
-            const context = await this.contextGatherer.gatherContext(identifier, {
-                includeDiff: true, // Description enhancement may need to see changes
-            });
-            const result = await this.descriptionEnhancer.enhanceWithContext(context, options);
-            logger.operation("Description Enhancement", "completed");
-            return result;
-        }
-        catch (error) {
-            logger.operation("Description Enhancement", "failed");
-            throw error;
-        }
-    }
-    /**
-     * Health check for all components
-     */
-    async healthCheck() {
-        const components = {};
-        try {
-            // Check Bitbucket provider
-            components.bitbucket = await this.bitbucketProvider.healthCheck();
-            // Check cache
-            components.cache = {
-                healthy: true,
-                stats: cache.stats(),
-            };
-            // Check NeuroLink (if initialized)
-            components.neurolink = {
-                healthy: true,
-                initialized: !!this.neurolink,
-            };
-            const allHealthy = Object.values(components).every((comp) => comp.healthy);
-            return {
-                healthy: allHealthy,
-                components,
-            };
-        }
-        catch (error) {
-            return {
-                healthy: false,
-                components: {
-                    ...components,
-                    error: error.message,
-                },
-            };
-        }
-    }
-    /**
-     * Get comprehensive statistics
-     */
-    getStats() {
-        return {
-            initialized: this.initialized,
-            config: {
-                features: Object.keys(this.config.features || {}),
-                cacheEnabled: this.config.cache?.enabled,
-            },
-            providers: {
-                bitbucket: this.bitbucketProvider?.getStats(),
-                context: this.contextGatherer?.getStats(),
-            },
-            cache: cache.stats(),
-        };
-    }
-    /**
-     * Clear all caches
-     */
-    clearCache() {
-        cache.clear();
-        this.bitbucketProvider?.clearCache();
-        logger.info("All caches cleared");
-    }
-    /**
-     * Ensure Guardian is initialized
-     */
-    async ensureInitialized() {
-        if (!this.initialized) {
-            await this.initialize();
-        }
-    }
-    /**
-     * Shutdown Guardian gracefully
-     */
-    async shutdown() {
-        logger.info("Shutting down Yama...");
-        // Clear caches
-        this.clearCache();
-        // Reset state
-        this.initialized = false;
-        logger.success("Yama shutdown complete");
-    }
-}
-// Export factory function
-export function createGuardian(config) {
-    return new Guardian(config);
-}
-// Export default instance
-export const guardian = new Guardian();
-//# sourceMappingURL=Guardian.js.map

package/dist/core/providers/BitbucketProvider.d.ts

@@ -1,105 +0,0 @@
-/**
- * Enhanced Bitbucket Provider - Optimized from both pr-police.js and pr-describe.js
- * Provides unified, cached, and optimized Bitbucket operations
- */
-import { PRIdentifier, PRInfo, PRDiff, GitCredentials } from "../../types/index.js";
-export interface BitbucketMCPResponse {
-    content?: Array<{
-        text?: string;
-    }>;
-    message?: string;
-    error?: string;
-}
-export declare class BitbucketProvider {
-    private apiClient;
-    private branchHandlers;
-    private pullRequestHandlers;
-    private reviewHandlers;
-    private fileHandlers;
-    private initialized;
-    private baseUrl;
-    private credentials;
-    constructor(credentials: GitCredentials);
-    /**
-     * Initialize MCP handlers with lazy loading and connection reuse
-     */
-    initialize(): Promise<void>;
-    /**
-     * Parse MCP response - exactly matching the working pr-police.js implementation
-     */
-    private parseMCPResponse;
-    /**
-     * Find PR for branch with intelligent caching
-     */
-    findPRForBranch(identifier: PRIdentifier): Promise<PRInfo>;
-    /**
-     * Get PR details with enhanced caching
-     */
-    getPRDetails(identifier: PRIdentifier): Promise<PRInfo>;
-    /**
-     * Get PR diff with smart caching and filtering
-     */
-    getPRDiff(identifier: PRIdentifier, contextLines?: number, excludePatterns?: string[], includePatterns?: string[]): Promise<PRDiff>;
-    /**
-     * Get file content with caching
-     */
-    getFileContent(workspace: string, repository: string, filePath: string, branch: string): Promise<string>;
-    /**
-     * List directory content with caching
-     */
-    listDirectoryContent(workspace: string, repository: string, path: string, branch: string): Promise<any[]>;
-    /**
-     * Update PR description with reviewer preservation
-     */
-    updatePRDescription(identifier: PRIdentifier, description: string): Promise<{
-        success: boolean;
-        message: string;
-    }>;
-    /**
-     * Add comment to PR with smart positioning and validation
-     */
-    addComment(identifier: PRIdentifier, commentText: string, options?: {
-        filePath?: string;
-        lineNumber?: number;
-        lineType?: "ADDED" | "REMOVED" | "CONTEXT";
-        codeSnippet?: string;
-        searchContext?: {
-            before: string[];
-            after: string[];
-        };
-        matchStrategy?: "exact" | "best" | "strict";
-        suggestion?: string;
-    }): Promise<{
-        success: boolean;
-        commentId?: number;
-    }>;
-    /**
-     * Batch operation support for multiple API calls
-     */
-    batchOperations<T>(operations: Array<() => Promise<T>>, options?: {
-        maxConcurrent?: number;
-        delayBetween?: number;
-        continueOnError?: boolean;
-    }): Promise<Array<{
-        success: boolean;
-        data?: T;
-        error?: string;
-    }>>;
-    /**
-     * Health check for the provider
-     */
-    healthCheck(): Promise<{
-        healthy: boolean;
-        details: any;
-    }>;
-    /**
-     * Get provider statistics and cache metrics
-     */
-    getStats(): any;
-    /**
-     * Clear provider-related cache entries
-     */
-    clearCache(): void;
-}
-export declare function createBitbucketProvider(credentials: GitCredentials): BitbucketProvider;
-//# sourceMappingURL=BitbucketProvider.d.ts.map