pr-checkmate 3.2.3 → 4.0.0

package/dist/esm/cli.js

@@ -1,9 +1,20 @@
 #!/usr/bin/env node
-import { COMMAND_TO_CHECK, FLAGS, STANDALONE_COMMANDS, TOOLING_COMMANDS } from './core/commands.js';
+import fs from 'node:fs';
+import path from 'node:path';
+import { evaluateHook } from './agent/hook.js';
+import { reportSetup, setupAgent } from './agent/setup.js';
+import { loadProjectConfig } from './config/loader.js';
+import { AGENT_COMMANDS, COMMAND_TO_CHECK, FLAGS, STANDALONE_COMMANDS, TOOLING_COMMANDS, } from './core/commands.js';
 import { runChecks } from './core/index.js';
 import { installProfiles, pruneCache, runDoctor } from './core/install/doctor.js';
+import { ensureGrypeDb } from './core/install/grype-db.js';
+import { toSarif } from './core/sarif.js';
 import { init } from './init.js';
-import { logger, getUpdateNotice } from './utils/index.js';
+import { serve } from './mcp/serve.js';
+import { createServerDefinition } from './mcp/tools.js';
+import { isolateInheritedStdio } from './utils/execa.js';
+import { getUpdateNotice, logger } from './utils/index.js';
+import { packageVersion } from './utils/package-version.js';
 const argv = process.argv.slice(2);
 /**
  * Flags are separated from positional arguments so they compose with every command
@@ -50,6 +61,28 @@ function rejectConflictingScope() {
         logger.error('[cli]: "--all" applies only to "install". Did you mean "--full"?');
         process.exit(1);
     }
+    // `mcp` speaks a protocol on stdout and `hook` is invoked by a harness with a
+    // fixed payload: neither has anything to configure from the command line, and a
+    // flag that quietly did nothing would look like it had.
+    if ((cmd === 'mcp' || cmd === 'hook') && flags.length > 0) {
+        logger.error(`[cli]: "${cmd}" takes no flags, got: ${flags.join(', ')}.`);
+        process.exit(1);
+    }
+    // Only a command that runs checks has findings to export; `all`, `precommit` and a
+    // named check do, every other standalone command does not.
+    const runsChecks = !cmd || cmd === 'all' || cmd === 'precommit' || !STANDALONE_COMMANDS.includes(cmd);
+    if (flags.includes('--sarif') && !runsChecks) {
+        logger.error('[cli]: "--sarif" applies only to commands that run checks.');
+        process.exit(1);
+    }
+    if (flags.includes('--no-hook') && cmd !== 'agent-setup') {
+        logger.error('[cli]: "--no-hook" applies only to "agent-setup".');
+        process.exit(1);
+    }
+    if (flags.includes('--full') && AGENT_COMMANDS.includes(cmd ?? '')) {
+        logger.error(`[cli]: "${cmd}" reviews nothing on its own, so "--full" has no meaning.`);
+        process.exit(1);
+    }
     if (flags.includes('--full') && TOOLING_COMMANDS.includes(cmd ?? '')) {
         logger.error(`[cli]: "${cmd}" manages tooling and reviews nothing, so "--full" has no meaning.`);
         process.exit(1);
@@ -71,6 +104,55 @@ function rejectExtraArgs() {
     logger.error(`[cli]: "${cmd}" takes no other arguments, got: ${args.slice(1).join(', ')}. Run them as a separate command.`);
     process.exit(1);
 }
+/**
+ * Write the report as SARIF when `--sarif` was passed. Written before the exit code
+ * is decided, so a failing run still leaves the file a dashboard needs to show why.
+ */
+function writeSarifIfRequested(report) {
+    if (!flags.includes('--sarif'))
+        return;
+    const file = path.resolve(process.cwd(), 'pr-checkmate.sarif');
+    fs.writeFileSync(file, `${JSON.stringify(toSarif(report, packageVersion()), null, 2)}\n`);
+    logger.info(`[sarif]: wrote ${file}`);
+}
+/** Everything the harness wrote to stdin, as text; empty when stdin is closed or a terminal. */
+async function readStdin() {
+    if (process.stdin.isTTY)
+        return '';
+    const chunks = [];
+    for await (const chunk of process.stdin)
+        chunks.push(Buffer.from(chunk));
+    return Buffer.concat(chunks).toString('utf-8');
+}
+/**
+ * The commands that serve AI agents. Returns whether `cmd` was one of them (and has
+ * therefore already exited); kept out of the main dispatcher so that one stays
+ * readable as the list of commands grows.
+ *
+ * `mcp` must stay ahead of anything that could print: from here until stdin closes,
+ * stdout carries protocol messages and nothing else.
+ */
+async function runAgentCommand() {
+    if (cmd === 'mcp') {
+        await serve(createServerDefinition());
+        process.exit(0);
+    }
+    if (cmd === 'hook') {
+        // Discarded rather than shown: the harness reads stdout and stderr of a hook
+        // as instructions to the model, so only the verdict may reach either.
+        isolateInheritedStdio('discard');
+        logger.setSink({ out: () => undefined, err: () => undefined });
+        const verdict = await evaluateHook(await readStdin(), process.cwd());
+        if (verdict.stderr)
+            process.stderr.write(`${verdict.stderr}\n`);
+        process.exit(verdict.exitCode);
+    }
+    if (cmd === 'agent-setup') {
+        reportSetup(setupAgent(process.cwd(), { hook: !flags.includes('--no-hook') }));
+        process.exit(0);
+    }
+    return false;
+}
 void (async () => {
     try {
         rejectUnknownFlags();
@@ -80,6 +162,8 @@ void (async () => {
             await init();
             process.exit(0);
         }
+        if (await runAgentCommand())
+            return;
         // Tooling management. These run no checks — they prepare, inspect or clean
         // up what the checks need, so they never touch the diff or the reporter.
         if (cmd === 'install') {
@@ -88,6 +172,17 @@ void (async () => {
             for (const result of failed) {
                 logger.error(`[install]: ❌ ${result.profiles.join(', ') || 'tooling'}: ${result.reason}`);
             }
+            // Warm grype's vulnerability database too, with no time cap: the download is
+            // hundreds of MB and the scan itself would only be allowed a couple of minutes.
+            // Best-effort — an absent grype or a failed download is a warning, not a
+            // failed install, since Grype Scan skips cleanly without it.
+            if (loadProjectConfig().grypeScan?.enabled !== false) {
+                const why = await ensureGrypeDb(process.cwd());
+                if (why && why !== 'ENOENT')
+                    logger.warn(`[install]: ⚠️ grype: ${why}`);
+                else if (!why)
+                    logger.info('[install]: grype vulnerability database is up to date');
+            }
             process.exit(failed.length > 0 ? 1 : 0);
         }
         if (cmd === 'doctor') {
@@ -110,12 +205,14 @@ void (async () => {
                 logger.info('');
                 notice.forEach(line => logger.info(line));
             }
+            writeSarifIfRequested(report);
             process.exit(report.ok ? 0 : 1);
         }
         // Local pre-commit: check the staged changes (index vs HEAD), print to
         // stdout, never modify files. Exits non-zero on failure to block the commit.
         if (cmd === 'precommit') {
             const report = await runChecks({ staged: true, reporter: 'stdout', write: false });
+            writeSarifIfRequested(report);
             process.exit(report.ok ? 0 : 1);
         }
         // Every remaining argument is a check name, so `pr-checkmate lint spellcheck`
@@ -128,6 +225,7 @@ void (async () => {
         }
         const checkNames = [...new Set(args.map(arg => COMMAND_TO_CHECK[arg]))];
         const report = await runChecks({ only: checkNames, reporter: 'stdout', write: true, full });
+        writeSarifIfRequested(report);
         process.exit(report.ok ? 0 : 1);
     }
     catch (err) {

package/dist/esm/config/constants.d.ts

@@ -95,6 +95,7 @@ export declare const SOURCE_EXTENSIONS: {
     json: string[];
     all: string[];
 };
+export declare const AGENT_SETUP_COMMAND = "npx pr-checkmate agent-setup";
 export declare const DEFAULT_COMMANDS: {
     'npx pr-checkmate init': string;
     'npx pr-checkmate all': string;
@@ -109,6 +110,7 @@ export declare const DEFAULT_COMMANDS: {
     'npx pr-checkmate diff-smell': string;
     'npx pr-checkmate pr-body': string;
     'npx pr-checkmate duplicate': string;
+    "npx pr-checkmate agent-setup": string;
 };
 /**
  * Packages allow-listed for the license check by default.

package/dist/esm/config/constants.js

@@ -225,6 +225,7 @@ export const SOURCE_EXTENSIONS = {
     json: ['.json'],
     all: ['.ts', '.tsx', '.js', '.jsx', '.json', '.md', '.mdx'],
 };
+export const AGENT_SETUP_COMMAND = 'npx pr-checkmate agent-setup';
 export const DEFAULT_COMMANDS = {
     'npx pr-checkmate init': 'Create pr-checkmate.json and the CI workflow (first-run setup)',
     'npx pr-checkmate all': 'Run all checks over the changes — the PR diff in CI, your branch changes locally',
@@ -239,6 +240,7 @@ export const DEFAULT_COMMANDS = {
     'npx pr-checkmate diff-smell': 'Scan git diff for code smells',
     'npx pr-checkmate pr-body': 'Validate PR description',
     'npx pr-checkmate duplicate': 'Detect duplicate code blocks (jscpd)',
+    [AGENT_SETUP_COMMAND]: 'Connect your AI agent: MCP server, rules for it and edit hooks (writes .mcp.json)',
 };
 /**
  * Packages allow-listed for the license check by default.
@@ -320,6 +322,8 @@ export const KNOWN_CONFIG_KEYS = new Set([
     'diffSecurity',
     'workflowSecurity',
     'dockerfileSecurity',
+    'agentInstructions',
+    'mcp',
     'sensitiveFileGuard',
     'migrationSafety',
     // dependencies

package/dist/esm/config/pr-checkmate.template.json

@@ -97,6 +97,16 @@
     "enabled": true,
     "ignore": []
   },
+  "agentInstructions": {
+    "enabled": true,
+    "ignore": []
+  },
+  "//mcp": "What the MCP server offers an AI agent here. 'enabled': false turns it off; 'disabledTools' hides tools by name; 'readOnly' hides the ones that write files. Applies from the agent's next request.",
+  "mcp": {
+    "enabled": true,
+    "disabledTools": [],
+    "readOnly": false
+  },
   "//sensitiveFileGuard": "Flags .env files, private keys, CI config and lockfiles. 'ignorePaths' excuses ONE file by glob (a .pem test fixture); 'ignore' silences a whole CATEGORY and would excuse the next real key too — reach for ignorePaths first.",
   "sensitiveFileGuard": {
     "enabled": true,
@@ -318,7 +328,7 @@
     "//ignores": "APPENDED to the built-in list: node_modules, dist, coverage, graphify-out, .claude and CHANGELOG.md.",
     "ignores": []
   },
-  "//7b-install": "WHICH TOOLING IS FETCHED. The package ships ~233 MB and no repository needs all of it. \"adaptive\" (default) fetches only what this repository turns out to need; \"eager\" fetches everything up front, which is what a closed network or a prebuilt image wants and is also the exact previous behaviour; \"manual\" fetches nothing because the tools are already on the runner. A missing tool never fails silently: the affected checks skip with a reason in the report, or fail the run outright with onMissingTool: \"error\".",
+  "//7b-install": "WHICH TOOLING IS FETCHED. The tooling totals ~233 MB and no repository needs all of it. \"adaptive\" (default) fetches only what this repository turns out to need; \"eager\" fetches everything up front, which is what a closed network or a prebuilt image wants and is also the exact previous behaviour; \"manual\" fetches nothing because the tools are already on the runner. A missing tool never fails silently: the affected checks skip with a reason in the report, or fail the run outright with onMissingTool: \"error\".",
   "install": {
     "strategy": "adaptive",
     "//profiles": "Extra profiles beyond what detection concluded, for generated code or a monorepo layout detection cannot see through. Names: core, js, python, cpp, spellcheck, markdown, commitlint, duplicate.",

package/dist/esm/core/checks/dependencies/dependency-check.js

@@ -2,8 +2,8 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { hasLocalConfig } from '../../../config/index.js';
 import { execa } from '../../../utils/execa.js';
-import { logger, cleanupTempFile, resolvePackageBin } from '../../../utils/index.js';
-import { isNpmProject, pass, fail, warn, skip } from '../../types.js';
+import { cleanupTempFile, logger, resolvePackageBin } from '../../../utils/index.js';
+import { fail, isNpmProject, pass, skip, warn } from '../../types.js';
 /**
  * Config files knip discovers on its own. When a client ships one, it is the source
  * of truth and pr-checkmate passes no config of its own — the same rule spellcheck

package/dist/esm/core/checks/dependencies/grype-scan.js

@@ -1,5 +1,6 @@
 import { execa } from '../../../utils/execa.js';
 import { collectDirectDeps, isCiEnvironment, logger, normalizeName, } from '../../../utils/index.js';
+import { ensureGrypeDb } from '../../install/grype-db.js';
 import { pass, skip, warn } from '../../types.js';
 import { notInstalled } from '../tool-install.js';
 const SEVERITY_ORDER = ['negligible', 'low', 'medium', 'high', 'critical'];
@@ -17,6 +18,14 @@ const TYPE_TO_ECOSYSTEM = {
  * looks like a hung commit — an advisory check must never be able to do that.
  */
 const DEFAULT_TIMEOUT_MS = 120000;
+/**
+ * Cap for refreshing grype's vulnerability database. A stale database (grype
+ * refuses one older than 5 days) is re-downloaded, hundreds of MB, which takes
+ * longer than the scan's own cap. Kept below the per-check timeout so the check
+ * itself reports the outcome instead of being cut off by the runner. `npx
+ * pr-checkmate install` refreshes it without any cap, ahead of time.
+ */
+const DB_UPDATE_TIMEOUT_MS = 240000;
 function severityRank(severity) {
     return SEVERITY_ORDER.indexOf((severity ?? '').toLowerCase());
 }
@@ -72,10 +81,19 @@ export const grypeScanCheck = {
         // third-party code is not something the client could fix anyway (see below).
         const excludes = (ctx.config.ignoreDirs ?? []).flatMap(dir => ['--exclude', `**/${dir}/**`]);
         const timeout = settings.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        const unusable = await ensureGrypeDb(ctx.cwd, DB_UPDATE_TIMEOUT_MS);
+        if (unusable === 'ENOENT')
+            return notInstalled('grype');
+        if (unusable) {
+            logger.warn(`[Grype Scan]: ⚠️ ${unusable} — skipping`);
+            return skip(unusable);
+        }
+        // The database was just checked, so the scan must not try to fetch one itself.
         const result = await execa('grype', ['dir:.', '-o', 'json', '-q', ...excludes], {
             cwd: ctx.cwd,
             reject: false,
             timeout,
+            env: { GRYPE_DB_AUTO_UPDATE: 'false' },
         });
         // execa v9 with reject:false resolves (not throws) with `code: 'ENOENT'`
         // when the binary is absent — detect the missing scanner on the result.

package/dist/esm/core/checks/dependencies/license-check.js

@@ -1,6 +1,6 @@
 import { execa } from '../../../utils/execa.js';
-import { logger, resolvePackageBin, getOwnDependencyClosure } from '../../../utils/index.js';
-import { isNpmProject, pass, fail, skip } from '../../types.js';
+import { getOwnDependencyClosure, logger, resolvePackageBin } from '../../../utils/index.js';
+import { fail, isNpmProject, pass, skip } from '../../types.js';
 const FORBIDDEN_LICENSES = ['GPL-2.0', 'GPL-3.0', 'AGPL-3.0', 'LGPL-2.0', 'LGPL-2.1', 'LGPL-3.0'];
 /** Strip the trailing "@version" to get the bare package name (scoped-safe). */
 function bareName(pkgKey) {

package/dist/esm/core/checks/dependencies/npm-audit.js

@@ -4,8 +4,8 @@ const __dirname = __dirnameFn(__fileURLToPath(import.meta.url));
 import fs from 'node:fs';
 import path from 'node:path';
 import { execa } from '../../../utils/execa.js';
-import { logger, findOwnPackageRoot } from '../../../utils/index.js';
-import { isNpmProject, pass, fail, skip } from '../../types.js';
+import { findOwnPackageRoot, logger } from '../../../utils/index.js';
+import { fail, isNpmProject, pass, skip } from '../../types.js';
 const SEVERITY_ORDER = ['info', 'low', 'moderate', 'high', 'critical'];
 function isSeverityAtLeast(severity, level) {
     const sevIdx = SEVERITY_ORDER.indexOf(severity);

package/dist/esm/core/checks/findings.js

@@ -2,6 +2,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { execa } from '../../utils/execa.js';
 import { logger, matchesAnyGlob } from '../../utils/index.js';
+import { fileFindings, noteLocation } from '../finding-store.js';
 import { listTrackedFiles } from '../targets.js';
 import { fail, pass, warn } from '../types.js';
 /**
@@ -370,6 +371,8 @@ export const DEFAULT_DATAFLOW_WINDOW = 10;
 const CROSS_LINE_SQL_LABEL = 'Interpolated value reaches a query (SQL injection risk, cross-line)';
 /** `@@ ... @@` — a new hunk, and the boundary taint never crosses. */
 const DIFF_HUNK_HEADER = /^@@ /;
+/** The first line of the new side of a hunk: `@@ -3,2 +10,4 @@` → 10. */
+const HUNK_NEW_START = /^@@ -\d+(?:,\d+)? \+(\d+)/;
 /**
  * Whether this line hands `name` to a query sink.
  *
@@ -443,6 +446,9 @@ export function scanDiffPatterns(stdout, patterns, opts = {}) {
     const mode = opts.comments ?? 'language';
     const ignorePaths = opts.ignorePaths ?? [];
     let syntax = 'both';
+    // Where the walk is, for findings that need to say so.
+    let file = '';
+    let newLine = 0;
     // Block comments span lines, so the state belongs to the walk, not to one line.
     let inBlockComment = false;
     // Whole files can be excluded by glob; the flag persists until the next header.
@@ -453,6 +459,7 @@ export function scanDiffPatterns(stdout, patterns, opts = {}) {
     for (const line of stdout.split('\n')) {
         const header = DIFF_FILE_HEADER.exec(line);
         if (header) {
+            file = header[1];
             syntax = mode === 'language' ? commentSyntaxFor(header[1]) : 'both';
             inBlockComment = false;
             skippingFile = ignorePaths.length > 0 && matchesAnyGlob(header[1], ignorePaths);
@@ -461,9 +468,15 @@ export function scanDiffPatterns(stdout, patterns, opts = {}) {
         }
         // Checked before the `+` filter below, which a hunk header does not satisfy.
         if (DIFF_HUNK_HEADER.test(line)) {
+            newLine = Number(HUNK_NEW_START.exec(line)?.[1] ?? 0);
             taint.reset();
             continue;
         }
+        // Counted before any skip: an ignored or excluded line still occupies a line
+        // number in the file, and the ones after it must not shift.
+        const lineNo = newLine;
+        if (line.startsWith('+'))
+            newLine++;
         if (skippingFile)
             continue;
         // Only added lines carry block-comment state: a `-` line is code being
@@ -475,18 +488,28 @@ export function scanDiffPatterns(stdout, patterns, opts = {}) {
         const prepared = uncomment(line, { mode, syntax, inBlockComment });
         inBlockComment = prepared.inBlockComment;
         const asCode = stripStringLiterals(prepared.text);
-        for (const { pattern, label, severity, view } of patterns) {
-            if (pattern.test(view === 'code' ? asCode : prepared.text)) {
-                const bucket = severity === 'error' ? errors : warnings;
-                (bucket[label] ?? (bucket[label] = [])).push(line.slice(1).trim().substring(0, SAMPLE_MAX_LENGTH));
-            }
-        }
+        const where = { file, line: lineNo };
+        recordMatches(patterns, { text: prepared.text, asCode }, line, where, { errors, warnings });
         if (taint.inspect(prepared.text, asCode)) {
-            (warnings[CROSS_LINE_SQL_LABEL] ?? (warnings[CROSS_LINE_SQL_LABEL] = [])).push(line.slice(1).trim().substring(0, SAMPLE_MAX_LENGTH));
+            record(warnings, CROSS_LINE_SQL_LABEL, line, where);
         }
     }
     return { errors, warnings };
 }
+/** File one added line under `label` and remember where it was, for findings that say so. */
+function record(bucket, label, line, where) {
+    const sample = line.slice(1).trim().substring(0, SAMPLE_MAX_LENGTH);
+    (bucket[label] ?? (bucket[label] = [])).push(sample);
+    noteLocation(label, sample, where.file, where.line);
+}
+/** File every pattern that matches one prepared line under its own label and severity. */
+function recordMatches(patterns, view, line, where, into) {
+    for (const { pattern, label, severity, view: wants } of patterns) {
+        if (pattern.test(wants === 'code' ? view.asCode : view.text)) {
+            record(severity === 'error' ? into.errors : into.warnings, label, line, where);
+        }
+    }
+}
 /**
  * Reduce one added line to what should be matched against: block comments
  * blanked (carrying the open state on), then the trailing line comment removed.
@@ -577,6 +600,7 @@ export function bucketTotal(bucket) {
  */
 export function reportCountedFindings(findings, ctx, opts) {
     const sev = severityEmitter(opts.severity, opts.fallback ?? 'warn');
+    fileFindings(findings, sev.icon === '❌' ? 'error' : 'warn');
     logFindings(findings, {
         prefix: opts.prefix,
         sampleLimit: opts.sampleLimit ?? ctx.config.log?.sampleLimit ?? 3,
@@ -681,6 +705,8 @@ export function reportSeverityBuckets(errorsIn, warningsIn, opts) {
     const ignore = opts.ignore ?? [];
     const filed = applyOverrides(dropIgnored(errorsIn, ignore), dropIgnored(warningsIn, ignore), opts.severityOverrides ?? {});
     const { errors, warnings } = filed;
+    fileFindings(errors, 'error');
+    fileFindings(warnings, 'warn');
     const totalErrors = bucketTotal(errors);
     const totalWarnings = bucketTotal(warnings);
     if (totalErrors === 0 && totalWarnings === 0)

package/dist/esm/core/checks/git/diff-smell.js

@@ -1,6 +1,6 @@
 import { logger } from '../../../utils/index.js';
 import { pass, skip } from '../../types.js';
-import { bucketTotal, emptyBuckets, mergeSeverityBuckets, reportCountedFindings, scanDiffPatterns, reviewLines, } from '../findings.js';
+import { bucketTotal, emptyBuckets, mergeSeverityBuckets, reportCountedFindings, reviewLines, scanDiffPatterns, } from '../findings.js';
 /**
  * Smells that are only smells in live code.
  *

package/dist/esm/core/checks/git/large-files.d.ts

@@ -1,2 +1,3 @@
 import { Check } from '../../types.js';
+export declare const DEFAULT_MAX_KB = 500;
 export declare const largeFilesCheck: Check;

package/dist/esm/core/checks/git/large-files.js

@@ -5,7 +5,7 @@ import { logger, matchesAnyGlob } from '../../../utils/index.js';
 import { resolveTargetFiles } from '../../targets.js';
 import { pass, skip } from '../../types.js';
 import { severityEmitter } from '../findings.js';
-const DEFAULT_MAX_KB = 500;
+export const DEFAULT_MAX_KB = 500;
 /**
  * Lockfiles are legitimately large and always generated, never accidental — so
  * they're exempt from the size/binary guard by default (a 600 KB

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

@@ -4,7 +4,7 @@ import { getSourcePaths } from '../../../config/index.js';
 import { execa } from '../../../utils/execa.js';
 import { logger, resolvePackageBin } from '../../../utils/index.js';
 import { resolveScopedTargetFiles } from '../../targets.js';
-import { pass, warn, skip } from '../../types.js';
+import { pass, skip, warn } from '../../types.js';
 /**
  * C/C++ source & header extensions clang-format understands. `.h` is intentionally
  * included even though it is ambiguous with C — clang-format handles both.

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

@@ -1,9 +1,10 @@
-import { hasLocalConfig, getSourcePaths, getPackageConfigPath, IGNORE_PATTERNS, } from '../../../config/index.js';
+import path from 'node:path';
+import { getPackageConfigPath, getSourcePaths, hasLocalConfig, IGNORE_PATTERNS, } from '../../../config/index.js';
 import { execa } from '../../../utils/execa.js';
-import { logger, resolvePackageBin } from '../../../utils/index.js';
+import { logger, registeredToolPaths, resolvePackageBin } from '../../../utils/index.js';
 import { clientToolPaths } from '../../install/reuse.js';
 import { resolveScopedTargetFiles } from '../../targets.js';
-import { pass, fail, warn, skip } from '../../types.js';
+import { fail, pass, skip, warn } from '../../types.js';
 /**
  * Resolve the ESLint binary under the client's `install.reuseLocal` policy.
  *
@@ -73,10 +74,18 @@ export const lintCheck = {
             logger.info(`[ESLint]: Using pr-checkmate config (ESLint v${version}, ${configFile})`);
         }
         IGNORE_PATTERNS.forEach(p => args.push('--ignore-pattern', p));
+        // Our bundled config loads its plugins through these roots, and an ESLint
+        // older than 9 resolves legacy-config plugins relative to the path below — in
+        // both cases the plugins are in a fetched profile rather than beside us.
+        const toolRoots = registeredToolPaths();
+        if (!hasLocal && version < 9 && toolRoots.length > 0) {
+            args.push('--resolve-plugins-relative-to', toolRoots[0]);
+        }
         const result = await execa(process.execPath, [eslintBin, ...args], {
             cwd: ctx.cwd,
             stdio: 'inherit',
             reject: false,
+            env: { PR_CHECKMATE_TOOL_ROOTS: toolRoots.join(path.delimiter) },
         });
         if (result.exitCode === 0)
             return pass();

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

@@ -1,10 +1,10 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { getPackageConfigPath, hasLocalConfig, IGNORE_PATTERNS, getSourcePaths, } from '../../../config/index.js';
+import { getPackageConfigPath, getSourcePaths, hasLocalConfig, IGNORE_PATTERNS, } from '../../../config/index.js';
 import { execa } from '../../../utils/execa.js';
-import { logger, cleanupTempFile, resolvePackageBin } from '../../../utils/index.js';
+import { cleanupTempFile, logger, resolvePackageBin } from '../../../utils/index.js';
 import { resolveScopedTargetFiles } from '../../targets.js';
-import { pass, warn, skip } from '../../types.js';
+import { pass, skip, warn } from '../../types.js';
 function loadUserPrettierConfig(cwd) {
     const configPath = path.join(cwd, 'pr-checkmate.json');
     if (!fs.existsSync(configPath))

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

@@ -2,8 +2,8 @@ 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';
+import { pass, skip, warn } from '../../types.js';
+import { createRuffWorkspace, PY_GLOBS } 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

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

@@ -2,8 +2,8 @@ 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';
+import { pass, skip, warn } from '../../types.js';
+import { createRuffWorkspace, PY_GLOBS } from './ruff-shared.js';
 /**
  * Lints changed Python files with Ruff, bundled as a self-contained WASM module
  * (`@astral-sh/ruff-wasm-nodejs`) so it runs on a bare Node image with no Python

package/dist/esm/core/checks/languages/ruff-shared.js

@@ -1,5 +1,6 @@
 import { createRequire as __createRequire } from 'node:module';
 const require = __createRequire(import.meta.url);
+import { resolvePackageBin } from '../../../utils/index.js';
 export const PY_GLOBS = ['*.py'];
 /**
  * The rules we lint Python with — pinned here rather than left to Ruff's defaults.
@@ -26,7 +27,11 @@ const SELECTED_RULES = ['E4', 'E7', 'E9', 'F'];
  * singleton) so the WASM module loads only when a check runs.
  */
 export function createRuffWorkspace() {
-    const { Workspace, PositionEncoding } = require('@astral-sh/ruff-wasm-nodejs');
+    // Resolved rather than required by name: the package lives in the `python`
+    // profile, which is fetched into the cache directory when this repository
+    // needs it, and a bare specifier only searches our own tree.
+    const entry = resolvePackageBin('@astral-sh/ruff-wasm-nodejs', 'ruff_wasm.js');
+    const { Workspace, PositionEncoding } = require(entry);
     const settings = {
         ...Workspace.defaultSettings(),
         lint: { select: SELECTED_RULES },

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

@@ -3,7 +3,7 @@ import path from 'node:path';
 import { execa } from '../../../utils/execa.js';
 import { logger, resolvePackageBin } from '../../../utils/index.js';
 import { clientToolPaths } from '../../install/reuse.js';
-import { pass, fail, warn, skip } from '../../types.js';
+import { fail, pass, skip, warn } from '../../types.js';
 /**
  * Prefer the consumer project's own TypeScript so its tsconfig is compiled by the
  * version it was written for; fall back to the compiler bundled with pr-checkmate.

package/dist/esm/core/checks/pr/commitlint.js

@@ -34,8 +34,10 @@ const DEFAULT_IGNORES = ['^Release\\b', '^chore\\(release\\):'];
 function buildTempConfig(types, ignores) {
     // Emit a CJS module so `ignores` can hold functions — commitlint requires
     // predicate functions there, which a JSON config cannot express.
-    // Resolve config-conventional via Node module resolution — robust to hoisting.
-    const configConventional = require.resolve('@commitlint/config-conventional');
+    // Resolved through the same roots as the binary, not by bare specifier: both
+    // live in the `commitlint` profile, which is fetched into the cache directory,
+    // and `require.resolve` alone only searches our own tree.
+    const configConventional = resolvePackageBin('@commitlint/config-conventional', 'lib/index.js');
     const content = `const patterns = ${JSON.stringify(ignores)}.map((p) => new RegExp(p, 'i'));
 module.exports = {
   extends: [${JSON.stringify(configConventional)}],

package/dist/esm/core/checks/pr/pr-body.js

@@ -1,6 +1,6 @@
 import fs from 'node:fs';
 import { logger } from '../../../utils/index.js';
-import { pass, warn, skip } from '../../types.js';
+import { pass, skip, warn } from '../../types.js';
 // Matches "Closes #123", "Fixes #45", "Resolves #7" or JIRA-style "PROJ-456".
 const TICKET_PATTERN = /(?:closes?|fixes?|resolves?)\s+#\d+|[A-Z][A-Z0-9]+-\d+/i;
 export const prBodyCheck = {

package/dist/esm/core/checks/pr/pr-size-check.d.ts

@@ -1,2 +1,4 @@
 import { Check } from '../../types.js';
+export declare const DEFAULT_MAX_FILES = 50;
+export declare const DEFAULT_MAX_LINES = 1000;
 export declare const prSizeCheck: Check;

package/dist/esm/core/checks/pr/pr-size-check.js

@@ -1,8 +1,8 @@
 import { execa } from '../../../utils/execa.js';
 import { logger } from '../../../utils/index.js';
-import { pass, warn, skip } from '../../types.js';
-const DEFAULT_MAX_FILES = 50;
-const DEFAULT_MAX_LINES = 1000;
+import { pass, skip, warn } from '../../types.js';
+export const DEFAULT_MAX_FILES = 50;
+export const DEFAULT_MAX_LINES = 1000;
 export const prSizeCheck = {
     name: 'PR Size',
     phase: 'informational',

package/dist/esm/core/checks/pr/pr-title-lint.js

@@ -1,6 +1,6 @@
 import fs from 'node:fs';
 import { logger } from '../../../utils/index.js';
-import { pass, warn, skip } from '../../types.js';
+import { pass, skip, warn } from '../../types.js';
 const CONVENTIONAL_PREFIX = /^(feat|fix|docs|style|refactor|test|chore|perf|ci|build|revert)(\(.+\))?!?: .+/;
 export const prTitleLintCheck = {
     name: 'PR Title',

package/dist/esm/core/checks/quality/dead-code.js

@@ -4,7 +4,7 @@ import { DEAD_CODE_IGNORE_DEFAULTS } from '../../../config/constants.js';
 import { execa } from '../../../utils/execa.js';
 import { logger, resolvePackageBin } from '../../../utils/index.js';
 import { clientToolPaths } from '../../install/reuse.js';
-import { pass, warn, skip } from '../../types.js';
+import { pass, skip, warn } from '../../types.js';
 /**
  * Resolve ts-unused-exports, preferring the consumer project's own copy (so a
  * repo pinned to a different major keeps its own behaviour) and falling back to

package/dist/esm/core/checks/quality/duplicate-check.js

@@ -6,7 +6,7 @@ import { getSourcePaths } from '../../../config/index.js';
 import { execa } from '../../../utils/execa.js';
 import { logger, resolvePackageBin } from '../../../utils/index.js';
 import { resolveScopedTargetFiles } from '../../targets.js';
-import { pass, warn, skip } from '../../types.js';
+import { pass, skip, warn } from '../../types.js';
 import { logSample } from '../findings.js';
 /**
  * The files to hand jscpd, per language.

package/dist/esm/core/checks/quality/markdown-lint.js

@@ -4,7 +4,7 @@ import { pathToFileURL } from 'node:url';
 import { GENERATED_DOC_FILES, getPackageConfigPath, hasLocalConfig, } from '../../../config/index.js';
 import { logger, resolvePackageBin } from '../../../utils/index.js';
 import { resolveTargetFiles } from '../../targets.js';
-import { pass, warn, skip } from '../../types.js';
+import { pass, skip, warn } from '../../types.js';
 function loadUserMarkdownConfig(cwd) {
     const configPath = path.join(cwd, 'pr-checkmate.json');
     if (!fs.existsSync(configPath))