@juspay/yama 1.6.0 → 2.1.0

package/dist/v2/config/ConfigLoader.js

@@ -0,0 +1,205 @@
+/**
+ * Multi-Layer Configuration Loader for Yama V2
+ * Loads and merges configuration from multiple sources
+ */
+import { readFile } from "fs/promises";
+import { existsSync } from "fs";
+import { parse as parseYAML } from "yaml";
+import { resolve } from "path";
+import { ConfigurationError } from "../types/v2.types.js";
+import { DefaultConfig } from "./DefaultConfig.js";
+export class ConfigLoader {
+    config = null;
+    configPath = null;
+    /**
+     * Load configuration from file with multi-layer support
+     */
+    async loadConfig(configPath) {
+        console.log("📋 Loading Yama V2 configuration...");
+        // Layer 1: Start with default config
+        let config = DefaultConfig.get();
+        // Layer 2: Load from file if provided or search for default locations
+        const filePath = await this.resolveConfigPath(configPath);
+        if (filePath) {
+            console.log(`   Reading config from: ${filePath}`);
+            const fileConfig = await this.loadConfigFile(filePath);
+            config = this.mergeConfigs(config, fileConfig);
+            this.configPath = filePath;
+        }
+        else {
+            console.log("   Using default configuration (no config file found)");
+        }
+        // Layer 3: Apply environment variable overrides
+        config = this.applyEnvironmentOverrides(config);
+        // Validate configuration
+        this.validateConfig(config);
+        this.config = config;
+        console.log("✅ Configuration loaded successfully\n");
+        return config;
+    }
+    /**
+     * Get current loaded configuration
+     */
+    getConfig() {
+        if (!this.config) {
+            throw new ConfigurationError("Configuration not loaded. Call loadConfig() first.");
+        }
+        return this.config;
+    }
+    /**
+     * Validate configuration completeness and correctness
+     */
+    async validate() {
+        if (!this.config) {
+            throw new ConfigurationError("No configuration to validate");
+        }
+        const errors = [];
+        // Validate AI config
+        if (!this.config.ai.provider) {
+            errors.push("AI provider not configured");
+        }
+        if (!this.config.ai.model) {
+            errors.push("AI model not configured");
+        }
+        // Check environment variables for Bitbucket (always required)
+        if (!process.env.BITBUCKET_USERNAME) {
+            errors.push("BITBUCKET_USERNAME environment variable not set");
+        }
+        if (!process.env.BITBUCKET_TOKEN) {
+            errors.push("BITBUCKET_TOKEN environment variable not set");
+        }
+        if (!process.env.BITBUCKET_BASE_URL) {
+            errors.push("BITBUCKET_BASE_URL environment variable not set");
+        }
+        if (this.config.mcpServers.jira.enabled) {
+            if (!process.env.JIRA_EMAIL) {
+                errors.push("JIRA_EMAIL environment variable not set");
+            }
+            if (!process.env.JIRA_API_TOKEN) {
+                errors.push("JIRA_API_TOKEN environment variable not set");
+            }
+            if (!process.env.JIRA_BASE_URL) {
+                errors.push("JIRA_BASE_URL environment variable not set");
+            }
+        }
+        if (errors.length > 0) {
+            throw new ConfigurationError(`Configuration validation failed:\n${errors.map((e) => `  - ${e}`).join("\n")}`);
+        }
+    }
+    /**
+     * Resolve configuration file path
+     */
+    async resolveConfigPath(configPath) {
+        // If explicit path provided, use it
+        if (configPath) {
+            const resolvedPath = resolve(configPath);
+            if (!existsSync(resolvedPath)) {
+                throw new ConfigurationError(`Configuration file not found: ${resolvedPath}`);
+            }
+            return resolvedPath;
+        }
+        // Search for default config files
+        const defaultPaths = [
+            "yama.config.yaml",
+            "config/yama.config.yaml",
+            ".yama/config.yaml",
+        ];
+        for (const path of defaultPaths) {
+            const resolvedPath = resolve(path);
+            if (existsSync(resolvedPath)) {
+                return resolvedPath;
+            }
+        }
+        return null;
+    }
+    /**
+     * Load configuration from YAML file
+     */
+    async loadConfigFile(filePath) {
+        try {
+            const content = await readFile(filePath, "utf-8");
+            const parsed = parseYAML(content);
+            return parsed;
+        }
+        catch (error) {
+            throw new ConfigurationError(`Failed to load config file: ${error.message}`, { filePath });
+        }
+    }
+    /**
+     * Deep merge two configuration objects
+     */
+    mergeConfigs(base, override) {
+        return this.deepMerge(base, override);
+    }
+    /**
+     * Deep merge utility
+     */
+    deepMerge(target, source) {
+        const output = { ...target };
+        if (this.isObject(target) && this.isObject(source)) {
+            Object.keys(source).forEach((key) => {
+                if (this.isObject(source[key])) {
+                    if (!(key in target)) {
+                        Object.assign(output, { [key]: source[key] });
+                    }
+                    else {
+                        output[key] = this.deepMerge(target[key], source[key]);
+                    }
+                }
+                else {
+                    Object.assign(output, { [key]: source[key] });
+                }
+            });
+        }
+        return output;
+    }
+    /**
+     * Check if value is an object
+     */
+    isObject(item) {
+        return item && typeof item === "object" && !Array.isArray(item);
+    }
+    /**
+     * Apply environment variable overrides
+     */
+    applyEnvironmentOverrides(config) {
+        // Override AI provider if env var set
+        if (process.env.AI_PROVIDER) {
+            config.ai.provider = process.env.AI_PROVIDER;
+        }
+        // Override AI model if env var set
+        if (process.env.AI_MODEL) {
+            config.ai.model = process.env.AI_MODEL;
+        }
+        // Override temperature if env var set
+        if (process.env.AI_TEMPERATURE) {
+            config.ai.temperature = parseFloat(process.env.AI_TEMPERATURE);
+        }
+        // Override max tokens if env var set
+        if (process.env.AI_MAX_TOKENS) {
+            config.ai.maxTokens = parseInt(process.env.AI_MAX_TOKENS, 10);
+        }
+        return config;
+    }
+    /**
+     * Basic configuration validation
+     */
+    validateConfig(config) {
+        if (!config.version) {
+            throw new ConfigurationError("Configuration version not specified");
+        }
+        if (config.version !== 2) {
+            throw new ConfigurationError(`Invalid configuration version: ${config.version}. Expected version 2.`);
+        }
+        if (!config.ai) {
+            throw new ConfigurationError("AI configuration missing");
+        }
+        if (!config.mcpServers) {
+            throw new ConfigurationError("MCP servers configuration missing");
+        }
+        if (!config.review) {
+            throw new ConfigurationError("Review configuration missing");
+        }
+    }
+}
+//# sourceMappingURL=ConfigLoader.js.map

package/dist/v2/config/DefaultConfig.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Default Configuration for Yama V2
+ * Provides sensible defaults when no config file is present
+ */
+import { YamaV2Config } from "../types/config.types.js";
+export declare class DefaultConfig {
+    static get(): YamaV2Config;
+}
+//# sourceMappingURL=DefaultConfig.d.ts.map

package/dist/v2/config/DefaultConfig.js

@@ -0,0 +1,187 @@
+/**
+ * Default Configuration for Yama V2
+ * Provides sensible defaults when no config file is present
+ */
+export class DefaultConfig {
+    static get() {
+        return {
+            version: 2,
+            configType: "yama-v2",
+            display: {
+                showBanner: true,
+                streamingMode: false,
+                verboseToolCalls: false,
+                showAIThinking: false,
+            },
+            ai: {
+                provider: "auto",
+                model: "gemini-2.5-pro",
+                temperature: 0.2,
+                maxTokens: 128000,
+                enableAnalytics: true,
+                enableEvaluation: false,
+                timeout: "15m",
+                retryAttempts: 3,
+                conversationMemory: {
+                    enabled: true,
+                    store: "memory",
+                    maxSessions: 50,
+                    maxTurnsPerSession: 300,
+                    enableSummarization: false,
+                },
+            },
+            mcpServers: {
+                bitbucket: {
+                    blockedTools: [],
+                },
+                jira: {
+                    enabled: false, // Opt-in: users must explicitly enable Jira integration
+                    blockedTools: [],
+                },
+            },
+            review: {
+                enabled: true,
+                workflowInstructions: `Follow the autonomous review workflow defined in the base system prompt.`,
+                focusAreas: [
+                    {
+                        name: "Security Analysis",
+                        priority: "CRITICAL",
+                        description: `
+- SQL/NoSQL injection vulnerabilities
+- Cross-Site Scripting (XSS)
+- Authentication/Authorization flaws
+- Hardcoded secrets, API keys, passwords
+- Input validation and sanitization
+- Data exposure and privacy violations
+- Insecure dependencies
+            `.trim(),
+                    },
+                    {
+                        name: "Performance Review",
+                        priority: "MAJOR",
+                        description: `
+- N+1 database query patterns
+- Missing indexes on queries
+- Memory leaks and resource management
+- Algorithm complexity (O(n²) or worse)
+- Inefficient loops and iterations
+- Missing caching opportunities
+- Blocking I/O in async contexts
+            `.trim(),
+                    },
+                    {
+                        name: "Code Quality",
+                        priority: "MAJOR",
+                        description: `
+- SOLID principle violations
+- Poor error handling
+- Missing edge case handling
+- Code duplication (DRY violations)
+- Poor naming conventions
+- Lack of modularity
+- Insufficient logging
+            `.trim(),
+                    },
+                ],
+                blockingCriteria: [], // Empty by default - no auto-blocking. Users can add custom criteria in their config.
+                excludePatterns: [
+                    "*.lock",
+                    "*.svg",
+                    "*.min.js",
+                    "*.map",
+                    "package-lock.json",
+                    "pnpm-lock.yaml",
+                    "yarn.lock",
+                ],
+                contextLines: 3,
+                maxFilesPerReview: 100,
+                fileAnalysisTimeout: "2m",
+                toolPreferences: {
+                    lazyLoading: true,
+                    cacheToolResults: true,
+                    parallelToolCalls: false,
+                    maxToolCallsPerFile: 20,
+                    enableCodeSearch: true,
+                    enableDirectoryListing: true,
+                },
+            },
+            descriptionEnhancement: {
+                enabled: true,
+                instructions: `Enhance the PR description using Jira requirements and diff analysis.`,
+                requiredSections: [
+                    {
+                        key: "summary",
+                        name: "📋 Summary",
+                        required: true,
+                        description: "Clear overview of what this PR accomplishes",
+                    },
+                    {
+                        key: "changes",
+                        name: "🔧 Changes Made",
+                        required: true,
+                        description: "Specific technical changes with file references",
+                    },
+                    {
+                        key: "jira",
+                        name: "🎫 Jira Reference",
+                        required: false,
+                        description: "Link to Jira ticket and requirement coverage",
+                    },
+                    {
+                        key: "testing",
+                        name: "🧪 Testing Strategy",
+                        required: true,
+                        description: "How changes were tested and validation approach",
+                    },
+                ],
+                preserveContent: true,
+                autoFormat: true,
+            },
+            memoryBank: {
+                enabled: true,
+                path: "memory-bank",
+                fallbackPaths: ["docs/memory-bank", ".memory-bank"],
+                standardFiles: [
+                    "project-overview.md",
+                    "architecture.md",
+                    "coding-standards.md",
+                    "security-guidelines.md",
+                ],
+            },
+            knowledgeBase: {
+                enabled: true,
+                path: ".yama/knowledge-base.md",
+                aiAuthorPatterns: ["Yama", "yama-bot", "yama-review"],
+                maxEntriesBeforeSummarization: 50,
+                summaryRetentionCount: 20,
+                autoCommit: false,
+            },
+            projectStandards: {
+                customPromptsPath: "config/prompts/",
+                additionalFocusAreas: [],
+                customBlockingRules: [],
+                severityOverrides: {},
+            },
+            monitoring: {
+                enabled: true,
+                logToolCalls: true,
+                logAIDecisions: true,
+                logTokenUsage: true,
+                exportFormat: "json",
+                exportPath: ".yama/analytics/",
+            },
+            performance: {
+                maxReviewDuration: "15m",
+                tokenBudget: {
+                    maxTokensPerReview: 500000,
+                    warningThreshold: 400000,
+                },
+                costControls: {
+                    maxCostPerReview: 2.0,
+                    warningThreshold: 1.5,
+                },
+            },
+        };
+    }
+}
+//# sourceMappingURL=DefaultConfig.js.map

package/dist/v2/core/LearningOrchestrator.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Learning Orchestrator
+ * Main entry point for the knowledge base learning feature
+ * Orchestrates PR comment extraction, AI analysis, and knowledge base updates
+ */
+import { LearnRequest, LearnResult } from "../learning/types.js";
+export declare class LearningOrchestrator {
+    private neurolink;
+    private mcpManager;
+    private configLoader;
+    private promptManager;
+    private config;
+    private initialized;
+    constructor();
+    /**
+     * Initialize the learning orchestrator
+     */
+    initialize(configPath?: string): Promise<void>;
+    /**
+     * Extract learnings from a merged PR
+     * Uses fully agentic AI approach - AI decides which tools to call
+     */
+    extractLearnings(request: LearnRequest): Promise<LearnResult>;
+    /**
+     * Build instructions for Step 1: Fetch PR comments
+     */
+    private buildFetchCommentsInstructions;
+    /**
+     * Build instructions for Step 2: Extract learnings from fetched data
+     */
+    private buildExtractionInstructions;
+    /**
+     * Parse structured response from AI output
+     */
+    private parseStructuredLearnings;
+    /**
+     * Initialize NeuroLink with observability
+     */
+    private initializeNeurolink;
+    /**
+     * Ensure orchestrator is initialized
+     */
+    private ensureInitialized;
+    /**
+     * Handle dry run mode
+     */
+    private handleDryRun;
+    /**
+     * Run AI-powered summarization
+     */
+    private runSummarization;
+    /**
+     * Create empty result for cases with no learnings
+     */
+    private createEmptyResult;
+    /**
+     * Log the final result
+     */
+    private logResult;
+}
+/**
+ * Factory function to create LearningOrchestrator
+ */
+export declare function createLearningOrchestrator(): LearningOrchestrator;
+//# sourceMappingURL=LearningOrchestrator.d.ts.map