pr-checkmate 3.0.4 → 3.1.0

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

@@ -0,0 +1,105 @@
+import { getSourcePaths } from '../../../config/index.js';
+import { execa } from '../../../utils/execa.js';
+import { logger, matchesAnyGlob } from '../../../utils/index.js';
+import { resolveScopedTargetFiles } from '../../targets.js';
+import { pass, skip } from '../../types.js';
+import { severityEmitter } from '../findings.js';
+/** 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',
+];
+export const missingTestsCheck = {
+    name: 'Missing Tests',
+    phase: 'informational',
+    requiresDiff: true,
+    applies(ctx) {
+        return ctx.config.missingTests?.enabled !== false;
+    },
+    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 resolveScopedTargetFiles(ctx, ['*'], getSourcePaths(ctx.cwd));
+        if (scopedList === null)
+            return skip('git unavailable');
+        const scoped = new Set(scopedList);
+        const added = [];
+        const touched = [];
+        try {
+            const { stdout } = await 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)
+                    continue;
+                // The two halves are scoped differently on purpose.
+                //
+                // What counts as *new source needing a test* stays inside `sourcePath`,
+                // so generated or out-of-scope directories never raise the question.
+                //
+                // What counts as *evidence a test was written* must not: tests
+                // conventionally live OUTSIDE the source directory — `tests/`,
+                // `__tests__/`, `spec/` at the repository root. Scoping this side too
+                // made the check unsatisfiable in the most ordinary layout there is
+                // (`sourcePath: "src"` with tests in `tests/`): no test change was ever
+                // visible, so the warning fired on every run however many tests were
+                // added with the code. A check that cannot be satisfied teaches people
+                // to ignore it, which costs more than the check is worth.
+                if (isTestFile(file))
+                    touched.push(file);
+                if (status === 'A' && scoped.has(file))
+                    added.push(file);
+            }
+        }
+        catch (err) {
+            logger.warn(`[Missing Tests]: ⚠️ Could not analyze diff\n${err}`);
+            return skip('diff unavailable');
+        }
+        const ignore = ctx.config.missingTests?.ignore ?? DEFAULT_IGNORE;
+        const addedSource = added.filter(f => SOURCE_EXT.test(f) && !isTestFile(f) && !matchesAnyGlob(f, ignore));
+        if (addedSource.length === 0)
+            return pass(); // no new source that would need a test
+        // A test added or modified anywhere in the diff satisfies the check —
+        // `touched` only ever holds test files, collected without the source scope.
+        if (touched.length > 0)
+            return pass();
+        const sev = 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/esm/core/checks/git/todo-fixme.d.ts

@@ -0,0 +1,7 @@
+import { Check } from '../../types.js';
+/**
+ * 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/esm/core/checks/git/todo-fixme.js

@@ -0,0 +1,80 @@
+import { logger } from '../../../utils/index.js';
+import { pass, skip } from '../../types.js';
+import { bucketTotal, reportCountedFindings, reviewLines } from '../findings.js';
+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).
+ */
+export const todoFixmeCheck = {
+    name: 'TODO/FIXME',
+    phase: 'informational',
+    // No `requiresDiff`: an untracked TODO is untracked regardless of its age
+    // (ticket 067). On a legacy codebase this is exactly the inventory question.
+    applies(ctx) {
+        return (ctx.config.todoFixme?.enabled !== false &&
+            (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 = {};
+            // One failed language set fails the check: a partial answer reported as a
+            // pass says the repository is clean when half of it was never read (072).
+            let reviewed = true;
+            if (ctx.languages.includes('python')) {
+                const pattern = buildPattern('#', keywords);
+                reviewed =
+                    (await reviewLines(ctx, ['*.py'], out => scan(out, pattern, requireTicket, findings))) &&
+                        reviewed;
+            }
+            if (ctx.languages.includes('kotlin')) {
+                const ktPattern = buildPattern('//|/\\*', keywords);
+                reviewed =
+                    (await reviewLines(ctx, ['*.kt', '*.kts', '*.java'], out => scan(out, ktPattern, requireTicket, findings))) && reviewed;
+            }
+            if (!reviewed)
+                return skip('git unavailable');
+            if (bucketTotal(findings) === 0)
+                return pass();
+            return reportCountedFindings(findings, ctx, {
+                prefix: 'TODO/FIXME',
+                severity: cfg?.severity,
+                suffix: requireTicket ? ' (no ticket reference)' : '',
+            });
+        }
+        catch (err) {
+            logger.warn(`[TODO/FIXME]: ⚠️ Could not analyze diff\n${err}`);
+            return skip('diff unavailable');
+        }
+    },
+};

package/dist/esm/core/checks/languages/cpp-format.d.ts

@@ -0,0 +1,7 @@
+import { Check } from '../../types.js';
+/**
+ * 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
+ * clang install. Read-only in check mode; rewrites files in place when `write`.
+ */
+export declare const cppFormatCheck: Check;

package/dist/esm/core/checks/languages/cpp-format.js

@@ -0,0 +1,91 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { getSourcePaths } from '../../../config/index.js';
+import { execa } from '../../../utils/execa.js';
+import { logger, resolvePackageBin } from '../../../utils/index.js';
+import { resolveScopedTargetFiles } from '../../targets.js';
+import { pass, warn, skip } from '../../types.js';
+/**
+ * C/C++ source & header extensions clang-format understands. `.h` is intentionally
+ * included even though it is ambiguous with C — clang-format handles both.
+ */
+const CPP_GLOBS = ['*.c', '*.cc', '*.cpp', '*.cxx', '*.c++', '*.h', '*.hh', '*.hpp', '*.hxx'];
+const DEFAULT_STYLE = 'LLVM';
+/**
+ * Resolves the clang-format style argument. Prefers the project's own `.clang-format`
+ * (via `--style=file`) so pr-checkmate never overrides a repo's established rules;
+ * falls back to the configured style, then LLVM.
+ */
+function resolveStyleArg(ctx) {
+    if (fs.existsSync(path.join(ctx.cwd, '.clang-format'))) {
+        return '--style=file';
+    }
+    const style = ctx.config.cpp?.clangFormat?.style ?? DEFAULT_STYLE;
+    return `--style=${style}`;
+}
+/** Counts distinct files flagged in clang-format's `--dry-run --Werror` diagnostics. */
+function countOffendingFiles(stderr) {
+    const files = new Set();
+    for (const line of stderr.split('\n')) {
+        const match = line.match(/^(.+?):\d+:\d+: (?:error|warning):/);
+        if (match)
+            files.add(match[1]);
+    }
+    return files.size;
+}
+/**
+ * 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
+ * clang install. Read-only in check mode; rewrites files in place when `write`.
+ */
+export const cppFormatCheck = {
+    name: 'C++ Format',
+    phase: 'format',
+    applies(ctx) {
+        return ctx.config.cpp?.enabled !== false && ctx.languages.includes('cpp');
+    },
+    async run(ctx) {
+        // Through `targets.ts`, not `git` directly. This check used to run its own
+        // `git ls-files`, which is the one mistake the authoring guide exists to
+        // prevent: it inherits neither `ignoreDirs` nor `sourcePath`. On a real C++
+        // repository that meant 403 files including a vendored copy of OpenCV — and
+        // in `write` mode clang-format was rewriting third-party sources the client
+        // does not own. It also crashed the WASM formatter, which is how this was
+        // found.
+        const targets = await resolveScopedTargetFiles(ctx, CPP_GLOBS, getSourcePaths(ctx.cwd));
+        if (targets === null)
+            return skip('git unavailable');
+        if (targets.length === 0)
+            return pass('no C/C++ files changed');
+        const cfBin = resolvePackageBin('@wasm-fmt/clang-format', 'clang-format-cli.cjs');
+        const styleArg = resolveStyleArg(ctx);
+        // Detect unformatted files without mutating anything.
+        const dry = await execa(process.execPath, [cfBin, '--dry-run', '--Werror', styleArg, ...targets], { cwd: ctx.cwd, reject: false });
+        if (dry.exitCode === 0)
+            return pass();
+        const offending = countOffendingFiles(dry.stderr) || targets.length;
+        if (!ctx.write) {
+            logger.warn(`[C++ Format]: ⚠️ ${offending} C/C++ file(s) need formatting`);
+            return warn(`${offending} file(s) need formatting (run with write to fix)`);
+        }
+        // write mode: rewrite the offending files in place so CI can auto-commit them.
+        const fix = await execa(process.execPath, [cfBin, '-i', styleArg, ...targets], {
+            cwd: ctx.cwd,
+            reject: false,
+        });
+        if (fix.exitCode !== 0) {
+            logger.warn(`[C++ Format]: ⚠️ clang-format -i failed\n${fix.stderr}`);
+            // A WASM runtime error is the formatter giving up on a file, not a verdict
+            // about the code — and `-i` means whatever it managed before the crash is
+            // already written, so the tree is half-formatted. Saying which it was
+            // matters: "failed to rewrite files" sent people looking for a style
+            // problem that does not exist.
+            const crashed = /RuntimeError|memory access out of bounds|abort\(/.test(fix.stderr);
+            return warn(crashed
+                ? 'clang-format crashed on one of these files — some may already have been rewritten'
+                : `clang-format could not rewrite the files (exit ${fix.exitCode ?? 'killed'})`);
+        }
+        logger.info(`[C++ Format]: ✅ Reformatted ${offending} C/C++ file(s)`);
+        return pass(`reformatted ${offending} file(s)`);
+    },
+};

package/dist/esm/core/checks/languages/external-checks.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Every check that runs a linter or formatter we do not ship, as a table.
+ *
+ * The engine is in `external-runner.ts`; this file is only the data. What is
+ * genuinely per-language turns out to be four things — the binary, its
+ * arguments, the files it looks at, and how to read its output — and everything
+ * else was the same in all eleven of the modules this replaces.
+ *
+ * Keeping the entries together rather than one per file is the point: it is now
+ * possible to read what nine checks do at once, and a divergence between two of
+ * them is visible instead of two directories apart. Adding a tenth is an entry,
+ * not a file.
+ *
+ * The user-facing documentation stays per check, in
+ * `documentation/checks/languages/`, because that is organised around the reader's
+ * question ("how do I configure ktlint") rather than around ours.
+ */
+/**
+ * Lints changed Kotlin files with ktlint (style and formatting both, so it
+ * doubles as the Kotlin format signal). Uses the repo's own `.editorconfig`
+ * when present.
+ */
+export declare const kotlinLintCheck: import("../../types.js").Check;
+/**
+ * Lints Swift with SwiftLint, which needs SourceKit and therefore a macOS
+ * runner. Runs over the directory rather than a file list — SwiftLint resolves
+ * its own `.swiftlint.yml` scope, and a file list would bypass the excludes a
+ * repo wrote there — so the resolved targets only decide whether it runs at all.
+ */
+export declare const swiftLintCheck: import("../../types.js").Check;
+/**
+ * Lints changed Ruby files with RuboCop, which covers layout as well as style,
+ * so it doubles as the Ruby format signal. Uses the repo's own `.rubocop.yml`
+ * when present.
+ */
+export declare const rubyLintCheck: import("../../types.js").Check;
+/**
+ * Lints changed shell scripts with ShellCheck. `-f gcc` gives one line per
+ * finding ending in an `[SC…]` code, which both a human and the count below can
+ * read directly.
+ *
+ * No language gate: shell is not something detection reports, and a `deploy.sh`
+ * in a Python repository is exactly the file this check exists for.
+ */
+export declare const shellcheckCheck: import("../../types.js").Check;
+/**
+ * Vets changed Go code with `go vet ./...`, which needs the Go toolchain (the
+ * formatter next door no longer does — see `go-format.ts`). `go vet` operates
+ * per package, so it runs over the module rather than a file list; the delta
+ * only decides whether it runs.
+ */
+export declare const goLintCheck: import("../../types.js").Check;
+/**
+ * Lints changed Rust with Clippy. It compiles the crate, so it runs over the
+ * crate rather than a file list; the delta only decides whether it runs.
+ */
+export declare const rustLintCheck: import("../../types.js").Check;
+/**
+ * Formats changed Rust with `cargo fmt`, not a bare `rustfmt`: cargo reads the
+ * crate's edition from `Cargo.toml`, and rustfmt invoked directly does not —
+ * which silently formats 2015-edition code by 2024 rules.
+ */
+export declare const rustFormatCheck: import("../../types.js").Check;
+/**
+ * Verifies C# formatting with `dotnet format`, which also runs the project's
+ * configured analyzers and style rules. It operates on the project or solution
+ * (and expects a prior `dotnet restore`), so it runs over the whole project; the
+ * delta only decides whether it runs.
+ */
+export declare const csharpFormatCheck: import("../../types.js").Check;
+/**
+ * Formats changed PHP with PHP-CS-Fixer, using the repo's own
+ * `.php-cs-fixer.php` when present. `--using-cache=no` because the cache keys on
+ * absolute paths, and a CI checkout directory that changes between runs makes a
+ * stale cache report files as clean that were never examined.
+ */
+export declare const phpFormatCheck: import("../../types.js").Check;

package/dist/esm/core/checks/languages/external-checks.js

@@ -0,0 +1,197 @@
+import { defineExternalFormat, defineExternalLint } from './external-runner.js';
+/**
+ * Every check that runs a linter or formatter we do not ship, as a table.
+ *
+ * The engine is in `external-runner.ts`; this file is only the data. What is
+ * genuinely per-language turns out to be four things — the binary, its
+ * arguments, the files it looks at, and how to read its output — and everything
+ * else was the same in all eleven of the modules this replaces.
+ *
+ * Keeping the entries together rather than one per file is the point: it is now
+ * possible to read what nine checks do at once, and a divergence between two of
+ * them is visible instead of two directories apart. Adding a tenth is an entry,
+ * not a file.
+ *
+ * The user-facing documentation stays per check, in
+ * `documentation/checks/languages/`, because that is organised around the reader's
+ * question ("how do I configure ktlint") rather than around ours.
+ */
+// ── lint ────────────────────────────────────────────────────────────────────
+/**
+ * Lints changed Kotlin files with ktlint (style and formatting both, so it
+ * doubles as the Kotlin format signal). Uses the repo's own `.editorconfig`
+ * when present.
+ */
+export const kotlinLintCheck = defineExternalLint({
+    name: 'ktlint',
+    bin: 'ktlint',
+    tool: 'ktlint',
+    globs: ['*.kt', '*.kts'],
+    language: 'kotlin',
+    configKey: 'kotlin',
+    subject: 'Kotlin files',
+    args: (_ctx, targets) => ['--reporter=plain', ...targets],
+});
+/**
+ * Lints Swift with SwiftLint, which needs SourceKit and therefore a macOS
+ * runner. Runs over the directory rather than a file list — SwiftLint resolves
+ * its own `.swiftlint.yml` scope, and a file list would bypass the excludes a
+ * repo wrote there — so the resolved targets only decide whether it runs at all.
+ */
+export const swiftLintCheck = defineExternalLint({
+    name: 'SwiftLint',
+    bin: 'swiftlint',
+    tool: 'swiftlint',
+    globs: ['*.swift'],
+    language: 'swift',
+    configKey: 'swift',
+    subject: 'Swift files',
+    args: ctx => ['lint', '--quiet', '--path', ctx.cwd],
+    // SwiftLint's plain output carries progress and summary lines too; only the
+    // diagnostics are findings, and the two levels are worth reporting apart.
+    keep: line => line.includes(': warning:') || line.includes(': error:'),
+    summary: lines => {
+        const errors = lines.filter(line => line.includes(': error:')).length;
+        return `${errors} error(s), ${lines.length - errors} warning(s)`;
+    },
+});
+/**
+ * Lints changed Ruby files with RuboCop, which covers layout as well as style,
+ * so it doubles as the Ruby format signal. Uses the repo's own `.rubocop.yml`
+ * when present.
+ */
+export const rubyLintCheck = defineExternalLint({
+    name: 'RuboCop',
+    bin: 'rubocop',
+    tool: 'rubocop',
+    globs: ['*.rb', '*.rake'],
+    language: 'ruby',
+    configKey: 'ruby',
+    subject: 'Ruby files',
+    args: (_ctx, targets) => ['--format', 'simple', ...targets],
+    // RuboCop ends with its own count — "12 offenses detected" — which says more
+    // than a line tally of an output format that mixes offences and file headers.
+    summary: lines => lines.find(line => /offense/i.test(line))?.trim() ?? `${lines.length} line(s) of output`,
+});
+/**
+ * Lints changed shell scripts with ShellCheck. `-f gcc` gives one line per
+ * finding ending in an `[SC…]` code, which both a human and the count below can
+ * read directly.
+ *
+ * No language gate: shell is not something detection reports, and a `deploy.sh`
+ * in a Python repository is exactly the file this check exists for.
+ */
+export const shellcheckCheck = defineExternalLint({
+    name: 'ShellCheck',
+    bin: 'shellcheck',
+    tool: 'shellcheck',
+    globs: ['*.sh', '*.bash', '*.ksh'],
+    configKey: 'shellcheck',
+    subject: 'shell scripts',
+    args: (ctx, targets) => {
+        const args = ['-f', 'gcc'];
+        const { minSeverity, ignore = [] } = ctx.config.shellcheck ?? {};
+        if (minSeverity)
+            args.push('-S', minSeverity);
+        if (ignore.length > 0)
+            args.push('-e', ignore.join(','));
+        return [...args, ...targets];
+    },
+    summary: (lines, targets) => `${lines.length} issue(s) in ${targets.length} file(s)`,
+});
+/**
+ * Vets changed Go code with `go vet ./...`, which needs the Go toolchain (the
+ * formatter next door no longer does — see `go-format.ts`). `go vet` operates
+ * per package, so it runs over the module rather than a file list; the delta
+ * only decides whether it runs.
+ */
+export const goLintCheck = defineExternalLint({
+    name: 'Go Vet',
+    bin: 'go',
+    tool: 'go',
+    toolLabel: 'go',
+    globs: ['*.go'],
+    language: 'go',
+    configKey: 'go',
+    subject: 'Go files',
+    args: () => ['vet', './...'],
+    // Diagnostics and build errors both land on stderr.
+    stderrFirst: true,
+    summary: lines => `${lines.length} diagnostic line(s)`,
+});
+/**
+ * Lints changed Rust with Clippy. It compiles the crate, so it runs over the
+ * crate rather than a file list; the delta only decides whether it runs.
+ */
+export const rustLintCheck = defineExternalLint({
+    name: 'Clippy',
+    bin: 'cargo',
+    tool: 'clippy',
+    toolLabel: 'cargo/clippy',
+    globs: ['*.rs'],
+    language: 'rust',
+    configKey: 'rust',
+    subject: 'Rust files',
+    args: () => ['clippy', '--quiet', '--', '-D', 'warnings'],
+    stderrFirst: true,
+    // Clippy interleaves diagnostics with compilation progress; only the lines
+    // that carry a level are findings.
+    keep: line => /\b(warning|error)\b/.test(line),
+    summary: lines => `${lines.length} clippy diagnostic(s)`,
+});
+// ── format ──────────────────────────────────────────────────────────────────
+/**
+ * Formats changed Rust with `cargo fmt`, not a bare `rustfmt`: cargo reads the
+ * crate's edition from `Cargo.toml`, and rustfmt invoked directly does not —
+ * which silently formats 2015-edition code by 2024 rules.
+ */
+export const rustFormatCheck = defineExternalFormat({
+    name: 'Rustfmt',
+    bin: 'cargo',
+    tool: 'rustfmt',
+    toolLabel: 'cargo',
+    globs: ['*.rs'],
+    language: 'rust',
+    configKey: 'rust',
+    subject: 'Rust files',
+    code: 'Rust code',
+    checkArgs: () => ['fmt', '--check'],
+    writeArgs: () => ['fmt'],
+});
+/**
+ * Verifies C# formatting with `dotnet format`, which also runs the project's
+ * configured analyzers and style rules. It operates on the project or solution
+ * (and expects a prior `dotnet restore`), so it runs over the whole project; the
+ * delta only decides whether it runs.
+ */
+export const csharpFormatCheck = defineExternalFormat({
+    name: 'C# Format',
+    bin: 'dotnet',
+    tool: 'dotnet',
+    toolLabel: 'dotnet SDK',
+    globs: ['*.cs'],
+    language: 'csharp',
+    configKey: 'csharp',
+    subject: 'C# files',
+    code: 'C# code',
+    checkArgs: () => ['format', '--verify-no-changes'],
+    writeArgs: () => ['format'],
+});
+/**
+ * Formats changed PHP with PHP-CS-Fixer, using the repo's own
+ * `.php-cs-fixer.php` when present. `--using-cache=no` because the cache keys on
+ * absolute paths, and a CI checkout directory that changes between runs makes a
+ * stale cache report files as clean that were never examined.
+ */
+export const phpFormatCheck = defineExternalFormat({
+    name: 'PHP CS Fixer',
+    bin: 'php-cs-fixer',
+    tool: 'php-cs-fixer',
+    globs: ['*.php'],
+    language: 'php',
+    configKey: 'php',
+    subject: 'PHP files',
+    code: 'PHP code',
+    checkArgs: targets => ['fix', '--using-cache=no', ...targets, '--dry-run'],
+    writeArgs: targets => ['fix', '--using-cache=no', ...targets],
+});