@juspay/yama 2.0.0 → 2.2.0

package/dist/v2/learning/KnowledgeBaseManager.js

@@ -0,0 +1,475 @@
+/**
+ * Knowledge Base Manager
+ * Handles reading, writing, and parsing the knowledge base markdown file
+ */
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { existsSync } from "fs";
+import { dirname, join } from "path";
+import { createHash } from "crypto";
+import { execFile } from "child_process";
+import { promisify } from "util";
+const execFileAsync = promisify(execFile);
+import { CATEGORY_SECTION_NAMES, } from "./types.js";
+/**
+ * Template for a new knowledge base file
+ */
+const KNOWLEDGE_BASE_TEMPLATE = `# Project Knowledge Base
+> Learned patterns, preferences, and guidelines from team feedback
+
+## Metadata
+- Last Updated: {{TIMESTAMP}}
+- Total Learnings: 0
+- Last Summarization: N/A
+
+---
+
+## False Positives (Don't Flag These)
+
+Things AI incorrectly flagged as issues. Avoid repeating these mistakes.
+
+---
+
+## Style Preferences (Team Conventions)
+
+Project-specific coding conventions that differ from general best practices.
+
+---
+
+## Missed Issues (Should Have Flagged)
+
+Patterns AI missed that should be caught in future reviews.
+
+---
+
+## Context & Domain Knowledge
+
+Project-specific context AI needs for accurate reviews.
+
+---
+
+## Enhancement Guidelines
+
+How AI should provide suggestions for this project.
+
+`;
+export class KnowledgeBaseManager {
+    config;
+    projectRoot;
+    constructor(config, projectRoot) {
+        this.config = config;
+        this.projectRoot = projectRoot || process.cwd();
+    }
+    /**
+     * Get the full path to the knowledge base file
+     */
+    getFilePath() {
+        return join(this.projectRoot, this.config.path);
+    }
+    /**
+     * Check if knowledge base file exists
+     */
+    exists() {
+        return existsSync(this.getFilePath());
+    }
+    /**
+     * Load and parse the knowledge base file
+     */
+    async load() {
+        if (!this.exists()) {
+            return this.createEmptyKnowledgeBase();
+        }
+        const content = await readFile(this.getFilePath(), "utf-8");
+        return this.parseMarkdown(content);
+    }
+    /**
+     * Append new learnings to the knowledge base
+     * Returns count of learnings actually added (excludes duplicates)
+     */
+    async append(learnings) {
+        const kb = await this.load();
+        let addedCount = 0;
+        for (const learning of learnings) {
+            // Check for duplicates
+            if (this.isDuplicate(kb, learning)) {
+                continue;
+            }
+            // Get or create section
+            let section = kb.sections.get(learning.category);
+            if (!section) {
+                section = {
+                    category: learning.category,
+                    subcategories: new Map(),
+                };
+                kb.sections.set(learning.category, section);
+            }
+            // Get or create subcategory
+            const subcatKey = learning.subcategory || "General";
+            let learningsList = section.subcategories.get(subcatKey);
+            if (!learningsList) {
+                learningsList = [];
+                section.subcategories.set(subcatKey, learningsList);
+            }
+            // Add the learning
+            learningsList.push(learning.learning);
+            addedCount++;
+        }
+        // Update metadata
+        kb.metadata.lastUpdated = new Date().toISOString();
+        kb.metadata.totalLearnings += addedCount;
+        // Write back
+        await this.write(kb);
+        return addedCount;
+    }
+    /**
+     * Write the knowledge base back to file
+     */
+    async write(kb) {
+        const content = this.toMarkdown(kb);
+        const filePath = this.getFilePath();
+        const dir = dirname(filePath);
+        // Ensure directory exists
+        if (!existsSync(dir)) {
+            await mkdir(dir, { recursive: true });
+        }
+        await writeFile(filePath, content, "utf-8");
+    }
+    /**
+     * Write raw markdown content directly to file
+     * Used by summarization to write AI-generated consolidated content
+     */
+    async writeRaw(content) {
+        const filePath = this.getFilePath();
+        const dir = dirname(filePath);
+        // Ensure directory exists
+        if (!existsSync(dir)) {
+            await mkdir(dir, { recursive: true });
+        }
+        await writeFile(filePath, content, "utf-8");
+    }
+    /**
+     * Create a new knowledge base file from template
+     */
+    async create() {
+        const content = KNOWLEDGE_BASE_TEMPLATE.replace("{{TIMESTAMP}}", new Date().toISOString());
+        const filePath = this.getFilePath();
+        const dir = dirname(filePath);
+        if (!existsSync(dir)) {
+            await mkdir(dir, { recursive: true });
+        }
+        await writeFile(filePath, content, "utf-8");
+    }
+    /**
+     * Get knowledge base content formatted for AI prompt injection
+     */
+    async getForPrompt() {
+        if (!this.config.enabled || !this.exists()) {
+            return null;
+        }
+        try {
+            const content = await readFile(this.getFilePath(), "utf-8");
+            // Remove metadata section for cleaner prompt
+            const lines = content.split("\n");
+            const filteredLines = [];
+            let inMetadata = false;
+            for (const line of lines) {
+                if (line.startsWith("## Metadata")) {
+                    inMetadata = true;
+                    continue;
+                }
+                if (inMetadata && line.startsWith("---")) {
+                    inMetadata = false;
+                    continue;
+                }
+                if (!inMetadata) {
+                    filteredLines.push(line);
+                }
+            }
+            return filteredLines.join("\n").trim();
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Get count of learnings in the knowledge base
+     */
+    async getLearningCount() {
+        const kb = await this.load();
+        return kb.metadata.totalLearnings;
+    }
+    /**
+     * Check if summarization is needed based on entry count
+     */
+    async needsSummarization() {
+        const count = await this.getLearningCount();
+        return count >= this.config.maxEntriesBeforeSummarization;
+    }
+    /**
+     * Commit the knowledge base file to git
+     * Uses execFile with argument arrays to prevent command injection
+     */
+    async commit(prId, learningsAdded) {
+        const filePath = this.config.path; // Relative path for git
+        // Validate inputs to prevent injection
+        const safePrId = Math.floor(Number(prId));
+        const safeLearningsAdded = Math.floor(Number(learningsAdded));
+        if (!Number.isFinite(safePrId) || safePrId < 0) {
+            throw new Error("Invalid PR ID");
+        }
+        try {
+            // Stage the file using execFile with args array (safe from injection)
+            await execFileAsync("git", ["add", filePath], { cwd: this.projectRoot });
+            // Create commit message
+            const commitMessage = `chore(yama): update knowledge base from PR #${safePrId}
+
+Added ${safeLearningsAdded} new learning${safeLearningsAdded !== 1 ? "s" : ""}.
+
+🤖 Generated with Yama`;
+            // Commit using execFile with args array (safe from injection)
+            await execFileAsync("git", ["commit", "-m", commitMessage], {
+                cwd: this.projectRoot,
+            });
+        }
+        catch (error) {
+            throw new Error(`Failed to commit knowledge base: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Generate a hash for deduplication
+     */
+    generateLearningId(learning) {
+        return createHash("md5")
+            .update(learning.toLowerCase().trim())
+            .digest("hex")
+            .substring(0, 12);
+    }
+    // ============================================================================
+    // Private Methods
+    // ============================================================================
+    /**
+     * Create an empty knowledge base structure
+     */
+    createEmptyKnowledgeBase() {
+        return {
+            metadata: {
+                lastUpdated: new Date().toISOString(),
+                totalLearnings: 0,
+            },
+            sections: new Map(),
+        };
+    }
+    /**
+     * Check if a learning already exists in the knowledge base
+     */
+    isDuplicate(kb, learning) {
+        const section = kb.sections.get(learning.category);
+        if (!section) {
+            return false;
+        }
+        const normalizedNew = learning.learning.toLowerCase().trim();
+        for (const [, learnings] of section.subcategories) {
+            for (const existing of learnings) {
+                const normalizedExisting = existing.toLowerCase().trim();
+                // Check for exact match or high similarity
+                if (normalizedExisting === normalizedNew ||
+                    this.isSimilar(normalizedExisting, normalizedNew)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    /**
+     * Check if two learnings are similar (simple similarity check)
+     */
+    isSimilar(a, b) {
+        // Remove common words and check overlap
+        const wordsA = new Set(a.split(/\s+/).filter((w) => w.length > 3));
+        const wordsB = new Set(b.split(/\s+/).filter((w) => w.length > 3));
+        if (wordsA.size === 0 || wordsB.size === 0) {
+            return false;
+        }
+        let overlap = 0;
+        for (const word of wordsA) {
+            if (wordsB.has(word)) {
+                overlap++;
+            }
+        }
+        const similarity = overlap / Math.max(wordsA.size, wordsB.size);
+        return similarity > 0.7; // 70% word overlap = similar
+    }
+    /**
+     * Parse markdown content into structured knowledge base
+     */
+    parseMarkdown(content) {
+        const kb = this.createEmptyKnowledgeBase();
+        const lines = content.split("\n");
+        let currentCategory = null;
+        let currentSubcategory = "General";
+        let inMetadata = false;
+        for (const line of lines) {
+            const trimmed = line.trim();
+            // Parse metadata
+            if (trimmed.startsWith("## Metadata")) {
+                inMetadata = true;
+                continue;
+            }
+            if (inMetadata) {
+                if (trimmed.startsWith("---")) {
+                    inMetadata = false;
+                    continue;
+                }
+                if (trimmed.startsWith("- Last Updated:")) {
+                    kb.metadata.lastUpdated = trimmed
+                        .replace("- Last Updated:", "")
+                        .trim();
+                }
+                else if (trimmed.startsWith("- Total Learnings:")) {
+                    kb.metadata.totalLearnings =
+                        parseInt(trimmed.replace("- Total Learnings:", "").trim(), 10) || 0;
+                }
+                else if (trimmed.startsWith("- Last Summarization:")) {
+                    const value = trimmed.replace("- Last Summarization:", "").trim();
+                    if (value !== "N/A") {
+                        kb.metadata.lastSummarization = value;
+                    }
+                }
+                continue;
+            }
+            // Parse category headers (## level)
+            if (trimmed.startsWith("## ")) {
+                const sectionName = trimmed.substring(3);
+                currentCategory = this.categoryFromSectionName(sectionName);
+                currentSubcategory = "General";
+                if (currentCategory) {
+                    kb.sections.set(currentCategory, {
+                        category: currentCategory,
+                        subcategories: new Map(),
+                    });
+                }
+                continue;
+            }
+            // Parse subcategory headers (### level)
+            if (trimmed.startsWith("### ")) {
+                currentSubcategory = trimmed.substring(4);
+                continue;
+            }
+            // Parse learning entries (- bullet points)
+            if (trimmed.startsWith("- ") && currentCategory) {
+                const learning = trimmed.substring(2);
+                const section = kb.sections.get(currentCategory);
+                if (section) {
+                    let learnings = section.subcategories.get(currentSubcategory);
+                    if (!learnings) {
+                        learnings = [];
+                        section.subcategories.set(currentSubcategory, learnings);
+                    }
+                    learnings.push(learning);
+                }
+            }
+        }
+        return kb;
+    }
+    /**
+     * Convert category section name back to category enum
+     */
+    categoryFromSectionName(name) {
+        for (const [category, sectionName] of Object.entries(CATEGORY_SECTION_NAMES)) {
+            if (name.includes(sectionName) || sectionName.includes(name)) {
+                return category;
+            }
+        }
+        // Fallback matching
+        const lowerName = name.toLowerCase();
+        if (lowerName.includes("false positive") ||
+            lowerName.includes("don't flag")) {
+            return "false_positive";
+        }
+        if (lowerName.includes("missed") || lowerName.includes("should have")) {
+            return "missed_issue";
+        }
+        if (lowerName.includes("style") || lowerName.includes("convention")) {
+            return "style_preference";
+        }
+        if (lowerName.includes("context") || lowerName.includes("domain")) {
+            return "domain_context";
+        }
+        if (lowerName.includes("enhancement") || lowerName.includes("guideline")) {
+            return "enhancement_guideline";
+        }
+        return null;
+    }
+    /**
+     * Convert knowledge base structure to markdown
+     */
+    toMarkdown(kb) {
+        const lines = [];
+        // Header
+        lines.push("# Project Knowledge Base");
+        lines.push("> Learned patterns, preferences, and guidelines from team feedback");
+        lines.push("");
+        // Metadata
+        lines.push("## Metadata");
+        lines.push(`- Last Updated: ${kb.metadata.lastUpdated}`);
+        lines.push(`- Total Learnings: ${kb.metadata.totalLearnings}`);
+        lines.push(`- Last Summarization: ${kb.metadata.lastSummarization || "N/A"}`);
+        lines.push("");
+        lines.push("---");
+        lines.push("");
+        // Sections in order
+        const categoryOrder = [
+            "false_positive",
+            "missed_issue",
+            "style_preference",
+            "domain_context",
+            "enhancement_guideline",
+        ];
+        for (const category of categoryOrder) {
+            const sectionName = CATEGORY_SECTION_NAMES[category];
+            lines.push(`## ${sectionName}`);
+            lines.push("");
+            const section = kb.sections.get(category);
+            if (section && section.subcategories.size > 0) {
+                // Sort subcategories
+                const sortedSubcats = Array.from(section.subcategories.entries()).sort(([a], [b]) => a.localeCompare(b));
+                for (const [subcategory, learnings] of sortedSubcats) {
+                    if (subcategory !== "General") {
+                        lines.push(`### ${subcategory}`);
+                    }
+                    for (const learning of learnings) {
+                        lines.push(`- ${learning}`);
+                    }
+                    lines.push("");
+                }
+            }
+            else {
+                // Add description placeholder for empty sections
+                lines.push(this.getSectionDescription(category));
+                lines.push("");
+            }
+            lines.push("---");
+            lines.push("");
+        }
+        return lines.join("\n");
+    }
+    /**
+     * Get description text for empty sections
+     */
+    getSectionDescription(category) {
+        switch (category) {
+            case "false_positive":
+                return "Things AI incorrectly flagged as issues. Avoid repeating these mistakes.";
+            case "missed_issue":
+                return "Patterns AI missed that should be caught in future reviews.";
+            case "style_preference":
+                return "Project-specific coding conventions that differ from general best practices.";
+            case "domain_context":
+                return "Project-specific context AI needs for accurate reviews.";
+            case "enhancement_guideline":
+                return "How AI should provide suggestions for this project.";
+            default:
+                return "";
+        }
+    }
+}
+//# sourceMappingURL=KnowledgeBaseManager.js.map

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

@@ -0,0 +1,121 @@
+/**
+ * Learning Types
+ * Type definitions for the knowledge base and learning extraction system
+ */
+/**
+ * Categories for extracted learnings
+ * Maps to sections in the knowledge base file
+ */
+export type LearningCategory = "false_positive" | "missed_issue" | "style_preference" | "domain_context" | "enhancement_guideline";
+/**
+ * Human-readable category names for knowledge base sections
+ */
+export declare const CATEGORY_SECTION_NAMES: Record<LearningCategory, string>;
+/**
+ * A single learning extracted from PR feedback
+ */
+export interface ExtractedLearning {
+    /** Unique hash for deduplication */
+    id: string;
+    /** Category of the learning */
+    category: LearningCategory;
+    /** Sub-category within the section (e.g., "Async Patterns", "Security") */
+    subcategory?: string;
+    /** The actionable, project-level guideline */
+    learning: string;
+    /** File patterns where this applies (e.g., ["services/*.ts"]) */
+    filePatterns?: string[];
+    /** Severity for missed_issue learnings */
+    severity?: string;
+    /** Source info for traceability (not displayed in KB) */
+    sourceInfo?: {
+        prId: number;
+        timestamp: string;
+    };
+}
+/**
+ * Metadata section of the knowledge base
+ */
+export interface KnowledgeBaseMetadata {
+    lastUpdated: string;
+    totalLearnings: number;
+    lastSummarization?: string;
+}
+/**
+ * A section in the knowledge base (maps to a category)
+ */
+export interface KnowledgeBaseSection {
+    category: LearningCategory;
+    subcategories: Map<string, string[]>;
+}
+/**
+ * Full parsed knowledge base structure
+ */
+export interface KnowledgeBase {
+    metadata: KnowledgeBaseMetadata;
+    sections: Map<LearningCategory, KnowledgeBaseSection>;
+}
+/**
+ * Request for the learn command
+ */
+export interface LearnRequest {
+    workspace: string;
+    repository: string;
+    pullRequestId: number;
+    dryRun?: boolean;
+    commit?: boolean;
+    summarize?: boolean;
+    outputPath?: string;
+    outputFormat?: "md" | "json";
+}
+/**
+ * Result from the learn command
+ */
+export interface LearnResult {
+    success: boolean;
+    prId: number;
+    learningsFound: number;
+    learningsAdded: number;
+    learningsDuplicate: number;
+    learnings: ExtractedLearning[];
+    knowledgeBasePath?: string;
+    committed?: boolean;
+    summarized?: boolean;
+    error?: string;
+}
+/**
+ * A comment from a PR
+ */
+export interface PRComment {
+    id: number;
+    text: string;
+    author: {
+        name: string;
+        displayName?: string;
+        email?: string;
+    };
+    createdAt: string;
+    filePath?: string;
+    lineNumber?: number;
+    parentId?: number;
+}
+/**
+ * A pair of AI comment and developer reply
+ */
+export interface CommentPair {
+    aiComment: PRComment;
+    developerReply: PRComment;
+    filePath?: string;
+    codeContext?: string;
+}
+/**
+ * Output format from AI learning extraction
+ */
+export interface AIExtractionOutput {
+    category: LearningCategory;
+    subcategory?: string;
+    learning: string;
+    filePatterns?: string[];
+    reasoning: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/v2/learning/types.js

@@ -0,0 +1,15 @@
+/**
+ * Learning Types
+ * Type definitions for the knowledge base and learning extraction system
+ */
+/**
+ * Human-readable category names for knowledge base sections
+ */
+export const CATEGORY_SECTION_NAMES = {
+    false_positive: "False Positives (Don't Flag These)",
+    missed_issue: "Missed Issues (Should Have Flagged)",
+    style_preference: "Style Preferences (Team Conventions)",
+    domain_context: "Context & Domain Knowledge",
+    enhancement_guideline: "Enhancement Guidelines",
+};
+//# sourceMappingURL=types.js.map

package/dist/v2/prompts/LangfusePromptManager.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Langfuse Prompt Manager
+ * Fetches prompts from Langfuse Prompt Management with local fallbacks
+ *
+ * Prompt Names in Langfuse:
+ * - yama-review: Review system prompt
+ * - yama-enhancement: Enhancement system prompt
+ */
+export declare class LangfusePromptManager {
+    private client;
+    private initialized;
+    constructor();
+    /**
+     * Initialize Langfuse client if credentials are available
+     */
+    private initializeClient;
+    /**
+     * Get the review system prompt
+     * Fetches from Langfuse if available, otherwise returns local fallback
+     */
+    getReviewPrompt(): Promise<string>;
+    /**
+     * Get the enhancement system prompt
+     * Fetches from Langfuse if available, otherwise returns local fallback
+     */
+    getEnhancementPrompt(): Promise<string>;
+    /**
+     * Get the learning extraction prompt
+     * Fetches from Langfuse if available, otherwise returns local fallback
+     * Langfuse prompt name: "yama-learning"
+     */
+    getLearningPrompt(): Promise<string>;
+    /**
+     * Get the summarization prompt
+     * Fetches from Langfuse if available, otherwise returns local fallback
+     * Langfuse prompt name: "yama-summarization"
+     */
+    getSummarizationPrompt(): Promise<string>;
+    /**
+     * Check if Langfuse is enabled
+     */
+    isEnabled(): boolean;
+    /**
+     * Shutdown Langfuse client gracefully
+     */
+    shutdown(): Promise<void>;
+}
+//# sourceMappingURL=LangfusePromptManager.d.ts.map