@juspay/yama 1.6.0 → 2.1.0

package/dist/v2/learning/FeedbackExtractor.js

@@ -0,0 +1,237 @@
+/**
+ * Feedback Extractor
+ * Identifies AI comments and developer replies from PR comments
+ */
+/**
+ * Text patterns that identify AI-generated comments
+ */
+const AI_TEXT_PATTERNS = [
+    "🔒 CRITICAL",
+    "⚠️ MAJOR",
+    "💡 MINOR",
+    "💬 SUGGESTION",
+    "**Issue**:",
+    "**Impact**:",
+    "**Fix**:",
+    "Yama Review",
+    "_Review powered by Yama_",
+    "🔒 SECURITY",
+    "⚡ PERFORMANCE",
+];
+export class FeedbackExtractor {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Check if a comment is from AI based on author and text patterns
+     */
+    isAIComment(comment) {
+        // Check author name patterns
+        const authorMatch = this.config.aiAuthorPatterns.some((pattern) => comment.author.name.toLowerCase().includes(pattern.toLowerCase()));
+        if (authorMatch) {
+            return true;
+        }
+        // Check text patterns
+        const textMatch = AI_TEXT_PATTERNS.some((pattern) => comment.text.includes(pattern));
+        return textMatch;
+    }
+    /**
+     * Check if a comment is a developer reply (not from AI)
+     */
+    isDeveloperComment(comment) {
+        return !this.isAIComment(comment);
+    }
+    /**
+     * Extract AI comment + developer reply pairs from a list of comments
+     */
+    extractCommentPairs(comments) {
+        const pairs = [];
+        // Group comments by parent (for threaded comments)
+        const commentsByParent = new Map();
+        const commentById = new Map();
+        for (const comment of comments) {
+            commentById.set(comment.id, comment);
+            const parentKey = comment.parentId;
+            if (!commentsByParent.has(parentKey)) {
+                commentsByParent.set(parentKey, []);
+            }
+            commentsByParent.get(parentKey).push(comment);
+        }
+        // Find AI comments with developer replies
+        for (const comment of comments) {
+            if (this.isAIComment(comment)) {
+                // Look for developer replies to this AI comment
+                const replies = commentsByParent.get(comment.id) || [];
+                const developerReplies = replies.filter((r) => this.isDeveloperComment(r));
+                for (const reply of developerReplies) {
+                    pairs.push({
+                        aiComment: comment,
+                        developerReply: reply,
+                        filePath: comment.filePath || reply.filePath,
+                    });
+                }
+            }
+        }
+        // Also check for inline comment threads (adjacent comments on same file/line)
+        const inlinePairs = this.findInlineCommentPairs(comments);
+        pairs.push(...inlinePairs);
+        return pairs;
+    }
+    /**
+     * Find comment pairs based on file/line proximity (for inline comments)
+     */
+    findInlineCommentPairs(comments) {
+        const pairs = [];
+        const processedIds = new Set();
+        // Group by file path and line
+        const byLocation = new Map();
+        for (const comment of comments) {
+            if (comment.filePath && comment.lineNumber) {
+                const key = `${comment.filePath}:${comment.lineNumber}`;
+                if (!byLocation.has(key)) {
+                    byLocation.set(key, []);
+                }
+                byLocation.get(key).push(comment);
+            }
+        }
+        // Find AI + developer pairs at same location
+        for (const [, locationComments] of byLocation) {
+            // Sort by timestamp
+            locationComments.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+            for (let i = 0; i < locationComments.length; i++) {
+                const aiComment = locationComments[i];
+                if (!this.isAIComment(aiComment) || processedIds.has(aiComment.id)) {
+                    continue;
+                }
+                // Look for developer reply after this AI comment
+                for (let j = i + 1; j < locationComments.length; j++) {
+                    const reply = locationComments[j];
+                    if (this.isDeveloperComment(reply) && !processedIds.has(reply.id)) {
+                        pairs.push({
+                            aiComment,
+                            developerReply: reply,
+                            filePath: aiComment.filePath,
+                        });
+                        processedIds.add(aiComment.id);
+                        processedIds.add(reply.id);
+                        break;
+                    }
+                }
+            }
+        }
+        return pairs;
+    }
+    /**
+     * Convert raw Bitbucket API comment to PRComment
+     */
+    convertBitbucketComment(rawComment) {
+        const author = rawComment.author;
+        const user = rawComment.user;
+        const authorData = author || user;
+        // Handle text extraction - Bitbucket Cloud uses content.raw
+        let text = rawComment.text;
+        if (!text) {
+            const content = rawComment.content;
+            if (typeof content === "string") {
+                text = content;
+            }
+            else if (content && typeof content === "object" && "raw" in content) {
+                text = content.raw;
+            }
+        }
+        return {
+            id: rawComment.id ||
+                parseInt(String(rawComment.id), 10) ||
+                Date.now(),
+            text: text || "",
+            author: {
+                name: authorData?.name ||
+                    authorData?.username ||
+                    authorData?.slug ||
+                    "Unknown",
+                displayName: authorData?.displayName,
+                email: authorData?.emailAddress,
+            },
+            createdAt: rawComment.createdDate ||
+                rawComment.created_on ||
+                new Date().toISOString(),
+            filePath: rawComment.path ||
+                rawComment.inline?.path,
+            lineNumber: rawComment.line ||
+                rawComment.inline?.to,
+            parentId: rawComment.parent?.id || undefined,
+        };
+    }
+    /**
+     * Extract meaningful feedback from a comment pair
+     * Determines if the developer reply contains actionable feedback
+     */
+    hasActionableFeedback(pair) {
+        const reply = pair.developerReply.text.toLowerCase();
+        // Skip very short replies (likely just acknowledgments like "ok" or "done")
+        if (reply.length < 20) {
+            return false;
+        }
+        // Skip pure acknowledgments
+        const acknowledgments = [
+            "fixed",
+            "done",
+            "ok",
+            "thanks",
+            "thank you",
+            "will do",
+            "good catch",
+            "nice catch",
+            "👍",
+            "✅",
+        ];
+        const isJustAcknowledgment = acknowledgments.some((ack) => reply.trim() === ack || reply.trim() === ack + ".");
+        if (isJustAcknowledgment) {
+            return false;
+        }
+        // Look for indicators of substantive feedback
+        const feedbackIndicators = [
+            "actually",
+            "but",
+            "however",
+            "not necessary",
+            "don't need",
+            "intentional",
+            "by design",
+            "we prefer",
+            "our convention",
+            "team decision",
+            "won't fix",
+            "false positive",
+            "not an issue",
+            "this is fine",
+            "this is okay",
+            "that's expected",
+            "that's intentional",
+            "on purpose",
+            "should also",
+            "you missed",
+            "also check",
+            "what about",
+            "consider",
+        ];
+        return feedbackIndicators.some((indicator) => reply.includes(indicator));
+    }
+    /**
+     * Get statistics about comment analysis
+     */
+    getCommentStats(comments) {
+        const pairs = this.extractCommentPairs(comments);
+        const actionablePairs = pairs.filter((p) => this.hasActionableFeedback(p));
+        return {
+            total: comments.length,
+            aiComments: comments.filter((c) => this.isAIComment(c)).length,
+            developerComments: comments.filter((c) => this.isDeveloperComment(c))
+                .length,
+            pairs: pairs.length,
+            actionablePairs: actionablePairs.length,
+        };
+    }
+}
+//# sourceMappingURL=FeedbackExtractor.js.map

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

@@ -0,0 +1,91 @@
+/**
+ * Knowledge Base Manager
+ * Handles reading, writing, and parsing the knowledge base markdown file
+ */
+import { KnowledgeBaseConfig } from "../types/config.types.js";
+import { KnowledgeBase, ExtractedLearning } from "./types.js";
+export declare class KnowledgeBaseManager {
+    private config;
+    private projectRoot;
+    constructor(config: KnowledgeBaseConfig, projectRoot?: string);
+    /**
+     * Get the full path to the knowledge base file
+     */
+    getFilePath(): string;
+    /**
+     * Check if knowledge base file exists
+     */
+    exists(): boolean;
+    /**
+     * Load and parse the knowledge base file
+     */
+    load(): Promise<KnowledgeBase>;
+    /**
+     * Append new learnings to the knowledge base
+     * Returns count of learnings actually added (excludes duplicates)
+     */
+    append(learnings: ExtractedLearning[]): Promise<number>;
+    /**
+     * Write the knowledge base back to file
+     */
+    write(kb: KnowledgeBase): Promise<void>;
+    /**
+     * Write raw markdown content directly to file
+     * Used by summarization to write AI-generated consolidated content
+     */
+    writeRaw(content: string): Promise<void>;
+    /**
+     * Create a new knowledge base file from template
+     */
+    create(): Promise<void>;
+    /**
+     * Get knowledge base content formatted for AI prompt injection
+     */
+    getForPrompt(): Promise<string | null>;
+    /**
+     * Get count of learnings in the knowledge base
+     */
+    getLearningCount(): Promise<number>;
+    /**
+     * Check if summarization is needed based on entry count
+     */
+    needsSummarization(): Promise<boolean>;
+    /**
+     * Commit the knowledge base file to git
+     * Uses execFile with argument arrays to prevent command injection
+     */
+    commit(prId: number, learningsAdded: number): Promise<void>;
+    /**
+     * Generate a hash for deduplication
+     */
+    generateLearningId(learning: string): string;
+    /**
+     * Create an empty knowledge base structure
+     */
+    private createEmptyKnowledgeBase;
+    /**
+     * Check if a learning already exists in the knowledge base
+     */
+    private isDuplicate;
+    /**
+     * Check if two learnings are similar (simple similarity check)
+     */
+    private isSimilar;
+    /**
+     * Parse markdown content into structured knowledge base
+     */
+    private parseMarkdown;
+    /**
+     * Convert category section name back to category enum
+     */
+    private categoryFromSectionName;
+    /**
+     * Convert knowledge base structure to markdown
+     */
+    private toMarkdown;
+    /**
+     * Get description text for empty sections
+     */
+    private getSectionDescription;
+}
+//# sourceMappingURL=KnowledgeBaseManager.d.ts.map