pr-checkmate 1.21.0 → 1.21.2

package/dist/scripts/dependency-check.js

@@ -15,31 +15,43 @@ async function runDependencyCheck() {
         utils_1.logger.warn('[runDependencyCheck]: ⚠️ No package.json found, skipping');
         return;
     }
+    // execa v9 always throws on non-zero exit; depcheck exits 255 when it finds issues
+    // but the JSON result is still in error.stdout — extract it either way
+    let stdout;
     try {
-        const { stdout } = await (0, execa_1.execa)('npx', ['depcheck', '--json'], { cwd: projectRoot });
-        const result = JSON.parse(stdout);
-        const unused = result.dependencies ?? [];
-        const missing = Object.keys(result.missing ?? {});
-        if (unused.length === 0 && missing.length === 0) {
-            utils_1.logger.info('[runDependencyCheck]: ✅ Dependencies are clean');
-            return;
-        }
-        if (unused.length > 0) {
-            utils_1.logger.warn(`[runDependencyCheck]: ⚠️ ${unused.length} unused dependency(ies):`);
-            unused.forEach(dep => utils_1.logger.warn(`  ${dep}`));
-        }
-        if (missing.length > 0) {
-            utils_1.logger.error(`[runDependencyCheck]: ❌ ${missing.length} missing dependency(ies):`);
-            missing.forEach(dep => utils_1.logger.error(`  ${dep} (used in: ${result.missing[dep]?.join(', ')})`));
-            throw new Error(`Missing dependencies: ${missing.join(', ')}`);
-        }
-        // Unused deps are warnings — don't block the build
+        ({ stdout } = await (0, execa_1.execa)('npx', ['depcheck', '--json'], { cwd: projectRoot }));
     }
     catch (err) {
-        const error = err;
-        if (error.message?.startsWith('Missing dependencies'))
+        if (err instanceof execa_1.ExecaError && err.stdout) {
+            stdout = err.stdout;
+        }
+        else {
+            utils_1.logger.error(`[runDependencyCheck]: ❌ Dependency check failed\n${err}`);
             throw err;
-        utils_1.logger.error(`[runDependencyCheck]: ❌ Dependency check failed\n${err}`);
-        throw err;
+        }
+    }
+    let result;
+    try {
+        result = JSON.parse(stdout);
+    }
+    catch {
+        utils_1.logger.error('[runDependencyCheck]: ❌ Failed to parse depcheck output');
+        throw new Error('depcheck produced invalid JSON');
+    }
+    const unused = result.dependencies ?? [];
+    const missing = Object.keys(result.missing ?? {});
+    if (unused.length === 0 && missing.length === 0) {
+        utils_1.logger.info('[runDependencyCheck]: ✅ Dependencies are clean');
+        return;
+    }
+    if (unused.length > 0) {
+        utils_1.logger.warn(`[runDependencyCheck]: ⚠️ ${unused.length} unused dependency(ies):`);
+        unused.forEach(dep => utils_1.logger.warn(`  ${dep}`));
+    }
+    if (missing.length > 0) {
+        utils_1.logger.error(`[runDependencyCheck]: ❌ ${missing.length} missing dependency(ies):`);
+        missing.forEach(dep => utils_1.logger.error(`  ${dep} (used in: ${result.missing[dep]?.join(', ')})`));
+        throw new Error(`Missing dependencies: ${missing.join(', ')}`);
     }
+    // Unused deps are warnings — don't block the build
 }

package/dist/scripts/diff-smell.js

@@ -0,0 +1,97 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runDiffSmell = runDiffSmell;
+const execa_1 = require("execa");
+const utils_1 = require("../utils");
+const result_collector_1 = require("../utils/result-collector");
+const loader_1 = require("../config/loader");
+const node_fs_1 = __importDefault(require("node:fs"));
+const SMELL_PATTERNS = [
+    // console.* calls added in diff (not in comments)
+    { pattern: /^\+(?!\+)(?:[^/]|\/[^/]).*\bconsole\.(log|error|warn|debug|info)\s*\(/, label: 'console.*()' },
+    { pattern: /^\+(?!\+).*\bdebugger\b/, label: 'debugger statement' },
+    { pattern: /^\+\s*\/\/\s*TODO\b/i, label: 'TODO comment' },
+    { pattern: /^\+\s*\/\/\s*FIXME\b/i, label: 'FIXME comment' },
+    { pattern: /^\+\s*\/\/\s*HACK\b/i, label: 'HACK comment' },
+    { pattern: /^\+\s*\/\/\s*XXX\b/i, label: 'XXX marker' },
+];
+function readBaseSha() {
+    const eventName = process.env.GITHUB_EVENT_NAME;
+    const eventPath = process.env.GITHUB_EVENT_PATH;
+    if (eventName !== 'pull_request' || !eventPath || !node_fs_1.default.existsSync(eventPath)) {
+        return null;
+    }
+    try {
+        const event = JSON.parse(node_fs_1.default.readFileSync(eventPath, 'utf-8'));
+        return event?.pull_request?.base?.sha ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+async function runDiffSmell() {
+    const cfg = (0, loader_1.loadProjectConfig)();
+    if (cfg.diffSmell?.enabled === false) {
+        utils_1.logger.info('[runDiffSmell]: Disabled in pr-checkmate.json, skipping');
+        result_collector_1.resultCollector.register('Diff Smells', 'skip');
+        return;
+    }
+    utils_1.logger.info('[runDiffSmell]: Scanning diff for code smells...');
+    const baseSha = readBaseSha();
+    if (!baseSha) {
+        utils_1.logger.info('[runDiffSmell]: Not in GitHub PR context, skipping');
+        result_collector_1.resultCollector.register('Diff Smells', 'skip');
+        return;
+    }
+    try {
+        const { stdout } = await (0, execa_1.execa)('git', [
+            'diff',
+            '--unified=0',
+            '--diff-filter=ACMR',
+            baseSha,
+            'HEAD',
+            '--',
+            '*.ts',
+            '*.tsx',
+            '*.js',
+            '*.jsx',
+        ]);
+        const lines = stdout.split('\n');
+        const findings = {};
+        for (const line of lines) {
+            for (const { pattern, label } of SMELL_PATTERNS) {
+                if (pattern.test(line)) {
+                    if (!findings[label])
+                        findings[label] = [];
+                    // Strip leading + and trim for display
+                    findings[label].push(line.slice(1).trim().substring(0, 100));
+                }
+            }
+        }
+        const totalFindings = Object.values(findings).reduce((sum, arr) => sum + arr.length, 0);
+        if (totalFindings === 0) {
+            utils_1.logger.info('[runDiffSmell]: ✅ No code smells detected in diff');
+            result_collector_1.resultCollector.register('Diff Smells', 'pass');
+            return;
+        }
+        utils_1.logger.warn(`[runDiffSmell]: ⚠️ Found ${totalFindings} code smell(s) in diff:`);
+        for (const [label, occurrences] of Object.entries(findings)) {
+            utils_1.logger.warn(`  ${label}: ${occurrences.length} occurrence(s)`);
+            occurrences.slice(0, 3).forEach(line => utils_1.logger.warn(`    ${line}`));
+            if (occurrences.length > 3) {
+                utils_1.logger.warn(`    ... and ${occurrences.length - 3} more`);
+            }
+        }
+        const summary = Object.entries(findings)
+            .map(([label, arr]) => `${arr.length}× ${label}`)
+            .join(', ');
+        result_collector_1.resultCollector.register('Diff Smells', 'warn', summary);
+    }
+    catch (err) {
+        utils_1.logger.warn(`[runDiffSmell]: ⚠️ Could not analyze diff\n${err}`);
+        result_collector_1.resultCollector.register('Diff Smells', 'skip');
+    }
+}

package/dist/scripts/duplicate-check.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runDuplicateCheck = runDuplicateCheck;
+const execa_1 = require("execa");
+const utils_1 = require("../utils");
+const result_collector_1 = require("../utils/result-collector");
+const loader_1 = require("../config/loader");
+const delta_1 = require("../utils/delta");
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = __importDefault(require("node:fs"));
+async function runDuplicateCheck() {
+    const cfg = (0, loader_1.loadProjectConfig)();
+    if (cfg.duplicate?.enabled === false) {
+        utils_1.logger.info('[runDuplicateCheck]: Disabled in pr-checkmate.json, skipping');
+        result_collector_1.resultCollector.register('Duplicate Code', 'skip');
+        return;
+    }
+    const minLines = cfg.duplicate?.minLines ?? 5;
+    const minTokens = cfg.duplicate?.minTokens ?? 50;
+    utils_1.logger.info('[runDuplicateCheck]: Checking for duplicate code...');
+    const projectRoot = process.cwd();
+    const changedFiles = await (0, delta_1.getChangedFiles)(['.ts', '.tsx', '.js', '.jsx']);
+    // In PR context but no relevant files changed
+    if (changedFiles !== null && changedFiles.length === 0) {
+        utils_1.logger.info('[runDuplicateCheck]: No relevant files changed, skipping');
+        result_collector_1.resultCollector.register('Duplicate Code', 'skip');
+        return;
+    }
+    // Fall back to src/ or project root when not in delta mode
+    const srcPath = node_path_1.default.join(projectRoot, 'src');
+    const targetPaths = changedFiles ?? (node_fs_1.default.existsSync(srcPath) ? [srcPath] : [projectRoot]);
+    try {
+        const result = await (0, execa_1.execa)('npx', [
+            'jscpd',
+            '--min-lines',
+            String(minLines),
+            '--min-tokens',
+            String(minTokens),
+            '--reporters',
+            'console',
+            '--ignore',
+            'node_modules/**,dist/**,.git/**',
+            '--quiet',
+            ...targetPaths,
+        ], { reject: false });
+        const output = [result.stdout, result.stderr].filter(Boolean).join('\n');
+        const clonesMatch = output.match(/(\d+)\s+clone/i);
+        const cloneCount = clonesMatch ? parseInt(clonesMatch[1], 10) : 0;
+        if (cloneCount > 0) {
+            utils_1.logger.warn(`[runDuplicateCheck]: ⚠️ Found ${cloneCount} duplicate block(s)`);
+            if (output)
+                utils_1.logger.warn(output);
+            result_collector_1.resultCollector.register('Duplicate Code', 'warn', `${cloneCount} duplicate block(s)`);
+        }
+        else {
+            utils_1.logger.info('[runDuplicateCheck]: ✅ No significant code duplication found');
+            result_collector_1.resultCollector.register('Duplicate Code', 'pass');
+        }
+    }
+    catch (err) {
+        utils_1.logger.warn(`[runDuplicateCheck]: ⚠️ Could not run duplicate check\n${err}`);
+        result_collector_1.resultCollector.register('Duplicate Code', 'skip');
+    }
+}

package/dist/scripts/index.js

@@ -25,7 +25,14 @@ const license_check_1 = require("./license-check");
 const pr_size_check_1 = require("./pr-size-check");
 const pr_title_lint_1 = require("./pr-title-lint");
 const outdated_deps_1 = require("./outdated-deps");
+const markdown_lint_1 = require("./markdown-lint");
+const typecheck_1 = require("./typecheck");
+const diff_smell_1 = require("./diff-smell");
+const pr_body_1 = require("./pr-body");
+const duplicate_check_1 = require("./duplicate-check");
+const pr_summary_1 = require("./pr-summary");
 const utils_1 = require("../utils");
+const result_collector_1 = require("../utils/result-collector");
 const lint_1 = require("./lint");
 __exportStar(require("./dependency-check"), exports);
 __exportStar(require("./lint"), exports);
@@ -37,34 +44,70 @@ __exportStar(require("./license-check"), exports);
 __exportStar(require("./pr-size-check"), exports);
 __exportStar(require("./pr-title-lint"), exports);
 __exportStar(require("./outdated-deps"), exports);
+__exportStar(require("./markdown-lint"), exports);
+__exportStar(require("./typecheck"), exports);
+__exportStar(require("./diff-smell"), exports);
+__exportStar(require("./pr-body"), exports);
+__exportStar(require("./duplicate-check"), exports);
+__exportStar(require("./pr-summary"), exports);
+/**
+ * Wraps a blocking check: registers 'pass' on success, 'fail' on throw (and re-throws).
+ */
+async function trackCheck(name, fn) {
+    try {
+        await fn();
+        result_collector_1.resultCollector.register(name, 'pass');
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message.split('\n')[0].substring(0, 120) : String(err);
+        result_collector_1.resultCollector.register(name, 'fail', msg);
+        throw err;
+    }
+}
+/**
+ * Wraps an informational check: registers 'pass' on success, 'warn' on throw (never re-throws).
+ */
+async function trackSoftCheck(name, fn) {
+    try {
+        await fn();
+        result_collector_1.resultCollector.register(name, 'pass');
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message.split('\n')[0].substring(0, 120) : String(err);
+        result_collector_1.resultCollector.register(name, 'warn', msg);
+    }
+}
 async function runJob(jobName) {
     utils_1.logger.info(`[runJob]: 🚀 Running job: ${jobName}`);
     try {
         switch (jobName) {
             case 'all':
-                // Phase 1: blocking checks in parallel
+                // Phase 1: blocking quality gates — run in parallel, fail fast on any throw
                 await Promise.all([
-                    (0, lint_1.runLint)(),
-                    (0, dependency_check_1.runDependencyCheck)(),
-                    (0, npm_audit_1.runNpmAudit)(),
-                    (0, security_1.runSecurityScan)(),
-                    (0, circular_deps_1.runCircularDeps)(),
-                    (0, license_check_1.runLicenseCheck)(),
+                    trackCheck('ESLint', lint_1.runLint),
+                    trackCheck('Dependencies', dependency_check_1.runDependencyCheck),
+                    trackCheck('NPM Audit', npm_audit_1.runNpmAudit),
+                    trackCheck('Security Scan', security_1.runSecurityScan),
+                    trackCheck('Circular Deps', circular_deps_1.runCircularDeps),
+                    trackCheck('License Check', license_check_1.runLicenseCheck),
+                    trackCheck('TypeScript', typecheck_1.runTypecheck),
                 ]);
-                // Phase 2: informational checks in parallel (never block)
+                // Phase 2: informational checks — old scripts tracked via wrapper,
+                // new scripts register themselves with accurate warn/skip status
                 await Promise.all([
-                    (0, pr_size_check_1.runPrSizeCheck)(),
-                    (0, pr_title_lint_1.runPrTitleLint)(),
-                    (0, outdated_deps_1.runOutdatedDeps)(),
-                    (0, spellcheck_1.runSpellcheck)().catch(() => utils_1.logger.warn('⚠️ Spellcheck found issues, continuing...')),
+                    trackSoftCheck('PR Size', pr_size_check_1.runPrSizeCheck),
+                    trackSoftCheck('PR Title', pr_title_lint_1.runPrTitleLint),
+                    trackSoftCheck('Outdated Deps', outdated_deps_1.runOutdatedDeps),
+                    trackSoftCheck('Markdown', markdown_lint_1.runMarkdownLint),
+                    trackSoftCheck('Spellcheck', spellcheck_1.runSpellcheck),
+                    (0, diff_smell_1.runDiffSmell)(),
+                    (0, pr_body_1.runPrBodyCheck)(),
+                    (0, duplicate_check_1.runDuplicateCheck)(),
                 ]);
-                // Phase 3: prettier last — writes files
-                try {
-                    await (0, prettier_autoformat_1.runPrettier)();
-                }
-                catch {
-                    utils_1.logger.warn('⚠️ Prettier failed, continuing...');
-                }
+                // Phase 3: prettier last — may write files, then auto-commit in CI
+                await trackSoftCheck('Prettier', prettier_autoformat_1.runPrettier);
+                // Phase 4: print summary table + post GitHub PR comment
+                await (0, pr_summary_1.runPrSummary)();
                 break;
             case 'lint':
                 await (0, lint_1.runLint)();
@@ -100,8 +143,23 @@ async function runJob(jobName) {
             case 'outdated':
                 await (0, outdated_deps_1.runOutdatedDeps)();
                 break;
+            case 'markdown':
+                await (0, markdown_lint_1.runMarkdownLint)();
+                break;
+            case 'typecheck':
+                await (0, typecheck_1.runTypecheck)();
+                break;
+            case 'diff-smell':
+                await (0, diff_smell_1.runDiffSmell)();
+                break;
+            case 'pr-body':
+                await (0, pr_body_1.runPrBodyCheck)();
+                break;
+            case 'duplicate':
+                await (0, duplicate_check_1.runDuplicateCheck)();
+                break;
             default:
-                utils_1.logger.warn(`[runJob]: Unknown job "${jobName}". Available: all, lint, deps, npm-audit, prettier, spellcheck, security, circular, license, pr-size, pr-title, outdated`);
+                utils_1.logger.warn(`[runJob]: Unknown job "${jobName}". Available: all, lint, deps, npm-audit, prettier, spellcheck, security, circular, license, pr-size, pr-title, outdated, markdown, typecheck, diff-smell, pr-body, duplicate`);
         }
     }
     catch (err) {

package/dist/scripts/license-check.js

@@ -22,7 +22,8 @@ async function runLicenseCheck() {
         const licenses = JSON.parse(stdout);
         const violations = [];
         for (const [pkg, info] of Object.entries(licenses)) {
-            const license = info.licenses ?? '';
+            const raw = info.licenses ?? '';
+            const license = Array.isArray(raw) ? raw.join(' OR ') : raw;
             if (FORBIDDEN_LICENSES.some(f => license.includes(f))) {
                 violations.push(`  ${pkg}: ${license}`);
             }

package/dist/scripts/markdown-lint.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runMarkdownLint = runMarkdownLint;
+const execa_1 = require("execa");
+const utils_1 = require("../utils");
+const delta_1 = require("../utils/delta");
+const config_1 = require("../config");
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = __importDefault(require("node:fs"));
+function loadUserMarkdownConfig() {
+    const configPath = node_path_1.default.join(process.cwd(), 'pr-checkmate.json');
+    if (!node_fs_1.default.existsSync(configPath)) {
+        return {};
+    }
+    try {
+        const config = JSON.parse(node_fs_1.default.readFileSync(configPath, 'utf-8'));
+        return config.markdownlint || {};
+    }
+    catch (err) {
+        utils_1.logger.warn(`[loadUserMarkdownConfig]: ⚠️ Failed to read markdownlint config from pr-checkmate.json: ${err}`);
+        return {};
+    }
+}
+async function runMarkdownLint() {
+    utils_1.logger.info('[runMarkdownLint]: 📝 Running Markdown lint...');
+    const root = process.cwd();
+    const changedFiles = await (0, delta_1.getChangedFiles)(['.md', '.mdx']);
+    const targets = changedFiles ?? [`${root}/**/*.md`];
+    const userConfig = loadUserMarkdownConfig();
+    // Prefer local .markdownlint.json → else fall back to bundled one
+    let configArg;
+    if ((0, config_1.hasLocalConfig)(['.markdownlint.json', '.markdownlint.jsonc', '.markdownlint.yaml', '.markdownlint.yml'])) {
+        utils_1.logger.info('[runMarkdownLint]: 📋 Using local .markdownlint config');
+        configArg = [];
+    }
+    else {
+        const bundledConfig = (0, config_1.getPackageConfigPath)('.markdownlint.json');
+        utils_1.logger.info('[runMarkdownLint]: 📋 Using pr-checkmate bundled markdownlint config');
+        configArg = ['--config', bundledConfig];
+    }
+    const extraIgnores = (userConfig.ignores ?? []).flatMap(p => ['--ignore', p]);
+    const args = [
+        'markdownlint',
+        ...targets,
+        ...configArg,
+        '--ignore', 'node_modules',
+        '--ignore', 'dist',
+        '--ignore', 'coverage',
+        ...extraIgnores,
+    ];
+    const result = await (0, execa_1.execa)('npx', args, { reject: false, stdio: 'inherit' });
+    if (result.exitCode === 0) {
+        utils_1.logger.info('[runMarkdownLint]: ✅ Markdown lint passed');
+    }
+    else {
+        utils_1.logger.warn('[runMarkdownLint]: ⚠️ Markdown lint found issues (see above)');
+        // warning only — never block
+    }
+}

package/dist/scripts/npm-audit.js

@@ -8,8 +8,16 @@ const utils_1 = require("../utils");
 const node_path_1 = __importDefault(require("node:path"));
 const node_fs_1 = __importDefault(require("node:fs"));
 const execa_1 = require("execa");
+const config_1 = require("../config");
+const SEVERITY_ORDER = ['info', 'low', 'moderate', 'high', 'critical'];
+function isSeverityAtLeast(severity, level) {
+    const sevIdx = SEVERITY_ORDER.indexOf(severity);
+    const lvlIdx = SEVERITY_ORDER.indexOf(level);
+    return sevIdx >= 0 && lvlIdx >= 0 && sevIdx >= lvlIdx;
+}
 /**
- * Run npm audit on the current project
+ * Run npm audit on the current project.
+ * Only fails on vulnerabilities in direct dependencies — transitive ones are silently ignored.
  */
 async function runNpmAudit() {
     utils_1.logger.info('Running npm audit...');
@@ -19,25 +27,27 @@ async function runNpmAudit() {
         utils_1.logger.warn('[runNpmAudit]: ⚠️ No package.json found in project root — skipping npm audit');
         return;
     }
+    const config = (0, config_1.loadProjectConfig)();
+    const auditLevel = config.security?.['npm-audit']?.auditLevel ?? 'moderate';
+    let report;
     try {
-        const { stdout, stderr } = await (0, execa_1.execa)('npm', ['audit', '--audit-level=moderate'], {
+        const { stdout } = await (0, execa_1.execa)('npm', ['audit', '--json'], {
             cwd: projectRoot,
+            reject: false,
         });
-        if (stdout)
-            utils_1.logger.info(stdout);
-        if (stderr)
-            utils_1.logger.warn(stderr);
-        utils_1.logger.info('[runNpmAudit]: ✅ NPM audit finished successfully');
+        report = JSON.parse(stdout);
     }
     catch (error) {
-        const err = error;
-        utils_1.logger.error('[runNpmAudit]: ❌ NPM audit found issues');
-        if (err.stdout)
-            utils_1.logger.error(err.stdout);
-        if (err.stderr)
-            utils_1.logger.warn(err.stderr);
-        if (!err.stdout && !err.stderr)
-            utils_1.logger.error(err.message);
-        throw err;
+        utils_1.logger.error('[runNpmAudit]: ❌ Failed to parse npm audit output');
+        throw error;
+    }
+    const directVulns = Object.values(report.vulnerabilities ?? {}).filter(v => v.isDirect && isSeverityAtLeast(v.severity, auditLevel));
+    if (directVulns.length === 0) {
+        utils_1.logger.info('[runNpmAudit]: ✅ NPM audit finished successfully');
+        return;
+    }
+    for (const v of directVulns) {
+        utils_1.logger.error(`[runNpmAudit]: ❌ ${v.name} — severity: ${v.severity}`);
     }
+    throw new Error(`[runNpmAudit]: ${directVulns.length} direct dependency vulnerability(ies) found at level "${auditLevel}" or above`);
 }

package/dist/scripts/pr-body.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPrBodyCheck = runPrBodyCheck;
+const utils_1 = require("../utils");
+const result_collector_1 = require("../utils/result-collector");
+const loader_1 = require("../config/loader");
+const node_fs_1 = __importDefault(require("node:fs"));
+// Matches "Closes #123", "Fixes #45", "Resolves #7" or JIRA-style "PROJ-456"
+const TICKET_PATTERN = /(?:closes?|fixes?|resolves?)\s+#\d+|[A-Z][A-Z0-9]+-\d+/i;
+async function runPrBodyCheck() {
+    const cfg = (0, loader_1.loadProjectConfig)();
+    if (cfg.prBody?.enabled === false) {
+        utils_1.logger.info('[runPrBodyCheck]: Disabled in pr-checkmate.json, skipping');
+        result_collector_1.resultCollector.register('PR Body', 'skip');
+        return;
+    }
+    const minLength = cfg.prBody?.minLength ?? 20;
+    const requireTicket = cfg.prBody?.requireTicket ?? true;
+    utils_1.logger.info('[runPrBodyCheck]: Checking PR description...');
+    const eventPath = process.env.GITHUB_EVENT_PATH;
+    if (!eventPath || !node_fs_1.default.existsSync(eventPath)) {
+        utils_1.logger.info('[runPrBodyCheck]: Not in GitHub CI, skipping');
+        result_collector_1.resultCollector.register('PR Body', 'skip');
+        return;
+    }
+    let event;
+    try {
+        event = JSON.parse(node_fs_1.default.readFileSync(eventPath, 'utf-8'));
+    }
+    catch (err) {
+        utils_1.logger.warn(`[runPrBodyCheck]: ⚠️ Could not read GitHub event\n${err}`);
+        result_collector_1.resultCollector.register('PR Body', 'skip');
+        return;
+    }
+    const pr = event.pull_request;
+    if (!pr) {
+        utils_1.logger.info('[runPrBodyCheck]: No PR data found, skipping');
+        result_collector_1.resultCollector.register('PR Body', 'skip');
+        return;
+    }
+    const body = pr.body ?? '';
+    const trimmed = body.trim();
+    const issues = [];
+    if (trimmed.length < minLength) {
+        issues.push(`description too short (${trimmed.length}/${minLength} chars min)`);
+    }
+    if (requireTicket && trimmed && !TICKET_PATTERN.test(trimmed)) {
+        issues.push('no ticket reference (e.g. "Closes #123" or "PROJ-456")');
+    }
+    if (issues.length > 0) {
+        utils_1.logger.warn('[runPrBodyCheck]: ⚠️ PR description issues:');
+        issues.forEach(issue => utils_1.logger.warn(`  • ${issue}`));
+        result_collector_1.resultCollector.register('PR Body', 'warn', issues.join('; '));
+    }
+    else {
+        utils_1.logger.info('[runPrBodyCheck]: ✅ PR description looks good');
+        result_collector_1.resultCollector.register('PR Body', 'pass');
+    }
+}