pr-checkmate 2.1.0 → 3.0.0

package/dist/core/install/ensure.js

@@ -74,9 +74,6 @@ function stageManifest(from, to) {
  */
 async function ensureProfile(profile, opts) {
     const { install } = opts;
-    if (install.strategy === 'manual') {
-        return { profile, status: 'skipped', reason: 'install.strategy is "manual"' };
-    }
     const source = manifestDir(profile);
     const expected = manifestHash(source);
     if (!expected) {
@@ -94,6 +91,28 @@ async function ensureProfile(profile, opts) {
     if (isInstalled(dir, expected)) {
         return { profile, status: 'cached', reason: 'already installed', dir };
     }
+    // Both of these mean "do not fetch", and both are asked AFTER the cache check
+    // above — because neither means "do not use what has already been fetched".
+    //
+    // `offline` was always in the right place; `manual` was not, and returned before
+    // the cache was ever looked at. So `install --all`, the command the product's
+    // own log recommends for pre-warming, did nothing for anyone who then set
+    // `manual` — including our Docker image, which sets it precisely because
+    // everything is supposed to already be there. `Python Types` in that image
+    // could not run at all (ticket 083).
+    // The env var as well as the config key, exactly as `PR_CHECKMATE_OFFLINE` is
+    // read below: the Docker image sets the strategy through the environment, and a
+    // guarantee that only holds when it is written in a config file is not a
+    // guarantee.
+    const strategy = process.env.PR_CHECKMATE_INSTALL_STRATEGY ?? install.strategy;
+    if (strategy === 'manual') {
+        return {
+            profile,
+            status: 'skipped',
+            reason: 'install.strategy is "manual" and the profile is not in the cache',
+            dir,
+        };
+    }
     if (install.offline || process.env.PR_CHECKMATE_OFFLINE === 'true') {
         return {
             profile,

package/dist/core/install/lock.d.ts

@@ -25,9 +25,10 @@ export declare function processAlive(pid: number): boolean;
  * @returns A release function, or `null` when the lock could not be created at
  *   all (an unwritable directory — the caller reports that, it is not fatal here).
  */
-export interface LockDeps {
+interface LockDeps {
     sleep?: (ms: number) => Promise<void>;
     now?: () => number;
     alive?: (pid: number) => boolean;
 }
 export declare function withLock(dir: string, timeoutMs: number, deps?: LockDeps): Promise<(() => void) | null>;
+export {};

package/dist/core/install/prepare.d.ts

@@ -0,0 +1,75 @@
+import type { PRCheckMateConfig } from '../../interfaces';
+import type { LanguageUsage } from '../../utils/detect-language';
+import { type EnsureOptions } from './ensure';
+import { type Profile } from './profiles';
+/**
+ * Whether a profile needs fetching at all, or already ships inside the package.
+ *
+ * This is the hinge the whole adaptive-install rollout turns on. Today every
+ * profile's packages sit in our `dependencies`, so every profile answers `true`
+ * here, nothing is ever fetched, and a run is byte-for-byte the run it was
+ * before any of this existed. When a package is moved out of `dependencies` it
+ * stops being present, its profile starts answering `false`, and the fetch turns
+ * itself on — no flag, no second code path, nothing to remember to flip.
+ *
+ * Which is what makes releases 2 and 3 of ticket 064 an edit to `package.json`
+ * rather than another change to this logic.
+ */
+export declare function profileSatisfiedLocally(profile: Profile): boolean;
+/** What the run knows about tooling before the first check starts. */
+export interface ToolingPlan {
+    /** Check name → why its tooling is not available. Empty on a healthy run. */
+    unavailable: Map<string, string>;
+    /** Profile directories tool resolution should search. */
+    dirs: string[];
+    /**
+     * True when tooling is missing and `install.onMissingTool` is `"error"`. The
+     * affected checks fail instead of skipping: in a closed contour a check that
+     * quietly stops running is worse than a red build.
+     */
+    fatal: boolean;
+}
+interface PrepareOptions {
+    cwd: string;
+    config: PRCheckMateConfig;
+    /** Detected languages with file counts — reused so the tree is scanned once. */
+    usage: LanguageUsage[];
+    /** Names of the checks this run intends to execute. */
+    selected: string[];
+    /** pr-checkmate's own version; part of the cache path. */
+    version: string;
+    /**
+     * The profile catalogue. Defaults to the shipped one; injected by tests.
+     *
+     * A seam rather than a mock of the module, for the same reason `ensure.ts` has
+     * one: every profile currently ships inside the package, so the interesting
+     * half of this function — a profile that is genuinely absent — is unreachable
+     * without either a network install in a unit test or a way to describe a
+     * profile that is not here. The code that runs when a package finally leaves
+     * `dependencies` must be tested before that day, not on it.
+     */
+    profiles?: Profile[];
+    /** The fetch itself, forwarded to `ensureProfile`. Injected by tests. */
+    installer?: EnsureOptions['installer'];
+}
+/**
+ * Make sure the tooling this run needs is present, and say what is missing.
+ *
+ * Runs once, before the first check, and answers two questions the run cannot
+ * proceed honestly without: which directories tool resolution should search, and
+ * which checks have no tool to run. The second is the one ticket 057 is about —
+ * a check whose tooling never arrived must appear in the report saying so, not
+ * vanish from it.
+ *
+ * Only profiles backing checks that are actually selected are considered, so
+ * `severity: { "Spellcheck": "off" }` stops costing a download rather than only a
+ * row in the report (lever B of ticket 064).
+ */
+export declare function prepareTooling(opts: PrepareOptions): Promise<ToolingPlan>;
+/**
+ * The plan for a run where preparation did not happen — nothing missing, nothing
+ * registered. Built fresh each time rather than shared: a caller holding a plan
+ * must not be able to see another run's.
+ */
+export declare function noTooling(): ToolingPlan;
+export {};

package/dist/core/install/prepare.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.profileSatisfiedLocally = profileSatisfiedLocally;
+exports.prepareTooling = prepareTooling;
+exports.noTooling = noTooling;
+const logger_1 = require("../../utils/logger");
+const resolve_bin_1 = require("../../utils/resolve-bin");
+const cache_1 = require("./cache");
+const ensure_1 = require("./ensure");
+const profiles_1 = require("./profiles");
+/**
+ * Whether a profile needs fetching at all, or already ships inside the package.
+ *
+ * This is the hinge the whole adaptive-install rollout turns on. Today every
+ * profile's packages sit in our `dependencies`, so every profile answers `true`
+ * here, nothing is ever fetched, and a run is byte-for-byte the run it was
+ * before any of this existed. When a package is moved out of `dependencies` it
+ * stops being present, its profile starts answering `false`, and the fetch turns
+ * itself on — no flag, no second code path, nothing to remember to flip.
+ *
+ * Which is what makes releases 2 and 3 of ticket 064 an edit to `package.json`
+ * rather than another change to this logic.
+ */
+function profileSatisfiedLocally(profile) {
+    return profile.packages.every(pkg => (0, resolve_bin_1.packagePresent)(pkg));
+}
+/** Profiles blocked outright by `install.deny`, with a line saying so. */
+function denied(profile, deny) {
+    const blocked = profile.packages.filter(pkg => deny.has(pkg));
+    if (blocked.length === 0)
+        return null;
+    return `install.deny lists ${blocked.join(', ')}`;
+}
+/**
+ * Make sure the tooling this run needs is present, and say what is missing.
+ *
+ * Runs once, before the first check, and answers two questions the run cannot
+ * proceed honestly without: which directories tool resolution should search, and
+ * which checks have no tool to run. The second is the one ticket 057 is about —
+ * a check whose tooling never arrived must appear in the report saying so, not
+ * vanish from it.
+ *
+ * Only profiles backing checks that are actually selected are considered, so
+ * `severity: { "Spellcheck": "off" }` stops costing a download rather than only a
+ * row in the report (lever B of ticket 064).
+ */
+async function prepareTooling(opts) {
+    // Every run starts from no registered roots. The SDK can call `runChecks` more
+    // than once in one process, and a directory registered by a previous run — for
+    // a different repository, with a different profile set — must not still be on
+    // the search path for this one.
+    (0, resolve_bin_1.clearToolPaths)();
+    const install = opts.config.install ?? {};
+    const strategy = process.env.PR_CHECKMATE_INSTALL_STRATEGY ?? install.strategy ?? 'adaptive';
+    const onMissing = install.onMissingTool ?? 'auto';
+    const deny = new Set(install.deny ?? []);
+    // Which profiles this repository needs: languages by file count, universal
+    // profiles by whether their check survived config. `install.profiles` and
+    // `excludeProfiles` have already had their say inside `planProfiles`.
+    const required = new Set((0, profiles_1.planProfiles)(opts.usage, opts.config)
+        .filter(decision => decision.required)
+        .map(decision => decision.profile));
+    // A profile nobody in this run would use is not worth a thought, let alone a
+    // download. `eager` opts out of that reasoning by definition: it exists so a
+    // container build or an air-gapped mirror can hold everything up front.
+    const chosen = opts.selected.length > 0 ? new Set(opts.selected) : null;
+    const wanted = (opts.profiles ?? profiles_1.PROFILES).filter(profile => {
+        if (strategy === 'eager')
+            return true;
+        if (!required.has(profile.name))
+            return false;
+        return !chosen || profile.checks.some(check => chosen.has(check));
+    });
+    const unavailable = new Map();
+    const dirs = [];
+    const miss = (profile, reason) => {
+        for (const check of profile.checks)
+            unavailable.set(check, reason);
+    };
+    // Resolved lazily, and at most once.
+    //
+    // Lazily because resolving is not a read: it creates the directory and, when the
+    // configured one is unwritable, warns about where fetched tooling will live
+    // instead. On a run that fetches nothing — every run, while the tooling still
+    // ships in `dependencies` — that warning is about a thing that never happens,
+    // and a container with a read-only home would print it on every single run.
+    // At most once because the warning belongs to the run, not to each profile.
+    let location;
+    const cacheDir = () => {
+        if (location === undefined)
+            location = (0, cache_1.resolveCacheDir)(opts.version, install.cacheDir);
+        return location;
+    };
+    for (const profile of wanted) {
+        // Bundled tooling is the answer to "where is it" for every profile today,
+        // and asking first is what keeps this whole path free of network calls.
+        if (profileSatisfiedLocally(profile))
+            continue;
+        const block = denied(profile, deny);
+        if (block) {
+            miss(profile, block);
+            continue;
+        }
+        // No early exit for `install.strategy: "manual"` any more. It means "never
+        // fetch", and `ensureProfile` enforces that — but only after checking the
+        // cache, so a pre-warmed profile is still used. Returning here instead
+        // meant `manual` also refused tooling that was already downloaded.
+        if (onMissing === 'skip') {
+            miss(profile, 'install.onMissingTool is "skip"');
+            continue;
+        }
+        const cache = cacheDir();
+        if (!cache) {
+            miss(profile, 'no writable cache directory for fetched tooling');
+            continue;
+        }
+        const result = await (0, ensure_1.ensureProfile)(profile.name, {
+            cwd: opts.cwd,
+            version: opts.version,
+            install,
+            ...(opts.installer ? { installer: opts.installer } : {}),
+        });
+        if (result.status === 'failed' || result.status === 'skipped') {
+            miss(profile, result.reason);
+            continue;
+        }
+        dirs.push(result.dir ?? (0, cache_1.profileDir)(cache.dir, profile.name));
+    }
+    if (unavailable.size > 0) {
+        // Always logged, never behind --debug. A check that did not run is the
+        // failure mode this whole layer exists to make loud.
+        const names = [...new Set(unavailable.keys())].join(', ');
+        logger_1.logger.warn(`[install]: ⚠️ tooling unavailable — these checks cannot run: ${names}`);
+        if (onMissing === 'error') {
+            logger_1.logger.error('[install]: ❌ install.onMissingTool is "error" — the affected checks fail');
+        }
+        else {
+            logger_1.logger.info('[install]:    Pre-warm the cache with: npx pr-checkmate install --all');
+        }
+    }
+    (0, resolve_bin_1.registerToolPaths)(dirs);
+    return { unavailable, dirs, fatal: onMissing === 'error' && unavailable.size > 0 };
+}
+/**
+ * The plan for a run where preparation did not happen — nothing missing, nothing
+ * registered. Built fresh each time rather than shared: a caller holding a plan
+ * must not be able to see another run's.
+ */
+function noTooling() {
+    return { unavailable: new Map(), dirs: [], fatal: false };
+}

package/dist/core/install/profiles.d.ts

@@ -12,7 +12,7 @@ import type { Language, LanguageUsage } from '../../utils/detect-language';
  * honest report: when a profile is missing, exactly those checks skip, with the
  * reason, instead of quietly disappearing (the mistake of ticket 057).
  */
-interface Profile {
+export interface Profile {
     name: ProfileName;
     /** Top-level packages installed for this profile. */
     packages: string[];
@@ -23,8 +23,23 @@ interface Profile {
      * enabled checks rather than by what the repository is written in.
      */
     languages?: Language[];
+    /**
+     * An extra condition on the client's config, for a language profile whose
+     * checks can be switched off by a key of their own.
+     *
+     * `severity: { "X": "off" }` is already honoured for every profile, but it is
+     * not the only off switch: `python.typecheck: false` and `go.enabled: false`
+     * are the ones a client actually writes, and a language profile decided on
+     * file counts alone downloads the tooling regardless. For `pytypes` that is
+     * 19 MB fetched to run nothing.
+     *
+     * Deliberately a predicate over the config rather than a list of keys: the
+     * condition it mirrors lives in the check's own `applies`, and expressing it
+     * the same way is what makes the two readable side by side.
+     */
+    enabledBy?(config: PRCheckMateConfig): boolean;
 }
-export type ProfileName = 'core' | 'js' | 'python' | 'cpp' | 'spellcheck' | 'markdown' | 'commitlint' | 'duplicate';
+export type ProfileName = 'core' | 'js' | 'python' | 'pytypes' | 'cpp' | 'go' | 'spellcheck' | 'markdown' | 'commitlint' | 'duplicate';
 /**
  * The catalogue.
  *
@@ -61,4 +76,3 @@ export interface ProfileDecision {
  * @returns One decision per profile, in catalogue order.
  */
 export declare function planProfiles(usage: LanguageUsage[], config: PRCheckMateConfig): ProfileDecision[];
-export {};

package/dist/core/install/profiles.js

@@ -54,12 +54,33 @@ exports.PROFILES = [
         checks: ['Ruff Lint', 'Ruff Format'],
         languages: ['python'],
     },
+    {
+        // Separate from `python` because it is 19 MB against ruff's 12, and because
+        // the two answer different questions: plenty of repositories want the linter
+        // and have their own opinion about type checking. Bundling them would make
+        // `python.typecheck: false` cost the download anyway, which is the feature
+        // defeating itself.
+        name: 'pytypes',
+        packages: ['pyright'],
+        checks: ['Python Types'],
+        languages: ['python'],
+        enabledBy: config => config.python?.typecheck !== false && config.python?.enabled !== false,
+    },
     {
         name: 'cpp',
         packages: ['@wasm-fmt/clang-format'],
         checks: ['C++ Format'],
         languages: ['cpp'],
     },
+    {
+        // Go Format only. `go vet` needs the toolchain itself, which is not ours to
+        // ship, so it stays a runner dependency and is deliberately absent here.
+        name: 'go',
+        packages: ['@wasm-fmt/gofmt'],
+        checks: ['Go Format'],
+        languages: ['go'],
+        enabledBy: config => config.go?.enabled !== false,
+    },
     {
         // The four below are not languages. They are single checks with heavy
         // tooling behind them, which is exactly why they are separate: switching
@@ -145,6 +166,12 @@ function decide(profile, usage, config, minFiles) {
     if (profile.name === 'core')
         return { required: true, reason: 'always installed' };
     if (profile.languages) {
+        // Asked before the file counts, because it is the cheaper and the more
+        // definite answer: a client who wrote `python.typecheck: false` has settled
+        // the question, and counting `.py` files can only override them.
+        if (profile.enabledBy && !profile.enabledBy(config)) {
+            return { required: false, reason: `${profile.checks.join(', ')} switched off` };
+        }
         const found = profile.languages
             .map(lang => usage.find(u => u.lang === lang))
             .filter((u) => Boolean(u) && u.files >= minFiles);

package/dist/core/install/reuse.d.ts

@@ -0,0 +1,41 @@
+import type { CheckContext } from '../types';
+/** One reuse decision, with the sentence that explains it. */
+interface ReuseDecision {
+    /** Search roots to prefer, or `undefined` to use our own copy. */
+    paths?: string[];
+    reason: string;
+}
+interface ReuseOptions {
+    /**
+     * The tool will read the client's OWN configuration file.
+     *
+     * When it will, the version check is the wrong question and must not be asked:
+     * a repository with ESLint 8 and a legacy `.eslintrc` can only be linted by
+     * ESLint 8, because ESLint 10 does not read eslintrc — and falling back to ours
+     * on the strength of a major mismatch would break precisely the case the reuse
+     * was there to serve. TypeScript is the same shape permanently: the check only
+     * applies when the repository has a `tsconfig.json`, so their compiler is
+     * always the one their config was written for.
+     *
+     * The version check exists for the opposite case — the client's old tool being
+     * handed configuration WE generated.
+     */
+    clientOwnsConfig?: boolean;
+}
+/**
+ * Decide whether this run should prefer the client's copy of `pkgName`.
+ *
+ * `compatible` (the default) reuses when the client's major matches ours, or when
+ * the client's own configuration is what the tool will read. A mismatch is not an
+ * error — we have our own copy — so it downgrades to ours with a line saying why.
+ */
+export declare function reuseDecision(pkgName: string, ctx: CheckContext, opts?: ReuseOptions): ReuseDecision;
+/**
+ * The search roots a check should prefer for `pkgName`, logging the reason once.
+ *
+ * The reason is logged rather than returned to each caller because it answers the
+ * question every confusing lint result starts with — "whose ESLint ran" — and no
+ * check should have to remember to say so.
+ */
+export declare function clientToolPaths(pkgName: string, ctx: CheckContext, opts?: ReuseOptions): string[] | undefined;
+export {};

package/dist/core/install/reuse.js

@@ -0,0 +1,107 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reuseDecision = reuseDecision;
+exports.clientToolPaths = clientToolPaths;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const logger_1 = require("../../utils/logger");
+const resolve_bin_1 = require("../../utils/resolve-bin");
+/**
+ * The major version we declare for a tool, from our own manifest.
+ *
+ * Read from `dependencies` rather than from the installed tree: what matters is
+ * the version our configuration was written against, and a hoisted install can
+ * resolve to something else entirely.
+ */
+function ownMajor(pkgName) {
+    try {
+        const manifest = node_path_1.default.join((0, resolve_bin_1.ownPackageRoot)(), 'package.json');
+        const deps = JSON.parse(node_fs_1.default.readFileSync(manifest, 'utf-8')).dependencies;
+        const range = deps?.[pkgName];
+        if (!range)
+            return null;
+        // `^10.6.0`, `>=3.0.0`, `~5.1` — the leading number is the major in every
+        // form we declare. Deliberately not a semver parser: this package ships zero
+        // runtime dependencies on purpose, and a major comparison is the only
+        // question being asked.
+        const major = /(\d+)/.exec(range)?.[1];
+        return major ? Number(major) : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** The major version of a package as the client actually has it installed. */
+function installedMajor(pkgName, from) {
+    let dir = from;
+    while (dir !== node_path_1.default.dirname(dir)) {
+        const manifest = node_path_1.default.join(dir, 'node_modules', pkgName, 'package.json');
+        try {
+            if (node_fs_1.default.existsSync(manifest)) {
+                const version = JSON.parse(node_fs_1.default.readFileSync(manifest, 'utf-8'))
+                    .version;
+                const major = version ? /(\d+)/.exec(version)?.[1] : undefined;
+                return major ? Number(major) : null;
+            }
+        }
+        catch {
+            return null;
+        }
+        dir = node_path_1.default.dirname(dir);
+    }
+    return null;
+}
+/**
+ * Decide whether this run should prefer the client's copy of `pkgName`.
+ *
+ * `compatible` (the default) reuses when the client's major matches ours, or when
+ * the client's own configuration is what the tool will read. A mismatch is not an
+ * error — we have our own copy — so it downgrades to ours with a line saying why.
+ */
+function reuseDecision(pkgName, ctx, opts = {}) {
+    const policy = ctx.config.install?.reuseLocal ?? 'compatible';
+    if (policy === 'off') {
+        return { reason: 'install.reuseLocal is "off" — using our own copy for reproducibility' };
+    }
+    const clientMajor = installedMajor(pkgName, ctx.cwd);
+    if (clientMajor === null) {
+        return { reason: `${pkgName} is not installed in the repository — using our own copy` };
+    }
+    if (policy === 'always') {
+        return {
+            paths: [ctx.cwd],
+            reason: `install.reuseLocal is "always" — using ${pkgName}@${clientMajor} from the repository`,
+        };
+    }
+    if (opts.clientOwnsConfig) {
+        return {
+            paths: [ctx.cwd],
+            reason: `using ${pkgName}@${clientMajor} from the repository — it reads the repository's own config`,
+        };
+    }
+    const ourMajor = ownMajor(pkgName);
+    if (ourMajor === null || clientMajor === ourMajor) {
+        return {
+            paths: [ctx.cwd],
+            reason: `using ${pkgName}@${clientMajor} from the repository (matches ours)`,
+        };
+    }
+    return {
+        reason: `the repository has ${pkgName}@${clientMajor} and our config is written for @${ourMajor} — using our own copy`,
+    };
+}
+/**
+ * The search roots a check should prefer for `pkgName`, logging the reason once.
+ *
+ * The reason is logged rather than returned to each caller because it answers the
+ * question every confusing lint result starts with — "whose ESLint ran" — and no
+ * check should have to remember to say so.
+ */
+function clientToolPaths(pkgName, ctx, opts = {}) {
+    const decision = reuseDecision(pkgName, ctx, opts);
+    logger_1.logger.debug(`[reuseLocal]: ${decision.reason}`);
+    return decision.paths;
+}

package/dist/core/registry.js

@@ -18,21 +18,13 @@ const merge_conflict_1 = require("./checks/git/merge-conflict");
 const missing_tests_1 = require("./checks/git/missing-tests");
 const todo_fixme_1 = require("./checks/git/todo-fixme");
 const cpp_format_1 = require("./checks/languages/cpp-format");
-const csharp_format_1 = require("./checks/languages/csharp-format");
+const external_checks_1 = require("./checks/languages/external-checks");
 const go_format_1 = require("./checks/languages/go-format");
-const go_lint_1 = require("./checks/languages/go-lint");
-const kotlin_lint_1 = require("./checks/languages/kotlin-lint");
 const lint_1 = require("./checks/languages/lint");
-const php_format_1 = require("./checks/languages/php-format");
 const prettier_1 = require("./checks/languages/prettier");
 const python_format_1 = require("./checks/languages/python-format");
 const python_lint_1 = require("./checks/languages/python-lint");
 const python_typecheck_1 = require("./checks/languages/python-typecheck");
-const ruby_lint_1 = require("./checks/languages/ruby-lint");
-const rust_format_1 = require("./checks/languages/rust-format");
-const rust_lint_1 = require("./checks/languages/rust-lint");
-const shellcheck_1 = require("./checks/languages/shellcheck");
-const swift_lint_1 = require("./checks/languages/swift-lint");
 const typecheck_1 = require("./checks/languages/typecheck");
 const commitlint_1 = require("./checks/pr/commitlint");
 const pr_body_1 = require("./checks/pr/pr-body");
@@ -101,18 +93,18 @@ exports.REGISTRY = [
     python_lint_1.pythonLintCheck,
     python_typecheck_1.pythonTypecheckCheck,
     dead_code_1.deadCodeCheck,
-    swift_lint_1.swiftLintCheck,
-    kotlin_lint_1.kotlinLintCheck,
-    go_lint_1.goLintCheck,
-    rust_lint_1.rustLintCheck,
-    ruby_lint_1.rubyLintCheck,
-    shellcheck_1.shellcheckCheck,
+    external_checks_1.swiftLintCheck,
+    external_checks_1.kotlinLintCheck,
+    external_checks_1.goLintCheck,
+    external_checks_1.rustLintCheck,
+    external_checks_1.rubyLintCheck,
+    external_checks_1.shellcheckCheck,
     // format
     prettier_1.prettierCheck,
     cpp_format_1.cppFormatCheck,
     python_format_1.pythonFormatCheck,
     go_format_1.goFormatCheck,
-    rust_format_1.rustFormatCheck,
-    csharp_format_1.csharpFormatCheck,
-    php_format_1.phpFormatCheck,
+    external_checks_1.rustFormatCheck,
+    external_checks_1.csharpFormatCheck,
+    external_checks_1.phpFormatCheck,
 ];

package/dist/core/reporters.js

@@ -8,6 +8,7 @@ exports.report = report;
 const node_fs_1 = __importDefault(require("node:fs"));
 const utils_1 = require("../utils");
 const http_1 = require("../utils/http");
+const package_version_1 = require("../utils/package-version");
 const STATUS_ICON = {
     pass: '✅',
     warn: '⚠️',
@@ -74,7 +75,7 @@ function buildMarkdownReport(report, cfg = {}) {
         // Say so rather than letting the table quietly disagree with the counts above.
         ...(hidden > 0 ? ['', `_${hidden} row(s) hidden by \`reporter.include\`._`] : []),
         '',
-        '_Generated by [PR CheckMate](https://www.npmjs.com/package/pr-checkmate)_',
+        `_Generated by [PR CheckMate](https://www.npmjs.com/package/pr-checkmate) v${(0, package_version_1.packageVersion)()}_`,
     ].join('\n');
 }
 /**
@@ -89,7 +90,12 @@ function printStdout(report, cfg) {
     const { passed, warned, failed, skipped } = report.summary;
     utils_1.logger.print('');
     utils_1.logger.print(SUMMARY_BORDER);
-    utils_1.logger.print('  PR CheckMate Summary');
+    // The version belongs in the headline, not in a footnote. Which copy of
+    // pr-checkmate produced a report is the first thing to establish when the
+    // report disagrees with what someone expects, and it is not otherwise
+    // recoverable from the log: a stale global install answers `pr-checkmate` on
+    // `PATH` ahead of the project's own, and reads the same config while doing it.
+    utils_1.logger.print(`  PR CheckMate Summary  ·  v${(0, package_version_1.packageVersion)()}`);
     utils_1.logger.print(SUMMARY_BORDER);
     for (const r of report.results) {
         const details = r.details ? `: ${r.details}` : '';