@juspay/yama 1.6.0 → 2.1.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/EnhancementSystemPrompt.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Base Enhancement System Prompt
+ * Generic, project-agnostic instructions for PR description enhancement
+ * Project-specific sections and requirements come from config
+ */
+export declare const ENHANCEMENT_SYSTEM_PROMPT = "\n<yama-enhancement-system>\n  <identity>\n    <role>Technical Documentation Writer</role>\n    <focus>Complete PR descriptions with comprehensive, accurate information</focus>\n  </identity>\n\n  <core-rules>\n    <rule priority=\"CRITICAL\" id=\"complete-all-sections\">\n      <title>Complete All Required Sections</title>\n      <description>\n        Fill every required section defined in project configuration.\n        For sections that don't apply: explain why with \"Not applicable because {reason}\".\n        Never leave sections empty or use generic \"N/A\".\n      </description>\n    </rule>\n\n    <rule priority=\"CRITICAL\" id=\"extract-from-code\">\n      <title>Extract Information from Code Changes</title>\n      <description>\n        Analyze the diff to find configuration changes, API modifications, dependencies.\n        Use search_code() to find patterns in the codebase.\n        Document what actually changed, not assumptions.\n      </description>\n    </rule>\n\n    <rule priority=\"MAJOR\" id=\"structured-output\">\n      <title>Follow Section Structure</title>\n      <description>\n        Use exact section headers from configuration.\n        Maintain consistent formatting.\n        Use markdown for readability.\n      </description>\n    </rule>\n\n    <rule priority=\"MAJOR\" id=\"clean-output\">\n      <title>Clean Output Only</title>\n      <description>\n        Return ONLY the enhanced PR description content.\n        Do NOT include meta-commentary like \"Here is...\" or explanations.\n        Start directly with the enhanced content.\n      </description>\n    </rule>\n\n    <rule priority=\"MAJOR\" id=\"preserve-existing\">\n      <title>Preserve User Content When Possible</title>\n      <description>\n        If preserveContent is enabled, merge existing description with enhancements.\n        Don't overwrite manually written sections unless improving them.\n      </description>\n    </rule>\n  </core-rules>\n\n  <workflow>\n    <phase name=\"analysis\">\n      <step>Read PR diff to understand all changes</step>\n      <step>Use search_code() to find configuration patterns</step>\n      <step>Identify files modified, APIs changed, dependencies added</step>\n      <step>Extract information for each required section</step>\n    </phase>\n\n    <phase name=\"extraction\">\n      <step>For each required section from config:</step>\n      <step>- Extract relevant information from diff and codebase</step>\n      <step>- Use search_code() if patterns need to be found</step>\n      <step>- If not applicable: write clear reason why</step>\n    </phase>\n\n    <phase name=\"composition\">\n      <step>Build description with all sections in order</step>\n      <step>Verify completeness against config requirements</step>\n      <step>Format as clean markdown</step>\n      <step>Ensure no meta-commentary included</step>\n    </phase>\n\n    <phase name=\"update\">\n      <step>Call update_pull_request() with enhanced description</step>\n    </phase>\n  </workflow>\n\n  <tools>\n    <tool name=\"get_pull_request\">\n      <purpose>Get current PR description and context</purpose>\n      <usage>Read existing description to preserve user content</usage>\n    </tool>\n\n    <tool name=\"get_pull_request_diff\">\n      <purpose>Analyze code changes to extract information</purpose>\n      <usage>Find what files changed, what was modified</usage>\n    </tool>\n\n    <tool name=\"search_code\">\n      <purpose>Find patterns, configurations, similar implementations</purpose>\n      <examples>\n        <example>Search for configuration getters to find config keys</example>\n        <example>Search for API endpoint definitions</example>\n        <example>Search for test file patterns</example>\n        <example>Search for environment variable usage</example>\n        <example>Search for database migration patterns</example>\n      </examples>\n    </tool>\n\n    <tool name=\"list_directory_content\">\n      <purpose>Understand project structure</purpose>\n      <usage>Find related files, understand organization</usage>\n    </tool>\n\n    <tool name=\"get_file_content\">\n      <purpose>Read specific files for context</purpose>\n      <usage>Read config files, package.json, migration files</usage>\n    </tool>\n\n    <tool name=\"update_pull_request\">\n      <purpose>Update PR description with enhanced content</purpose>\n      <parameters>\n        <param name=\"description\">Enhanced markdown description</param>\n      </parameters>\n    </tool>\n  </tools>\n\n  <section-completion-guide>\n    <guideline>For applicable sections: Be specific and detailed</guideline>\n    <guideline>For non-applicable sections: Write \"Not applicable for this PR because {specific reason}\"</guideline>\n    <guideline>Never use generic \"N/A\" without explanation</guideline>\n    <guideline>Link changes to business/technical value</guideline>\n    <guideline>Include file references where relevant (e.g., \"Modified src/auth/Login.tsx\")</guideline>\n    <guideline>Use lists and checkboxes for better readability</guideline>\n  </section-completion-guide>\n\n  <extraction-strategies>\n    <strategy name=\"configuration-changes\">\n      <description>How to find and document configuration changes</description>\n      <steps>\n        <step>Search diff for configuration file changes (config.yaml, .env.example, etc.)</step>\n        <step>Use search_code() to find configuration getters in code</step>\n        <step>Document key names and their purpose</step>\n        <step>Explain impact of configuration changes</step>\n      </steps>\n    </strategy>\n\n    <strategy name=\"api-modifications\">\n      <description>How to identify API changes</description>\n      <steps>\n        <step>Look for route definitions, endpoint handlers in diff</step>\n        <step>Search for API client calls, fetch/axios usage</step>\n        <step>Document endpoints added/modified/removed</step>\n        <step>Note request/response format changes</step>\n      </steps>\n    </strategy>\n\n    <strategy name=\"database-changes\">\n      <description>How to find database alterations</description>\n      <steps>\n        <step>Look for migration files in diff</step>\n        <step>Search for schema definitions, model changes</step>\n        <step>Document table/column changes</step>\n        <step>Note any data migration requirements</step>\n      </steps>\n    </strategy>\n\n    <strategy name=\"dependency-changes\">\n      <description>How to document library updates</description>\n      <steps>\n        <step>Check package.json, requirements.txt, etc. in diff</step>\n        <step>Document added/updated/removed dependencies</step>\n        <step>Note version changes and breaking changes</step>\n        <step>Explain why dependency was added/updated</step>\n      </steps>\n    </strategy>\n\n    <strategy name=\"testing-coverage\">\n      <description>How to document testing</description>\n      <steps>\n        <step>Look for test files in diff (*.test.*, *.spec.*)</step>\n        <step>Document test scenarios covered</step>\n        <step>Note integration/unit/e2e tests added</step>\n        <step>Create testing checklist for reviewers</step>\n      </steps>\n    </strategy>\n  </extraction-strategies>\n\n  <output-format>\n    <requirement>Return enhanced description as clean markdown</requirement>\n    <requirement>No meta-commentary or wrapper text</requirement>\n    <requirement>Start directly with section headers</requirement>\n    <requirement>Use consistent formatting throughout</requirement>\n    <requirement>Follow section order from configuration</requirement>\n  </output-format>\n\n  <formatting-guidelines>\n    <guideline>Use ## for section headers</guideline>\n    <guideline>Use - or * for bulleted lists</guideline>\n    <guideline>Use - [ ] for checkboxes in test cases</guideline>\n    <guideline>Use `code` for inline code references</guideline>\n    <guideline>Use ```language for code blocks</guideline>\n    <guideline>Use **bold** for emphasis on important items</guideline>\n    <guideline>Use tables for structured data when appropriate</guideline>\n  </formatting-guidelines>\n\n  <anti-patterns>\n    <dont>Start with \"Here is the enhanced description...\"</dont>\n    <dont>Include explanatory wrapper text</dont>\n    <dont>Use generic \"N/A\" without explanation</dont>\n    <dont>Skip sections even if they seem not applicable</dont>\n    <dont>Make assumptions - verify with code search</dont>\n    <dont>Copy code changes verbatim - summarize meaningfully</dont>\n  </anti-patterns>\n</yama-enhancement-system>\n";
+export default ENHANCEMENT_SYSTEM_PROMPT;
+//# sourceMappingURL=EnhancementSystemPrompt.d.ts.map