pr-checkmate 3.0.4 → 3.1.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/{core → esm/core}/checks/languages/go-format.js

@@ -1,17 +1,11 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.goFormatCheck = void 0;
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const node_url_1 = require("node:url");
-const utils_1 = require("../../../utils");
-const targets_1 = require("../../targets");
-const types_1 = require("../../types");
-const tool_install_1 = require("../tool-install");
-const external_runner_1 = require("./external-runner");
+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.
@@ -35,12 +29,12 @@ const GO_GLOBS = ['*.go'];
  */
 async function loadBundledGofmt() {
     try {
-        const entry = (0, utils_1.resolvePackageBin)('@wasm-fmt/gofmt', 'gofmt_node.js');
-        const mod = (await import((0, node_url_1.pathToFileURL)(entry).href));
+        const entry = resolvePackageBin('@wasm-fmt/gofmt', 'gofmt_node.js');
+        const mod = (await import(pathToFileURL(entry).href));
         return mod.format;
     }
     catch (err) {
-        utils_1.logger.warn(`[Go Format]: ⚠️ bundled gofmt could not be loaded\n${err}`);
+        logger.warn(`[Go Format]: ⚠️ bundled gofmt could not be loaded\n${err}`);
         return null;
     }
 }
@@ -61,14 +55,14 @@ async function loadBundledGofmt() {
  */
 function verdictFor(ctx, unformatted) {
     if (unformatted.length === 0)
-        return (0, types_1.pass)();
+        return pass();
     if (!ctx.write) {
-        utils_1.logger.warn(`[Go Format]: ⚠️ ${unformatted.length} Go file(s) need formatting`);
-        unformatted.slice(0, 10).forEach(file => utils_1.logger.warn(`  ${file}`));
-        return (0, types_1.warn)(`${unformatted.length} file(s) need formatting (run with write to fix)`);
+        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)`);
     }
-    utils_1.logger.info(`[Go Format]: ✅ Reformatted ${unformatted.length} Go file(s)`);
-    return (0, types_1.pass)(`reformatted ${unformatted.length} file(s)`);
+    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.
@@ -83,7 +77,7 @@ function verdictFor(ctx, unformatted) {
  * @returns The outcome, or `null` when there is no system `gofmt` to ask.
  */
 async function formatWithSystemGofmt(ctx, targets) {
-    const list = await (0, external_runner_1.runTool)(ctx, 'gofmt', ['-l', ...targets]);
+    const list = await runTool(ctx, 'gofmt', ['-l', ...targets]);
     if (list.missing)
         return null;
     const unformatted = list.stdout.split('\n').filter(Boolean);
@@ -91,10 +85,10 @@ async function formatWithSystemGofmt(ctx, targets) {
     // having been considered at all.
     if (unformatted.length === 0 || !ctx.write)
         return verdictFor(ctx, unformatted);
-    const fix = await (0, external_runner_1.runTool)(ctx, 'gofmt', ['-w', ...unformatted]);
+    const fix = await runTool(ctx, 'gofmt', ['-w', ...unformatted]);
     if (fix.missing || fix.exitCode !== 0) {
-        utils_1.logger.warn(`[Go Format]: ⚠️ gofmt -w failed\n${fix.missing ? '' : fix.stderr}`);
-        return (0, types_1.warn)('gofmt failed to rewrite files');
+        logger.warn(`[Go Format]: ⚠️ gofmt -w failed\n${fix.missing ? '' : fix.stderr}`);
+        return warn('gofmt failed to rewrite files');
     }
     return verdictFor(ctx, unformatted);
 }
@@ -109,10 +103,10 @@ async function formatWithSystemGofmt(ctx, targets) {
 function formatWithBundledGofmt(ctx, targets, format) {
     const unformatted = [];
     for (const rel of targets) {
-        const abs = node_path_1.default.join(ctx.cwd, rel);
+        const abs = path.join(ctx.cwd, rel);
         let content;
         try {
-            content = node_fs_1.default.readFileSync(abs, 'utf-8');
+            content = fs.readFileSync(abs, 'utf-8');
         }
         catch {
             continue; // renamed or removed between the diff and the read
@@ -125,14 +119,14 @@ function formatWithBundledGofmt(ctx, targets, format) {
             // 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.
-            utils_1.logger.warn(`[Go Format]: ⚠️ could not parse ${rel} (syntax error?)\n${err}`);
+            logger.warn(`[Go Format]: ⚠️ could not parse ${rel} (syntax error?)\n${err}`);
             continue;
         }
         if (formatted === content)
             continue;
         unformatted.push(rel);
         if (ctx.write)
-            node_fs_1.default.writeFileSync(abs, formatted);
+            fs.writeFileSync(abs, formatted);
     }
     return verdictFor(ctx, unformatted);
 }
@@ -142,14 +136,14 @@ function formatWithBundledGofmt(ctx, targets, format) {
  * Read-only in check mode; rewrites in place when `write`, so CI can auto-commit
  * — mirrors the Prettier/C++/Ruff format checks.
  */
-exports.goFormatCheck = {
+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 (0, targets_1.resolveTargets)(ctx, GO_GLOBS, {
+        const targets = await resolveTargets(ctx, GO_GLOBS, {
             onEmpty: { pass: 'no Go files changed' },
         });
         if (!Array.isArray(targets))
@@ -162,8 +156,8 @@ exports.goFormatCheck = {
         // loaded, which means a partial install of this package. Installing Go is
         // the fix a client can actually act on.
         if (!format)
-            return (0, tool_install_1.notInstalled)('gofmt', 'gofmt');
-        utils_1.logger.debug('[Go Format]: no system gofmt — using the bundled WASM formatter');
+            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;

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

@@ -0,0 +1,61 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { logger } from '../../../utils/index.js';
+import { resolveTargetFiles } from '../../targets.js';
+import { pass, warn, skip } from '../../types.js';
+import { PY_GLOBS, createRuffWorkspace } from './ruff-shared.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 const pythonFormatCheck = {
+    name: 'Ruff Format',
+    phase: 'format',
+    applies(ctx) {
+        return (ctx.config.python?.enabled !== false &&
+            ctx.config.python?.ruff?.format !== false &&
+            ctx.languages.includes('python'));
+    },
+    async run(ctx) {
+        const targets = await resolveTargetFiles(ctx, PY_GLOBS);
+        if (targets === null)
+            return skip('git unavailable');
+        if (targets.length === 0)
+            return pass('no Python files changed');
+        const workspace = createRuffWorkspace();
+        let unformatted = 0;
+        for (const rel of targets) {
+            const abs = path.join(ctx.cwd, rel);
+            let content;
+            try {
+                content = fs.readFileSync(abs, 'utf-8');
+            }
+            catch {
+                continue; // renamed/removed between diff and read — skip
+            }
+            let formatted;
+            try {
+                formatted = workspace.format(content);
+            }
+            catch (err) {
+                // A syntax error makes Ruff throw — that's a lint concern, not a format failure.
+                logger.warn(`[Ruff Format]: ⚠️ Could not format ${rel} (syntax error?)\n${err}`);
+                continue;
+            }
+            if (formatted === content)
+                continue;
+            unformatted += 1;
+            if (ctx.write)
+                fs.writeFileSync(abs, formatted);
+        }
+        if (unformatted === 0)
+            return pass();
+        if (!ctx.write) {
+            logger.warn(`[Ruff Format]: ⚠️ ${unformatted} Python file(s) need formatting`);
+            return warn(`${unformatted} file(s) need formatting (run with write to fix)`);
+        }
+        logger.info(`[Ruff Format]: ✅ Reformatted ${unformatted} Python file(s)`);
+        return pass(`reformatted ${unformatted} file(s)`);
+    },
+};