pr-checkmate 3.0.4 → 3.2.0

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

@@ -0,0 +1,119 @@
+import { Check, CheckContext, type Language } from '../../types.js';
+import { type ExternalTool } from '../tool-install.js';
+/**
+ * The one shape every check that shells out to somebody else's linter has.
+ *
+ * Eleven of these were written by copying a neighbour, and copying is what they
+ * had in common: `resolveTargetFiles` → `execa` → the same seven-line comment
+ * about `ENOENT` → split the output → log ten lines and a "… and N more". Of the
+ * ~600 lines that produced, about sixty said anything specific to a language.
+ *
+ * The cost of that was not the duplication. It was that each copy diverged
+ * slightly, so a fix landed in one of eleven places: the `git unavailable` skip
+ * was missing from some, the ten-line truncation counted differently in others,
+ * and `⏭️ ktlint: ktlint not installed` outlived four rewrites of the message it
+ * was supposed to match. Behaviour that is meant to be identical everywhere
+ * belongs in one function; what is genuinely per-language belongs in a table.
+ *
+ * Two factories rather than one, because a linter and a formatter differ in the
+ * only part that matters — a linter reads output, a formatter runs twice and may
+ * write. Folding them together would mean a spec with half its fields unused.
+ */
+/**
+ * Config blocks that gate a language check with `enabled: false`.
+ *
+ * Named as a union rather than typed as `keyof PRCheckMateConfig` so a spec
+ * cannot point at `reporter` or `install` and typecheck.
+ */
+type LanguageConfigKey = 'csharp' | 'go' | 'kotlin' | 'php' | 'ruby' | 'rust' | 'shellcheck' | 'swift';
+/**
+ * A finished tool run, with "the tool is not here" as a case of its own rather
+ * than an exception.
+ */
+type ToolRun = {
+    missing: true;
+} | {
+    missing: false;
+    exitCode: number | undefined;
+    stdout: string;
+    stderr: string;
+};
+/**
+ * Run an external tool, telling an absent binary apart from a failing one.
+ *
+ * execa v9 with `reject: false` does NOT throw on a missing binary — it resolves
+ * with `code: 'ENOENT'`. Detecting that on the result rather than in a
+ * `try`/`catch` (which never fires here) is the difference between an honest skip
+ * and a missing linter reporting a clean pass. This comment used to be repeated
+ * verbatim in eleven files, which is roughly how long it takes for one of the
+ * copies to lose it.
+ */
+export declare function runTool(ctx: CheckContext, bin: string, args: string[]): Promise<ToolRun>;
+/** The fields both factories read; each adds the part that differs. */
+interface ExternalSpecBase {
+    /** Display name — the report row, and the log prefix. */
+    name: string;
+    /** The binary to run. */
+    bin: string;
+    /** Key into the install-hint table, so the skip says how to fix itself. */
+    tool: ExternalTool;
+    /**
+     * How to name the tool in the skip. Omit when the check's own name already is
+     * the binary's name, or the message stutters (`ktlint: ktlint not installed`).
+     */
+    toolLabel?: string;
+    /** Pathspecs the check operates on, e.g. `['*.kt', '*.kts']`. */
+    globs: string[];
+    /**
+     * Language gate. Omit for a check that applies to any repository — ShellCheck
+     * runs wherever there is a `.sh`, and shell is not a detected language.
+     */
+    language?: Language;
+    /** Config block whose `enabled: false` switches the check off. */
+    configKey: LanguageConfigKey;
+    /** Plural noun for the nothing-to-do pass: `no Kotlin files changed`. */
+    subject: string;
+}
+/** A check that runs somebody else's linter and reports what it said. */
+export interface ExternalLintSpec extends ExternalSpecBase {
+    /**
+     * Arguments for the run. Given `ctx` as well as the files because not every
+     * linter takes a file list — `go vet` works per package and SwiftLint per
+     * directory, and for those the resolved targets only decide whether to run.
+     */
+    args(ctx: CheckContext, targets: string[]): string[];
+    /** Which output lines are findings. Default: every non-blank line. */
+    keep?(line: string): boolean;
+    /** How to phrase the count. Default: `N issue(s)`. */
+    summary?(lines: string[], targets: string[]): string;
+    /** Read stderr ahead of stdout, for tools that diagnose there. */
+    stderrFirst?: boolean;
+}
+/** A check that runs somebody else's formatter, read-only unless `write`. */
+export interface ExternalFormatSpec extends ExternalSpecBase {
+    /** Singular noun for the verdicts: `PHP code needs formatting`. */
+    code: string;
+    /** Arguments for the read-only pass. */
+    checkArgs(targets: string[]): string[];
+    /** Arguments for the pass that rewrites files. */
+    writeArgs(targets: string[]): string[];
+}
+/**
+ * Build an informational lint check from its spec.
+ *
+ * Informational for all of them, and not a field: these checks depend on a tool
+ * we do not ship, so on a runner without it they cannot distinguish clean code
+ * from unexamined code. A gate that silently stops gating is worse than no gate,
+ * and a client who wants one promotes the check with `severity`.
+ */
+export declare function defineExternalLint(spec: ExternalLintSpec): Check;
+/**
+ * Build a format check from its spec: detect, then rewrite only when asked.
+ *
+ * The two passes are deliberate. A check run must never change the tree unless
+ * the caller said `write`, and in `write` mode CI needs the files actually
+ * rewritten so it can commit them — so the read-only pass is the one that decides
+ * the verdict, and the second only carries it out.
+ */
+export declare function defineExternalFormat(spec: ExternalFormatSpec): Check;
+export {};

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

@@ -0,0 +1,138 @@
+import { execa } from '../../../utils/execa.js';
+import { logger } from '../../../utils/index.js';
+import { resolveTargets } from '../../targets.js';
+import { pass, warn, } from '../../types.js';
+import { logSample } from '../findings.js';
+import { notInstalled } from '../tool-install.js';
+/**
+ * Run an external tool, telling an absent binary apart from a failing one.
+ *
+ * execa v9 with `reject: false` does NOT throw on a missing binary — it resolves
+ * with `code: 'ENOENT'`. Detecting that on the result rather than in a
+ * `try`/`catch` (which never fires here) is the difference between an honest skip
+ * and a missing linter reporting a clean pass. This comment used to be repeated
+ * verbatim in eleven files, which is roughly how long it takes for one of the
+ * copies to lose it.
+ */
+export async function runTool(ctx, bin, args) {
+    const result = await execa(bin, args, { cwd: ctx.cwd, reject: false });
+    if (result.code === 'ENOENT')
+        return { missing: true };
+    return {
+        missing: false,
+        exitCode: result.exitCode,
+        stdout: result.stdout,
+        stderr: result.stderr,
+    };
+}
+/** Both streams as one blob — some tools diagnose on stdout, some on stderr. */
+function combinedOutput(run, stderrFirst) {
+    const streams = stderrFirst ? [run.stderr, run.stdout] : [run.stdout, run.stderr];
+    return streams.filter(Boolean).join('\n').trim();
+}
+/** Every non-blank line is a finding, unless a spec says otherwise. */
+function isNotBlank(line) {
+    return line.trim().length > 0;
+}
+/** `N issue(s)`, unless a spec phrases its count differently. */
+function countIssues(lines) {
+    return `${lines.length} issue(s)`;
+}
+/** Whether a language check is switched on for this repository. */
+function isEnabled(ctx, key, language) {
+    if (ctx.config[key]?.enabled === false)
+        return false;
+    return language === undefined || ctx.languages.includes(language);
+}
+/**
+ * Assemble the `Check` both factories return, given the part that differs.
+ *
+ * Everything here is identical between a linter and a formatter — the name, the
+ * `applies` gate, and resolving the files — and only `phase` and `work` are not.
+ * Kept as a third function rather than merged into one factory with a flag,
+ * because the two specs are genuinely different shapes: a linter reads output, a
+ * formatter runs twice and may write. One factory would mean a spec with half its
+ * fields unused, which is the trade this file's header argues against.
+ */
+function defineExternal(spec, phase, work) {
+    return {
+        name: spec.name,
+        phase,
+        applies(ctx) {
+            return isEnabled(ctx, spec.configKey, spec.language);
+        },
+        async run(ctx) {
+            const targets = await resolveTargets(ctx, spec.globs, {
+                onEmpty: { pass: `no ${spec.subject} changed` },
+            });
+            if (!Array.isArray(targets))
+                return targets;
+            return work(ctx, targets);
+        },
+    };
+}
+/**
+ * Build an informational lint check from its spec.
+ *
+ * Informational for all of them, and not a field: these checks depend on a tool
+ * we do not ship, so on a runner without it they cannot distinguish clean code
+ * from unexamined code. A gate that silently stops gating is worse than no gate,
+ * and a client who wants one promotes the check with `severity`.
+ */
+export function defineExternalLint(spec) {
+    return defineExternal(spec, 'informational', async (ctx, targets) => {
+        const run = await runTool(ctx, spec.bin, spec.args(ctx, targets));
+        if (run.missing)
+            return notInstalled(spec.tool, spec.toolLabel);
+        const output = combinedOutput(run, spec.stderrFirst);
+        // Exit 0 is the tool's verdict. Empty output on a non-zero exit is a tool
+        // that objected without saying to what, and there is nothing to put in a
+        // report either way — so both are a pass rather than a warn reading
+        // "0 issue(s)".
+        if (run.exitCode === 0 || !output) {
+            logger.info(`[${spec.name}]: ✅ No issues found`);
+            return pass();
+        }
+        const lines = output.split('\n').filter(spec.keep ?? isNotBlank);
+        // The tool objected and none of its output matched what this check knows how
+        // to read — a build error ahead of the lint pass, usually. Naming the exit
+        // code is thin, but a clean pass over an objection is a lie.
+        const summary = lines.length > 0
+            ? (spec.summary ?? countIssues)(lines, targets)
+            : `${spec.bin} exited ${run.exitCode ?? 'without a code'} with no readable diagnostics`;
+        logSample(spec.name, `${summary}:`, lines);
+        return warn(summary);
+    });
+}
+/**
+ * Build a format check from its spec: detect, then rewrite only when asked.
+ *
+ * The two passes are deliberate. A check run must never change the tree unless
+ * the caller said `write`, and in `write` mode CI needs the files actually
+ * rewritten so it can commit them — so the read-only pass is the one that decides
+ * the verdict, and the second only carries it out.
+ */
+export function defineExternalFormat(spec) {
+    return defineExternal(spec, 'format', async (ctx, targets) => {
+        const dry = await runTool(ctx, spec.bin, spec.checkArgs(targets));
+        if (dry.missing)
+            return notInstalled(spec.tool, spec.toolLabel);
+        if (dry.exitCode === 0)
+            return pass();
+        if (!ctx.write) {
+            logger.warn(`[${spec.name}]: ⚠️ ${spec.code} needs formatting`);
+            return warn(`${spec.code} needs formatting (run with write to fix)`);
+        }
+        const fix = await runTool(ctx, spec.bin, spec.writeArgs(targets));
+        // `missing` cannot happen here — the same binary answered a moment ago — but
+        // it is a case of the type, and collapsing it into the failure branch is both
+        // correct and shorter than asserting it away.
+        if (fix.missing || fix.exitCode !== 0) {
+            const detail = fix.missing ? '' : `\n${fix.stderr}`;
+            logger.warn(`[${spec.name}]: ⚠️ ${spec.bin} failed to rewrite files${detail}`);
+            return warn(`${spec.bin} failed to rewrite files`);
+        }
+        logger.info(`[${spec.name}]: ✅ Reformatted ${spec.code}`);
+        return pass(`reformatted ${spec.code}`);
+    });
+}

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

@@ -0,0 +1,8 @@
+import { Check } from '../../types.js';
+/**
+ * Formats changed Go files with gofmt — the runner's own when it has one, and a
+ * bundled WASM build otherwise, so the check has no runner dependency at all.
+ * Read-only in check mode; rewrites in place when `write`, so CI can auto-commit
+ * — mirrors the Prettier/C++/Ruff format checks.
+ */
+export declare const goFormatCheck: Check;

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

@@ -0,0 +1,163 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { logger, resolvePackageBin } from '../../../utils/index.js';
+import { resolveTargets } from '../../targets.js';
+import { pass, warn } from '../../types.js';
+import { notInstalled } from '../tool-install.js';
+import { runTool } from './external-runner.js';
+const GO_GLOBS = ['*.go'];
+/**
+ * Load the bundled WASM gofmt, or explain why it could not be loaded.
+ *
+ * This is what stopped `⏭️ Go Format: gofmt not installed` from being the answer
+ * on every runner without a Go toolchain — a ~285 KB WASM build of gofmt does
+ * the same job with nothing to install, the same way Ruff covers Python and
+ * clang-format covers C++.
+ *
+ * Three details, each of which was a way to get this wrong:
+ *
+ * - **Resolved through `resolvePackageBin`, not a bare specifier.** The package
+ *   may live in a fetched profile directory rather than in our own tree, and only
+ *   the resolver knows about those. A bare `import('@wasm-fmt/gofmt')` resolves
+ *   relative to this file and would miss it.
+ * - **`gofmt_node.js` explicitly**, because the package's `exports` map routes
+ *   `.` per runtime and the node entry is the one that reads the `.wasm` off disk.
+ * - **A dynamic `import()`.** The package is ESM and we emit CommonJS;
+ *   `require` cannot load it, and TypeScript preserves dynamic `import()` in CJS
+ *   output under `module: NodeNext` precisely so this works.
+ */
+async function loadBundledGofmt() {
+    try {
+        const entry = resolvePackageBin('@wasm-fmt/gofmt', 'gofmt_node.js');
+        const mod = (await import(pathToFileURL(entry).href));
+        return mod.format;
+    }
+    catch (err) {
+        logger.warn(`[Go Format]: ⚠️ bundled gofmt could not be loaded\n${err}`);
+        return null;
+    }
+}
+/**
+ * The verdict, given the files that turned out to need formatting.
+ *
+ * Shared by both routes on purpose. It was written out twice — once after
+ * `gofmt -l` and once after the in-memory comparison — and the two copies are how
+ * the wording of a verdict comes to depend on whether Go happens to be installed
+ * on the runner (ticket 079). What a client is told about their code must not be a
+ * function of our own resolution order.
+ *
+ * Called only once the rewriting, if any, is done — so reaching the last branch
+ * means the files really were rewritten and CI has something to commit. The
+ * routes differ in when that happens (the system route shells out to `gofmt -w`,
+ * the bundled one wrote each file as it went) and in nothing this function can
+ * see.
+ */
+function verdictFor(ctx, unformatted) {
+    if (unformatted.length === 0)
+        return pass();
+    if (!ctx.write) {
+        logger.warn(`[Go Format]: ⚠️ ${unformatted.length} Go file(s) need formatting`);
+        unformatted.slice(0, 10).forEach(file => logger.warn(`  ${file}`));
+        return warn(`${unformatted.length} file(s) need formatting (run with write to fix)`);
+    }
+    logger.info(`[Go Format]: ✅ Reformatted ${unformatted.length} Go file(s)`);
+    return pass(`reformatted ${unformatted.length} file(s)`);
+}
+/**
+ * Format with the runner's own `gofmt`, when it has one.
+ *
+ * Tried ahead of the bundled copy on purpose, and it is the same policy as
+ * preferring a repo's `.clang-format` or its own ESLint: gofmt's output is a
+ * function of the Go release, and the one release we know a repository agrees
+ * with is the one installed beside it. Reaching for ours first would mean
+ * rewriting a Go 1.18 tree by current rules in `write` mode — us and their CI
+ * reformatting the same files in opposite directions.
+ *
+ * @returns The outcome, or `null` when there is no system `gofmt` to ask.
+ */
+async function formatWithSystemGofmt(ctx, targets) {
+    const list = await runTool(ctx, 'gofmt', ['-l', ...targets]);
+    if (list.missing)
+        return null;
+    const unformatted = list.stdout.split('\n').filter(Boolean);
+    // Decided before the rewrite, so a read-only run answers without `gofmt -w`
+    // having been considered at all.
+    if (unformatted.length === 0 || !ctx.write)
+        return verdictFor(ctx, unformatted);
+    const fix = await runTool(ctx, 'gofmt', ['-w', ...unformatted]);
+    if (fix.missing || fix.exitCode !== 0) {
+        logger.warn(`[Go Format]: ⚠️ gofmt -w failed\n${fix.missing ? '' : fix.stderr}`);
+        return warn('gofmt failed to rewrite files');
+    }
+    return verdictFor(ctx, unformatted);
+}
+/**
+ * Format in-process with the bundled WASM gofmt — the route taken on a runner
+ * with no Go toolchain, which is most of them.
+ *
+ * Compares rather than trusting an exit code, because the WASM build is a
+ * library and not a CLI: it formats a string and says nothing about whether it
+ * changed anything. Mirrors the Ruff format check for that reason.
+ */
+function formatWithBundledGofmt(ctx, targets, format) {
+    const unformatted = [];
+    for (const rel of targets) {
+        const abs = path.join(ctx.cwd, rel);
+        let content;
+        try {
+            content = fs.readFileSync(abs, 'utf-8');
+        }
+        catch {
+            continue; // renamed or removed between the diff and the read
+        }
+        let formatted;
+        try {
+            formatted = format(content);
+        }
+        catch (err) {
+            // gofmt parses before it formats, so a throw here is a syntax error. That
+            // is Go Vet's finding to report, not a formatting verdict — and calling it
+            // one sends people looking for a style problem that does not exist.
+            logger.warn(`[Go Format]: ⚠️ could not parse ${rel} (syntax error?)\n${err}`);
+            continue;
+        }
+        if (formatted === content)
+            continue;
+        unformatted.push(rel);
+        if (ctx.write)
+            fs.writeFileSync(abs, formatted);
+    }
+    return verdictFor(ctx, unformatted);
+}
+/**
+ * Formats changed Go files with gofmt — the runner's own when it has one, and a
+ * bundled WASM build otherwise, so the check has no runner dependency at all.
+ * Read-only in check mode; rewrites in place when `write`, so CI can auto-commit
+ * — mirrors the Prettier/C++/Ruff format checks.
+ */
+export const goFormatCheck = {
+    name: 'Go Format',
+    phase: 'format',
+    applies(ctx) {
+        return ctx.config.go?.enabled !== false && ctx.languages.includes('go');
+    },
+    async run(ctx) {
+        const targets = await resolveTargets(ctx, GO_GLOBS, {
+            onEmpty: { pass: 'no Go files changed' },
+        });
+        if (!Array.isArray(targets))
+            return targets;
+        const viaSystem = await formatWithSystemGofmt(ctx, targets);
+        if (viaSystem)
+            return viaSystem;
+        const format = await loadBundledGofmt();
+        // Neither route: no Go toolchain on the runner AND our own copy could not be
+        // loaded, which means a partial install of this package. Installing Go is
+        // the fix a client can actually act on.
+        if (!format)
+            return notInstalled('gofmt', 'gofmt');
+        logger.debug('[Go Format]: no system gofmt — using the bundled WASM formatter');
+        return formatWithBundledGofmt(ctx, targets, format);
+    },
+};

package/dist/esm/core/checks/languages/lint.d.ts

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

package/dist/esm/core/checks/languages/lint.js

@@ -0,0 +1,92 @@
+import { hasLocalConfig, getSourcePaths, getPackageConfigPath, IGNORE_PATTERNS, } from '../../../config/index.js';
+import { execa } from '../../../utils/execa.js';
+import { logger, resolvePackageBin } from '../../../utils/index.js';
+import { clientToolPaths } from '../../install/reuse.js';
+import { resolveScopedTargetFiles } from '../../targets.js';
+import { pass, fail, warn, skip } from '../../types.js';
+/**
+ * Resolve the ESLint binary under the client's `install.reuseLocal` policy.
+ *
+ * A repo pinned to ESLint 8 with a legacy `.eslintrc.*` must run ITS ESLint —
+ * ours does not read eslintrc — so when the client owns the config the version is
+ * not asked about. When the config is the flat one WE generate, it is: ESLint 8
+ * cannot read it, and reusing their copy there produced a failure about our
+ * configuration rather than about their code. That asymmetry is the whole reason
+ * `clientOwnsConfig` exists (ticket 064, lever A).
+ */
+function resolveESLintBin(ctx, clientOwnsConfig) {
+    return resolvePackageBin('eslint', 'bin/eslint.js', {
+        paths: clientToolPaths('eslint', ctx, { clientOwnsConfig }),
+    });
+}
+async function getESLintMajorVersion(eslintBin) {
+    try {
+        const { stdout } = await execa(process.execPath, [eslintBin, '--version']);
+        const match = stdout.match(/v?(\d+)\./);
+        return match ? parseInt(match[1], 10) : 8;
+    }
+    catch {
+        return 8;
+    }
+}
+export const lintCheck = {
+    name: 'ESLint',
+    phase: 'blocking',
+    applies(ctx) {
+        return ctx.languages.includes('typescript') || ctx.languages.includes('javascript');
+    },
+    async run(ctx) {
+        const targets = await resolveScopedTargetFiles(ctx, ['*.ts', '*.tsx', '*.js', '*.jsx'], getSourcePaths(ctx.cwd));
+        if (targets === null)
+            return skip('git unavailable');
+        if (targets.length === 0)
+            return pass('no TypeScript/JavaScript files to lint');
+        // Whose config decides whose binary, so this is read BEFORE resolving one.
+        // It used to be the other way round, which is how a client's ESLint 8 ended
+        // up pointed at the flat config we generate.
+        const hasLocal = hasLocalConfig(['eslint.config.mjs', 'eslint.config.js', '.eslintrc.js', '.eslintrc.json', '.eslintrc'], ctx.cwd);
+        const eslintBin = resolveESLintBin(ctx, hasLocal);
+        const version = await getESLintMajorVersion(eslintBin);
+        const args = [...targets];
+        // `--ext` is an eslintrc-only flag. Under flat config (ESLint 9+) it is
+        // obsolete — extensions come from the config's `files` glob — and in
+        // ESLint 10 passing it makes explicit files fall back to the default JS
+        // parser, breaking TypeScript linting. Only pass it on the legacy path.
+        if (version < 9)
+            args.push('--ext', '.ts,.tsx,.js,.jsx');
+        // Files are named explicitly, so any of them that the config ignores produces a
+        // "File ignored because of a matching ignore pattern" warning. That is a fact
+        // about the config, not about the client's code, and a whole-repo run surfaces
+        // one per ignored-but-tracked file (`.eslintrc.js`, generated sources). The flag
+        // suppresses the warning only — nothing changes about which files are linted.
+        if (version >= 9)
+            args.push('--no-warn-ignored');
+        // Only auto-fix when the caller allows file mutations.
+        if (ctx.write)
+            args.push('--fix');
+        if (hasLocal) {
+            logger.info(`[ESLint]: Using local config (${targets.length} file(s))`);
+        }
+        else {
+            const configFile = version >= 9 ? 'eslint.config.mjs' : '.eslintrc.js';
+            args.push('--config', getPackageConfigPath(configFile));
+            logger.info(`[ESLint]: Using pr-checkmate config (ESLint v${version}, ${configFile})`);
+        }
+        IGNORE_PATTERNS.forEach(p => args.push('--ignore-pattern', p));
+        const result = await execa(process.execPath, [eslintBin, ...args], {
+            cwd: ctx.cwd,
+            stdio: 'inherit',
+            reject: false,
+        });
+        if (result.exitCode === 0)
+            return pass();
+        // ESLint exits 1 for lint errors and 2 for a fatal error — a config it cannot
+        // load, an unresolvable plugin, a parser it cannot construct. Only the
+        // former is the client's code. Treating exit 2 as "lint errors found" turned
+        // a config incompatibility (often between our bundled config and the client's
+        // toolchain) into a red gate on their PR, and named the wrong cause.
+        if (result.exitCode === 1)
+            return fail('lint errors found');
+        return warn(`eslint failed to run (exit ${result.exitCode ?? 'killed'})${hasLocal ? '' : ' — using the pr-checkmate config'}`);
+    },
+};

package/dist/esm/core/checks/languages/prettier.d.ts

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

package/dist/esm/core/checks/languages/prettier.js

@@ -0,0 +1,85 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { getPackageConfigPath, hasLocalConfig, IGNORE_PATTERNS, getSourcePaths, } from '../../../config/index.js';
+import { execa } from '../../../utils/execa.js';
+import { logger, cleanupTempFile, resolvePackageBin } from '../../../utils/index.js';
+import { resolveScopedTargetFiles } from '../../targets.js';
+import { pass, warn, skip } from '../../types.js';
+function loadUserPrettierConfig(cwd) {
+    const configPath = path.join(cwd, 'pr-checkmate.json');
+    if (!fs.existsSync(configPath))
+        return {};
+    try {
+        return JSON.parse(fs.readFileSync(configPath, 'utf-8')).prettier?.rules || {};
+    }
+    catch (err) {
+        logger.warn(`[Prettier]: ⚠️ Failed to read prettier config: ${err}`);
+        return {};
+    }
+}
+function createTempPrettierConfig(cwd) {
+    const defaultConfig = JSON.parse(fs.readFileSync(getPackageConfigPath('.prettierrc'), 'utf-8'));
+    const merged = { ...defaultConfig, ...loadUserPrettierConfig(cwd) };
+    const tempConfigPath = path.join(cwd, '.prettierrc.temp.json');
+    fs.writeFileSync(tempConfigPath, JSON.stringify(merged, null, 2));
+    return tempConfigPath;
+}
+function createTempIgnoreFile(cwd) {
+    const file = path.join(cwd, '.prettierignore.temp');
+    fs.writeFileSync(file, IGNORE_PATTERNS.join('\n'), 'utf-8');
+    return file;
+}
+export const prettierCheck = {
+    name: 'Prettier',
+    phase: 'format',
+    applies(ctx) {
+        return ctx.languages.includes('typescript') || ctx.languages.includes('javascript');
+    },
+    async run(ctx) {
+        const targets = await resolveScopedTargetFiles(ctx, ['*.ts', '*.tsx', '*.js', '*.jsx', '*.json', '*.md'], getSourcePaths(ctx.cwd));
+        if (targets === null)
+            return skip('git unavailable');
+        if (targets.length === 0)
+            return pass('no files to format');
+        const projectIgnore = path.join(ctx.cwd, '.prettierignore');
+        const gitignore = path.join(ctx.cwd, '.gitignore');
+        let tempIgnore = null;
+        let ignorePath;
+        if (fs.existsSync(projectIgnore))
+            ignorePath = projectIgnore;
+        else if (fs.existsSync(gitignore))
+            ignorePath = gitignore;
+        else
+            ignorePath = tempIgnore = createTempIgnoreFile(ctx.cwd);
+        const hasLocal = hasLocalConfig(['.prettierrc', '.prettierrc.json', '.prettierrc.js', 'prettier.config.js'], ctx.cwd);
+        // write=true → format in place; write=false → report-only (`--check`, never mutates files).
+        const mode = ctx.write ? '--write' : '--check';
+        let tempConfig = null;
+        let args;
+        if (hasLocal) {
+            args = [mode, ...targets, '--ignore-path', ignorePath];
+        }
+        else {
+            tempConfig = createTempPrettierConfig(ctx.cwd);
+            args = [mode, ...targets, '--config', tempConfig, '--ignore-path', ignorePath];
+        }
+        const prettierBin = resolvePackageBin('prettier', 'bin/prettier.cjs');
+        try {
+            const result = await execa(process.execPath, [prettierBin, ...args], {
+                cwd: ctx.cwd,
+                stdio: 'inherit',
+                reject: false,
+            });
+            if (result.exitCode === 0)
+                return pass();
+            // In --check mode a non-zero exit means "some files are not formatted".
+            return warn(ctx.write ? 'prettier failed' : 'unformatted files (run with write to fix)');
+        }
+        finally {
+            if (tempIgnore)
+                cleanupTempFile(tempIgnore);
+            if (tempConfig)
+                cleanupTempFile(tempConfig);
+        }
+    },
+};

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

@@ -0,0 +1,7 @@
+import { Check } from '../../types.js';
+/**
+ * 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
+ * files in place when `write` so CI can auto-commit — mirrors the Prettier/C++ checks.
+ */
+export declare const pythonFormatCheck: Check;