pr-checkmate 1.22.7 → 1.23.0

package/dist/core/checks/git/missing-tests.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.missingTestsCheck = void 0;
+const config_1 = require("../../../config");
+const utils_1 = require("../../../utils");
+const execa_1 = require("../../../utils/execa");
+const targets_1 = require("../../targets");
+const types_1 = require("../../types");
+const findings_1 = require("../findings");
+/** Source-file extensions across the supported languages. */
+const SOURCE_EXT = /\.(ts|tsx|js|jsx|mjs|cjs|py|kt|kts|java|swift|cpp|cc|cxx|c|h|hpp|go|rb)$/i;
+/** Test-file conventions across languages. */
+function isTestFile(file) {
+    return (/\.(test|spec)\.[cm]?[jt]sx?$/i.test(file) || // foo.test.ts, foo.spec.jsx
+        /(^|\/)__tests__\//.test(file) ||
+        /(^|\/)tests?\//i.test(file) || // test/ or tests/ dir
+        /(^|\/)test_[^/]+\.py$/.test(file) || // test_foo.py
+        /_test\.(py|go)$/.test(file) || // foo_test.py, foo_test.go
+        /(Test|Spec)s?\.(kt|java|swift)$/.test(file) // FooTest.kt, FooSpec.swift
+    );
+}
+/**
+ * Source files that legitimately ship without a test of their own. Setting
+ * `missingTests.ignore` REPLACES this list (same convention as duplicate/
+ * dead-code ignores).
+ */
+const DEFAULT_IGNORE = [
+    '**/*.d.ts',
+    '**/index.ts',
+    '**/index.tsx',
+    '**/index.js',
+    '**/index.jsx',
+    '**/*.config.*',
+    '**/migrations/**',
+    '**/migrate/**',
+    '**/__init__.py',
+];
+exports.missingTestsCheck = {
+    name: 'Missing Tests',
+    phase: 'informational',
+    applies(ctx) {
+        return ctx.config.missingTests?.enabled !== false && Boolean(ctx.baseSha);
+    },
+    async run(ctx) {
+        // Scope the same way lint does — a client's `sourcePath` and `ignoreDirs`
+        // both apply, so generated/out-of-scope dirs never count as "new source".
+        const scopedList = await (0, targets_1.resolveScopedTargetFiles)(ctx, ['*'], (0, config_1.getSourcePaths)());
+        if (scopedList === null)
+            return (0, types_1.skip)('git unavailable');
+        const scoped = new Set(scopedList);
+        const added = [];
+        const touched = [];
+        try {
+            const { stdout } = await (0, execa_1.execa)('git', [
+                'diff',
+                '--name-status',
+                '--diff-filter=ACM',
+                ctx.baseSha,
+                ctx.headSha ?? 'HEAD',
+            ], { cwd: ctx.cwd });
+            for (const line of stdout.split('\n')) {
+                if (!line)
+                    continue;
+                const [status, ...rest] = line.split('\t');
+                const file = rest.join('\t');
+                if (!file || !scoped.has(file))
+                    continue;
+                touched.push(file);
+                if (status === 'A')
+                    added.push(file);
+            }
+        }
+        catch (err) {
+            utils_1.logger.warn(`[Missing Tests]: ⚠️ Could not analyze diff\n${err}`);
+            return (0, types_1.skip)('diff unavailable');
+        }
+        const ignore = ctx.config.missingTests?.ignore ?? DEFAULT_IGNORE;
+        const addedSource = added.filter(f => SOURCE_EXT.test(f) && !isTestFile(f) && !(0, utils_1.matchesAnyGlob)(f, ignore));
+        if (addedSource.length === 0)
+            return (0, types_1.pass)(); // no new source that would need a test
+        // A test added OR modified anywhere in scope satisfies the check.
+        if (touched.some(isTestFile))
+            return (0, types_1.pass)();
+        const sev = (0, findings_1.severityEmitter)(ctx.config.missingTests?.severity, 'warn');
+        addedSource
+            .slice(0, 5)
+            .forEach(f => sev.log(`[Missing Tests]: ${sev.icon} new source without tests: ${f}`));
+        if (addedSource.length > 5)
+            sev.log(`[Missing Tests]: ${sev.icon} ... and ${addedSource.length - 5} more`);
+        return sev.emit(`${addedSource.length} new source file(s) added without any test changes`);
+    },
+};

package/dist/core/checks/git/todo-fixme.d.ts

@@ -0,0 +1,7 @@
+import { Check } from '../../types';
+/**
+ * Flags leftover TODO/FIXME/XXX/HACK markers in Python and Kotlin/Java comments.
+ * JS/TS markers are already handled by the Diff Smells check, so this stays out
+ * of those globs to avoid double-reporting (same split as Leftover Debug).
+ */
+export declare const todoFixmeCheck: Check;

package/dist/core/checks/git/todo-fixme.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.todoFixmeCheck = void 0;
+const utils_1 = require("../../../utils");
+const types_1 = require("../../types");
+const findings_1 = require("../findings");
+const DEFAULT_KEYWORDS = ['TODO', 'FIXME', 'XXX', 'HACK'];
+/** A ticket reference in the comment: `#123` or JIRA-style `PROJ-456`. */
+const TICKET_PATTERN = /#\d+|[A-Z][A-Z0-9]+-\d+/;
+/**
+ * Build an added-line matcher for a comment style. `commentFragment` is a regex
+ * alternation of the language's comment openers (`#` for Python; `//`/`/*` for
+ * Kotlin/Java). Keywords are escaped and captured so the finding is labelled.
+ */
+function buildPattern(commentFragment, keywords) {
+    const kw = keywords.map(k => k.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|');
+    return new RegExp(`^\\+.*(?:${commentFragment})\\s*(${kw})\\b`, 'i');
+}
+/** Bucket matching added lines by keyword, honouring opt-out and requireTicket. */
+function scan(stdout, pattern, requireTicket, findings) {
+    for (const line of stdout.split('\n')) {
+        if (line.includes('pr-checkmate-ignore'))
+            continue;
+        const match = pattern.exec(line);
+        if (!match)
+            continue;
+        // With requireTicket, a marker that already links a ticket is acceptable.
+        if (requireTicket && TICKET_PATTERN.test(line))
+            continue;
+        const keyword = match[1].toUpperCase();
+        (findings[keyword] ?? (findings[keyword] = [])).push(line.slice(1).trim().substring(0, 100));
+    }
+}
+/**
+ * Flags leftover TODO/FIXME/XXX/HACK markers in Python and Kotlin/Java comments.
+ * JS/TS markers are already handled by the Diff Smells check, so this stays out
+ * of those globs to avoid double-reporting (same split as Leftover Debug).
+ */
+exports.todoFixmeCheck = {
+    name: 'TODO/FIXME',
+    phase: 'informational',
+    applies(ctx) {
+        return (ctx.config.todoFixme?.enabled !== false &&
+            Boolean(ctx.baseSha) &&
+            (ctx.languages.includes('python') || ctx.languages.includes('kotlin')));
+    },
+    async run(ctx) {
+        try {
+            const cfg = ctx.config.todoFixme;
+            const keywords = cfg?.keywords ?? DEFAULT_KEYWORDS;
+            const requireTicket = cfg?.requireTicket ?? false;
+            const findings = {};
+            if (ctx.languages.includes('python')) {
+                scan(await (0, findings_1.diffAddedLines)(ctx, ['*.py']), buildPattern('#', keywords), requireTicket, findings);
+            }
+            if (ctx.languages.includes('kotlin')) {
+                const ktPattern = buildPattern('//|/\\*', keywords);
+                scan(await (0, findings_1.diffAddedLines)(ctx, ['*.kt', '*.kts', '*.java']), ktPattern, requireTicket, findings);
+            }
+            if ((0, findings_1.bucketTotal)(findings) === 0)
+                return (0, types_1.pass)();
+            const sev = (0, findings_1.severityEmitter)(cfg?.severity, 'warn');
+            (0, findings_1.logFindings)(findings, { prefix: 'TODO/FIXME', sampleLimit: 3, isError: sev.icon === '❌' });
+            const summary = Object.entries(findings)
+                .map(([label, arr]) => `${arr.length}× ${label}`)
+                .join(', ') + (requireTicket ? ' (no ticket reference)' : '');
+            return sev.emit(summary);
+        }
+        catch (err) {
+            utils_1.logger.warn(`[TODO/FIXME]: ⚠️ Could not analyze diff\n${err}`);
+            return (0, types_1.skip)('diff unavailable');
+        }
+    },
+};

package/dist/core/checks/{cpp-format.d.ts → languages/cpp-format.d.ts}

@@ -1,4 +1,4 @@
-import { Check } from '../types';
+import { Check } from '../../types';
 /**
  * Formats C/C++ code with clang-format, bundled as a self-contained WASM CLI
  * (`@wasm-fmt/clang-format`) so it runs on a bare Node image with no system

package/dist/core/checks/{cpp-format.js → languages/cpp-format.js}

@@ -6,9 +6,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.cppFormatCheck = 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");
 /**
  * C/C++ source & header extensions clang-format understands. `.h` is intentionally
  * included even though it is ambiguous with C — clang-format handles both.

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

@@ -0,0 +1,13 @@
+import { Check } from '../../types';
+/**
+ * Formats/verifies C# code with `dotnet format` (which also runs the configured
+ * analyzers/whitespace/style rules). Runner-dependency: needs the .NET SDK on
+ * the runner, gracefully skipping when absent. Read-only in check mode
+ * (`--verify-no-changes`); rewrites in place with `dotnet format` when `write`,
+ * so CI can auto-commit — mirrors the other format checks.
+ *
+ * Note: `dotnet format` operates on the project/solution (needs a prior
+ * `dotnet restore`), so it runs over the whole project; the delta check only
+ * gates whether it runs at all.
+ */
+export declare const csharpFormatCheck: Check;

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

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.csharpFormatCheck = void 0;
+const utils_1 = require("../../../utils");
+const execa_1 = require("../../../utils/execa");
+const targets_1 = require("../../targets");
+const types_1 = require("../../types");
+const CS_GLOBS = ['*.cs'];
+/**
+ * Formats/verifies C# code with `dotnet format` (which also runs the configured
+ * analyzers/whitespace/style rules). Runner-dependency: needs the .NET SDK on
+ * the runner, gracefully skipping when absent. Read-only in check mode
+ * (`--verify-no-changes`); rewrites in place with `dotnet format` when `write`,
+ * so CI can auto-commit — mirrors the other format checks.
+ *
+ * Note: `dotnet format` operates on the project/solution (needs a prior
+ * `dotnet restore`), so it runs over the whole project; the delta check only
+ * gates whether it runs at all.
+ */
+exports.csharpFormatCheck = {
+    name: 'C# Format',
+    phase: 'format',
+    applies(ctx) {
+        return ctx.config.csharp?.enabled !== false && ctx.languages.includes('csharp');
+    },
+    async run(ctx) {
+        const targets = await (0, targets_1.resolveTargetFiles)(ctx, CS_GLOBS);
+        if (targets === null)
+            return (0, types_1.skip)('git unavailable');
+        if (targets.length === 0)
+            return (0, types_1.pass)('no C# files changed');
+        const check = await (0, execa_1.execa)('dotnet', ['format', '--verify-no-changes'], {
+            cwd: ctx.cwd,
+            reject: false,
+        });
+        if (check.code === 'ENOENT')
+            return (0, types_1.skip)('dotnet SDK not installed');
+        if (check.exitCode === 0)
+            return (0, types_1.pass)();
+        if (!ctx.write) {
+            utils_1.logger.warn('[C# Format]: ⚠️ C# code needs formatting (dotnet format --verify-no-changes failed)');
+            return (0, types_1.warn)('C# code needs formatting (run with write to fix)');
+        }
+        const fix = await (0, execa_1.execa)('dotnet', ['format'], { cwd: ctx.cwd, reject: false });
+        if (fix.exitCode !== 0) {
+            utils_1.logger.warn(`[C# Format]: ⚠️ dotnet format failed\n${fix.stderr}`);
+            return (0, types_1.warn)('dotnet format failed to rewrite files');
+        }
+        utils_1.logger.info('[C# Format]: ✅ Reformatted C# code');
+        return (0, types_1.pass)('reformatted C# code');
+    },
+};

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

@@ -0,0 +1,8 @@
+import { Check } from '../../types';
+/**
+ * Formats changed Go files with `gofmt`. Runner-dependency (needs `gofmt` on the
+ * runner), gracefully skipping when absent. Read-only in check mode (`gofmt -l`
+ * lists files that differ from gofmt output); rewrites in place with `gofmt -w`
+ * when `write`, so CI can auto-commit — mirrors the Prettier/C++/Ruff format checks.
+ */
+export declare const goFormatCheck: Check;

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

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.goFormatCheck = void 0;
+const utils_1 = require("../../../utils");
+const execa_1 = require("../../../utils/execa");
+const targets_1 = require("../../targets");
+const types_1 = require("../../types");
+const GO_GLOBS = ['*.go'];
+/**
+ * Formats changed Go files with `gofmt`. Runner-dependency (needs `gofmt` on the
+ * runner), gracefully skipping when absent. Read-only in check mode (`gofmt -l`
+ * lists files that differ from gofmt output); rewrites in place with `gofmt -w`
+ * when `write`, so CI can auto-commit — mirrors the Prettier/C++/Ruff format checks.
+ */
+exports.goFormatCheck = {
+    name: 'Go Format',
+    phase: 'format',
+    applies(ctx) {
+        return ctx.config.go?.enabled !== false && ctx.languages.includes('go');
+    },
+    async run(ctx) {
+        const targets = await (0, targets_1.resolveTargetFiles)(ctx, GO_GLOBS);
+        if (targets === null)
+            return (0, types_1.skip)('git unavailable');
+        if (targets.length === 0)
+            return (0, types_1.pass)('no Go files changed');
+        const list = await (0, execa_1.execa)('gofmt', ['-l', ...targets], { 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 (list.code === 'ENOENT')
+            return (0, types_1.skip)('gofmt not installed');
+        const unformatted = list.stdout.split('\n').filter(Boolean);
+        if (unformatted.length === 0)
+            return (0, types_1.pass)();
+        if (!ctx.write) {
+            utils_1.logger.warn(`[Go Format]: ⚠️ ${unformatted.length} Go file(s) need formatting`);
+            unformatted.slice(0, 10).forEach(f => utils_1.logger.warn(`  ${f}`));
+            return (0, types_1.warn)(`${unformatted.length} file(s) need formatting (run with write to fix)`);
+        }
+        const fix = await (0, execa_1.execa)('gofmt', ['-w', ...unformatted], { cwd: ctx.cwd, reject: false });
+        if (fix.exitCode !== 0) {
+            utils_1.logger.warn(`[Go Format]: ⚠️ gofmt -w failed\n${fix.stderr}`);
+            return (0, types_1.warn)('gofmt failed to rewrite files');
+        }
+        utils_1.logger.info(`[Go Format]: ✅ Reformatted ${unformatted.length} Go file(s)`);
+        return (0, types_1.pass)(`reformatted ${unformatted.length} file(s)`);
+    },
+};

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

@@ -0,0 +1,8 @@
+import { Check } from '../../types';
+/**
+ * Vets changed Go code with `go vet ./...`. Runner-dependency: requires the Go
+ * toolchain on the runner (like SwiftLint/ktlint), and gracefully skips when
+ * `go` is absent. `go vet` operates per-package, so it runs over the module
+ * rather than a file list; the delta check only gates whether it runs at all.
+ */
+export declare const goLintCheck: Check;

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

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.goLintCheck = void 0;
+const utils_1 = require("../../../utils");
+const execa_1 = require("../../../utils/execa");
+const targets_1 = require("../../targets");
+const types_1 = require("../../types");
+const GO_GLOBS = ['*.go'];
+/**
+ * Vets changed Go code with `go vet ./...`. Runner-dependency: requires the Go
+ * toolchain on the runner (like SwiftLint/ktlint), and gracefully skips when
+ * `go` is absent. `go vet` operates per-package, so it runs over the module
+ * rather than a file list; the delta check only gates whether it runs at all.
+ */
+exports.goLintCheck = {
+    name: 'Go Vet',
+    phase: 'informational',
+    applies(ctx) {
+        return ctx.config.go?.enabled !== false && ctx.languages.includes('go');
+    },
+    async run(ctx) {
+        const targets = await (0, targets_1.resolveTargetFiles)(ctx, GO_GLOBS);
+        if (targets === null)
+            return (0, types_1.skip)('git unavailable');
+        if (targets.length === 0)
+            return (0, types_1.pass)('no Go files changed');
+        const result = await (0, execa_1.execa)('go', ['vet', './...'], { cwd: ctx.cwd, reject: false });
+        // execa v9 with reject:false does NOT throw on a missing binary — it resolves
+        // with `code: 'ENOENT'`. Detect that on the result, not via try/catch.
+        if (result.code === 'ENOENT')
+            return (0, types_1.skip)('go not installed');
+        if (result.exitCode === 0) {
+            utils_1.logger.info('[Go Vet]: ✅ No issues found');
+            return (0, types_1.pass)();
+        }
+        // go vet writes diagnostics (and build errors) to stderr.
+        const lines = [result.stderr, result.stdout]
+            .filter(Boolean)
+            .join('\n')
+            .split('\n')
+            .filter(Boolean);
+        utils_1.logger.warn(`[Go Vet]: ⚠️ ${lines.length} line(s) of diagnostics:`);
+        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} diagnostic line(s)`);
+    },
+};

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

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

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

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.kotlinLintCheck = 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 KOTLIN_GLOBS = ['*.kt', '*.kts'];
 exports.kotlinLintCheck = {
     name: 'ktlint',
@@ -18,19 +18,15 @@ exports.kotlinLintCheck = {
             return (0, types_1.skip)('git unavailable');
         if (targets.length === 0)
             return (0, types_1.pass)('no Kotlin files changed');
-        let result;
-        try {
-            result = await (0, execa_1.execa)('ktlint', ['--reporter=plain', ...targets], {
-                cwd: ctx.cwd,
-                reject: false,
-            });
-        }
-        catch (err) {
-            if (err.code === 'ENOENT') {
-                return (0, types_1.skip)('ktlint not installed');
-            }
-            throw err;
-        }
+        const result = await (0, execa_1.execa)('ktlint', ['--reporter=plain', ...targets], {
+            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)('ktlint not installed');
         const output = [result.stdout, result.stderr].filter(Boolean).join('\n').trim();
         if (result.exitCode === 0 || !output) {
             utils_1.logger.info('[ktlint]: ✅ No issues found');

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

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

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

@@ -1,15 +1,24 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.lintCheck = void 0;
-const node_path_1 = __importDefault(require("node:path"));
-const config_1 = require("../../config");
-const utils_1 = require("../../utils");
-const delta_1 = require("../../utils/delta");
-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 targets_1 = require("../../targets");
+const types_1 = require("../../types");
+/**
+ * Resolve the ESLint binary, preferring the consumer project's own copy so a
+ * repo pinned to ESLint 8 (+ legacy `.eslintrc.*`) keeps working. Falls back to
+ * the version bundled with pr-checkmate when the project has no local install.
+ */
+function resolveESLintBin(cwd) {
+    try {
+        return (0, utils_1.resolvePackageBin)('eslint', 'bin/eslint.js', { paths: [cwd] });
+    }
+    catch {
+        return (0, utils_1.resolvePackageBin)('eslint', 'bin/eslint.js');
+    }
+}
 async function getESLintMajorVersion(eslintBin) {
     try {
         const { stdout } = await (0, execa_1.execa)(process.execPath, [eslintBin, '--version']);
@@ -27,10 +36,12 @@ exports.lintCheck = {
         return ctx.languages.includes('typescript') || ctx.languages.includes('javascript');
     },
     async run(ctx) {
-        const eslintBin = (0, utils_1.resolvePackageBin)('eslint', 'bin/eslint.js');
-        const sourcePath = (0, config_1.getSourcePath)();
-        const changedFiles = await (0, delta_1.getChangedFiles)(['.ts', '.tsx', '.js', '.jsx']);
-        const targets = changedFiles ?? [node_path_1.default.join(ctx.cwd, sourcePath)];
+        const eslintBin = resolveESLintBin(ctx.cwd);
+        const targets = await (0, targets_1.resolveScopedTargetFiles)(ctx, ['*.ts', '*.tsx', '*.js', '*.jsx'], (0, config_1.getSourcePaths)());
+        if (targets === null)
+            return (0, types_1.skip)('git unavailable');
+        if (targets.length === 0)
+            return (0, types_1.pass)('no TypeScript/JavaScript files to lint');
         const hasLocal = (0, config_1.hasLocalConfig)([
             'eslint.config.mjs',
             'eslint.config.js',
@@ -50,7 +61,7 @@ exports.lintCheck = {
         if (ctx.write)
             args.push('--fix');
         if (hasLocal) {
-            utils_1.logger.info(`[ESLint]: Using local config (checking: ${sourcePath})`);
+            utils_1.logger.info(`[ESLint]: Using local config (${targets.length} file(s))`);
         }
         else {
             const configFile = version >= 9 ? 'eslint.config.mjs' : '.eslintrc.js';

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

@@ -0,0 +1,9 @@
+import { Check } from '../../types';
+/**
+ * Formats changed PHP files with PHP-CS-Fixer. Runner-dependency: needs
+ * `php-cs-fixer` on the runner, gracefully skipping when absent. Read-only in
+ * check mode (`--dry-run`); rewrites in place when `write`, so CI can
+ * auto-commit — mirrors the other format checks. Uses the repo's own
+ * `.php-cs-fixer.php` config when present.
+ */
+export declare const phpFormatCheck: Check;

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

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.phpFormatCheck = void 0;
+const utils_1 = require("../../../utils");
+const execa_1 = require("../../../utils/execa");
+const targets_1 = require("../../targets");
+const types_1 = require("../../types");
+const PHP_GLOBS = ['*.php'];
+/**
+ * Formats changed PHP files with PHP-CS-Fixer. Runner-dependency: needs
+ * `php-cs-fixer` on the runner, gracefully skipping when absent. Read-only in
+ * check mode (`--dry-run`); rewrites in place when `write`, so CI can
+ * auto-commit — mirrors the other format checks. Uses the repo's own
+ * `.php-cs-fixer.php` config when present.
+ */
+exports.phpFormatCheck = {
+    name: 'PHP CS Fixer',
+    phase: 'format',
+    applies(ctx) {
+        return ctx.config.php?.enabled !== false && ctx.languages.includes('php');
+    },
+    async run(ctx) {
+        const targets = await (0, targets_1.resolveTargetFiles)(ctx, PHP_GLOBS);
+        if (targets === null)
+            return (0, types_1.skip)('git unavailable');
+        if (targets.length === 0)
+            return (0, types_1.pass)('no PHP files changed');
+        const baseArgs = ['fix', '--using-cache=no', ...targets];
+        const dry = await (0, execa_1.execa)('php-cs-fixer', [...baseArgs, '--dry-run'], {
+            cwd: ctx.cwd,
+            reject: false,
+        });
+        if (dry.code === 'ENOENT')
+            return (0, types_1.skip)('php-cs-fixer not installed');
+        if (dry.exitCode === 0)
+            return (0, types_1.pass)();
+        if (!ctx.write) {
+            utils_1.logger.warn('[PHP CS Fixer]: ⚠️ PHP code needs formatting');
+            return (0, types_1.warn)('PHP code needs formatting (run with write to fix)');
+        }
+        const fix = await (0, execa_1.execa)('php-cs-fixer', baseArgs, { cwd: ctx.cwd, reject: false });
+        if (fix.exitCode !== 0) {
+            utils_1.logger.warn(`[PHP CS Fixer]: ⚠️ php-cs-fixer failed\n${fix.stderr}`);
+            return (0, types_1.warn)('php-cs-fixer failed to rewrite files');
+        }
+        utils_1.logger.info('[PHP CS Fixer]: ✅ Reformatted PHP code');
+        return (0, types_1.pass)('reformatted PHP code');
+    },
+};

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

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

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

@@ -6,11 +6,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.prettierCheck = 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 delta_1 = require("../../utils/delta");
-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 targets_1 = require("../../targets");
+const types_1 = require("../../types");
 function loadUserPrettierConfig(cwd) {
     const configPath = node_path_1.default.join(cwd, 'pr-checkmate.json');
     if (!node_fs_1.default.existsSync(configPath))
@@ -42,11 +42,11 @@ exports.prettierCheck = {
         return ctx.languages.includes('typescript') || ctx.languages.includes('javascript');
     },
     async run(ctx) {
-        const sourcePath = (0, config_1.getSourcePath)();
-        const changedFiles = await (0, delta_1.getChangedFiles)(['.ts', '.tsx', '.js', '.jsx', '.json', '.md']);
-        const targets = changedFiles ?? [
-            `${node_path_1.default.join(ctx.cwd, sourcePath)}/**/*.{ts,tsx,js,jsx,json,md}`,
-        ];
+        const targets = await (0, targets_1.resolveScopedTargetFiles)(ctx, ['*.ts', '*.tsx', '*.js', '*.jsx', '*.json', '*.md'], (0, config_1.getSourcePaths)());
+        if (targets === null)
+            return (0, types_1.skip)('git unavailable');
+        if (targets.length === 0)
+            return (0, types_1.pass)('no files to format');
         const projectIgnore = node_path_1.default.join(ctx.cwd, '.prettierignore');
         const gitignore = node_path_1.default.join(ctx.cwd, '.gitignore');
         let tempIgnore = null;

package/dist/core/checks/{python-format.d.ts → languages/python-format.d.ts}

@@ -1,4 +1,4 @@
-import { Check } from '../types';
+import { Check } from '../../types';
 /**
  * Formats changed Python files with Ruff's formatter (WASM, no Python/pip needed).
  * Read-only in check mode (`warn` when files differ from formatted output); rewrites

package/dist/core/checks/{python-format.js → languages/python-format.js}

@@ -6,9 +6,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.pythonFormatCheck = void 0;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
-const utils_1 = require("../../utils");
-const targets_1 = require("../targets");
-const types_1 = require("../types");
+const utils_1 = require("../../../utils");
+const targets_1 = require("../../targets");
+const types_1 = require("../../types");
 const ruff_shared_1 = require("./ruff-shared");
 /**
  * Formats changed Python files with Ruff's formatter (WASM, no Python/pip needed).

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

@@ -1,4 +1,4 @@
-import { Check } from '../types';
+import { Check } from '../../types';
 /**
  * Lints changed Python files with Ruff, bundled as a self-contained WASM module
  * (`@astral-sh/ruff-wasm-nodejs`) so it runs on a bare Node image with no Python

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

@@ -6,9 +6,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.pythonLintCheck = void 0;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
-const utils_1 = require("../../utils");
-const targets_1 = require("../targets");
-const types_1 = require("../types");
+const utils_1 = require("../../../utils");
+const targets_1 = require("../../targets");
+const types_1 = require("../../types");
 const ruff_shared_1 = require("./ruff-shared");
 /**
  * Lints changed Python files with Ruff, bundled as a self-contained WASM module