pr-checkmate 3.0.4 → 3.1.0

package/dist/{core → cjs/core}/checks/languages/external-checks.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.phpFormatCheck = exports.csharpFormatCheck = exports.rustFormatCheck = exports.rustLintCheck = exports.goLintCheck = exports.shellcheckCheck = exports.rubyLintCheck = exports.swiftLintCheck = exports.kotlinLintCheck = void 0;
-const external_runner_1 = require("./external-runner");
+const external_runner_js_1 = require("./external-runner.js");
 /**
  * Every check that runs a linter or formatter we do not ship, as a table.
  *
@@ -25,7 +25,7 @@ const external_runner_1 = require("./external-runner");
  * doubles as the Kotlin format signal). Uses the repo's own `.editorconfig`
  * when present.
  */
-exports.kotlinLintCheck = (0, external_runner_1.defineExternalLint)({
+exports.kotlinLintCheck = (0, external_runner_js_1.defineExternalLint)({
     name: 'ktlint',
     bin: 'ktlint',
     tool: 'ktlint',
@@ -41,7 +41,7 @@ exports.kotlinLintCheck = (0, external_runner_1.defineExternalLint)({
  * 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.
  */
-exports.swiftLintCheck = (0, external_runner_1.defineExternalLint)({
+exports.swiftLintCheck = (0, external_runner_js_1.defineExternalLint)({
     name: 'SwiftLint',
     bin: 'swiftlint',
     tool: 'swiftlint',
@@ -63,7 +63,7 @@ exports.swiftLintCheck = (0, external_runner_1.defineExternalLint)({
  * so it doubles as the Ruby format signal. Uses the repo's own `.rubocop.yml`
  * when present.
  */
-exports.rubyLintCheck = (0, external_runner_1.defineExternalLint)({
+exports.rubyLintCheck = (0, external_runner_js_1.defineExternalLint)({
     name: 'RuboCop',
     bin: 'rubocop',
     tool: 'rubocop',
@@ -84,7 +84,7 @@ exports.rubyLintCheck = (0, external_runner_1.defineExternalLint)({
  * 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.
  */
-exports.shellcheckCheck = (0, external_runner_1.defineExternalLint)({
+exports.shellcheckCheck = (0, external_runner_js_1.defineExternalLint)({
     name: 'ShellCheck',
     bin: 'shellcheck',
     tool: 'shellcheck',
@@ -108,7 +108,7 @@ exports.shellcheckCheck = (0, external_runner_1.defineExternalLint)({
  * per package, so it runs over the module rather than a file list; the delta
  * only decides whether it runs.
  */
-exports.goLintCheck = (0, external_runner_1.defineExternalLint)({
+exports.goLintCheck = (0, external_runner_js_1.defineExternalLint)({
     name: 'Go Vet',
     bin: 'go',
     tool: 'go',
@@ -126,7 +126,7 @@ exports.goLintCheck = (0, external_runner_1.defineExternalLint)({
  * 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.
  */
-exports.rustLintCheck = (0, external_runner_1.defineExternalLint)({
+exports.rustLintCheck = (0, external_runner_js_1.defineExternalLint)({
     name: 'Clippy',
     bin: 'cargo',
     tool: 'clippy',
@@ -148,7 +148,7 @@ exports.rustLintCheck = (0, external_runner_1.defineExternalLint)({
  * crate's edition from `Cargo.toml`, and rustfmt invoked directly does not —
  * which silently formats 2015-edition code by 2024 rules.
  */
-exports.rustFormatCheck = (0, external_runner_1.defineExternalFormat)({
+exports.rustFormatCheck = (0, external_runner_js_1.defineExternalFormat)({
     name: 'Rustfmt',
     bin: 'cargo',
     tool: 'rustfmt',
@@ -167,7 +167,7 @@ exports.rustFormatCheck = (0, external_runner_1.defineExternalFormat)({
  * (and expects a prior `dotnet restore`), so it runs over the whole project; the
  * delta only decides whether it runs.
  */
-exports.csharpFormatCheck = (0, external_runner_1.defineExternalFormat)({
+exports.csharpFormatCheck = (0, external_runner_js_1.defineExternalFormat)({
     name: 'C# Format',
     bin: 'dotnet',
     tool: 'dotnet',
@@ -186,7 +186,7 @@ exports.csharpFormatCheck = (0, external_runner_1.defineExternalFormat)({
  * absolute paths, and a CI checkout directory that changes between runs makes a
  * stale cache report files as clean that were never examined.
  */
-exports.phpFormatCheck = (0, external_runner_1.defineExternalFormat)({
+exports.phpFormatCheck = (0, external_runner_js_1.defineExternalFormat)({
     name: 'PHP CS Fixer',
     bin: 'php-cs-fixer',
     tool: 'php-cs-fixer',

package/dist/{core → cjs/core}/checks/languages/external-runner.d.ts

@@ -1,5 +1,5 @@
-import { Check, CheckContext, type Language } from '../../types';
-import { type ExternalTool } from '../tool-install';
+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.
  *

package/dist/{core → cjs/core}/checks/languages/external-runner.js

@@ -3,12 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.runTool = runTool;
 exports.defineExternalLint = defineExternalLint;
 exports.defineExternalFormat = defineExternalFormat;
-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");
-const tool_install_1 = require("../tool-install");
+const execa_js_1 = require("../../../utils/execa.js");
+const index_js_1 = require("../../../utils/index.js");
+const targets_js_1 = require("../../targets.js");
+const types_js_1 = require("../../types.js");
+const findings_js_1 = require("../findings.js");
+const tool_install_js_1 = require("../tool-install.js");
 /**
  * Run an external tool, telling an absent binary apart from a failing one.
  *
@@ -20,7 +20,7 @@ const tool_install_1 = require("../tool-install");
  * copies to lose it.
  */
 async function runTool(ctx, bin, args) {
-    const result = await (0, execa_1.execa)(bin, args, { cwd: ctx.cwd, reject: false });
+    const result = await (0, execa_js_1.execa)(bin, args, { cwd: ctx.cwd, reject: false });
     if (result.code === 'ENOENT')
         return { missing: true };
     return {
@@ -67,7 +67,7 @@ function defineExternal(spec, phase, work) {
             return isEnabled(ctx, spec.configKey, spec.language);
         },
         async run(ctx) {
-            const targets = await (0, targets_1.resolveTargets)(ctx, spec.globs, {
+            const targets = await (0, targets_js_1.resolveTargets)(ctx, spec.globs, {
                 onEmpty: { pass: `no ${spec.subject} changed` },
             });
             if (!Array.isArray(targets))
@@ -88,15 +88,15 @@ 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 (0, tool_install_1.notInstalled)(spec.tool, spec.toolLabel);
+            return (0, tool_install_js_1.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) {
-            utils_1.logger.info(`[${spec.name}]: ✅ No issues found`);
-            return (0, types_1.pass)();
+            index_js_1.logger.info(`[${spec.name}]: ✅ No issues found`);
+            return (0, types_js_1.pass)();
         }
         const lines = output.split('\n').filter(spec.keep ?? isNotBlank);
         // The tool objected and none of its output matched what this check knows how
@@ -105,8 +105,8 @@ function defineExternalLint(spec) {
         const summary = lines.length > 0
             ? (spec.summary ?? countIssues)(lines, targets)
             : `${spec.bin} exited ${run.exitCode ?? 'without a code'} with no readable diagnostics`;
-        (0, findings_1.logSample)(spec.name, `${summary}:`, lines);
-        return (0, types_1.warn)(summary);
+        (0, findings_js_1.logSample)(spec.name, `${summary}:`, lines);
+        return (0, types_js_1.warn)(summary);
     });
 }
 /**
@@ -121,12 +121,12 @@ function defineExternalFormat(spec) {
     return defineExternal(spec, 'format', async (ctx, targets) => {
         const dry = await runTool(ctx, spec.bin, spec.checkArgs(targets));
         if (dry.missing)
-            return (0, tool_install_1.notInstalled)(spec.tool, spec.toolLabel);
+            return (0, tool_install_js_1.notInstalled)(spec.tool, spec.toolLabel);
         if (dry.exitCode === 0)
-            return (0, types_1.pass)();
+            return (0, types_js_1.pass)();
         if (!ctx.write) {
-            utils_1.logger.warn(`[${spec.name}]: ⚠️ ${spec.code} needs formatting`);
-            return (0, types_1.warn)(`${spec.code} needs formatting (run with write to fix)`);
+            index_js_1.logger.warn(`[${spec.name}]: ⚠️ ${spec.code} needs formatting`);
+            return (0, types_js_1.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
@@ -134,10 +134,10 @@ function defineExternalFormat(spec) {
         // correct and shorter than asserting it away.
         if (fix.missing || fix.exitCode !== 0) {
             const detail = fix.missing ? '' : `\n${fix.stderr}`;
-            utils_1.logger.warn(`[${spec.name}]: ⚠️ ${spec.bin} failed to rewrite files${detail}`);
-            return (0, types_1.warn)(`${spec.bin} failed to rewrite files`);
+            index_js_1.logger.warn(`[${spec.name}]: ⚠️ ${spec.bin} failed to rewrite files${detail}`);
+            return (0, types_js_1.warn)(`${spec.bin} failed to rewrite files`);
         }
-        utils_1.logger.info(`[${spec.name}]: ✅ Reformatted ${spec.code}`);
-        return (0, types_1.pass)(`reformatted ${spec.code}`);
+        index_js_1.logger.info(`[${spec.name}]: ✅ Reformatted ${spec.code}`);
+        return (0, types_js_1.pass)(`reformatted ${spec.code}`);
     });
 }

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

@@ -1,4 +1,4 @@
-import { Check } from '../../types';
+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.

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

@@ -0,0 +1,202 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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 index_js_1 = require("../../../utils/index.js");
+const targets_js_1 = require("../../targets.js");
+const types_js_1 = require("../../types.js");
+const tool_install_js_1 = require("../tool-install.js");
+const external_runner_js_1 = require("./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 = (0, index_js_1.resolvePackageBin)('@wasm-fmt/gofmt', 'gofmt_node.js');
+        const mod = (await Promise.resolve(`${(0, node_url_1.pathToFileURL)(entry).href}`).then(s => __importStar(require(s))));
+        return mod.format;
+    }
+    catch (err) {
+        index_js_1.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 (0, types_js_1.pass)();
+    if (!ctx.write) {
+        index_js_1.logger.warn(`[Go Format]: ⚠️ ${unformatted.length} Go file(s) need formatting`);
+        unformatted.slice(0, 10).forEach(file => index_js_1.logger.warn(`  ${file}`));
+        return (0, types_js_1.warn)(`${unformatted.length} file(s) need formatting (run with write to fix)`);
+    }
+    index_js_1.logger.info(`[Go Format]: ✅ Reformatted ${unformatted.length} Go file(s)`);
+    return (0, types_js_1.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 (0, external_runner_js_1.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 (0, external_runner_js_1.runTool)(ctx, 'gofmt', ['-w', ...unformatted]);
+    if (fix.missing || fix.exitCode !== 0) {
+        index_js_1.logger.warn(`[Go Format]: ⚠️ gofmt -w failed\n${fix.missing ? '' : fix.stderr}`);
+        return (0, types_js_1.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 = node_path_1.default.join(ctx.cwd, rel);
+        let content;
+        try {
+            content = node_fs_1.default.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.
+            index_js_1.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);
+    }
+    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.
+ */
+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_js_1.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 (0, tool_install_js_1.notInstalled)('gofmt', 'gofmt');
+        index_js_1.logger.debug('[Go Format]: no system gofmt — using the bundled WASM formatter');
+        return formatWithBundledGofmt(ctx, targets, format);
+    },
+};

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

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

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

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.lintCheck = void 0;
-const config_1 = require("../../../config");
-const utils_1 = require("../../../utils");
-const execa_1 = require("../../../utils/execa");
-const reuse_1 = require("../../install/reuse");
-const targets_1 = require("../../targets");
-const types_1 = require("../../types");
+const index_js_1 = require("../../../config/index.js");
+const execa_js_1 = require("../../../utils/execa.js");
+const index_js_2 = require("../../../utils/index.js");
+const reuse_js_1 = require("../../install/reuse.js");
+const targets_js_1 = require("../../targets.js");
+const types_js_1 = require("../../types.js");
 /**
  * Resolve the ESLint binary under the client's `install.reuseLocal` policy.
  *
@@ -18,13 +18,13 @@ const types_1 = require("../../types");
  * `clientOwnsConfig` exists (ticket 064, lever A).
  */
 function resolveESLintBin(ctx, clientOwnsConfig) {
-    return (0, utils_1.resolvePackageBin)('eslint', 'bin/eslint.js', {
-        paths: (0, reuse_1.clientToolPaths)('eslint', ctx, { clientOwnsConfig }),
+    return (0, index_js_2.resolvePackageBin)('eslint', 'bin/eslint.js', {
+        paths: (0, reuse_js_1.clientToolPaths)('eslint', ctx, { clientOwnsConfig }),
     });
 }
 async function getESLintMajorVersion(eslintBin) {
     try {
-        const { stdout } = await (0, execa_1.execa)(process.execPath, [eslintBin, '--version']);
+        const { stdout } = await (0, execa_js_1.execa)(process.execPath, [eslintBin, '--version']);
         const match = stdout.match(/v?(\d+)\./);
         return match ? parseInt(match[1], 10) : 8;
     }
@@ -39,15 +39,15 @@ exports.lintCheck = {
         return ctx.languages.includes('typescript') || ctx.languages.includes('javascript');
     },
     async run(ctx) {
-        const targets = await (0, targets_1.resolveScopedTargetFiles)(ctx, ['*.ts', '*.tsx', '*.js', '*.jsx'], (0, config_1.getSourcePaths)(ctx.cwd));
+        const targets = await (0, targets_js_1.resolveScopedTargetFiles)(ctx, ['*.ts', '*.tsx', '*.js', '*.jsx'], (0, index_js_1.getSourcePaths)(ctx.cwd));
         if (targets === null)
-            return (0, types_1.skip)('git unavailable');
+            return (0, types_js_1.skip)('git unavailable');
         if (targets.length === 0)
-            return (0, types_1.pass)('no TypeScript/JavaScript files to lint');
+            return (0, types_js_1.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 = (0, config_1.hasLocalConfig)(['eslint.config.mjs', 'eslint.config.js', '.eslintrc.js', '.eslintrc.json', '.eslintrc'], ctx.cwd);
+        const hasLocal = (0, index_js_1.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];
@@ -68,28 +68,28 @@ exports.lintCheck = {
         if (ctx.write)
             args.push('--fix');
         if (hasLocal) {
-            utils_1.logger.info(`[ESLint]: Using local config (${targets.length} file(s))`);
+            index_js_2.logger.info(`[ESLint]: Using local config (${targets.length} file(s))`);
         }
         else {
             const configFile = version >= 9 ? 'eslint.config.mjs' : '.eslintrc.js';
-            args.push('--config', (0, config_1.getPackageConfigPath)(configFile));
-            utils_1.logger.info(`[ESLint]: Using pr-checkmate config (ESLint v${version}, ${configFile})`);
+            args.push('--config', (0, index_js_1.getPackageConfigPath)(configFile));
+            index_js_2.logger.info(`[ESLint]: Using pr-checkmate config (ESLint v${version}, ${configFile})`);
         }
-        config_1.IGNORE_PATTERNS.forEach(p => args.push('--ignore-pattern', p));
-        const result = await (0, execa_1.execa)(process.execPath, [eslintBin, ...args], {
+        index_js_1.IGNORE_PATTERNS.forEach(p => args.push('--ignore-pattern', p));
+        const result = await (0, execa_js_1.execa)(process.execPath, [eslintBin, ...args], {
             cwd: ctx.cwd,
             stdio: 'inherit',
             reject: false,
         });
         if (result.exitCode === 0)
-            return (0, types_1.pass)();
+            return (0, types_js_1.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 (0, types_1.fail)('lint errors found');
-        return (0, types_1.warn)(`eslint failed to run (exit ${result.exitCode ?? 'killed'})${hasLocal ? '' : ' — using the pr-checkmate config'}`);
+            return (0, types_js_1.fail)('lint errors found');
+        return (0, types_js_1.warn)(`eslint failed to run (exit ${result.exitCode ?? 'killed'})${hasLocal ? '' : ' — using the pr-checkmate config'}`);
     },
 };

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

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

package/dist/{core → cjs/core}/checks/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 execa_1 = require("../../../utils/execa");
-const targets_1 = require("../../targets");
-const types_1 = require("../../types");
+const index_js_1 = require("../../../config/index.js");
+const execa_js_1 = require("../../../utils/execa.js");
+const index_js_2 = require("../../../utils/index.js");
+const targets_js_1 = require("../../targets.js");
+const types_js_1 = require("../../types.js");
 function loadUserPrettierConfig(cwd) {
     const configPath = node_path_1.default.join(cwd, 'pr-checkmate.json');
     if (!node_fs_1.default.existsSync(configPath))
@@ -19,12 +19,12 @@ function loadUserPrettierConfig(cwd) {
         return JSON.parse(node_fs_1.default.readFileSync(configPath, 'utf-8')).prettier?.rules || {};
     }
     catch (err) {
-        utils_1.logger.warn(`[Prettier]: ⚠️ Failed to read prettier config: ${err}`);
+        index_js_2.logger.warn(`[Prettier]: ⚠️ Failed to read prettier config: ${err}`);
         return {};
     }
 }
 function createTempPrettierConfig(cwd) {
-    const defaultConfig = JSON.parse(node_fs_1.default.readFileSync((0, config_1.getPackageConfigPath)('.prettierrc'), 'utf-8'));
+    const defaultConfig = JSON.parse(node_fs_1.default.readFileSync((0, index_js_1.getPackageConfigPath)('.prettierrc'), 'utf-8'));
     const merged = { ...defaultConfig, ...loadUserPrettierConfig(cwd) };
     const tempConfigPath = node_path_1.default.join(cwd, '.prettierrc.temp.json');
     node_fs_1.default.writeFileSync(tempConfigPath, JSON.stringify(merged, null, 2));
@@ -32,7 +32,7 @@ function createTempPrettierConfig(cwd) {
 }
 function createTempIgnoreFile(cwd) {
     const file = node_path_1.default.join(cwd, '.prettierignore.temp');
-    node_fs_1.default.writeFileSync(file, config_1.IGNORE_PATTERNS.join('\n'), 'utf-8');
+    node_fs_1.default.writeFileSync(file, index_js_1.IGNORE_PATTERNS.join('\n'), 'utf-8');
     return file;
 }
 exports.prettierCheck = {
@@ -42,11 +42,11 @@ exports.prettierCheck = {
         return ctx.languages.includes('typescript') || ctx.languages.includes('javascript');
     },
     async run(ctx) {
-        const targets = await (0, targets_1.resolveScopedTargetFiles)(ctx, ['*.ts', '*.tsx', '*.js', '*.jsx', '*.json', '*.md'], (0, config_1.getSourcePaths)(ctx.cwd));
+        const targets = await (0, targets_js_1.resolveScopedTargetFiles)(ctx, ['*.ts', '*.tsx', '*.js', '*.jsx', '*.json', '*.md'], (0, index_js_1.getSourcePaths)(ctx.cwd));
         if (targets === null)
-            return (0, types_1.skip)('git unavailable');
+            return (0, types_js_1.skip)('git unavailable');
         if (targets.length === 0)
-            return (0, types_1.pass)('no files to format');
+            return (0, types_js_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;
@@ -57,7 +57,7 @@ exports.prettierCheck = {
             ignorePath = gitignore;
         else
             ignorePath = tempIgnore = createTempIgnoreFile(ctx.cwd);
-        const hasLocal = (0, config_1.hasLocalConfig)(['.prettierrc', '.prettierrc.json', '.prettierrc.js', 'prettier.config.js'], ctx.cwd);
+        const hasLocal = (0, index_js_1.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;
@@ -69,23 +69,23 @@ exports.prettierCheck = {
             tempConfig = createTempPrettierConfig(ctx.cwd);
             args = [mode, ...targets, '--config', tempConfig, '--ignore-path', ignorePath];
         }
-        const prettierBin = (0, utils_1.resolvePackageBin)('prettier', 'bin/prettier.cjs');
+        const prettierBin = (0, index_js_2.resolvePackageBin)('prettier', 'bin/prettier.cjs');
         try {
-            const result = await (0, execa_1.execa)(process.execPath, [prettierBin, ...args], {
+            const result = await (0, execa_js_1.execa)(process.execPath, [prettierBin, ...args], {
                 cwd: ctx.cwd,
                 stdio: 'inherit',
                 reject: false,
             });
             if (result.exitCode === 0)
-                return (0, types_1.pass)();
+                return (0, types_js_1.pass)();
             // In --check mode a non-zero exit means "some files are not formatted".
-            return (0, types_1.warn)(ctx.write ? 'prettier failed' : 'unformatted files (run with write to fix)');
+            return (0, types_js_1.warn)(ctx.write ? 'prettier failed' : 'unformatted files (run with write to fix)');
         }
         finally {
             if (tempIgnore)
-                (0, utils_1.cleanupTempFile)(tempIgnore);
+                (0, index_js_2.cleanupTempFile)(tempIgnore);
             if (tempConfig)
-                (0, utils_1.cleanupTempFile)(tempConfig);
+                (0, index_js_2.cleanupTempFile)(tempConfig);
         }
     },
 };

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

@@ -1,4 +1,4 @@
-import { Check } from '../../types';
+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