pr-checkmate 1.22.7 → 1.23.0

package/dist/core/checks/languages/python-typecheck.d.ts

@@ -0,0 +1,9 @@
+import { Check } from '../../types';
+/**
+ * Type-checks changed Python files — the Python analogue of the TypeScript
+ * `tsc --noEmit` check. Runner-dependency (needs mypy or pyright on the runner),
+ * gracefully skipping when neither is present. Informational by design (like
+ * Ruff lint) so teams can adopt gradually; force a checker with
+ * `python.typeChecker`, else mypy is tried first, then pyright.
+ */
+export declare const pythonTypecheckCheck: Check;

package/dist/core/checks/languages/python-typecheck.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pythonTypecheckCheck = void 0;
+const utils_1 = require("../../../utils");
+const execa_1 = require("../../../utils/execa");
+const targets_1 = require("../../targets");
+const types_1 = require("../../types");
+const ruff_shared_1 = require("./ruff-shared");
+/** Run a type checker over the target files, or return null if the binary is absent. */
+async function runChecker(ctx, bin, targets) {
+    const result = await (0, execa_1.execa)(bin, targets, { cwd: ctx.cwd, reject: false });
+    if (result.code === 'ENOENT')
+        return null;
+    return { exitCode: result.exitCode, stdout: result.stdout, stderr: result.stderr };
+}
+/**
+ * Type-checks changed Python files — the Python analogue of the TypeScript
+ * `tsc --noEmit` check. Runner-dependency (needs mypy or pyright on the runner),
+ * gracefully skipping when neither is present. Informational by design (like
+ * Ruff lint) so teams can adopt gradually; force a checker with
+ * `python.typeChecker`, else mypy is tried first, then pyright.
+ */
+exports.pythonTypecheckCheck = {
+    name: 'Python Types',
+    phase: 'informational',
+    applies(ctx) {
+        return (ctx.config.python?.enabled !== false &&
+            ctx.config.python?.typecheck !== false &&
+            ctx.languages.includes('python'));
+    },
+    async run(ctx) {
+        const targets = await (0, targets_1.resolveTargetFiles)(ctx, ruff_shared_1.PY_GLOBS);
+        if (targets === null)
+            return (0, types_1.skip)('git unavailable');
+        if (targets.length === 0)
+            return (0, types_1.pass)('no Python files changed');
+        const forced = ctx.config.python?.typeChecker;
+        const order = forced ? [forced] : ['mypy', 'pyright'];
+        let result = null;
+        let used = '';
+        for (const bin of order) {
+            result = await runChecker(ctx, bin, targets);
+            if (result) {
+                used = bin;
+                break;
+            }
+        }
+        if (!result)
+            return (0, types_1.skip)(`${forced ?? 'mypy/pyright'} not installed`);
+        if (result.exitCode === 0) {
+            utils_1.logger.info(`[Python Types]: ✅ No type errors (${used})`);
+            return (0, types_1.pass)();
+        }
+        const lines = [result.stdout, result.stderr]
+            .filter(Boolean)
+            .join('\n')
+            .split('\n')
+            .filter(l => /\berror\b|\bwarning\b/i.test(l));
+        utils_1.logger.warn(`[Python Types]: ⚠️ type issues (${used}):`);
+        lines.slice(0, 10).forEach(l => utils_1.logger.warn(`  ${l}`));
+        if (lines.length > 10)
+            utils_1.logger.warn(`  ... and ${lines.length - 10} more`);
+        const summary = lines.find(l => /found\s+\d+\s+error/i.test(l)) ?? `${lines.length} type issue(s)`;
+        return (0, types_1.warn)(summary.trim());
+    },
+};

package/dist/core/checks/languages/ruby-lint.d.ts

@@ -0,0 +1,8 @@
+import { Check } from '../../types';
+/**
+ * Lints changed Ruby files with RuboCop (which covers both style and layout, so
+ * it doubles as the formatting signal). Runner-dependency: needs `rubocop` on
+ * the runner, gracefully skipping when absent. Uses the repo's own `.rubocop.yml`
+ * when present.
+ */
+export declare const rubyLintCheck: Check;

package/dist/core/checks/languages/ruby-lint.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rubyLintCheck = void 0;
+const utils_1 = require("../../../utils");
+const execa_1 = require("../../../utils/execa");
+const targets_1 = require("../../targets");
+const types_1 = require("../../types");
+const RUBY_GLOBS = ['*.rb', '*.rake'];
+/**
+ * Lints changed Ruby files with RuboCop (which covers both style and layout, so
+ * it doubles as the formatting signal). Runner-dependency: needs `rubocop` on
+ * the runner, gracefully skipping when absent. Uses the repo's own `.rubocop.yml`
+ * when present.
+ */
+exports.rubyLintCheck = {
+    name: 'RuboCop',
+    phase: 'informational',
+    applies(ctx) {
+        return ctx.config.ruby?.enabled !== false && ctx.languages.includes('ruby');
+    },
+    async run(ctx) {
+        const targets = await (0, targets_1.resolveTargetFiles)(ctx, RUBY_GLOBS);
+        if (targets === null)
+            return (0, types_1.skip)('git unavailable');
+        if (targets.length === 0)
+            return (0, types_1.pass)('no Ruby files changed');
+        const result = await (0, execa_1.execa)('rubocop', ['--format', 'simple', ...targets], {
+            cwd: ctx.cwd,
+            reject: false,
+        });
+        if (result.code === 'ENOENT')
+            return (0, types_1.skip)('rubocop not installed');
+        if (result.exitCode === 0) {
+            utils_1.logger.info('[RuboCop]: ✅ No offenses found');
+            return (0, types_1.pass)();
+        }
+        const lines = [result.stdout, result.stderr]
+            .filter(Boolean)
+            .join('\n')
+            .split('\n')
+            .filter(l => l.trim());
+        utils_1.logger.warn('[RuboCop]: ⚠️ offenses detected:');
+        lines.slice(0, 10).forEach(l => utils_1.logger.warn(`  ${l}`));
+        if (lines.length > 10)
+            utils_1.logger.warn(`  ... and ${lines.length - 10} more line(s)`);
+        // RuboCop's summary line looks like "N offenses detected".
+        const summary = lines.find(l => /offense/i.test(l)) ?? `${lines.length} line(s) of output`;
+        return (0, types_1.warn)(summary.trim());
+    },
+};

package/dist/core/checks/languages/rust-format.d.ts

@@ -0,0 +1,9 @@
+import { Check } from '../../types';
+/**
+ * Formats changed Rust code with `cargo fmt` (which respects the crate's edition
+ * from Cargo.toml, unlike a bare `rustfmt`). Runner-dependency, gracefully
+ * skipping when `cargo` is absent. Read-only in check mode (`cargo fmt --check`);
+ * rewrites in place with `cargo fmt` when `write`, so CI can auto-commit —
+ * mirrors the Prettier/C++/Go format checks.
+ */
+export declare const rustFormatCheck: Check;

package/dist/core/checks/languages/rust-format.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rustFormatCheck = void 0;
+const utils_1 = require("../../../utils");
+const execa_1 = require("../../../utils/execa");
+const targets_1 = require("../../targets");
+const types_1 = require("../../types");
+const RUST_GLOBS = ['*.rs'];
+/**
+ * Formats changed Rust code with `cargo fmt` (which respects the crate's edition
+ * from Cargo.toml, unlike a bare `rustfmt`). Runner-dependency, gracefully
+ * skipping when `cargo` is absent. Read-only in check mode (`cargo fmt --check`);
+ * rewrites in place with `cargo fmt` when `write`, so CI can auto-commit —
+ * mirrors the Prettier/C++/Go format checks.
+ */
+exports.rustFormatCheck = {
+    name: 'Rustfmt',
+    phase: 'format',
+    applies(ctx) {
+        return ctx.config.rust?.enabled !== false && ctx.languages.includes('rust');
+    },
+    async run(ctx) {
+        const targets = await (0, targets_1.resolveTargetFiles)(ctx, RUST_GLOBS);
+        if (targets === null)
+            return (0, types_1.skip)('git unavailable');
+        if (targets.length === 0)
+            return (0, types_1.pass)('no Rust files changed');
+        const check = await (0, execa_1.execa)('cargo', ['fmt', '--check'], { cwd: ctx.cwd, reject: false });
+        if (check.code === 'ENOENT')
+            return (0, types_1.skip)('cargo not installed');
+        if (check.exitCode === 0)
+            return (0, types_1.pass)();
+        if (!ctx.write) {
+            utils_1.logger.warn('[Rustfmt]: ⚠️ Rust code is not formatted (cargo fmt --check failed)');
+            return (0, types_1.warn)('Rust code needs formatting (run with write to fix)');
+        }
+        const fix = await (0, execa_1.execa)('cargo', ['fmt'], { cwd: ctx.cwd, reject: false });
+        if (fix.exitCode !== 0) {
+            utils_1.logger.warn(`[Rustfmt]: ⚠️ cargo fmt failed\n${fix.stderr}`);
+            return (0, types_1.warn)('cargo fmt failed to rewrite files');
+        }
+        utils_1.logger.info('[Rustfmt]: ✅ Reformatted Rust code');
+        return (0, types_1.pass)('reformatted Rust code');
+    },
+};

package/dist/core/checks/languages/rust-lint.d.ts

@@ -0,0 +1,8 @@
+import { Check } from '../../types';
+/**
+ * Lints changed Rust code with Clippy (`cargo clippy -- -D warnings`).
+ * Runner-dependency: needs the Rust toolchain + clippy on the runner, and
+ * gracefully skips when absent. Clippy compiles the whole crate, so it runs over
+ * the crate rather than a file list; the delta check only gates whether it runs.
+ */
+export declare const rustLintCheck: Check;

package/dist/core/checks/languages/rust-lint.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rustLintCheck = void 0;
+const utils_1 = require("../../../utils");
+const execa_1 = require("../../../utils/execa");
+const targets_1 = require("../../targets");
+const types_1 = require("../../types");
+const RUST_GLOBS = ['*.rs'];
+/**
+ * Lints changed Rust code with Clippy (`cargo clippy -- -D warnings`).
+ * Runner-dependency: needs the Rust toolchain + clippy on the runner, and
+ * gracefully skips when absent. Clippy compiles the whole crate, so it runs over
+ * the crate rather than a file list; the delta check only gates whether it runs.
+ */
+exports.rustLintCheck = {
+    name: 'Clippy',
+    phase: 'informational',
+    applies(ctx) {
+        return ctx.config.rust?.enabled !== false && ctx.languages.includes('rust');
+    },
+    async run(ctx) {
+        const targets = await (0, targets_1.resolveTargetFiles)(ctx, RUST_GLOBS);
+        if (targets === null)
+            return (0, types_1.skip)('git unavailable');
+        if (targets.length === 0)
+            return (0, types_1.pass)('no Rust files changed');
+        const result = await (0, execa_1.execa)('cargo', ['clippy', '--quiet', '--', '-D', 'warnings'], {
+            cwd: ctx.cwd,
+            reject: false,
+        });
+        // execa v9 with reject:false resolves (not throws) with `code: 'ENOENT'` when
+        // the binary is absent — detect the missing toolchain on the result.
+        if (result.code === 'ENOENT')
+            return (0, types_1.skip)('cargo/clippy not installed');
+        if (result.exitCode === 0) {
+            utils_1.logger.info('[Clippy]: ✅ No issues found');
+            return (0, types_1.pass)();
+        }
+        // Clippy writes diagnostics to stderr.
+        const lines = result.stderr
+            .split('\n')
+            .filter(l => /\b(warning|error)\b/.test(l))
+            .filter(Boolean);
+        utils_1.logger.warn(`[Clippy]: ⚠️ ${lines.length} diagnostic line(s):`);
+        lines.slice(0, 10).forEach(l => utils_1.logger.warn(`  ${l}`));
+        if (lines.length > 10)
+            utils_1.logger.warn(`  ... and ${lines.length - 10} more`);
+        return (0, types_1.warn)(`${lines.length || 'unknown'} clippy diagnostic(s)`);
+    },
+};

package/dist/core/checks/{swift-lint.d.ts → languages/swift-lint.d.ts}

@@ -1,2 +1,2 @@
-import { Check } from '../types';
+import { Check } from '../../types';
 export declare const swiftLintCheck: Check;

package/dist/core/checks/{swift-lint.js → languages/swift-lint.js}

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.swiftLintCheck = void 0;
-const utils_1 = require("../../utils");
-const execa_1 = require("../../utils/execa");
-const targets_1 = require("../targets");
-const types_1 = require("../types");
+const utils_1 = require("../../../utils");
+const execa_1 = require("../../../utils/execa");
+const targets_1 = require("../../targets");
+const types_1 = require("../../types");
 const SWIFT_GLOBS = ['*.swift'];
 exports.swiftLintCheck = {
     name: 'SwiftLint',
@@ -18,19 +18,15 @@ exports.swiftLintCheck = {
             return (0, types_1.skip)('git unavailable');
         if (targets.length === 0)
             return (0, types_1.pass)('no Swift files changed');
-        let result;
-        try {
-            result = await (0, execa_1.execa)('swiftlint', ['lint', '--quiet', '--path', ctx.cwd], {
-                cwd: ctx.cwd,
-                reject: false,
-            });
-        }
-        catch (err) {
-            if (err.code === 'ENOENT') {
-                return (0, types_1.skip)('swiftlint not installed');
-            }
-            throw err;
-        }
+        const result = await (0, execa_1.execa)('swiftlint', ['lint', '--quiet', '--path', ctx.cwd], {
+            cwd: ctx.cwd,
+            reject: false,
+        });
+        // execa v9 with reject:false does NOT throw on a missing binary — it resolves
+        // with `code: 'ENOENT'`. Detect the absent toolchain on the result, not via a
+        // try/catch (which never fires here and would let a missing linter pass silently).
+        if (result.code === 'ENOENT')
+            return (0, types_1.skip)('swiftlint not installed');
         const output = [result.stdout, result.stderr].filter(Boolean).join('\n').trim();
         if (result.exitCode === 0 || !output) {
             utils_1.logger.info('[SwiftLint]: ✅ No issues found');

package/dist/core/checks/{typecheck.d.ts → languages/typecheck.d.ts}

@@ -1,2 +1,2 @@
-import { Check } from '../types';
+import { Check } from '../../types';
 export declare const typecheckCheck: Check;

package/dist/core/checks/{typecheck.js → languages/typecheck.js}

@@ -6,9 +6,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.typecheckCheck = void 0;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
-const utils_1 = require("../../utils");
-const execa_1 = require("../../utils/execa");
-const types_1 = require("../types");
+const utils_1 = require("../../../utils");
+const execa_1 = require("../../../utils/execa");
+const types_1 = require("../../types");
 /**
  * Prefer the consumer project's own TypeScript so its tsconfig is compiled by the
  * version it was written for; fall back to the compiler bundled with pr-checkmate.

package/dist/core/checks/{commitlint.d.ts → pr/commitlint.d.ts}

@@ -1,2 +1,2 @@
-import { Check } from '../types';
+import { Check } from '../../types';
 export declare const commitlintCheck: Check;

package/dist/core/checks/{commitlint.js → pr/commitlint.js}

@@ -7,10 +7,10 @@ exports.commitlintCheck = void 0;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
-const config_1 = require("../../config");
-const utils_1 = require("../../utils");
-const execa_1 = require("../../utils/execa");
-const types_1 = require("../types");
+const config_1 = require("../../../config");
+const utils_1 = require("../../../utils");
+const execa_1 = require("../../../utils/execa");
+const types_1 = require("../../types");
 const LOCAL_CONFIG_FILES = [
     'commitlint.config.cjs',
     'commitlint.config.js',

package/dist/core/checks/{pr-body.d.ts → pr/pr-body.d.ts}

@@ -1,2 +1,2 @@
-import { Check } from '../types';
+import { Check } from '../../types';
 export declare const prBodyCheck: Check;

package/dist/core/checks/{pr-body.js → pr/pr-body.js}

@@ -5,8 +5,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.prBodyCheck = void 0;
 const node_fs_1 = __importDefault(require("node:fs"));
-const utils_1 = require("../../utils");
-const types_1 = require("../types");
+const utils_1 = require("../../../utils");
+const types_1 = require("../../types");
 // 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;
 exports.prBodyCheck = {

package/dist/core/checks/{pr-size-check.d.ts → pr/pr-size-check.d.ts}

@@ -1,2 +1,2 @@
-import { Check } from '../types';
+import { Check } from '../../types';
 export declare const prSizeCheck: Check;

package/dist/core/checks/{pr-size-check.js → pr/pr-size-check.js}

@@ -1,20 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.prSizeCheck = void 0;
-const utils_1 = require("../../utils");
-const execa_1 = require("../../utils/execa");
-const types_1 = require("../types");
-const WARN_FILES = 50;
-const WARN_LINES = 1000;
+const utils_1 = require("../../../utils");
+const execa_1 = require("../../../utils/execa");
+const types_1 = require("../../types");
+const DEFAULT_MAX_FILES = 50;
+const DEFAULT_MAX_LINES = 1000;
 exports.prSizeCheck = {
     name: 'PR Size',
     phase: 'informational',
     applies(ctx) {
-        return Boolean(ctx.baseSha);
+        return ctx.config.prSize?.enabled !== false && Boolean(ctx.baseSha);
     },
     async run(ctx) {
+        const maxFiles = ctx.config.prSize?.maxFiles ?? DEFAULT_MAX_FILES;
+        const maxLines = ctx.config.prSize?.maxLines ?? DEFAULT_MAX_LINES;
         try {
-            const { stdout } = await (0, execa_1.execa)('git', ['diff', '--shortstat', ctx.baseSha, 'HEAD'], {
+            const { stdout } = await (0, execa_1.execa)('git', ['diff', '--shortstat', ctx.baseSha, ctx.headSha ?? 'HEAD'], {
                 cwd: ctx.cwd,
             });
             // "5 files changed, 123 insertions(+), 45 deletions(-)"
@@ -24,10 +26,10 @@ exports.prSizeCheck = {
             const lines = insertions + deletions;
             utils_1.logger.info(`[PR Size]: ${fileCount} files changed, ${lines} lines`);
             const issues = [];
-            if (fileCount > WARN_FILES)
-                issues.push(`${fileCount} files (recommended < ${WARN_FILES})`);
-            if (lines > WARN_LINES)
-                issues.push(`${lines} lines (recommended < ${WARN_LINES})`);
+            if (fileCount > maxFiles)
+                issues.push(`${fileCount} files (recommended < ${maxFiles})`);
+            if (lines > maxLines)
+                issues.push(`${lines} lines (recommended < ${maxLines})`);
             if (issues.length > 0) {
                 issues.forEach(i => utils_1.logger.warn(`[PR Size]: ⚠️ Large PR: ${i}`));
                 return (0, types_1.warn)(issues.join(', '));

package/dist/core/checks/{pr-title-lint.d.ts → pr/pr-title-lint.d.ts}

@@ -1,2 +1,2 @@
-import { Check } from '../types';
+import { Check } from '../../types';
 export declare const prTitleLintCheck: Check;

package/dist/core/checks/{pr-title-lint.js → pr/pr-title-lint.js}

@@ -5,8 +5,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.prTitleLintCheck = void 0;
 const node_fs_1 = __importDefault(require("node:fs"));
-const utils_1 = require("../../utils");
-const types_1 = require("../types");
+const utils_1 = require("../../../utils");
+const types_1 = require("../../types");
 const CONVENTIONAL_PREFIX = /^(feat|fix|docs|style|refactor|test|chore|perf|ci|build|revert)(\(.+\))?!?: .+/;
 exports.prTitleLintCheck = {
     name: 'PR Title',

package/dist/core/checks/quality/case-collision.d.ts

@@ -0,0 +1,8 @@
+import { Check } from '../../types';
+/**
+ * Flags tracked files whose paths differ only by case (e.g. `Foo.ts` vs
+ * `foo.ts`). Such pairs coexist on Linux (case-sensitive) but collide on macOS/
+ * Windows and in many Docker layers, silently breaking checkouts and builds.
+ * Whole-repo scan (not delta), scoped to `sourcePath` and honouring `ignoreDirs`.
+ */
+export declare const caseCollisionCheck: Check;

package/dist/core/checks/quality/case-collision.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.caseCollisionCheck = void 0;
+const config_1 = require("../../../config");
+const utils_1 = require("../../../utils");
+const targets_1 = require("../../targets");
+const types_1 = require("../../types");
+/**
+ * Flags tracked files whose paths differ only by case (e.g. `Foo.ts` vs
+ * `foo.ts`). Such pairs coexist on Linux (case-sensitive) but collide on macOS/
+ * Windows and in many Docker layers, silently breaking checkouts and builds.
+ * Whole-repo scan (not delta), scoped to `sourcePath` and honouring `ignoreDirs`.
+ */
+exports.caseCollisionCheck = {
+    name: 'Case Collision',
+    phase: 'informational',
+    applies(ctx) {
+        return ctx.config.caseCollision?.enabled !== false;
+    },
+    async run(ctx) {
+        const files = await (0, targets_1.listTrackedFiles)(ctx, ['*'], (0, config_1.getSourcePaths)());
+        if (files.length === 0)
+            return (0, types_1.skip)('no tracked files');
+        const byLower = new Map();
+        for (const f of files) {
+            const key = f.toLowerCase();
+            let set = byLower.get(key);
+            if (!set) {
+                set = new Set();
+                byLower.set(key, set);
+            }
+            set.add(f);
+        }
+        const collisions = [...byLower.values()].filter(set => set.size > 1);
+        if (collisions.length === 0)
+            return (0, types_1.pass)();
+        collisions.forEach(set => utils_1.logger.warn(`[Case Collision]: ⚠️ ${[...set].join(' ↔ ')}`));
+        return (0, types_1.warn)(`${collisions.length} case-collision(s) — paths differing only by case`);
+    },
+};

package/dist/core/checks/quality/config-validation.d.ts

@@ -0,0 +1,8 @@
+import { Check } from '../../types';
+/**
+ * Validates pr-checkmate.json itself: warns on unknown top-level keys (typos
+ * like `mergeConfict` that silently do nothing) and on invalid values in the
+ * `severity` map. Reads the raw file so it checks what the user actually wrote,
+ * not the merged defaults. `//`-comment keys and `$schema` are ignored.
+ */
+export declare const configValidationCheck: Check;

package/dist/core/checks/quality/config-validation.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configValidationCheck = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const config_1 = require("../../../config");
+const utils_1 = require("../../../utils");
+const types_1 = require("../../types");
+const VALID_SEVERITIES = ['error', 'warn', 'off'];
+/**
+ * Validates pr-checkmate.json itself: warns on unknown top-level keys (typos
+ * like `mergeConfict` that silently do nothing) and on invalid values in the
+ * `severity` map. Reads the raw file so it checks what the user actually wrote,
+ * not the merged defaults. `//`-comment keys and `$schema` are ignored.
+ */
+exports.configValidationCheck = {
+    name: 'Config Validation',
+    phase: 'informational',
+    applies(ctx) {
+        return ctx.config.configValidation?.enabled !== false;
+    },
+    async run(ctx) {
+        const file = node_path_1.default.join(ctx.cwd, 'pr-checkmate.json');
+        let raw;
+        try {
+            raw = node_fs_1.default.readFileSync(file, 'utf-8');
+        }
+        catch {
+            return (0, types_1.skip)('no pr-checkmate.json');
+        }
+        let json;
+        try {
+            json = JSON.parse(raw);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message.split('\n')[0] : String(err);
+            return (0, types_1.warn)(`pr-checkmate.json is not valid JSON: ${msg}`);
+        }
+        const issues = [];
+        for (const key of Object.keys(json)) {
+            if (key.startsWith('//') || key === '$schema')
+                continue;
+            if (!config_1.KNOWN_CONFIG_KEYS.has(key))
+                issues.push(`unknown key "${key}"`);
+        }
+        const sev = json.severity;
+        if (sev && typeof sev === 'object') {
+            for (const [name, val] of Object.entries(sev)) {
+                if (!VALID_SEVERITIES.includes(val)) {
+                    issues.push(`severity["${name}"] must be error|warn|off (got ${JSON.stringify(val)})`);
+                }
+            }
+        }
+        if (issues.length === 0)
+            return (0, types_1.pass)();
+        issues.slice(0, 10).forEach(i => utils_1.logger.warn(`[Config Validation]: ⚠️ ${i}`));
+        const sample = issues.slice(0, 3).join('; ');
+        return (0, types_1.warn)(`${issues.length} config issue(s): ${sample}${issues.length > 3 ? ' …' : ''}`);
+    },
+};

package/dist/core/checks/quality/coverage.d.ts

@@ -0,0 +1,2 @@
+import { Check } from '../../types';
+export declare const coverageCheck: Check;

package/dist/core/checks/quality/coverage.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.coverageCheck = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const types_1 = require("../../types");
+const findings_1 = require("../findings");
+/**
+ * Common coverage-report locations across languages/tools. Presence of any one
+ * means the test step produced coverage. Reports are usually git-ignored, so we
+ * probe the working tree with fs, not git. A client with a non-standard path
+ * sets `coverage.reportPath`.
+ */
+const DEFAULT_REPORTS = [
+    'coverage/lcov.info', // JS/TS (lcov), C++
+    'lcov.info',
+    'coverage/coverage-final.json', // istanbul
+    'coverage/coverage-summary.json',
+    'coverage/cobertura-coverage.xml', // Cobertura (JS, Python)
+    'coverage/clover.xml',
+    'coverage.xml', // Python (pytest-cov / coverage.py)
+    'coverage.out', // Go
+    'build/reports/jacoco/test/jacocoTestReport.xml', // Kotlin/Java (Gradle)
+    'target/site/jacoco/jacoco.xml', // Java (Maven)
+];
+exports.coverageCheck = {
+    name: 'Coverage',
+    phase: 'informational',
+    /**
+     * Opt-in: only runs when a repo explicitly enables it (`coverage.enabled:
+     * true`). Presence-warning by default everywhere would be pure noise in repos
+     * that don't collect coverage — so a client turns it on to say "we produce
+     * coverage", and the check then guards against the report silently going
+     * missing (a broken `--coverage` flag, tests not running, etc.).
+     */
+    applies(ctx) {
+        return ctx.config.coverage?.enabled === true;
+    },
+    async run(ctx) {
+        const cfg = ctx.config.coverage;
+        const candidates = cfg?.reportPath
+            ? Array.isArray(cfg.reportPath)
+                ? cfg.reportPath
+                : [cfg.reportPath]
+            : DEFAULT_REPORTS;
+        const found = candidates.find(rel => {
+            try {
+                return node_fs_1.default.statSync(node_path_1.default.join(ctx.cwd, rel)).size > 0;
+            }
+            catch {
+                return false;
+            }
+        });
+        if (found)
+            return (0, types_1.pass)(`coverage report found: ${found}`);
+        const sev = (0, findings_1.severityEmitter)(cfg?.severity, 'warn');
+        sev.log(`[Coverage]: ${sev.icon} no coverage report found (looked for ${candidates.length} location(s), e.g. ${candidates.slice(0, 3).join(', ')})`);
+        return sev.emit('no coverage report found — is the test step running with coverage enabled?');
+    },
+};

package/dist/core/checks/{dead-code.d.ts → quality/dead-code.d.ts}

@@ -1,2 +1,2 @@
-import { Check } from '../types';
+import { Check } from '../../types';
 export declare const deadCodeCheck: Check;

package/dist/core/checks/{dead-code.js → quality/dead-code.js}

@@ -6,10 +6,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.deadCodeCheck = void 0;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
-const constants_1 = require("../../config/constants");
-const utils_1 = require("../../utils");
-const execa_1 = require("../../utils/execa");
-const types_1 = require("../types");
+const constants_1 = require("../../../config/constants");
+const utils_1 = require("../../../utils");
+const execa_1 = require("../../../utils/execa");
+const types_1 = require("../../types");
 exports.deadCodeCheck = {
     name: 'Dead Code',
     phase: 'informational',