@juspay/yama 1.1.0

package/dist/utils/ConfigManager.js

@@ -0,0 +1,555 @@
+"use strict";
+/**
+ * Enhanced Configuration Manager for Yama
+ * Handles configuration loading, validation, and merging from multiple sources
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configManager = exports.ConfigManager = void 0;
+exports.createConfigManager = createConfigManager;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const yaml_1 = __importDefault(require("yaml"));
+const types_1 = require("../types");
+const Logger_1 = require("./Logger");
+class ConfigManager {
+    constructor() {
+        this.config = null;
+        this.configPaths = [];
+        this.setupConfigPaths();
+    }
+    /**
+     * Setup configuration file search paths
+     */
+    setupConfigPaths() {
+        const cwd = process.cwd();
+        const homeDir = require('os').homedir();
+        this.configPaths = [
+            path_1.default.join(cwd, 'yama.config.yaml'),
+            path_1.default.join(cwd, 'yama.config.yml'),
+            path_1.default.join(cwd, 'yama.config.json'),
+            path_1.default.join(cwd, '.yama.yaml'),
+            path_1.default.join(cwd, '.yama.yml'),
+            path_1.default.join(cwd, '.yama.json'),
+            path_1.default.join(homeDir, '.yama', 'config.yaml'),
+            path_1.default.join(homeDir, '.yama', 'config.yml'),
+            path_1.default.join(homeDir, '.yama', 'config.json'),
+            path_1.default.join(homeDir, '.config', 'yama', 'config.yaml'),
+            path_1.default.join(homeDir, '.config', 'yama', 'config.yml'),
+            path_1.default.join(homeDir, '.config', 'yama', 'config.json')
+        ];
+    }
+    /**
+     * Load configuration from files and environment
+     */
+    async loadConfig(configPath) {
+        if (this.config) {
+            return this.config;
+        }
+        Logger_1.logger.debug('Loading Yama configuration...');
+        // Start with default config
+        let config = this.deepClone(ConfigManager.DEFAULT_CONFIG);
+        // If specific config path provided, use only that
+        if (configPath) {
+            if (!fs_1.default.existsSync(configPath)) {
+                throw new types_1.ConfigurationError(`Configuration file not found: ${configPath}`);
+            }
+            const fileConfig = await this.loadConfigFile(configPath);
+            config = this.mergeConfigs(config, fileConfig);
+            Logger_1.logger.debug(`Loaded configuration from: ${configPath}`);
+        }
+        else {
+            // Search for config files in predefined paths
+            for (const configFilePath of this.configPaths) {
+                if (fs_1.default.existsSync(configFilePath)) {
+                    try {
+                        const fileConfig = await this.loadConfigFile(configFilePath);
+                        config = this.mergeConfigs(config, fileConfig);
+                        Logger_1.logger.debug(`Loaded configuration from: ${configFilePath}`);
+                        break;
+                    }
+                    catch (error) {
+                        Logger_1.logger.warn(`Failed to load config from ${configFilePath}:`, error);
+                    }
+                }
+            }
+        }
+        // Override with environment variables
+        config = this.applyEnvironmentOverrides(config);
+        // Validate configuration
+        this.validateConfig(config);
+        this.config = config;
+        Logger_1.logger.debug('Configuration loaded successfully');
+        return config;
+    }
+    /**
+     * Load configuration from a specific file
+     */
+    async loadConfigFile(filePath) {
+        try {
+            const content = fs_1.default.readFileSync(filePath, 'utf8');
+            const ext = path_1.default.extname(filePath).toLowerCase();
+            switch (ext) {
+                case '.yaml':
+                case '.yml':
+                    return yaml_1.default.parse(content);
+                case '.json':
+                    return JSON.parse(content);
+                default:
+                    throw new types_1.ConfigurationError(`Unsupported config file format: ${ext}`);
+            }
+        }
+        catch (error) {
+            throw new types_1.ConfigurationError(`Failed to parse config file ${filePath}: ${error.message}`);
+        }
+    }
+    /**
+     * Apply environment variable overrides
+     */
+    applyEnvironmentOverrides(config) {
+        const env = process.env;
+        // AI Provider overrides
+        if (env.AI_PROVIDER) {
+            config.providers.ai.provider = env.AI_PROVIDER;
+        }
+        if (env.AI_MODEL) {
+            config.providers.ai.model = env.AI_MODEL;
+        }
+        if (env.AI_TIMEOUT) {
+            config.providers.ai.timeout = env.AI_TIMEOUT;
+        }
+        if (env.AI_TEMPERATURE) {
+            config.providers.ai.temperature = parseFloat(env.AI_TEMPERATURE);
+        }
+        if (env.AI_MAX_TOKENS) {
+            config.providers.ai.maxTokens = parseInt(env.AI_MAX_TOKENS);
+        }
+        // Git Provider overrides
+        if (env.BITBUCKET_USERNAME) {
+            config.providers.git.credentials.username = env.BITBUCKET_USERNAME;
+        }
+        if (env.BITBUCKET_TOKEN) {
+            config.providers.git.credentials.token = env.BITBUCKET_TOKEN;
+        }
+        if (env.BITBUCKET_BASE_URL) {
+            config.providers.git.credentials.baseUrl = env.BITBUCKET_BASE_URL;
+        }
+        // Feature toggles
+        if (env.ENABLE_CODE_REVIEW !== undefined) {
+            config.features.codeReview.enabled = env.ENABLE_CODE_REVIEW === 'true';
+        }
+        if (env.ENABLE_DESCRIPTION_ENHANCEMENT !== undefined) {
+            config.features.descriptionEnhancement.enabled = env.ENABLE_DESCRIPTION_ENHANCEMENT === 'true';
+        }
+        if (env.ENABLE_SECURITY_SCAN !== undefined) {
+            config.features.securityScan.enabled = env.ENABLE_SECURITY_SCAN === 'true';
+        }
+        if (env.ENABLE_ANALYTICS !== undefined) {
+            config.features.analytics.enabled = env.ENABLE_ANALYTICS === 'true';
+        }
+        // Cache configuration
+        if (env.CACHE_ENABLED !== undefined) {
+            config.cache.enabled = env.CACHE_ENABLED === 'true';
+        }
+        if (env.CACHE_TTL) {
+            config.cache.ttl = env.CACHE_TTL;
+        }
+        if (env.CACHE_STORAGE) {
+            config.cache.storage = env.CACHE_STORAGE;
+        }
+        // Debug mode
+        if (env.GUARDIAN_DEBUG === 'true') {
+            Logger_1.logger.setLevel('debug');
+            Logger_1.logger.setVerbose(true);
+        }
+        Logger_1.logger.debug('Applied environment variable overrides');
+        return config;
+    }
+    /**
+     * Validate configuration
+     */
+    validateConfig(config) {
+        const errors = [];
+        // Validate AI provider credentials
+        if (!config.providers.ai.provider) {
+            errors.push('AI provider must be specified');
+        }
+        // Validate Git provider credentials
+        if (!config.providers.git.credentials.username) {
+            errors.push('Git username must be specified');
+        }
+        if (!config.providers.git.credentials.token) {
+            errors.push('Git token must be specified');
+        }
+        // Validate enabled features have required configuration
+        if (config.features.codeReview.enabled) {
+            if (!config.features.codeReview.severityLevels?.length) {
+                errors.push('Code review severity levels must be specified when enabled');
+            }
+        }
+        if (config.features.descriptionEnhancement.enabled) {
+            if (!config.features.descriptionEnhancement.requiredSections?.length) {
+                errors.push('Description enhancement required sections must be specified when enabled');
+            }
+        }
+        // Validate cache configuration
+        if (config.cache?.enabled) {
+            if (!config.cache.storage) {
+                errors.push('Cache storage type must be specified when cache is enabled');
+            }
+        }
+        if (errors.length > 0) {
+            throw new types_1.ConfigurationError(`Configuration validation failed:\n${errors.map(e => `  - ${e}`).join('\n')}`);
+        }
+        Logger_1.logger.debug('Configuration validation passed');
+    }
+    /**
+     * Merge two configuration objects deeply
+     */
+    mergeConfigs(base, override) {
+        return this.deepMerge(base, override);
+    }
+    /**
+     * Deep merge utility
+     */
+    deepMerge(target, source) {
+        const result = { ...target };
+        for (const key in source) {
+            if (source[key] !== null && typeof source[key] === 'object' && !Array.isArray(source[key])) {
+                result[key] = this.deepMerge(target[key] || {}, source[key]);
+            }
+            else {
+                result[key] = source[key];
+            }
+        }
+        return result;
+    }
+    /**
+     * Deep clone utility
+     */
+    deepClone(obj) {
+        return JSON.parse(JSON.stringify(obj));
+    }
+    /**
+     * Get current configuration
+     */
+    getConfig() {
+        if (!this.config) {
+            throw new types_1.ConfigurationError('Configuration not loaded. Call loadConfig() first.');
+        }
+        return this.config;
+    }
+    /**
+     * Create default configuration file
+     */
+    async createDefaultConfig(outputPath) {
+        const defaultPath = outputPath || path_1.default.join(process.cwd(), 'yama.config.yaml');
+        const configContent = yaml_1.default.stringify(ConfigManager.DEFAULT_CONFIG, {
+            indent: 2,
+            lineWidth: 100
+        });
+        // Add comments to make the config file more user-friendly
+        const commentedConfig = this.addConfigComments(configContent);
+        fs_1.default.writeFileSync(defaultPath, commentedConfig, 'utf8');
+        Logger_1.logger.info(`Default configuration created at: ${defaultPath}`);
+        return defaultPath;
+    }
+    /**
+     * Add helpful comments to configuration file
+     */
+    addConfigComments(content) {
+        const header = `# Yama Configuration
+# This file configures all aspects of Yama behavior
+# For more information, visit: https://github.com/juspay/yama
+
+`;
+        const sections = [
+            '# AI Provider Configuration',
+            '# Git Platform Configuration',
+            '# Feature Configuration',
+            '# Cache Configuration',
+            '# Performance Configuration',
+            '# Custom Rules Configuration',
+            '# Reporting Configuration'
+        ];
+        let commented = header + content;
+        // Add section comments (this is a simplified approach)
+        sections.forEach(section => {
+            const key = section.split(' ')[1].toLowerCase();
+            commented = commented.replace(new RegExp(`^(${key}:)`, 'm'), `${section}\n$1`);
+        });
+        return commented;
+    }
+    /**
+     * Validate specific configuration section
+     */
+    validateSection(section, config) {
+        try {
+            switch (section) {
+                case 'providers':
+                    return this.validateProviders(config);
+                case 'features':
+                    return this.validateFeatures(config);
+                case 'cache':
+                    return this.validateCache(config);
+                default:
+                    return true;
+            }
+        }
+        catch (error) {
+            Logger_1.logger.error(`Validation failed for section ${section}:`, error);
+            return false;
+        }
+    }
+    validateProviders(providers) {
+        return !!(providers?.ai?.provider && providers?.git?.credentials?.username && providers?.git?.credentials?.token);
+    }
+    validateFeatures(features) {
+        return !!(features && typeof features === 'object');
+    }
+    validateCache(cacheConfig) {
+        if (!cacheConfig?.enabled)
+            return true;
+        return !!(cacheConfig.storage && cacheConfig.ttl);
+    }
+    /**
+     * Get configuration schema for validation
+     */
+    getSchema() {
+        return {
+            type: 'object',
+            required: ['providers', 'features'],
+            properties: {
+                providers: {
+                    type: 'object',
+                    required: ['ai', 'git'],
+                    properties: {
+                        ai: {
+                            type: 'object',
+                            required: ['provider'],
+                            properties: {
+                                provider: { type: 'string' },
+                                model: { type: 'string' },
+                                enableFallback: { type: 'boolean' },
+                                enableAnalytics: { type: 'boolean' },
+                                timeout: { type: ['string', 'number'] },
+                                temperature: { type: 'number', minimum: 0, maximum: 2 },
+                                maxTokens: { type: 'number', minimum: 1 }
+                            }
+                        },
+                        git: {
+                            type: 'object',
+                            required: ['platform', 'credentials'],
+                            properties: {
+                                platform: { type: 'string', enum: ['bitbucket', 'github', 'gitlab', 'azure-devops'] },
+                                credentials: {
+                                    type: 'object',
+                                    required: ['username', 'token'],
+                                    properties: {
+                                        username: { type: 'string' },
+                                        token: { type: 'string' },
+                                        baseUrl: { type: 'string' }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                },
+                features: {
+                    type: 'object',
+                    required: ['codeReview', 'descriptionEnhancement'],
+                    properties: {
+                        codeReview: {
+                            type: 'object',
+                            required: ['enabled'],
+                            properties: {
+                                enabled: { type: 'boolean' },
+                                severityLevels: { type: 'array', items: { type: 'string' } },
+                                categories: { type: 'array', items: { type: 'string' } },
+                                excludePatterns: { type: 'array', items: { type: 'string' } }
+                            }
+                        },
+                        descriptionEnhancement: {
+                            type: 'object',
+                            required: ['enabled'],
+                            properties: {
+                                enabled: { type: 'boolean' },
+                                preserveContent: { type: 'boolean' },
+                                requiredSections: { type: 'array' },
+                                autoFormat: { type: 'boolean' }
+                            }
+                        }
+                    }
+                }
+            }
+        };
+    }
+    /**
+     * Find the first available configuration file
+     */
+    findConfigFile() {
+        for (const configPath of this.configPaths) {
+            if (fs_1.default.existsSync(configPath)) {
+                return configPath;
+            }
+        }
+        return null;
+    }
+    /**
+     * Watch configuration file for changes and reload automatically
+     */
+    watchConfig(callback) {
+        if (!this.configPaths.length) {
+            Logger_1.logger.warn('No configuration file found to watch');
+            return () => { };
+        }
+        const configPath = this.findConfigFile();
+        if (!configPath) {
+            Logger_1.logger.warn('No configuration file found to watch');
+            return () => { };
+        }
+        Logger_1.logger.debug(`Watching configuration file: ${configPath}`);
+        fs_1.default.watchFile(configPath, { interval: 1000 }, async () => {
+            try {
+                Logger_1.logger.info('Configuration file changed, reloading...');
+                const newConfig = await this.loadConfig();
+                if (callback) {
+                    callback(newConfig);
+                }
+                Logger_1.logger.success('Configuration reloaded successfully');
+            }
+            catch (error) {
+                Logger_1.logger.error(`Failed to reload configuration: ${error.message}`);
+            }
+        });
+        // Return cleanup function
+        return () => {
+            fs_1.default.unwatchFile(configPath);
+            Logger_1.logger.debug('Stopped watching configuration file');
+        };
+    }
+    /**
+     * Enable hot-reload for configuration
+     */
+    enableHotReload(callback) {
+        return this.watchConfig(callback);
+    }
+}
+exports.ConfigManager = ConfigManager;
+/**
+ * Default configuration
+ */
+ConfigManager.DEFAULT_CONFIG = {
+    providers: {
+        ai: {
+            provider: 'auto',
+            enableFallback: true,
+            enableAnalytics: false,
+            enableEvaluation: false,
+            timeout: '10m',
+            retryAttempts: 3,
+            temperature: 0.3,
+            maxTokens: 1000000
+        },
+        git: {
+            platform: 'bitbucket',
+            credentials: {
+                username: process.env.BITBUCKET_USERNAME || '',
+                token: process.env.BITBUCKET_TOKEN || '',
+                baseUrl: process.env.BITBUCKET_BASE_URL || 'https://your-bitbucket-server.com'
+            }
+        }
+    },
+    features: {
+        codeReview: {
+            enabled: true,
+            severityLevels: ['CRITICAL', 'MAJOR', 'MINOR', 'SUGGESTION'],
+            categories: ['security', 'performance', 'maintainability', 'functionality', 'error_handling', 'testing'],
+            excludePatterns: ['*.lock', '*.svg', '*.min.js', '*.map'],
+            contextLines: 3,
+            systemPrompt: 'You are an Expert Security Code Reviewer for enterprise applications. Your role is to:\n\n🔒 SECURITY FIRST: Prioritize security vulnerabilities and data protection\n⚡ PERFORMANCE AWARE: Identify performance bottlenecks and optimization opportunities\n🏗️ QUALITY FOCUSED: Ensure maintainable, readable, and robust code\n🛡️ ERROR RESILIENT: Verify comprehensive error handling and edge cases\n\nYou provide actionable, educational feedback with specific examples and solutions.\nFocus on critical issues that could impact production systems.',
+            focusAreas: ['🔒 Security Analysis (CRITICAL PRIORITY)', '⚡ Performance Review', '🏗️ Code Quality', '🧪 Testing & Error Handling']
+        },
+        descriptionEnhancement: {
+            enabled: true,
+            preserveContent: true,
+            requiredSections: [
+                { 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 }
+            ],
+            autoFormat: true,
+            systemPrompt: 'You are an Expert Technical Writer specializing in pull request documentation. Your role is to:\n\n📝 CLARITY FIRST: Create clear, comprehensive PR descriptions that help reviewers understand the changes\n🎥 STORY TELLING: Explain the \'why\' behind changes, not just the \'what\'\n📈 STRUCTURED: Follow consistent formatting with required sections\n🔗 CONTEXTUAL: Link changes to business value and technical rationale\n\nCRITICAL INSTRUCTION: Return ONLY the enhanced PR description content as clean markdown. Do NOT include any meta-commentary, explanations about what you\'re doing, or introductory text like "I will enhance..." or "Here is the enhanced description:". \n\nOutput the enhanced description directly without any wrapper text or explanations.',
+            outputTemplate: '# PR Title Enhancement (if needed)\n\n## Summary\n[Clear overview of what this PR accomplishes]\n\n## Changes Made\n[Specific technical changes - be precise]\n\n## Testing\n[How the changes were tested]\n\n## Impact\n[Business/technical impact and considerations]\n\n## Additional Notes\n[Any deployment notes, follow-ups, or special considerations]',
+            enhancementInstructions: 'Return ONLY the enhanced PR description as clean markdown. Do NOT include any explanatory text, meta-commentary, or phrases like "Here is the enhanced description:" or "I will enhance...".\n\nStart directly with the enhanced description content using this structure:'
+        },
+        securityScan: {
+            enabled: true,
+            level: 'strict',
+            scanTypes: ['secrets', 'vulnerabilities', 'dependencies']
+        },
+        analytics: {
+            enabled: true,
+            trackMetrics: true,
+            exportFormat: 'json'
+        }
+    },
+    cache: {
+        enabled: true,
+        ttl: '1h',
+        maxSize: '100MB',
+        storage: 'memory'
+    },
+    performance: {
+        batch: {
+            enabled: true,
+            maxConcurrent: 5,
+            delayBetween: '1s'
+        },
+        optimization: {
+            reuseConnections: true,
+            compressRequests: true,
+            enableHttp2: true
+        }
+    },
+    rules: {
+        security: [
+            {
+                name: 'No hardcoded secrets',
+                pattern: '(password|secret|key|token)\\s*[=:]\\s*[\'"][^\'"]{8,}[\'"]',
+                severity: 'CRITICAL',
+                message: 'Hardcoded secrets detected',
+                suggestion: 'Use environment variables or secure configuration management'
+            }
+        ],
+        performance: [
+            {
+                name: 'Avoid N+1 queries',
+                pattern: 'for.*\\.(find|get|query|select)',
+                severity: 'MAJOR',
+                message: 'Potential N+1 query pattern detected',
+                suggestion: 'Consider using batch queries or joins'
+            }
+        ]
+    },
+    reporting: {
+        formats: ['markdown', 'json'],
+        includeAnalytics: true,
+        includeMetrics: true
+    },
+    monitoring: {
+        enabled: true,
+        metrics: ['performance', 'cache', 'api_calls'],
+        exportFormat: 'json',
+        interval: '5m'
+    }
+};
+// Export singleton instance
+exports.configManager = new ConfigManager();
+// Export factory function
+function createConfigManager() {
+    return new ConfigManager();
+}
+//# sourceMappingURL=ConfigManager.js.map

package/dist/utils/Logger.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Enhanced Logger utility - Optimized from both pr-police.js and pr-describe.js
+ * Provides consistent logging across all Guardian operations
+ */
+import { Logger as ILogger, LogLevel, LoggerOptions } from '../types';
+export declare class Logger implements ILogger {
+    private options;
+    constructor(options?: Partial<LoggerOptions>);
+    private shouldLog;
+    private formatMessage;
+    private colorize;
+    debug(message: string, ...args: any[]): void;
+    info(message: string, ...args: any[]): void;
+    warn(message: string, ...args: any[]): void;
+    error(message: string, ...args: any[]): void;
+    badge(): void;
+    phase(message: string): void;
+    success(message: string): void;
+    operation(operation: string, status: 'started' | 'completed' | 'failed'): void;
+    violation(severity: string, message: string, file?: string): void;
+    progress(current: number, total: number, operation: string): void;
+    private createProgressBar;
+    child(context: Record<string, any>): Logger;
+    setLevel(level: LogLevel): void;
+    setVerbose(verbose: boolean): void;
+    getConfig(): LoggerOptions;
+}
+export declare const logger: Logger;
+export declare function createLogger(options?: Partial<LoggerOptions>): Logger;
+//# sourceMappingURL=Logger.d.ts.map