@juspay/yama 2.0.0 → 2.2.0

package/dist/v2/core/LearningOrchestrator.js

@@ -0,0 +1,499 @@
+/**
+ * Learning Orchestrator
+ * Main entry point for the knowledge base learning feature
+ * Orchestrates PR comment extraction, AI analysis, and knowledge base updates
+ */
+import { NeuroLink } from "@juspay/neurolink";
+import { MCPServerManager } from "./MCPServerManager.js";
+import { ConfigLoader } from "../config/ConfigLoader.js";
+import { LangfusePromptManager } from "../prompts/LangfusePromptManager.js";
+import { KnowledgeBaseManager } from "../learning/KnowledgeBaseManager.js";
+import { buildObservabilityConfigFromEnv, validateObservabilityConfig, } from "../utils/ObservabilityConfig.js";
+export class LearningOrchestrator {
+    neurolink;
+    mcpManager;
+    configLoader;
+    promptManager;
+    config;
+    initialized = false;
+    constructor() {
+        this.configLoader = new ConfigLoader();
+        this.mcpManager = new MCPServerManager();
+        this.promptManager = new LangfusePromptManager();
+    }
+    /**
+     * Initialize the learning orchestrator
+     */
+    async initialize(configPath) {
+        if (this.initialized) {
+            return;
+        }
+        console.log("🧠 Initializing Learning Orchestrator...\n");
+        try {
+            // Load configuration
+            this.config = await this.configLoader.loadConfig(configPath);
+            // Initialize NeuroLink
+            console.log("   🔧 Initializing NeuroLink AI engine...");
+            this.neurolink = this.initializeNeurolink();
+            console.log("   ✅ NeuroLink initialized\n");
+            // Setup MCP servers (need Bitbucket for PR access)
+            await this.mcpManager.setupMCPServers(this.neurolink, this.config.mcpServers);
+            console.log("   ✅ MCP servers ready\n");
+            this.initialized = true;
+            console.log("✅ Learning Orchestrator initialized\n");
+        }
+        catch (error) {
+            console.error("\n❌ Initialization failed:", error.message);
+            throw error;
+        }
+    }
+    /**
+     * Extract learnings from a merged PR
+     * Uses fully agentic AI approach - AI decides which tools to call
+     */
+    async extractLearnings(request) {
+        await this.ensureInitialized();
+        console.log("\n" + "─".repeat(60));
+        console.log(`📚 Extracting learnings from PR #${request.pullRequestId}`);
+        console.log("─".repeat(60));
+        console.log(`   Workspace: ${request.workspace}`);
+        console.log(`   Repository: ${request.repository}`);
+        console.log(`   Mode: ${request.dryRun ? "🔵 DRY RUN" : "🔴 LIVE"}`);
+        console.log("─".repeat(60) + "\n");
+        try {
+            // STEP 1: Fetch PR comments using agentic approach (with tools)
+            console.log("📥 Step 1: Fetching PR comments via Bitbucket MCP...");
+            const fetchInstructions = this.buildFetchCommentsInstructions(request);
+            const fetchResponse = await this.neurolink.generate({
+                input: { text: fetchInstructions },
+                provider: this.config.ai.provider,
+                model: this.config.ai.model,
+                temperature: 0.1,
+                maxTokens: 50000,
+                timeout: this.config.ai.timeout,
+                context: {
+                    operation: "learning-fetch-comments",
+                    prId: request.pullRequestId,
+                },
+            });
+            const commentsData = fetchResponse.content || "";
+            console.log("   ✅ PR data fetched\n");
+            // STEP 2: Extract learnings with structured schema (no tools needed)
+            console.log("🤖 Step 2: Extracting learnings with structured output...");
+            const learningPrompt = await this.promptManager.getLearningPrompt();
+            const extractionInstructions = this.buildExtractionInstructions(request, learningPrompt, commentsData);
+            // Extract learnings - disableTools since we already have the data
+            const extractResponse = await this.neurolink.generate({
+                input: { text: extractionInstructions },
+                provider: this.config.ai.provider,
+                model: this.config.ai.model,
+                temperature: 0.2,
+                maxTokens: 10000,
+                timeout: "2m",
+                disableTools: true, // No tools needed for extraction phase
+                context: {
+                    operation: "learning-extraction",
+                    prId: request.pullRequestId,
+                },
+            });
+            // Parse structured response
+            const learnings = this.parseStructuredLearnings(extractResponse, request.pullRequestId);
+            console.log(`\n📊 AI extracted ${learnings.length} learnings\n`);
+            if (learnings.length === 0) {
+                // Log extraction response for debugging
+                console.log("🔍 Extraction Response (for debugging):");
+                console.log("─".repeat(60));
+                const responsePreview = JSON.stringify(extractResponse.content || extractResponse, null, 2).slice(0, 2000);
+                console.log(responsePreview);
+                console.log("─".repeat(60) + "\n");
+                return this.createEmptyResult(request, "No actionable learnings found from PR feedback");
+            }
+            // Handle dry run vs live mode
+            if (request.dryRun) {
+                return this.handleDryRun(request, learnings);
+            }
+            // Update knowledge base
+            console.log("📝 Updating knowledge base...");
+            const kbManager = new KnowledgeBaseManager(this.config.knowledgeBase, process.cwd());
+            // Create if doesn't exist
+            if (!kbManager.exists()) {
+                console.log("   Creating new knowledge base file...");
+                await kbManager.create();
+            }
+            const addedCount = await kbManager.append(learnings);
+            const duplicateCount = learnings.length - addedCount;
+            console.log(`   ✅ Added ${addedCount} learnings`);
+            if (duplicateCount > 0) {
+                console.log(`   ⏭️  Skipped ${duplicateCount} duplicates`);
+            }
+            // Check if summarization is needed
+            let summarized = false;
+            if (request.summarize || (await kbManager.needsSummarization())) {
+                console.log("\n🔄 Running summarization...");
+                await this.runSummarization(kbManager);
+                summarized = true;
+                console.log("   ✅ Summarization complete");
+            }
+            // Commit if requested
+            let committed = false;
+            if (request.commit || this.config.knowledgeBase.autoCommit) {
+                console.log("\n📤 Committing knowledge base...");
+                await kbManager.commit(request.pullRequestId, addedCount);
+                committed = true;
+                console.log("   ✅ Changes committed");
+            }
+            // Return result
+            const result = {
+                success: true,
+                prId: request.pullRequestId,
+                learningsFound: learnings.length,
+                learningsAdded: addedCount,
+                learningsDuplicate: duplicateCount,
+                learnings,
+                knowledgeBasePath: kbManager.getFilePath(),
+                committed,
+                summarized,
+            };
+            this.logResult(result);
+            return result;
+        }
+        catch (error) {
+            console.error("\n❌ Learning extraction failed:", error.message);
+            return {
+                success: false,
+                prId: request.pullRequestId,
+                learningsFound: 0,
+                learningsAdded: 0,
+                learningsDuplicate: 0,
+                learnings: [],
+                error: error.message,
+            };
+        }
+    }
+    /**
+     * Build instructions for Step 1: Fetch PR comments
+     */
+    buildFetchCommentsInstructions(request) {
+        const aiPatterns = this.config.knowledgeBase.aiAuthorPatterns.join(", ");
+        return `
+<task>Fetch and analyze ALL PR comments for learning extraction</task>
+
+<pr-details>
+  <workspace>${request.workspace}</workspace>
+  <repository>${request.repository}</repository>
+  <pull_request_id>${request.pullRequestId}</pull_request_id>
+</pr-details>
+
+<instructions>
+1. Use get_pull_request tool to fetch the PR details including all comments/activities
+2. Look through ALL comments on the PR (both active and resolved if available)
+3. Identify AI-generated comments by:
+   - Author patterns: ${aiPatterns}
+   - Text patterns: Comments starting with "🔒 CRITICAL:", "⚠️ MAJOR:", "💡 MINOR:", "💬 SUGGESTION:", or "Yama Review"
+4. For each AI comment, look for developer replies (threaded responses or comments at same location)
+5. IMPORTANT: Also identify DEVELOPER comments that are NOT replies to AI comments
+   - These represent issues that AI MISSED and should have caught
+   - Look for inline code comments from developers (not AI) that point out bugs, issues, or improvements
+6. Output a structured summary of what you found
+</instructions>
+
+<output-format>
+Provide a detailed summary in this format:
+
+## PR Overview
+- Title: [PR title]
+- State: [merged/open/etc]
+- Total comments found: [N]
+
+## AI Comments Found
+For each AI comment, list:
+- Author: [name]
+- Severity: [CRITICAL/MAJOR/MINOR/SUGGESTION]
+- Comment text: [the comment]
+- Location: [file path and line if inline]
+
+## Developer Replies to AI Comments
+For each developer reply to an AI comment:
+- Original AI comment: [brief summary]
+- Developer reply: [the full reply text]
+- Developer name: [name]
+
+## Developer Comments (NOT replies to AI)
+IMPORTANT: List ALL developer-authored inline comments that are NOT replies to AI.
+These represent issues AI MISSED and should have caught.
+For each:
+- Developer name: [name]
+- File: [file path]
+- Line: [line number if available]
+- Comment text: [the full comment]
+- Type: [bug/issue/suggestion/question]
+
+If there are no developer comments (other than replies), state: "NO INDEPENDENT DEVELOPER COMMENTS FOUND"
+</output-format>
+
+Fetch the PR data now.
+`;
+    }
+    /**
+     * Build instructions for Step 2: Extract learnings from fetched data
+     */
+    buildExtractionInstructions(request, learningPrompt, commentsData) {
+        return `
+<task>Extract project-level learnings from PR feedback</task>
+
+<fetched-pr-data>
+${commentsData}
+</fetched-pr-data>
+
+${learningPrompt}
+
+<extraction-rules>
+Extract learnings from TWO sources:
+
+1. DEVELOPER REPLIES TO AI COMMENTS:
+   - Developer explained why AI was wrong → false_positive
+   - Developer provided context AI should know → domain_context
+   - Developer indicated team preference → style_preference
+   - Developer suggested how AI should improve → enhancement_guideline
+
+2. INDEPENDENT DEVELOPER COMMENTS (not replies to AI):
+   - These are issues AI MISSED and should have caught → missed_issue
+   - If a developer added their own inline comment about a bug/issue, AI failed to spot it
+   - Extract what type of issue it was so AI can catch similar issues in future
+
+IMPORTANT RULES:
+- Make learnings GENERIC - remove PR-specific details (file names, line numbers, variable names)
+- Focus on the underlying principle or pattern that can apply to future reviews
+- If BOTH "NO DEVELOPER REPLIES" AND "NO INDEPENDENT DEVELOPER COMMENTS", return empty learnings
+
+Categories:
+- false_positive: Developer explained why AI was wrong
+- missed_issue: Developer pointed out something AI should have caught (including independent comments)
+- style_preference: Team conventions that differ from general practice
+- domain_context: Project-specific knowledge AI needs
+- enhancement_guideline: How AI should provide better suggestions
+</extraction-rules>
+
+<output-format>
+Return a JSON object in this exact format (wrapped in a json code block):
+
+\`\`\`json
+{
+  "learnings": [
+    {
+      "category": "false_positive|missed_issue|style_preference|domain_context|enhancement_guideline",
+      "subcategory": "Optional grouping (e.g., 'Async Patterns', 'Error Handling')",
+      "learning": "The GENERIC, PROJECT-LEVEL guideline",
+      "filePatterns": ["Optional array of file patterns where this applies"],
+      "reasoning": "Why this learning was extracted"
+    }
+  ],
+  "summary": {
+    "totalAIComments": 0,
+    "totalDeveloperReplies": 0,
+    "totalIndependentDevComments": 0,
+    "actionablePairsFound": 0
+  }
+}
+\`\`\`
+
+If no actionable feedback found, return empty learnings array with appropriate summary counts.
+</output-format>
+
+Analyze the PR data above and extract learnings.
+`;
+    }
+    /**
+     * Parse structured response from AI output
+     */
+    parseStructuredLearnings(response, prId) {
+        try {
+            const content = (response.content || "");
+            // Find JSON in response (may be in code block)
+            const jsonMatch = content.match(/```json\s*([\s\S]*?)\s*```/) ||
+                content.match(/\{[\s\S]*\}/);
+            if (!jsonMatch) {
+                console.log("   ⚠️ No JSON found in extraction response");
+                return [];
+            }
+            const jsonStr = jsonMatch[1] || jsonMatch[0];
+            const parsed = JSON.parse(jsonStr);
+            // Log summary if available
+            if (parsed.summary) {
+                const devComments = parsed.summary.totalIndependentDevComments || 0;
+                console.log(`   📊 Summary: ${parsed.summary.totalAIComments} AI comments, ${parsed.summary.totalDeveloperReplies} dev replies, ${devComments} independent dev comments`);
+            }
+            if (!parsed.learnings || !Array.isArray(parsed.learnings)) {
+                return [];
+            }
+            const kbManager = new KnowledgeBaseManager(this.config.knowledgeBase, process.cwd());
+            return parsed.learnings.map((item) => ({
+                id: kbManager.generateLearningId(item.learning),
+                category: item.category,
+                subcategory: item.subcategory,
+                learning: item.learning,
+                filePatterns: item.filePatterns,
+                sourceInfo: {
+                    prId,
+                    timestamp: new Date().toISOString(),
+                },
+            }));
+        }
+        catch (error) {
+            console.warn("   ⚠️ Failed to parse structured output:", error.message);
+            return [];
+        }
+    }
+    // ============================================================================
+    // Private Methods
+    // ============================================================================
+    /**
+     * Initialize NeuroLink with observability
+     */
+    initializeNeurolink() {
+        const observabilityConfig = buildObservabilityConfigFromEnv();
+        const neurolinkConfig = {
+            conversationMemory: this.config.ai.conversationMemory,
+        };
+        if (observabilityConfig &&
+            validateObservabilityConfig(observabilityConfig)) {
+            neurolinkConfig.observability = observabilityConfig;
+        }
+        return new NeuroLink(neurolinkConfig);
+    }
+    /**
+     * Ensure orchestrator is initialized
+     */
+    async ensureInitialized() {
+        if (!this.initialized) {
+            await this.initialize();
+        }
+    }
+    /**
+     * Handle dry run mode
+     */
+    handleDryRun(request, learnings) {
+        console.log("\n📋 DRY RUN - Extracted learnings preview:\n");
+        if (request.outputFormat === "json") {
+            console.log(JSON.stringify({
+                prId: request.pullRequestId,
+                learningsFound: learnings.length,
+                learnings: learnings.map((l) => ({
+                    category: l.category,
+                    subcategory: l.subcategory,
+                    learning: l.learning,
+                })),
+            }, null, 2));
+        }
+        else {
+            // Markdown format
+            const byCategory = new Map();
+            for (const learning of learnings) {
+                const cat = learning.category;
+                if (!byCategory.has(cat)) {
+                    byCategory.set(cat, []);
+                }
+                byCategory.get(cat).push(learning);
+            }
+            for (const [category, items] of byCategory) {
+                console.log(`## ${category.replace(/_/g, " ").toUpperCase()}`);
+                for (const item of items) {
+                    console.log(`- ${item.learning}`);
+                }
+                console.log("");
+            }
+            console.log("─".repeat(60));
+            console.log("Run without --dry-run to commit these learnings.");
+        }
+        return {
+            success: true,
+            prId: request.pullRequestId,
+            learningsFound: learnings.length,
+            learningsAdded: 0,
+            learningsDuplicate: 0,
+            learnings,
+        };
+    }
+    /**
+     * Run AI-powered summarization
+     */
+    async runSummarization(kbManager) {
+        const currentContent = await kbManager.getForPrompt();
+        if (!currentContent) {
+            return;
+        }
+        const systemPrompt = await this.promptManager.getSummarizationPrompt();
+        const prompt = `
+${systemPrompt}
+
+<current-knowledge-base>
+${currentContent}
+</current-knowledge-base>
+
+Consolidate the learnings as instructed. Return the complete updated knowledge base in markdown format.
+`;
+        const response = await this.neurolink.generate({
+            input: { text: prompt },
+            provider: this.config.ai.provider,
+            model: this.config.ai.model,
+            temperature: 0.2,
+            maxTokens: 30000,
+        });
+        // Parse and update the knowledge base
+        const newContent = (response.content || "");
+        // Extract markdown content (may be in code block)
+        let markdownContent = newContent;
+        const mdMatch = newContent.match(/```(?:markdown|md)?\s*([\s\S]*?)```/);
+        if (mdMatch) {
+            markdownContent = mdMatch[1].trim();
+        }
+        // Verify it looks like valid markdown KB
+        if (markdownContent.includes("# Project Knowledge Base")) {
+            // Write the summarized content directly to file
+            await kbManager.writeRaw(markdownContent);
+        }
+    }
+    /**
+     * Create empty result for cases with no learnings
+     */
+    createEmptyResult(request, reason) {
+        console.log(`\n⚠️ ${reason}\n`);
+        return {
+            success: true,
+            prId: request.pullRequestId,
+            learningsFound: 0,
+            learningsAdded: 0,
+            learningsDuplicate: 0,
+            learnings: [],
+        };
+    }
+    /**
+     * Log the final result
+     */
+    logResult(result) {
+        console.log("\n" + "═".repeat(60));
+        console.log("✅ Learning Extraction Complete");
+        console.log("═".repeat(60));
+        console.log(`   PR: #${result.prId}`);
+        console.log(`   Learnings found: ${result.learningsFound}`);
+        console.log(`   Learnings added: ${result.learningsAdded}`);
+        console.log(`   Duplicates skipped: ${result.learningsDuplicate}`);
+        if (result.knowledgeBasePath) {
+            console.log(`   Knowledge base: ${result.knowledgeBasePath}`);
+        }
+        if (result.committed) {
+            console.log(`   📤 Changes committed`);
+        }
+        if (result.summarized) {
+            console.log(`   🔄 Knowledge base summarized`);
+        }
+        console.log("═".repeat(60) + "\n");
+    }
+}
+/**
+ * Factory function to create LearningOrchestrator
+ */
+export function createLearningOrchestrator() {
+    return new LearningOrchestrator();
+}
+//# sourceMappingURL=LearningOrchestrator.js.map

package/dist/v2/core/MCPServerManager.js

@@ -14,10 +14,10 @@ export class MCPServerManager {
     async setupMCPServers(neurolink, config) {
         console.log("🔌 Setting up MCP servers...");
         // Setup Bitbucket MCP (always enabled)
-        await this.setupBitbucketMCP(neurolink);
+        await this.setupBitbucketMCP(neurolink, config.bitbucket?.blockedTools);
         // Setup Jira MCP (optional)
         if (config.jira.enabled) {
-            await this.setupJiraMCP(neurolink);
+            await this.setupJiraMCP(neurolink, config.jira.blockedTools);
         }
         else {
             console.log("   ⏭️  Jira MCP disabled in config");
@@ -28,7 +28,7 @@ export class MCPServerManager {
     /**
      * Setup Bitbucket MCP server (hardcoded, always enabled)
      */
-    async setupBitbucketMCP(neurolink) {
+    async setupBitbucketMCP(neurolink, blockedTools) {
         try {
             console.log("   🔧 Registering Bitbucket MCP server...");
             // Verify environment variables
@@ -47,8 +47,12 @@ export class MCPServerManager {
                     BITBUCKET_TOKEN: process.env.BITBUCKET_TOKEN,
                     BITBUCKET_BASE_URL: process.env.BITBUCKET_BASE_URL,
                 },
+                blockedTools: blockedTools || [],
             });
             console.log("   ✅ Bitbucket MCP server registered and tools available");
+            if (blockedTools && blockedTools.length > 0) {
+                console.log(`   🚫 Blocked tools: ${blockedTools.join(", ")}`);
+            }
         }
         catch (error) {
             throw new MCPServerError(`Failed to setup Bitbucket MCP server: ${error.message}`);
@@ -57,7 +61,7 @@ export class MCPServerManager {
     /**
      * Setup Jira MCP server (hardcoded, optionally enabled)
      */
-    async setupJiraMCP(neurolink) {
+    async setupJiraMCP(neurolink, blockedTools) {
         try {
             console.log("   🔧 Registering Jira MCP server...");
             // Validate required Jira environment variables
@@ -79,8 +83,12 @@ export class MCPServerManager {
                     JIRA_API_TOKEN: process.env.JIRA_API_TOKEN,
                     JIRA_BASE_URL: process.env.JIRA_BASE_URL,
                 },
+                blockedTools: blockedTools || [],
             });
             console.log("   ✅ Jira MCP server registered and tools available");
+            if (blockedTools && blockedTools.length > 0) {
+                console.log(`   🚫 Blocked tools: ${blockedTools.join(", ")}`);
+            }
         }
         catch (error) {
             // Jira is optional, so we warn instead of throwing

package/dist/v2/learning/FeedbackExtractor.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Feedback Extractor
+ * Identifies AI comments and developer replies from PR comments
+ */
+import { KnowledgeBaseConfig } from "../types/config.types.js";
+import { PRComment, CommentPair } from "./types.js";
+export declare class FeedbackExtractor {
+    private config;
+    constructor(config: KnowledgeBaseConfig);
+    /**
+     * Check if a comment is from AI based on author and text patterns
+     */
+    isAIComment(comment: PRComment): boolean;
+    /**
+     * Check if a comment is a developer reply (not from AI)
+     */
+    isDeveloperComment(comment: PRComment): boolean;
+    /**
+     * Extract AI comment + developer reply pairs from a list of comments
+     */
+    extractCommentPairs(comments: PRComment[]): CommentPair[];
+    /**
+     * Find comment pairs based on file/line proximity (for inline comments)
+     */
+    private findInlineCommentPairs;
+    /**
+     * Convert raw Bitbucket API comment to PRComment
+     */
+    convertBitbucketComment(rawComment: Record<string, unknown>): PRComment;
+    /**
+     * Extract meaningful feedback from a comment pair
+     * Determines if the developer reply contains actionable feedback
+     */
+    hasActionableFeedback(pair: CommentPair): boolean;
+    /**
+     * Get statistics about comment analysis
+     */
+    getCommentStats(comments: PRComment[]): {
+        total: number;
+        aiComments: number;
+        developerComments: number;
+        pairs: number;
+        actionablePairs: number;
+    };
+}
+//# sourceMappingURL=FeedbackExtractor.d.ts.map