decision-guardian 1.1.0

package/dist/adapters/github/actions-logger.js

@@ -0,0 +1,88 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActionsLogger = void 0;
+/**
+ * ActionsLogger — ILogger implementation wrapping @actions/core.
+ *
+ * Used when running inside the GitHub Actions runtime.
+ */
+const core = __importStar(require("@actions/core"));
+class ActionsLogger {
+    info(message) {
+        core.info(message);
+    }
+    warning(message) {
+        core.warning(message);
+    }
+    error(message) {
+        core.error(message);
+    }
+    debug(message) {
+        core.debug(message);
+    }
+    startGroup(name) {
+        core.startGroup(name);
+    }
+    endGroup() {
+        core.endGroup();
+    }
+    // ── Actions-Specific Methods ──────────────────────────────────
+    /**
+     * Set an output variable for subsequent steps.
+     */
+    setOutput(name, value) {
+        core.setOutput(name, value);
+    }
+    /**
+     * Mark the action as failed with an error message.
+     */
+    setFailed(message) {
+        core.setFailed(message);
+    }
+    /**
+     * Get an input variable from the action configuration.
+     */
+    getInput(name, required) {
+        return core.getInput(name, { required });
+    }
+    /**
+     * Get a boolean input variable from the action configuration.
+     */
+    getBooleanInput(name) {
+        return core.getBooleanInput(name);
+    }
+}
+exports.ActionsLogger = ActionsLogger;

package/dist/adapters/github/comment.js

@@ -0,0 +1,601 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommentManager = void 0;
+/**
+ * CommentManager — GitHub PR commenting logic.
+ */
+const github = __importStar(require("@actions/github"));
+const crypto = __importStar(require("crypto"));
+class CommentManager {
+    octokit;
+    logger;
+    MARKER = '<!-- decision-guardian-v1 -->';
+    ALL_CLEAR_HASH = 'all-clear';
+    MAX_COMMENT_LENGTH = 60000; // GitHub API limit is 65536
+    constructor(token, logger) {
+        this.octokit = github.getOctokit(token);
+        this.logger = logger;
+    }
+    /**
+     * Post or update comment on PR with decision alerts
+     */
+    async postAlert(matches, prContext) {
+        const MAX_RETRIES = 3;
+        for (let retry = 0; retry < MAX_RETRIES; retry++) {
+            try {
+                await this._postAlertAttempt(matches, prContext);
+                return;
+            }
+            catch (error) {
+                const errWithStatus = error;
+                if (errWithStatus.status === 409 && retry < MAX_RETRIES - 1) {
+                    this.logger.warning(`Conflict detected when posting comment, retrying... (${retry + 1}/${MAX_RETRIES})`);
+                    await new Promise((r) => setTimeout(r, 1000 * (retry + 1)));
+                    continue;
+                }
+                throw error;
+            }
+        }
+    }
+    /**
+     * Core logic for posting or updating comment
+     */
+    async _postAlertAttempt(matches, prContext) {
+        matches.sort((a, b) => {
+            const idCompare = a.decision.id.localeCompare(b.decision.id);
+            if (idCompare !== 0)
+                return idCompare;
+            return a.file.localeCompare(b.file);
+        });
+        let owner;
+        let repo;
+        let pull_number;
+        if (prContext) {
+            owner = prContext.owner;
+            repo = prContext.repo;
+            pull_number = prContext.number;
+        }
+        else {
+            const context = github.context;
+            if (!context.payload.pull_request) {
+                this.logger.warning('Not a pull request event, skipping comment');
+                return;
+            }
+            owner = context.repo.owner;
+            repo = context.repo.repo;
+            pull_number = context.payload.pull_request.number;
+        }
+        const newHash = this.hashContent(matches);
+        const newBody = this.formatComment(matches, newHash);
+        const existingComments = await this.findExistingComments(owner, repo, pull_number);
+        let targetComment = existingComments.length > 0 ? existingComments[0] : null;
+        if (existingComments.length > 1) {
+            this.logger.info(`Found ${existingComments.length} duplicate comments, cleaning up...`);
+            for (let i = 1; i < existingComments.length; i++) {
+                try {
+                    await this.octokit.rest.issues.deleteComment({
+                        owner,
+                        repo,
+                        comment_id: existingComments[i].id,
+                    });
+                }
+                catch (error) {
+                    this.logger.warning(`Failed to delete duplicate comment ${existingComments[i].id}: ${error}`);
+                }
+            }
+        }
+        if (targetComment) {
+            const oldHash = this.extractHash(targetComment.body);
+            if (oldHash === newHash) {
+                this.logger.info('Existing comment is up-to-date, skipping update');
+                return;
+            }
+            try {
+                await this.octokit.rest.issues.updateComment({
+                    owner,
+                    repo,
+                    comment_id: targetComment.id,
+                    body: newBody,
+                });
+                this.logger.info(`Updated existing comment (${matches.length} matches)`);
+                return;
+            }
+            catch (error) {
+                const errWithStatus = error;
+                if (errWithStatus.status === 404) {
+                    this.logger.warning(`Comment ${targetComment.id} was deleted, creating new one`);
+                    targetComment = null;
+                }
+                else {
+                    const message = error instanceof Error ? error.message : String(error);
+                    this.logger.error(`Failed to update comment: ${message}`);
+                    throw error;
+                }
+            }
+        }
+        if (!targetComment) {
+            try {
+                await this.octokit.rest.issues.createComment({
+                    owner,
+                    repo,
+                    issue_number: pull_number,
+                    body: newBody,
+                });
+                this.logger.info(`Posted new decision alert (${matches.length} matches)`);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                this.logger.error(`Failed to post comment: ${message}`);
+                throw error;
+            }
+        }
+    }
+    /**
+     * Update existing comment to "All Clear" status when no matches are found.
+     * Only updates if there was a previous Decision Guardian comment.
+     */
+    async postAllClear(prContext) {
+        let owner;
+        let repo;
+        let pull_number;
+        if (prContext) {
+            owner = prContext.owner;
+            repo = prContext.repo;
+            pull_number = prContext.number;
+        }
+        else {
+            const context = github.context;
+            if (!context.payload.pull_request) {
+                this.logger.warning('Not a pull request event, skipping all-clear comment');
+                return;
+            }
+            owner = context.repo.owner;
+            repo = context.repo.repo;
+            pull_number = context.payload.pull_request.number;
+        }
+        const existingComments = await this.findExistingComments(owner, repo, pull_number);
+        if (existingComments.length === 0) {
+            this.logger.info('No existing Decision Guardian comment found, skipping all-clear update');
+            return;
+        }
+        const targetComment = existingComments[0];
+        const oldHash = this.extractHash(targetComment.body);
+        if (oldHash === this.ALL_CLEAR_HASH) {
+            this.logger.info('Comment is already showing all-clear status, skipping update');
+            return;
+        }
+        if (existingComments.length > 1) {
+            this.logger.info(`Found ${existingComments.length} duplicate comments, cleaning up...`);
+            for (let i = 1; i < existingComments.length; i++) {
+                try {
+                    await this.octokit.rest.issues.deleteComment({
+                        owner,
+                        repo,
+                        comment_id: existingComments[i].id,
+                    });
+                }
+                catch (error) {
+                    this.logger.warning(`Failed to delete duplicate comment ${existingComments[i].id}: ${error}`);
+                }
+            }
+        }
+        const allClearBody = this.buildAllClearComment();
+        try {
+            await this.octokit.rest.issues.updateComment({
+                owner,
+                repo,
+                comment_id: targetComment.id,
+                body: allClearBody,
+            });
+            this.logger.info('Updated comment to all-clear status');
+            return;
+        }
+        catch (error) {
+            const errWithStatus = error;
+            if (errWithStatus.status === 404) {
+                this.logger.warning(`Comment ${targetComment.id} was deleted, skipping all-clear update`);
+                return;
+            }
+            const message = error instanceof Error ? error.message : String(error);
+            this.logger.error(`Failed to update comment to all-clear status: ${message}`);
+            throw error;
+        }
+    }
+    /**
+     * Find all existing Decision Guardian comments
+     */
+    async findExistingComments(owner, repo, issue_number) {
+        try {
+            const found = [];
+            let page = 1;
+            const MAX_PAGES = 100; // Prevent infinite loops (10,000 comments max)
+            while (page <= MAX_PAGES) {
+                const { data } = await this.octokit.rest.issues.listComments({
+                    owner,
+                    repo,
+                    issue_number,
+                    per_page: 100,
+                    page,
+                });
+                const matches = data
+                    .filter((c) => c.body?.includes(this.MARKER))
+                    .map((c) => ({ id: c.id, body: c.body || '' }));
+                found.push(...matches);
+                if (data.length < 100)
+                    break;
+                page++;
+            }
+            return found;
+        }
+        catch (error) {
+            this.logger.warning('Failed to fetch existing comments, will create new');
+            return [];
+        }
+    }
+    /**
+     * Generate content hash based on decision IDs, files, and matched patterns
+     */
+    hashContent(matches) {
+        const key = matches
+            .map((m) => `${m.decision.id}:${m.file}:${m.matchDetails?.matchedPatterns?.join(',') || ''}`)
+            .sort()
+            .join('|');
+        return crypto.createHash('sha256').update(key, 'utf8').digest('hex').substring(0, 16);
+    }
+    /**
+     * Extract hash from existing comment
+     */
+    extractHash(commentBody) {
+        // Match both hex hashes (16 chars) and special hashes like 'all-clear'
+        const match = commentBody.match(/<!-- hash:([a-z0-9-]+) -->/);
+        return match ? match[1] : null;
+    }
+    /**
+     * Format matches into markdown comment
+     */
+    formatComment(matches, hash) {
+        const fullComment = this.buildFullComment(matches, hash);
+        if (fullComment.length > this.MAX_COMMENT_LENGTH) {
+            this.logger.warning(`Comment would exceed ${this.MAX_COMMENT_LENGTH} chars (${fullComment.length}), truncating...`);
+            return this.buildTruncatedComment(matches, hash);
+        }
+        return fullComment;
+    }
+    /**
+     * Build the full comment without truncation
+     */
+    buildFullComment(matches, hash) {
+        const grouped = this.groupBySeverity(matches);
+        const uniqueFiles = new Set(matches.map((m) => m.file)).size;
+        const uniqueDecisions = new Set(matches.map((m) => m.decision.id)).size;
+        let comment = `${this.MARKER}\n`;
+        comment += `<!-- hash:${hash} -->\n\n`;
+        comment += `## ⚠️ Decision Context Alert\n\n`;
+        comment += `This PR modifies **${uniqueFiles} file(s)** that trigger **${uniqueDecisions} architectural decision(s)**.\n\n`;
+        if (grouped.critical.length > 0) {
+            comment += `### 🔴 Critical Decisions (${grouped.critical.length})\n\n`;
+            for (const match of grouped.critical) {
+                comment += this.formatMatch(match);
+            }
+        }
+        if (grouped.warning.length > 0) {
+            comment += `### 🟡 Important Decisions (${grouped.warning.length})\n\n`;
+            for (const match of grouped.warning) {
+                comment += this.formatMatch(match);
+            }
+        }
+        if (grouped.info.length > 0) {
+            comment += `### ℹ️ Informational (${grouped.info.length})\n\n`;
+            for (const match of grouped.info) {
+                comment += this.formatMatch(match);
+            }
+        }
+        comment += `\n---\n`;
+        comment += `*🤖 Generated by [Decision Guardian](https://github.com/DecispherHQ/decision-guardian). `;
+        comment += `Update decisions in your \`.decispher/\` folder if needed.*\n`;
+        return comment;
+    }
+    /**
+     * Build the "All Clear" comment when no decision rules are triggered
+     */
+    buildAllClearComment() {
+        let comment = `${this.MARKER}\n`;
+        comment += `<!-- hash:${this.ALL_CLEAR_HASH} -->\n\n`;
+        comment += `## ✅ Decision Guardian - All Clear\n\n`;
+        comment += `This PR no longer modifies any files protected by architectural decisions.\n\n`;
+        comment += `> **Great job!** All previously flagged decision contexts have been resolved.\n\n`;
+        comment += `---\n`;
+        comment += `*🤖 Generated by [Decision Guardian](https://github.com/DecispherHQ/decision-guardian). `;
+        comment += `Update decisions in your \`.decispher/\` folder if needed.*\n`;
+        return comment;
+    }
+    /**
+     * Build truncated comment when full comment exceeds GitHub's limit
+     */
+    buildTruncatedComment(matches, hash) {
+        const detailLimits = [20, 10, 5, 2, 0];
+        const fileLimitsPerDecision = [10, 5, 3, 1];
+        for (const maxDetailed of detailLimits) {
+            for (const maxFilesPerDecision of fileLimitsPerDecision) {
+                const comment = this.buildTruncatedCommentWithLimits(matches, hash, maxDetailed, maxFilesPerDecision);
+                if (comment.length <= this.MAX_COMMENT_LENGTH) {
+                    return comment;
+                }
+            }
+        }
+        const ultraCompact = this.buildUltraCompactComment(matches, hash);
+        if (ultraCompact.length <= this.MAX_COMMENT_LENGTH) {
+            return ultraCompact;
+        }
+        this.logger.warning(`Comment still too long (${ultraCompact.length} chars), applying hard truncation`);
+        return this.hardTruncate(ultraCompact);
+    }
+    /**
+     * Build truncated comment with specific limits for detailed matches and files per decision
+     */
+    buildTruncatedCommentWithLimits(matches, hash, maxDetailedMatches, maxFilesPerDecision) {
+        const grouped = this.groupBySeverity(matches);
+        const uniqueFiles = new Set(matches.map((m) => m.file)).size;
+        const uniqueDecisions = new Set(matches.map((m) => m.decision.id)).size;
+        let comment = `${this.MARKER}\n`;
+        comment += `<!-- hash:${hash} -->\n\n`;
+        comment += `## ⚠️ Decision Context Alert\n\n`;
+        comment += `> **Large PR**: **${uniqueFiles} file(s)** trigger **${uniqueDecisions} decision(s)** - showing summary.\n\n`;
+        let detailedCount = 0;
+        const remainingMatches = [];
+        if (grouped.critical.length > 0) {
+            comment += `### 🔴 Critical Decisions (${grouped.critical.length})\n\n`;
+            for (const match of grouped.critical) {
+                if (detailedCount < maxDetailedMatches) {
+                    comment += this.formatMatch(match);
+                    detailedCount++;
+                }
+                else {
+                    remainingMatches.push(match);
+                }
+            }
+        }
+        if (grouped.warning.length > 0) {
+            comment += `### 🟡 Important Decisions (${grouped.warning.length})\n\n`;
+            for (const match of grouped.warning) {
+                if (detailedCount < maxDetailedMatches) {
+                    comment += this.formatMatch(match);
+                    detailedCount++;
+                }
+                else {
+                    remainingMatches.push(match);
+                }
+            }
+        }
+        if (grouped.info.length > 0) {
+            comment += `### ℹ️ Informational (${grouped.info.length})\n\n`;
+            for (const match of grouped.info) {
+                if (detailedCount < maxDetailedMatches) {
+                    comment += this.formatMatch(match);
+                    detailedCount++;
+                }
+                else {
+                    remainingMatches.push(match);
+                }
+            }
+        }
+        if (remainingMatches.length > 0) {
+            comment += this.buildSummarySectionForRemainingWithLimit(remainingMatches, maxFilesPerDecision);
+        }
+        comment += `\n---\n`;
+        comment += `*🤖 Generated by [Decision Guardian](https://github.com/DecispherHQ/decision-guardian). `;
+        comment += `Showing ${detailedCount} of ${matches.length} matches.*\n`;
+        return comment;
+    }
+    /**
+     * Build ultra-compact comment showing only counts (last resort before hard truncation)
+     */
+    buildUltraCompactComment(matches, hash) {
+        const grouped = this.groupBySeverity(matches);
+        const byDecision = new Map();
+        for (const match of matches) {
+            const existing = byDecision.get(match.decision.id);
+            if (existing) {
+                existing.count++;
+            }
+            else {
+                byDecision.set(match.decision.id, {
+                    count: 1,
+                    severity: match.decision.severity || 'info',
+                });
+            }
+        }
+        const uniqueFiles = new Set(matches.map((m) => m.file)).size;
+        let comment = `${this.MARKER}\n`;
+        comment += `<!-- hash:${hash} -->\n\n`;
+        comment += `## ⚠️ Decision Context Alert\n\n`;
+        comment += `> ⚠️ **Very Large PR**: **${uniqueFiles} file(s)** trigger **${byDecision.size} decision(s)**.\n\n`;
+        comment += `### Summary\n\n`;
+        comment += `| Severity | Count |\n`;
+        comment += `|----------|-------|\n`;
+        comment += `| 🔴 Critical | ${grouped.critical.length} |\n`;
+        comment += `| 🟡 Warning | ${grouped.warning.length} |\n`;
+        comment += `| ℹ️ Info | ${grouped.info.length} |\n\n`;
+        comment += `### Decisions Triggered\n\n`;
+        const sortedDecisions = [...byDecision.entries()].sort((a, b) => b[1].count - a[1].count);
+        const maxDecisionsToShow = 50;
+        for (let i = 0; i < Math.min(sortedDecisions.length, maxDecisionsToShow); i++) {
+            const [id, info] = sortedDecisions[i];
+            const icon = info.severity === 'critical' ? '🔴' : info.severity === 'warning' ? '🟡' : 'ℹ️';
+            comment += `- ${icon} **${id}**: ${info.count} file(s)\n`;
+        }
+        if (sortedDecisions.length > maxDecisionsToShow) {
+            comment += `- *...and ${sortedDecisions.length - maxDecisionsToShow} more decisions*\n`;
+        }
+        comment += `\n---\n`;
+        comment += `*🤖 Generated by [Decision Guardian](https://github.com/DecispherHQ/decision-guardian). `;
+        comment += `Details truncated.*\n`;
+        return comment;
+    }
+    /**
+     * Hard truncate comment as final safety measure
+     */
+    hardTruncate(comment) {
+        const truncationNotice = `\n\n---\n*⚠️ Comment truncated due to GitHub's 65536 character limit.*\n`;
+        const maxLength = this.MAX_COMMENT_LENGTH - truncationNotice.length;
+        let breakPoint = comment.lastIndexOf('\n', maxLength);
+        if (breakPoint < maxLength * 0.8) {
+            breakPoint = maxLength;
+        }
+        return comment.substring(0, breakPoint) + truncationNotice;
+    }
+    /**
+     * Build a compact summary section for matches that couldn't be shown in detail
+     */
+    buildSummarySectionForRemaining(matches) {
+        return this.buildSummarySectionForRemainingWithLimit(matches, 10);
+    }
+    /**
+     * Build a compact summary section with configurable file limit per decision
+     */
+    buildSummarySectionForRemainingWithLimit(matches, maxFilesPerDecision) {
+        const byDecision = new Map();
+        for (const match of matches) {
+            const files = byDecision.get(match.decision.id) || [];
+            files.push(match.file);
+            byDecision.set(match.decision.id, files);
+        }
+        let section = `\n### 📋 Additional Matches (${matches.length} more)\n\n`;
+        section += `<details>\n<summary>Click to expand summary of remaining files</summary>\n\n`;
+        for (const [decisionId, files] of byDecision) {
+            section += `**${decisionId}** (${files.length} files):\n`;
+            const displayFiles = files.slice(0, maxFilesPerDecision);
+            const remainingCount = files.length - displayFiles.length;
+            for (const file of displayFiles) {
+                section += `- \`${file}\`\n`;
+            }
+            if (remainingCount > 0) {
+                section += `- *...and ${remainingCount} more files*\n`;
+            }
+            section += `\n`;
+        }
+        section += `</details>\n\n`;
+        return section;
+    }
+    /**
+     * Format a single match with link to source, blockquote context, and collapsible for long content
+     */
+    formatMatch(match) {
+        const escapeMarkdown = (str) => {
+            return str
+                .replace(/[\\`*_{}[\]()#+\-.!]/g, '\\$&')
+                .replace(/</g, '&lt;')
+                .replace(/>/g, '&gt;');
+        };
+        const { file, decision, matchedPattern, matchDetails } = match;
+        let patternDisplay = matchedPattern;
+        if (matchDetails && matchDetails.matchedPatterns && matchDetails.matchedPatterns.length > 0) {
+            patternDisplay = matchDetails.matchedPatterns.slice(0, 3).join(', ');
+            if (matchDetails.matchedPatterns.length > 3) {
+                patternDisplay += ` (+${matchDetails.matchedPatterns.length - 3} more)`;
+            }
+        }
+        const matchType = matchDetails ? 'Rule-based' : 'File pattern';
+        // Build source file link (full GitHub blob URL)
+        const workspaceRoot = process.env.GITHUB_WORKSPACE || process.cwd();
+        let relativeSourceFile = decision.sourceFile;
+        const normalizedSource = decision.sourceFile.replace(/\\/g, '/');
+        const normalizedWorkspace = workspaceRoot.replace(/\\/g, '/');
+        if (normalizedSource.startsWith(normalizedWorkspace)) {
+            relativeSourceFile = normalizedSource
+                .substring(normalizedWorkspace.length)
+                .replace(/^\//, '');
+        }
+        // Construct full GitHub blob URL for the source file (if context available)
+        let sourceLink;
+        const context = github.context;
+        if (context?.repo?.owner && context?.repo?.repo) {
+            const repoUrl = `https://github.com/${context.repo.owner}/${context.repo.repo}`;
+            const ref = context.payload?.pull_request?.head?.sha || context.sha || 'HEAD';
+            const blobUrl = `${repoUrl}/blob/${ref}/${relativeSourceFile}`;
+            sourceLink =
+                decision.lineNumber > 0
+                    ? `[${relativeSourceFile}](${blobUrl}#L${decision.lineNumber})`
+                    : `[${relativeSourceFile}](${blobUrl})`;
+        }
+        else {
+            // Fallback when context is not available
+            sourceLink = `\`${relativeSourceFile}\``;
+        }
+        // Format context with blockquote, collapsible if long (>300 chars)
+        const contextText = decision.context.trim();
+        const CONTEXT_THRESHOLD = 300;
+        let contextSection;
+        if (contextText.length > CONTEXT_THRESHOLD) {
+            // Long context: use collapsible
+            const preview = contextText.substring(0, 150).trim() + '...';
+            contextSection = `> ${escapeMarkdown(preview)}\n\n`;
+            contextSection += `<details>\n<summary>📖 Read full context</summary>\n\n`;
+            contextSection += `> ${escapeMarkdown(contextText).split('\n').join('\n> ')}\n\n`;
+            contextSection += `</details>\n`;
+        }
+        else {
+            // Short context: use simple blockquote
+            contextSection = `> ${escapeMarkdown(contextText).split('\n').join('\n> ')}\n`;
+        }
+        return `
+#### ${escapeMarkdown(decision.id)}: ${escapeMarkdown(decision.title)}
+
+| | |
+|---|---|
+| **File** | \`${escapeMarkdown(file)}\` |
+| **Pattern** | \`${escapeMarkdown(patternDisplay)}\` |
+| **Type** | ${matchType} |
+| **Date** | ${escapeMarkdown(decision.date)} |
+| **Source** | ${sourceLink} |
+
+${contextSection}
+---
+
+`;
+    }
+    /**
+     * Group matches by severity
+     */
+    groupBySeverity(matches) {
+        return {
+            critical: matches.filter((m) => m.decision.severity === 'critical'),
+            warning: matches.filter((m) => m.decision.severity === 'warning'),
+            info: matches.filter((m) => m.decision.severity === 'info'),
+        };
+    }
+}
+exports.CommentManager = CommentManager;