@juspay/yama 1.0.0

package/dist/features/DescriptionEnhancer.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Enhanced Description Enhancer - Optimized to work with Unified Context
+ * Preserves all original functionality from pr-describe.js but optimized
+ */
+import { EnhancementOptions, EnhancementResult, AIProviderConfig } from "../types";
+import { UnifiedContext } from "../core/ContextGatherer";
+import { BitbucketProvider } from "../core/providers/BitbucketProvider";
+export declare class DescriptionEnhancer {
+    private neurolink;
+    private bitbucketProvider;
+    private aiConfig;
+    private defaultRequiredSections;
+    constructor(bitbucketProvider: BitbucketProvider, aiConfig: AIProviderConfig);
+    /**
+     * Enhance description using pre-gathered unified context (OPTIMIZED)
+     */
+    enhanceWithContext(context: UnifiedContext, options: EnhancementOptions): Promise<EnhancementResult>;
+    /**
+     * Analyze existing PR description content
+     */
+    private analyzeExistingContent;
+    /**
+     * Extract preservable content (media, files, links)
+     */
+    private extractPreservableContent;
+    /**
+     * Validate presence of required sections
+     */
+    private validateRequiredSections;
+    /**
+     * Extract content for a specific section
+     */
+    private extractSectionContent;
+    /**
+     * Identify content gaps (TODOs, unanswered questions, etc.)
+     */
+    private identifyContentGaps;
+    /**
+     * Generate enhanced description using AI and unified context
+     */
+    private generateEnhancedDescription;
+    /**
+     * Build comprehensive enhancement prompt using unified context
+     */
+    private buildEnhancementPrompt;
+    /**
+     * Update PR description in Bitbucket
+     */
+    private updatePRDescription;
+    /**
+     * Show description preview for dry run
+     */
+    private showDescriptionPreview;
+    /**
+     * Generate enhancement result summary
+     */
+    private generateEnhancementResult;
+    /**
+     * Get enhancement statistics
+     */
+    getStats(): any;
+}
+export declare function createDescriptionEnhancer(bitbucketProvider: BitbucketProvider, aiConfig: AIProviderConfig): DescriptionEnhancer;
+//# sourceMappingURL=DescriptionEnhancer.d.ts.map

package/dist/features/DescriptionEnhancer.js

@@ -0,0 +1,448 @@
+"use strict";
+/**
+ * Enhanced Description Enhancer - Optimized to work with Unified Context
+ * Preserves all original functionality from pr-describe.js but optimized
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DescriptionEnhancer = void 0;
+exports.createDescriptionEnhancer = createDescriptionEnhancer;
+const types_1 = require("../types");
+const Logger_1 = require("../utils/Logger");
+class DescriptionEnhancer {
+    constructor(bitbucketProvider, aiConfig) {
+        this.defaultRequiredSections = [
+            { key: "changelog", name: "Changelog (Modules Modified)", required: true },
+            {
+                key: "testcases",
+                name: "Test Cases (What to be tested)",
+                required: true,
+            },
+            {
+                key: "config_changes",
+                name: "CAC Config Or Service Config Changes",
+                required: true,
+            },
+        ];
+        this.bitbucketProvider = bitbucketProvider;
+        this.aiConfig = aiConfig;
+    }
+    /**
+     * Enhance description using pre-gathered unified context (OPTIMIZED)
+     */
+    async enhanceWithContext(context, options) {
+        const startTime = Date.now();
+        try {
+            Logger_1.logger.phase("📝 Enhancing PR description...");
+            Logger_1.logger.info(`Processing PR #${context.pr.id}: "${context.pr.title}"`);
+            // Step 1: Analyze existing content and identify what needs enhancement
+            const analysisResult = this.analyzeExistingContent(context.pr.description, options.customSections || this.defaultRequiredSections);
+            Logger_1.logger.info(`Content analysis: ${analysisResult.preservedContent.media.length} media items, ` +
+                `${analysisResult.missingCount} missing sections`);
+            // Step 2: Generate enhanced description using AI
+            const enhancedDescription = await this.generateEnhancedDescription(context, analysisResult, options);
+            // Step 3: Update PR description if not dry run
+            if (!options.dryRun) {
+                await this.updatePRDescription(context, enhancedDescription);
+            }
+            else {
+                this.showDescriptionPreview(enhancedDescription, analysisResult);
+            }
+            const duration = Math.round((Date.now() - startTime) / 1000);
+            const result = this.generateEnhancementResult(context.pr.description, enhancedDescription, analysisResult, duration);
+            Logger_1.logger.success(`Description enhancement completed in ${duration}s: ` +
+                `${result.sectionsAdded.length} sections added, ${result.sectionsEnhanced.length} enhanced`);
+            return result;
+        }
+        catch (error) {
+            Logger_1.logger.error(`Description enhancement failed: ${error.message}`);
+            throw new types_1.ProviderError(`Description enhancement failed: ${error.message}`);
+        }
+    }
+    /**
+     * Analyze existing PR description content
+     */
+    analyzeExistingContent(description, requiredSections) {
+        Logger_1.logger.debug("Analyzing existing PR description content...");
+        // Extract preservable content (media, files, links)
+        const preservedContent = this.extractPreservableContent(description);
+        // Validate required sections
+        const sectionsAnalysis = this.validateRequiredSections(description, requiredSections);
+        const missingCount = sectionsAnalysis.filter((s) => !s.present).length;
+        // Identify content gaps
+        const gaps = this.identifyContentGaps(description);
+        return {
+            requiredSections: sectionsAnalysis,
+            missingCount,
+            preservedContent,
+            gaps,
+        };
+    }
+    /**
+     * Extract preservable content (media, files, links)
+     */
+    extractPreservableContent(description) {
+        const preservableContent = {
+            media: [],
+            files: [],
+            links: [],
+            originalText: description || "",
+        };
+        if (!description) {
+            return preservableContent;
+        }
+        // Extract images and media (screenshots, etc.)
+        const mediaRegex = /!\[.*?\]\(.*?\)|<img[^>]*>|<video[^>]*>|<audio[^>]*>/g;
+        preservableContent.media = description.match(mediaRegex) || [];
+        // Extract file attachments
+        const fileRegex = /\[.*?\]\([^)]*\.(pdf|doc|docx|xls|xlsx|ppt|pptx|zip|rar|tar|gz)[^)]*\)/gi;
+        preservableContent.files = description.match(fileRegex) || [];
+        // Extract links (excluding images and files)
+        const linkRegex = /\[[^\]]*\]\([^)]+\)/g;
+        const allLinks = description.match(linkRegex) || [];
+        preservableContent.links = allLinks.filter((link) => !mediaRegex.test(link) && !fileRegex.test(link));
+        Logger_1.logger.debug(`Preservable content: ${preservableContent.media.length} media, ` +
+            `${preservableContent.files.length} files, ${preservableContent.links.length} links`);
+        return preservableContent;
+    }
+    /**
+     * Validate presence of required sections
+     */
+    validateRequiredSections(description, requiredSections) {
+        if (!description) {
+            return requiredSections.map((section) => ({
+                ...section,
+                present: false,
+                content: "",
+            }));
+        }
+        const sectionPatterns = {
+            changelog: [
+                /##.*?[Cc]hangelog/i,
+                /##.*?[Mm]odules?\s+[Mm]odified/i,
+                /##.*?[Cc]hanges?\s+[Mm]ade/i,
+                /📋.*?[Cc]hangelog/i,
+            ],
+            testcases: [
+                /##.*?[Tt]est\s+[Cc]ases?/i,
+                /##.*?[Tt]esting/i,
+                /🧪.*?[Tt]est/i,
+                /##.*?[Tt]est\s+[Pp]lan/i,
+            ],
+            config_changes: [
+                /##.*?[Cc]onfig/i,
+                /##.*?CAC/i,
+                /##.*?[Ss]ervice\s+[Cc]onfig/i,
+                /⚙️.*?[Cc]onfig/i,
+            ],
+        };
+        return requiredSections.map((section) => {
+            const patterns = sectionPatterns[section.key];
+            const isPresent = patterns
+                ? patterns.some((pattern) => pattern.test(description))
+                : false;
+            return {
+                ...section,
+                present: isPresent,
+                content: isPresent
+                    ? this.extractSectionContent(description, patterns || [])
+                    : "",
+            };
+        });
+    }
+    /**
+     * Extract content for a specific section
+     */
+    extractSectionContent(description, patterns) {
+        for (const pattern of patterns) {
+            const match = description.match(pattern);
+            if (match) {
+                const startIndex = match.index + match[0].length;
+                const nextHeaderIndex = description
+                    .substring(startIndex)
+                    .search(/\n##/);
+                const endIndex = nextHeaderIndex === -1
+                    ? description.length
+                    : startIndex + nextHeaderIndex;
+                return description.substring(startIndex, endIndex).trim();
+            }
+        }
+        return "";
+    }
+    /**
+     * Identify content gaps (TODOs, unanswered questions, etc.)
+     */
+    identifyContentGaps(description) {
+        const gaps = [];
+        if (!description) {
+            gaps.push("No description provided");
+            return gaps;
+        }
+        // Check for unanswered questions and placeholders
+        const gapMarkers = [
+            { pattern: /\?\s*$/gm, name: "unanswered questions" },
+            { pattern: /TODO/gi, name: "TODO items" },
+            { pattern: /FIXME/gi, name: "FIXME items" },
+            { pattern: /\[TBD\]/gi, name: "TBD placeholders" },
+            { pattern: /\[TO BE DETERMINED\]/gi, name: "TBD placeholders" },
+            { pattern: /\[PENDING\]/gi, name: "pending items" },
+        ];
+        gapMarkers.forEach((marker) => {
+            const matches = description.match(marker.pattern);
+            if (matches) {
+                gaps.push(`${matches.length} ${marker.name}`);
+            }
+        });
+        return gaps;
+    }
+    /**
+     * Generate enhanced description using AI and unified context
+     */
+    async generateEnhancedDescription(context, analysisResult, options) {
+        Logger_1.logger.debug("Generating AI-enhanced description...");
+        // 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();
+        }
+        const enhancementPrompt = this.buildEnhancementPrompt(context, analysisResult, options);
+        try {
+            const result = await this.neurolink.generate({
+                input: { text: enhancementPrompt },
+                provider: this.aiConfig.provider,
+                model: this.aiConfig.model,
+                temperature: this.aiConfig.temperature || 0.7,
+                maxTokens: this.aiConfig.maxTokens || 1000000,
+                timeout: "8m", // Longer timeout for description generation
+                enableAnalytics: this.aiConfig.enableAnalytics,
+                enableEvaluation: this.aiConfig.enableEvaluation,
+            });
+            let enhancedDescription = result.content ||
+                result.text ||
+                result.response ||
+                "";
+            // Clean up any markdown code blocks if AI wrapped the response
+            enhancedDescription = enhancedDescription
+                .replace(/^```markdown\s*/, "")
+                .replace(/\s*```$/, "")
+                .trim();
+            if (!enhancedDescription) {
+                throw new Error("AI generated empty description");
+            }
+            // Validate that required sections are present after enhancement
+            const finalValidation = this.validateRequiredSections(enhancedDescription, options.customSections || this.defaultRequiredSections);
+            const stillMissing = finalValidation.filter((s) => !s.present);
+            if (stillMissing.length > 0) {
+                Logger_1.logger.warn(`Warning: ${stillMissing.length} required sections still missing after AI enhancement`);
+            }
+            return enhancedDescription;
+        }
+        catch (error) {
+            if (error.message?.includes("timeout")) {
+                Logger_1.logger.error("⏰ Description enhancement timed out after 8 minutes");
+                throw new Error("Enhancement timeout - try with smaller diff or adjust timeout");
+            }
+            Logger_1.logger.error(`AI description generation failed: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * Build comprehensive enhancement prompt using unified context
+     */
+    buildEnhancementPrompt(context, analysisResult, _options) {
+        // Prepare diff information based on strategy
+        let diffInfo = "";
+        if (context.diffStrategy.strategy === "whole" && context.prDiff) {
+            diffInfo = `**Diff Strategy**: Whole PR diff (${context.diffStrategy.fileCount} files)
+**Changes**: ${JSON.stringify(context.prDiff.fileChanges?.slice(0, 20) || [], null, 2)}`;
+        }
+        else if (context.diffStrategy.strategy === "file-by-file" &&
+            context.fileDiffs) {
+            const fileList = Array.from(context.fileDiffs.keys()).slice(0, 20);
+            diffInfo = `**Diff Strategy**: File-by-file analysis (${context.diffStrategy.fileCount} files)
+**Modified Files**: ${JSON.stringify(fileList, null, 2)}`;
+        }
+        return `You are an expert technical writer specializing in comprehensive PR descriptions.
+
+## PR INFORMATION:
+**Title**: ${context.pr.title}
+**Author**: ${context.pr.author}
+**Current Description**: 
+${analysisResult.preservedContent.originalText || "[No existing description]"}
+
+## CODE CHANGES ANALYSIS:
+${diffInfo}
+
+## PROJECT CONTEXT:
+${context.projectContext.memoryBank.summary}
+
+## PROJECT RULES:
+${context.projectContext.clinerules || "No specific rules defined"}
+
+## CONTENT PRESERVATION REQUIREMENTS:
+**CRITICAL**: This is content ENHANCEMENT, not replacement!
+
+### Preserved Content Analysis:
+- **Media Items**: ${analysisResult.preservedContent.media.length} (${analysisResult.preservedContent.media.join(", ")})
+- **File Attachments**: ${analysisResult.preservedContent.files.length} (${analysisResult.preservedContent.files.join(", ")})
+- **Links**: ${analysisResult.preservedContent.links.length}
+- **Content Gaps**: ${analysisResult.gaps.join(", ") || "None identified"}
+
+### PRESERVATION RULES:
+- **NEVER REMOVE**: Screenshots, images, file attachments, existing explanations, or links
+- **PRESERVE EXACTLY**: All media links, file references, and existing valuable content
+- **ONLY ADD**: Missing required sections or enhance clearly incomplete ones
+- **MAINTAIN**: Original structure, tone, and author's explanations
+
+## REQUIRED SECTIONS STATUS:
+${analysisResult.requiredSections
+            .map((section) => `
+**${section.name}**:
+- Present: ${section.present ? "✅ Yes" : "❌ Missing"}
+- Content: ${section.content ? `"${section.content.substring(0, 100)}..."` : "None"}
+- Action Needed: ${section.present ? ((section.content?.length || 0) < 50 ? "Enhancement" : "None") : "Add Section"}`)
+            .join("")}
+
+## REQUIRED SECTIONS TO IMPLEMENT:
+
+### 1. 📋 CHANGELOG (Modules Modified)
+**Purpose**: Clear documentation of what changed
+**Content Requirements**:
+- List specific files/modules modified, added, or removed
+- Categorize changes (Features, Bug Fixes, Improvements, Breaking Changes)
+- Mention key components affected
+- Highlight any architectural changes
+
+### 2. 🧪 TEST CASES (What to be tested)
+**Purpose**: Comprehensive testing guidance
+**Content Requirements**:
+- Unit tests to run or add
+- Integration test scenarios
+- Manual testing steps for reviewers
+- Edge cases to verify
+- Regression testing considerations
+- Performance testing if applicable
+
+### 3. ⚙️ CAC CONFIG OR SERVICE CONFIG CHANGES
+**Purpose**: Infrastructure and configuration impact
+**Content Requirements**:
+- Configuration files modified
+- Environment variables added/changed/removed
+- Service configuration updates
+- Database schema changes
+- Deployment considerations
+- If no config changes: explicitly state "No configuration changes required"
+
+## ENHANCEMENT STRATEGY:
+
+### For Missing Sections:
+1. **START** with the complete existing description
+2. **ANALYZE** the code changes to understand the scope
+3. **ADD** each missing required section with comprehensive content
+4. **EXTRACT** relevant information from the diff to populate sections
+
+### For Incomplete Sections:
+1. **PRESERVE** all existing content in the section
+2. **ENHANCE** with additional details based on code analysis
+3. **MAINTAIN** the original structure and format
+
+### Content Generation Guidelines:
+- **Be Specific**: Use actual file names, function names, and module names from the changes
+- **Be Actionable**: Provide clear, executable test instructions
+- **Be Complete**: Cover all aspects of the change comprehensively
+- **Be Professional**: Maintain technical accuracy and clear communication
+
+## OUTPUT REQUIREMENTS:
+Return the COMPLETE enhanced description as properly formatted markdown text (NOT JSON).
+
+**CRITICAL INSTRUCTIONS**:
+1. **START WITH**: The entire existing description as your foundation
+2. **PRESERVE**: Every single piece of existing content (media, links, explanations)
+3. **ADD ONLY**: Missing required sections at appropriate locations
+4. **ENHANCE ONLY**: Clearly incomplete sections with additional details
+5. **EXTRACT**: Specific details from the code changes for accuracy
+6. **MAINTAIN**: Professional tone and clear markdown formatting
+
+Generate the enhanced description now, ensuring ALL preservation requirements are met:`;
+    }
+    /**
+     * Update PR description in Bitbucket
+     */
+    async updatePRDescription(context, enhancedDescription) {
+        Logger_1.logger.debug(`Updating PR description for #${context.pr.id}...`);
+        try {
+            await this.bitbucketProvider.updatePRDescription(context.identifier, enhancedDescription);
+            Logger_1.logger.success("✅ PR description updated successfully");
+        }
+        catch (error) {
+            Logger_1.logger.error(`Failed to update PR description: ${error.message}`);
+            throw new types_1.ProviderError(`Description update failed: ${error.message}`);
+        }
+    }
+    /**
+     * Show description preview for dry run
+     */
+    showDescriptionPreview(enhancedDescription, analysisResult) {
+        console.log("\n" + "═".repeat(80));
+        console.log("📝 ENHANCED PR DESCRIPTION PREVIEW");
+        console.log("═".repeat(80));
+        console.log(enhancedDescription);
+        console.log("═".repeat(80));
+        console.log("\n📊 ENHANCEMENT SUMMARY:");
+        console.log(`✅ Required sections completed: ${analysisResult.requiredSections.filter((s) => s.present).length}/${analysisResult.requiredSections.length}`);
+        console.log(`📎 Preserved content: ${analysisResult.preservedContent.media.length} media items, ${analysisResult.preservedContent.files.length} files`);
+        console.log(`📏 Enhanced description length: ${enhancedDescription.length} characters`);
+        if (analysisResult.gaps.length > 0) {
+            console.log(`🔍 Content gaps addressed: ${analysisResult.gaps.join(", ")}`);
+        }
+    }
+    /**
+     * Generate enhancement result summary
+     */
+    generateEnhancementResult(originalDescription, enhancedDescription, analysisResult, _duration) {
+        // Determine what sections were added or enhanced
+        const originalSections = this.validateRequiredSections(originalDescription, analysisResult.requiredSections);
+        const enhancedSections = this.validateRequiredSections(enhancedDescription, analysisResult.requiredSections);
+        const sectionsAdded = enhancedSections
+            .filter((enhanced, i) => enhanced.present && !originalSections[i].present)
+            .map((s) => s.name);
+        const sectionsEnhanced = enhancedSections
+            .filter((enhanced, i) => enhanced.present &&
+            originalSections[i].present &&
+            (enhanced.content?.length || 0) >
+                (originalSections[i].content?.length || 0) + 50)
+            .map((s) => s.name);
+        const completedSections = enhancedSections.filter((s) => s.present).length;
+        return {
+            originalDescription: originalDescription || "",
+            enhancedDescription,
+            sectionsAdded,
+            sectionsEnhanced,
+            preservedItems: {
+                media: analysisResult.preservedContent.media.length,
+                files: analysisResult.preservedContent.files.length,
+                links: analysisResult.preservedContent.links.length,
+            },
+            statistics: {
+                originalLength: originalDescription?.length || 0,
+                enhancedLength: enhancedDescription.length,
+                completedSections,
+                totalSections: analysisResult.requiredSections.length,
+            },
+        };
+    }
+    /**
+     * Get enhancement statistics
+     */
+    getStats() {
+        return {
+            defaultSections: this.defaultRequiredSections.length,
+            aiProvider: this.aiConfig.provider,
+        };
+    }
+}
+exports.DescriptionEnhancer = DescriptionEnhancer;
+function createDescriptionEnhancer(bitbucketProvider, aiConfig) {
+    return new DescriptionEnhancer(bitbucketProvider, aiConfig);
+}
+//# sourceMappingURL=DescriptionEnhancer.js.map

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Yama - Main package exports
+ * Provides both programmatic API and CLI access
+ */
+export { Guardian, createGuardian, guardian } from "./core/Guardian";
+export { ContextGatherer, createContextGatherer } from "./core/ContextGatherer";
+export type { UnifiedContext, ProjectContext, DiffStrategy, } from "./core/ContextGatherer";
+export { BitbucketProvider, createBitbucketProvider, } from "./core/providers/BitbucketProvider";
+export { CodeReviewer, createCodeReviewer } from "./features/CodeReviewer";
+export { DescriptionEnhancer, createDescriptionEnhancer, } from "./features/DescriptionEnhancer";
+export { Logger, createLogger, logger } from "./utils/Logger";
+export { Cache, createCache, cache } from "./utils/Cache";
+export { ConfigManager, createConfigManager, configManager, } from "./utils/ConfigManager";
+export * from "./types";
+export { main as cli } from "./cli/index";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,60 @@
+"use strict";
+/**
+ * Yama - Main package exports
+ * Provides both programmatic API and CLI access
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cli = exports.configManager = exports.createConfigManager = exports.ConfigManager = exports.cache = exports.createCache = exports.Cache = exports.logger = exports.createLogger = exports.Logger = exports.createDescriptionEnhancer = exports.DescriptionEnhancer = exports.createCodeReviewer = exports.CodeReviewer = exports.createBitbucketProvider = exports.BitbucketProvider = exports.createContextGatherer = exports.ContextGatherer = exports.guardian = exports.createGuardian = exports.Guardian = void 0;
+// Core classes
+var Guardian_1 = require("./core/Guardian");
+Object.defineProperty(exports, "Guardian", { enumerable: true, get: function () { return Guardian_1.Guardian; } });
+Object.defineProperty(exports, "createGuardian", { enumerable: true, get: function () { return Guardian_1.createGuardian; } });
+Object.defineProperty(exports, "guardian", { enumerable: true, get: function () { return Guardian_1.guardian; } });
+var ContextGatherer_1 = require("./core/ContextGatherer");
+Object.defineProperty(exports, "ContextGatherer", { enumerable: true, get: function () { return ContextGatherer_1.ContextGatherer; } });
+Object.defineProperty(exports, "createContextGatherer", { enumerable: true, get: function () { return ContextGatherer_1.createContextGatherer; } });
+// Providers
+var BitbucketProvider_1 = require("./core/providers/BitbucketProvider");
+Object.defineProperty(exports, "BitbucketProvider", { enumerable: true, get: function () { return BitbucketProvider_1.BitbucketProvider; } });
+Object.defineProperty(exports, "createBitbucketProvider", { enumerable: true, get: function () { return BitbucketProvider_1.createBitbucketProvider; } });
+// Features
+var CodeReviewer_1 = require("./features/CodeReviewer");
+Object.defineProperty(exports, "CodeReviewer", { enumerable: true, get: function () { return CodeReviewer_1.CodeReviewer; } });
+Object.defineProperty(exports, "createCodeReviewer", { enumerable: true, get: function () { return CodeReviewer_1.createCodeReviewer; } });
+var DescriptionEnhancer_1 = require("./features/DescriptionEnhancer");
+Object.defineProperty(exports, "DescriptionEnhancer", { enumerable: true, get: function () { return DescriptionEnhancer_1.DescriptionEnhancer; } });
+Object.defineProperty(exports, "createDescriptionEnhancer", { enumerable: true, get: function () { return DescriptionEnhancer_1.createDescriptionEnhancer; } });
+// Utilities
+var Logger_1 = require("./utils/Logger");
+Object.defineProperty(exports, "Logger", { enumerable: true, get: function () { return Logger_1.Logger; } });
+Object.defineProperty(exports, "createLogger", { enumerable: true, get: function () { return Logger_1.createLogger; } });
+Object.defineProperty(exports, "logger", { enumerable: true, get: function () { return Logger_1.logger; } });
+var Cache_1 = require("./utils/Cache");
+Object.defineProperty(exports, "Cache", { enumerable: true, get: function () { return Cache_1.Cache; } });
+Object.defineProperty(exports, "createCache", { enumerable: true, get: function () { return Cache_1.createCache; } });
+Object.defineProperty(exports, "cache", { enumerable: true, get: function () { return Cache_1.cache; } });
+var ConfigManager_1 = require("./utils/ConfigManager");
+Object.defineProperty(exports, "ConfigManager", { enumerable: true, get: function () { return ConfigManager_1.ConfigManager; } });
+Object.defineProperty(exports, "createConfigManager", { enumerable: true, get: function () { return ConfigManager_1.createConfigManager; } });
+Object.defineProperty(exports, "configManager", { enumerable: true, get: function () { return ConfigManager_1.configManager; } });
+// Types
+__exportStar(require("./types"), exports);
+// CLI
+var index_1 = require("./cli/index");
+Object.defineProperty(exports, "cli", { enumerable: true, get: function () { return index_1.main; } });
+// Note: Use named import { Guardian } from '@juspay/yama' instead
+//# sourceMappingURL=index.js.map