@juspay/yama 1.1.0 → 1.2.0

package/dist/utils/ConfigManager.js

@@ -1,23 +1,156 @@
-"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 {
+import fs from "fs";
+import path from "path";
+import yaml from "yaml";
+import { homedir } from "os";
+import { ConfigurationError } from "../types/index.js";
+import { logger } from "./Logger.js";
+import { validateProviderTokenLimit } from "./ProviderLimits.js";
+export class ConfigManager {
+    config = null;
+    configPaths = [];
+    /**
+     * Default configuration
+     */
+    static DEFAULT_CONFIG = {
+        providers: {
+            ai: {
+                provider: "auto",
+                enableFallback: true,
+                enableAnalytics: false,
+                enableEvaluation: false,
+                timeout: "10m",
+                retryAttempts: 3,
+                temperature: 0.3,
+                maxTokens: 65000,
+            },
+            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",
+        },
+        memoryBank: {
+            enabled: true,
+            path: "memory-bank",
+            fallbackPaths: ["docs/memory-bank", ".memory-bank"],
+        },
+    };
     constructor() {
-        this.config = null;
-        this.configPaths = [];
         this.setupConfigPaths();
     }
     /**
@@ -25,20 +158,20 @@ class ConfigManager {
      */
     setupConfigPaths() {
         const cwd = process.cwd();
-        const homeDir = require('os').homedir();
+        const homeDir = 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')
+            path.join(cwd, "yama.config.yaml"),
+            path.join(cwd, "yama.config.yml"),
+            path.join(cwd, "yama.config.json"),
+            path.join(cwd, ".yama.yaml"),
+            path.join(cwd, ".yama.yml"),
+            path.join(cwd, ".yama.json"),
+            path.join(homeDir, ".yama", "config.yaml"),
+            path.join(homeDir, ".yama", "config.yml"),
+            path.join(homeDir, ".yama", "config.json"),
+            path.join(homeDir, ".config", "yama", "config.yaml"),
+            path.join(homeDir, ".config", "yama", "config.yml"),
+            path.join(homeDir, ".config", "yama", "config.json"),
         ];
     }
     /**
@@ -48,40 +181,42 @@ class ConfigManager {
         if (this.config) {
             return this.config;
         }
-        Logger_1.logger.debug('Loading Yama configuration...');
+        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}`);
+            if (!fs.existsSync(configPath)) {
+                throw new 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}`);
+            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)) {
+                if (fs.existsSync(configFilePath)) {
                     try {
                         const fileConfig = await this.loadConfigFile(configFilePath);
                         config = this.mergeConfigs(config, fileConfig);
-                        Logger_1.logger.debug(`Loaded configuration from: ${configFilePath}`);
+                        logger.debug(`Loaded configuration from: ${configFilePath}`);
                         break;
                     }
                     catch (error) {
-                        Logger_1.logger.warn(`Failed to load config from ${configFilePath}:`, error);
+                        logger.warn(`Failed to load config from ${configFilePath}:`, error);
                     }
                 }
             }
         }
         // Override with environment variables
         config = this.applyEnvironmentOverrides(config);
+        // Apply provider-aware token limits
+        config = this.applyProviderTokenLimits(config);
         // Validate configuration
         this.validateConfig(config);
         this.config = config;
-        Logger_1.logger.debug('Configuration loaded successfully');
+        logger.debug("Configuration loaded successfully");
         return config;
     }
     /**
@@ -89,22 +224,34 @@ class ConfigManager {
      */
     async loadConfigFile(filePath) {
         try {
-            const content = fs_1.default.readFileSync(filePath, 'utf8');
-            const ext = path_1.default.extname(filePath).toLowerCase();
+            const content = fs.readFileSync(filePath, "utf8");
+            const ext = path.extname(filePath).toLowerCase();
             switch (ext) {
-                case '.yaml':
-                case '.yml':
-                    return yaml_1.default.parse(content);
-                case '.json':
+                case ".yaml":
+                case ".yml":
+                    return yaml.parse(content);
+                case ".json":
                     return JSON.parse(content);
                 default:
-                    throw new types_1.ConfigurationError(`Unsupported config file format: ${ext}`);
+                    throw new ConfigurationError(`Unsupported config file format: ${ext}`);
             }
         }
         catch (error) {
-            throw new types_1.ConfigurationError(`Failed to parse config file ${filePath}: ${error.message}`);
+            throw new ConfigurationError(`Failed to parse config file ${filePath}: ${error.message}`);
         }
     }
+    /**
+     * Apply provider-aware token limits using shared utility
+     */
+    applyProviderTokenLimits(config) {
+        const provider = config.providers.ai.provider || 'auto';
+        const configuredTokens = config.providers.ai.maxTokens;
+        // Use the shared utility to validate and adjust token limits
+        const validatedTokens = validateProviderTokenLimit(provider, configuredTokens, false // Use standard limits for configuration
+        );
+        config.providers.ai.maxTokens = validatedTokens;
+        return config;
+    }
     /**
      * Apply environment variable overrides
      */
@@ -138,20 +285,22 @@ class ConfigManager {
         }
         // Feature toggles
         if (env.ENABLE_CODE_REVIEW !== undefined) {
-            config.features.codeReview.enabled = env.ENABLE_CODE_REVIEW === 'true';
+            config.features.codeReview.enabled = env.ENABLE_CODE_REVIEW === "true";
         }
         if (env.ENABLE_DESCRIPTION_ENHANCEMENT !== undefined) {
-            config.features.descriptionEnhancement.enabled = env.ENABLE_DESCRIPTION_ENHANCEMENT === 'true';
+            config.features.descriptionEnhancement.enabled =
+                env.ENABLE_DESCRIPTION_ENHANCEMENT === "true";
         }
         if (env.ENABLE_SECURITY_SCAN !== undefined) {
-            config.features.securityScan.enabled = env.ENABLE_SECURITY_SCAN === 'true';
+            config.features.securityScan.enabled =
+                env.ENABLE_SECURITY_SCAN === "true";
         }
         if (env.ENABLE_ANALYTICS !== undefined) {
-            config.features.analytics.enabled = env.ENABLE_ANALYTICS === 'true';
+            config.features.analytics.enabled = env.ENABLE_ANALYTICS === "true";
         }
         // Cache configuration
         if (env.CACHE_ENABLED !== undefined) {
-            config.cache.enabled = env.CACHE_ENABLED === 'true';
+            config.cache.enabled = env.CACHE_ENABLED === "true";
         }
         if (env.CACHE_TTL) {
             config.cache.ttl = env.CACHE_TTL;
@@ -160,11 +309,11 @@ class ConfigManager {
             config.cache.storage = env.CACHE_STORAGE;
         }
         // Debug mode
-        if (env.GUARDIAN_DEBUG === 'true') {
-            Logger_1.logger.setLevel('debug');
-            Logger_1.logger.setVerbose(true);
+        if (env.GUARDIAN_DEBUG === "true") {
+            logger.setLevel("debug");
+            logger.setVerbose(true);
         }
-        Logger_1.logger.debug('Applied environment variable overrides');
+        logger.debug("Applied environment variable overrides");
         return config;
     }
     /**
@@ -174,36 +323,36 @@ class ConfigManager {
         const errors = [];
         // Validate AI provider credentials
         if (!config.providers.ai.provider) {
-            errors.push('AI provider must be specified');
+            errors.push("AI provider must be specified");
         }
         // Validate Git provider credentials
         if (!config.providers.git.credentials.username) {
-            errors.push('Git username must be specified');
+            errors.push("Git username must be specified");
         }
         if (!config.providers.git.credentials.token) {
-            errors.push('Git token must be specified');
+            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');
+                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');
+                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');
+                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')}`);
+            throw new ConfigurationError(`Configuration validation failed:\n${errors.map((e) => `  - ${e}`).join("\n")}`);
         }
-        Logger_1.logger.debug('Configuration validation passed');
+        logger.debug("Configuration validation passed");
     }
     /**
      * Merge two configuration objects deeply
@@ -217,7 +366,9 @@ class ConfigManager {
     deepMerge(target, source) {
         const result = { ...target };
         for (const key in source) {
-            if (source[key] !== null && typeof source[key] === 'object' && !Array.isArray(source[key])) {
+            if (source[key] !== null &&
+                typeof source[key] === "object" &&
+                !Array.isArray(source[key])) {
                 result[key] = this.deepMerge(target[key] || {}, source[key]);
             }
             else {
@@ -237,7 +388,7 @@ class ConfigManager {
      */
     getConfig() {
         if (!this.config) {
-            throw new types_1.ConfigurationError('Configuration not loaded. Call loadConfig() first.');
+            throw new ConfigurationError("Configuration not loaded. Call loadConfig() first.");
         }
         return this.config;
     }
@@ -245,15 +396,15 @@ class ConfigManager {
      * 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, {
+        const defaultPath = outputPath || path.join(process.cwd(), "yama.config.yaml");
+        const configContent = yaml.stringify(ConfigManager.DEFAULT_CONFIG, {
             indent: 2,
-            lineWidth: 100
+            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}`);
+        fs.writeFileSync(defaultPath, commentedConfig, "utf8");
+        logger.info(`Default configuration created at: ${defaultPath}`);
         return defaultPath;
     }
     /**
@@ -266,19 +417,19 @@ class ConfigManager {
 
 `;
         const sections = [
-            '# AI Provider Configuration',
-            '# Git Platform Configuration',
-            '# Feature Configuration',
-            '# Cache Configuration',
-            '# Performance Configuration',
-            '# Custom Rules Configuration',
-            '# Reporting Configuration'
+            "# 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`);
+        sections.forEach((section) => {
+            const key = section.split(" ")[1].toLowerCase();
+            commented = commented.replace(new RegExp(`^(${key}:)`, "m"), `${section}\n$1`);
         });
         return commented;
     }
@@ -288,30 +439,33 @@ class ConfigManager {
     validateSection(section, config) {
         try {
             switch (section) {
-                case 'providers':
+                case "providers":
                     return this.validateProviders(config);
-                case 'features':
+                case "features":
                     return this.validateFeatures(config);
-                case 'cache':
+                case "cache":
                     return this.validateCache(config);
                 default:
                     return true;
             }
         }
         catch (error) {
-            Logger_1.logger.error(`Validation failed for section ${section}:`, error);
+            logger.error(`Validation failed for section ${String(section)}:`, error);
             return false;
         }
     }
     validateProviders(providers) {
-        return !!(providers?.ai?.provider && providers?.git?.credentials?.username && providers?.git?.credentials?.token);
+        return !!(providers?.ai?.provider &&
+            providers?.git?.credentials?.username &&
+            providers?.git?.credentials?.token);
     }
     validateFeatures(features) {
-        return !!(features && typeof features === 'object');
+        return !!(features && typeof features === "object");
     }
     validateCache(cacheConfig) {
-        if (!cacheConfig?.enabled)
+        if (!cacheConfig?.enabled) {
             return true;
+        }
         return !!(cacheConfig.storage && cacheConfig.ttl);
     }
     /**
@@ -319,71 +473,74 @@ class ConfigManager {
      */
     getSchema() {
         return {
-            type: 'object',
-            required: ['providers', 'features'],
+            type: "object",
+            required: ["providers", "features"],
             properties: {
                 providers: {
-                    type: 'object',
-                    required: ['ai', 'git'],
+                    type: "object",
+                    required: ["ai", "git"],
                     properties: {
                         ai: {
-                            type: 'object',
-                            required: ['provider'],
+                            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 }
-                            }
+                                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'],
+                            type: "object",
+                            required: ["platform", "credentials"],
                             properties: {
-                                platform: { type: 'string', enum: ['bitbucket', 'github', 'gitlab', 'azure-devops'] },
+                                platform: {
+                                    type: "string",
+                                    enum: ["bitbucket", "github", "gitlab", "azure-devops"],
+                                },
                                 credentials: {
-                                    type: 'object',
-                                    required: ['username', 'token'],
+                                    type: "object",
+                                    required: ["username", "token"],
                                     properties: {
-                                        username: { type: 'string' },
-                                        token: { type: 'string' },
-                                        baseUrl: { type: 'string' }
-                                    }
-                                }
-                            }
-                        }
-                    }
+                                        username: { type: "string" },
+                                        token: { type: "string" },
+                                        baseUrl: { type: "string" },
+                                    },
+                                },
+                            },
+                        },
+                    },
                 },
                 features: {
-                    type: 'object',
-                    required: ['codeReview', 'descriptionEnhancement'],
+                    type: "object",
+                    required: ["codeReview", "descriptionEnhancement"],
                     properties: {
                         codeReview: {
-                            type: 'object',
-                            required: ['enabled'],
+                            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' } }
-                            }
+                                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'],
+                            type: "object",
+                            required: ["enabled"],
                             properties: {
-                                enabled: { type: 'boolean' },
-                                preserveContent: { type: 'boolean' },
-                                requiredSections: { type: 'array' },
-                                autoFormat: { type: 'boolean' }
-                            }
-                        }
-                    }
-                }
-            }
+                                enabled: { type: "boolean" },
+                                preserveContent: { type: "boolean" },
+                                requiredSections: { type: "array" },
+                                autoFormat: { type: "boolean" },
+                            },
+                        },
+                    },
+                },
+            },
         };
     }
     /**
@@ -391,7 +548,7 @@ class ConfigManager {
      */
     findConfigFile() {
         for (const configPath of this.configPaths) {
-            if (fs_1.default.existsSync(configPath)) {
+            if (fs.existsSync(configPath)) {
                 return configPath;
             }
         }
@@ -402,32 +559,32 @@ class ConfigManager {
      */
     watchConfig(callback) {
         if (!this.configPaths.length) {
-            Logger_1.logger.warn('No configuration file found to watch');
+            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');
+            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 () => {
+        logger.debug(`Watching configuration file: ${configPath}`);
+        fs.watchFile(configPath, { interval: 1000 }, async () => {
             try {
-                Logger_1.logger.info('Configuration file changed, reloading...');
+                logger.info("Configuration file changed, reloading...");
                 const newConfig = await this.loadConfig();
                 if (callback) {
                     callback(newConfig);
                 }
-                Logger_1.logger.success('Configuration reloaded successfully');
+                logger.success("Configuration reloaded successfully");
             }
             catch (error) {
-                Logger_1.logger.error(`Failed to reload configuration: ${error.message}`);
+                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');
+            fs.unwatchFile(configPath);
+            logger.debug("Stopped watching configuration file");
         };
     }
     /**
@@ -437,119 +594,10 @@ class ConfigManager {
         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 const configManager = new ConfigManager();
 // Export factory function
-function createConfigManager() {
+export function createConfigManager() {
     return new ConfigManager();
 }
 //# sourceMappingURL=ConfigManager.js.map