pr-checkmate 1.22.7 → 1.23.0

package/dist/core/targets.d.ts

@@ -6,6 +6,22 @@ import type { CheckContext } from './types';
  * `null` when git itself is unusable (caller should `skip`).
  *
  * Only ACMR files are returned (Added/Copied/Modified/Renamed) — deletions are
- * excluded, so every returned path exists on disk and is safe to read.
+ * excluded. Results are additionally filtered to paths that still exist on disk,
+ * so a rename/move within the diff range (where the old path shows up but no
+ * longer exists) can never hand a missing path to a downstream tool like ESLint
+ * or Prettier, which crash hard on a non-existent pattern.
  */
 export declare function resolveTargetFiles(ctx: CheckContext, globs: string[]): Promise<string[] | null>;
+/**
+ * Like {@link resolveTargetFiles} but restricts results to the configured
+ * `sourcePath`(s). Preserves the semantics of the old `sourcePath` full-scan
+ * fallback while gaining delta support on every platform via `ctx.baseSha`.
+ */
+export declare function resolveScopedTargetFiles(ctx: CheckContext, globs: string[], sourcePaths: string[]): Promise<string[] | null>;
+/**
+ * List ALL tracked files matching `globs` (never delta), scoped to
+ * `sourcePath`(s). For whole-repo analyses like circular-dependency detection
+ * that need the full graph, not just the PR diff. Using `git ls-files` means
+ * untracked `node_modules` is excluded by construction.
+ */
+export declare function listTrackedFiles(ctx: CheckContext, globs: string[], sourcePaths: string[]): Promise<string[]>;

package/dist/core/targets.js

@@ -1,8 +1,28 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveTargetFiles = resolveTargetFiles;
+exports.resolveScopedTargetFiles = resolveScopedTargetFiles;
+exports.listTrackedFiles = listTrackedFiles;
+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");
+/**
+ * Drop files that live under any excluded directory (client `ignoreDirs` or the
+ * curated default), matched on any path segment so nesting depth doesn't matter.
+ * Applied to every check's file list so build/tooling/report dirs are never
+ * scanned, even when committed.
+ */
+function excludeIgnoredDirs(files) {
+    const ignored = new Set((0, config_1.getIgnoredDirs)());
+    if (ignored.size === 0)
+        return files;
+    return files.filter(f => !f.split('/').some(segment => ignored.has(segment)));
+}
 /**
  * Lists the files a language check should operate on, matched by pathspec `globs`
  * (e.g. `['*.py']`). Uses the PR diff range when available (delta mode), else
@@ -10,7 +30,10 @@ const execa_1 = require("../utils/execa");
  * `null` when git itself is unusable (caller should `skip`).
  *
  * Only ACMR files are returned (Added/Copied/Modified/Renamed) — deletions are
- * excluded, so every returned path exists on disk and is safe to read.
+ * excluded. Results are additionally filtered to paths that still exist on disk,
+ * so a rename/move within the diff range (where the old path shows up but no
+ * longer exists) can never hand a missing path to a downstream tool like ESLint
+ * or Prettier, which crash hard on a non-existent pattern.
  */
 async function resolveTargetFiles(ctx, globs) {
     try {
@@ -25,11 +48,16 @@ async function resolveTargetFiles(ctx, globs) {
                 ...globs,
             ]
             : ['ls-files', ...globs];
-        const { stdout } = await (0, execa_1.execa)('git', args, { cwd: ctx.cwd, reject: false });
-        const files = stdout
+        const cacheKey = `t:${args.join('
')}`;
+        let stdout = ctx.cache?.get(cacheKey);
+        if (stdout === undefined) {
+            stdout = (await (0, execa_1.execa)('git', args, { cwd: ctx.cwd, reject: false })).stdout;
+            ctx.cache?.set(cacheKey, stdout);
+        }
+        const files = excludeIgnoredDirs(stdout
             .split('\n')
             .map(f => f.trim())
-            .filter(Boolean);
+            .filter(Boolean)).filter(f => node_fs_1.default.existsSync(node_path_1.default.join(ctx.cwd, f)));
         utils_1.logger.info(`[targets]: ${ctx.baseSha ? '📂 Delta' : 'Full scan'}: ${files.length} file(s) for ${globs.join(', ')}`);
         return files;
     }
@@ -38,3 +66,45 @@ async function resolveTargetFiles(ctx, globs) {
         return null;
     }
 }
+/**
+ * Restrict a list of repo-relative paths to the configured `sourcePath`(s).
+ * A source path of `.` (or one that normalizes to empty) imposes no
+ * restriction, so the whole repo is considered.
+ */
+function scopeToSourcePaths(files, sourcePaths) {
+    const scopes = sourcePaths.map(p => p.replace(/^\.\/?/, '').replace(/\/+$/, '')).filter(Boolean);
+    if (scopes.length === 0)
+        return files;
+    return files.filter(f => scopes.some(s => f === s || f.startsWith(`${s}/`)));
+}
+/**
+ * Like {@link resolveTargetFiles} but restricts results to the configured
+ * `sourcePath`(s). Preserves the semantics of the old `sourcePath` full-scan
+ * fallback while gaining delta support on every platform via `ctx.baseSha`.
+ */
+async function resolveScopedTargetFiles(ctx, globs, sourcePaths) {
+    const files = await resolveTargetFiles(ctx, globs);
+    if (files === null)
+        return null;
+    return scopeToSourcePaths(files, sourcePaths);
+}
+/**
+ * List ALL tracked files matching `globs` (never delta), scoped to
+ * `sourcePath`(s). For whole-repo analyses like circular-dependency detection
+ * that need the full graph, not just the PR diff. Using `git ls-files` means
+ * untracked `node_modules` is excluded by construction.
+ */
+async function listTrackedFiles(ctx, globs, sourcePaths) {
+    try {
+        const { stdout } = await (0, execa_1.execa)('git', ['ls-files', ...globs], { cwd: ctx.cwd, reject: false });
+        const files = excludeIgnoredDirs(stdout
+            .split('\n')
+            .map(f => f.trim())
+            .filter(Boolean));
+        return scopeToSourcePaths(files, sourcePaths);
+    }
+    catch (err) {
+        utils_1.logger.warn(`[targets]: ⚠️ Could not list tracked files\n${err}`);
+        return [];
+    }
+}

package/dist/core/types.d.ts

@@ -24,6 +24,12 @@ export interface CheckContext {
     /** Diff range for delta-aware checks; undefined → full-repo scan. */
     baseSha?: string;
     headSha?: string;
+    /**
+     * Per-run memoization cache for identical git invocations (many checks diff
+     * the same range). Created once per `runChecks`; safe because git state is
+     * stable within a run. Keyed by the git args.
+     */
+    cache?: Map<string, string>;
 }
 /** Outcome of a single check — the name is attached by the orchestrator. */
 export interface CheckOutcome {
@@ -42,7 +48,7 @@ export interface Check {
     applies(ctx: CheckContext): boolean | Promise<boolean>;
     run(ctx: CheckContext): Promise<CheckOutcome>;
 }
-export type ReporterKind = 'none' | 'stdout' | 'github';
+export type ReporterKind = 'none' | 'stdout' | 'github' | 'gitlab' | 'bitbucket' | 'auto';
 /** Custom reporter: receives the final report to emit however the consumer wants. */
 export type ReporterFn = (report: CheckReport) => void | Promise<void>;
 export interface RunOptions {
@@ -78,6 +84,12 @@ export interface RunOptions {
     config?: PRCheckMateConfig;
     baseSha?: string;
     headSha?: string;
+    /**
+     * Pre-commit / local mode: check the staged changes (index vs HEAD) instead of
+     * a PR range. Implemented by diffing HEAD against the index tree
+     * (`git write-tree`), so every delta-aware check works unchanged.
+     */
+    staged?: boolean;
 }
 export interface CheckReport {
     results: CheckResult[];

package/dist/index.d.ts

@@ -6,5 +6,5 @@
 export { runChecks, buildContext, REGISTRY } from './core';
 export { pass, warn, fail, skip, defineCheck } from './core';
 export type { Check, CheckContext, CheckOutcome, CheckReport, CheckResult, CheckStatus, Language, Phase, ReporterFn, ReporterKind, RunOptions, } from './core';
-export { getSourcePath, getPackageConfigPath, hasLocalConfig } from './config';
+export { getSourcePath, getSourcePaths, getIgnoredDirs, getPackageConfigPath, hasLocalConfig, } from './config';
 export type { PRCheckMateConfig } from './interfaces';

package/dist/index.js

@@ -5,7 +5,7 @@
  * @module pr-checkmate
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasLocalConfig = exports.getPackageConfigPath = exports.getSourcePath = exports.defineCheck = exports.skip = exports.fail = exports.warn = exports.pass = exports.REGISTRY = exports.buildContext = exports.runChecks = void 0;
+exports.hasLocalConfig = exports.getPackageConfigPath = exports.getIgnoredDirs = exports.getSourcePaths = exports.getSourcePath = exports.defineCheck = exports.skip = exports.fail = exports.warn = exports.pass = exports.REGISTRY = exports.buildContext = exports.runChecks = void 0;
 // Primary programmatic API: run checks and receive a structured report.
 // Never throws for violations, never calls process.exit — the caller decides.
 var core_1 = require("./core");
@@ -22,5 +22,7 @@ Object.defineProperty(exports, "defineCheck", { enumerable: true, get: function
 // Config helpers for consumers embedding pr-checkmate.
 var config_1 = require("./config");
 Object.defineProperty(exports, "getSourcePath", { enumerable: true, get: function () { return config_1.getSourcePath; } });
+Object.defineProperty(exports, "getSourcePaths", { enumerable: true, get: function () { return config_1.getSourcePaths; } });
+Object.defineProperty(exports, "getIgnoredDirs", { enumerable: true, get: function () { return config_1.getIgnoredDirs; } });
 Object.defineProperty(exports, "getPackageConfigPath", { enumerable: true, get: function () { return config_1.getPackageConfigPath; } });
 Object.defineProperty(exports, "hasLocalConfig", { enumerable: true, get: function () { return config_1.hasLocalConfig; } });

package/dist/init.js

@@ -10,19 +10,45 @@ const inquirer_1 = __importDefault(require("inquirer"));
 const config_1 = require("./config");
 const utils_1 = require("./utils");
 const CONFIG_FILE = path_1.default.resolve(process.cwd(), 'pr-checkmate.json');
+/**
+ * Load the canonical default ESLint rules (the same set eslint.config.mjs
+ * applies) so the generated pr-checkmate.json lists every rule for the user to
+ * change or disable. Falls back to an empty object if the file is unavailable.
+ */
+function loadDefaultEslintRules() {
+    try {
+        return JSON.parse(fs_1.default.readFileSync((0, config_1.getPackageConfigPath)('eslint-default-rules.json'), 'utf-8'));
+    }
+    catch (err) {
+        utils_1.logger.warn(`[init]: ⚠️ Could not load default ESLint rules: ${err}`);
+        return {};
+    }
+}
 /**
  * Default configuration structure with customization options
  */
 const DEFAULT_CONFIG = {
-    sourcePath: 'src',
+    // Points editors (VS Code, etc.) at the bundled JSON schema for autocomplete
+    // and inline validation of this file.
+    $schema: './node_modules/pr-checkmate/pr-checkmate.schema.json',
+    // Human-readable hints. JSON has no comments, so these `//`-prefixed keys are
+    // just informational strings — PR CheckMate ignores them at runtime.
+    '// reporting': [
+        'Results post to the PR/MR automatically.',
+        'GitHub: no setup — the runner injects GITHUB_TOKEN; just keep `permissions: pull-requests: write` in the workflow.',
+        'GitLab: create a token (Project → Settings → Access Tokens, scope `api`) and add it as CI/CD variable GITLAB_TOKEN.',
+        'Bitbucket: create a token (Repo → Settings → Access tokens, scope pull-requests:write) and add it as repo variable BITBUCKET_TOKEN.',
+        'The token lives in YOUR CI variables, never in this file. Without it, checks still run and print to the log — only the comment is skipped.',
+    ].join(' '),
+    sourcePath: '.',
+    // Directories excluded from every check (matched on any path segment). Edit
+    // freely — add your own generated/vendored dirs or remove ones you want scanned.
+    ignoreDirs: config_1.IGNORED_DIRS,
     commands: config_1.DEFAULT_COMMANDS,
-    // ESLint customization
+    // ESLint — the full default rule set is written out so every rule is visible
+    // and editable. Change any value, or set a rule to "off" to disable it.
     eslint: {
-        rules: {
-            // Off by default: its `--fix` injects empty `/** */` JSDoc stubs into
-            // client source files. Set to 'warn'/'error' to opt into doc enforcement.
-            'jsdoc/require-jsdoc': 'off',
-        },
+        rules: loadDefaultEslintRules(),
         ignorePatterns: [],
     },
     // Prettier customization
@@ -80,6 +106,57 @@ const DEFAULT_CONFIG = {
         // test runner. Add barrels/entry points here to exempt intentional exports.
         ignoreFiles: config_1.DEAD_CODE_IGNORE_DEFAULTS,
     },
+    // User-defined rules: regex patterns run against added diff lines. The escape
+    // hatch to enforce any project rule without code. Example entry:
+    //   { "name": "no-focused-tests", "pattern": "\\b(describe|it)\\.only\\(",
+    //     "message": "focused test left in", "severity": "error",
+    //     "include": ["src/**"], "exclude": ["**/*.test.*"] }
+    customRules: [],
+    // Universal per-check severity override, keyed by the check's display name (as
+    // shown in the report). "error" fails the run, "warn" is advisory, "off"
+    // disables the check. Empty by default — every check uses its built-in
+    // severity. Examples: { "Merge Conflict": "warn", "ESLint": "error" }.
+    severity: {},
+    // Git / PR-diff heuristics (delta-aware). Merge Conflict is blocking by
+    // default; the rest are advisory — promote any of them with `severity`.
+    mergeConflict: { enabled: true },
+    leftoverDebug: { enabled: true },
+    lockfileDrift: { enabled: true },
+    largeFiles: { enabled: true, maxSizeKb: 500, allow: [] },
+    missingTests: { enabled: true },
+    todoFixme: { enabled: true, requireTicket: false },
+    migrationSafety: { enabled: true },
+    // Security (regex diff scans + sensitive-file guard). Secret scan / npm audit
+    // live under `security`.
+    diffSecurity: { enabled: true },
+    sensitiveFileGuard: { enabled: true },
+    workflowSecurity: { enabled: true }, // GitHub Actions: injection, unpinned actions
+    dockerfileSecurity: { enabled: true }, // Dockerfile: :latest, USER root, curl|bash, …
+    caseCollision: { enabled: true }, // files differing only by case
+    vulnScan: { enabled: false }, // cross-language dep vulns (osv-scanner, runner-dependency)
+    // Test-coverage presence. Opt-in: enable once your CI produces a coverage
+    // report (lcov/cobertura/jacoco/…); warns if none is found.
+    coverage: { enabled: false },
+    // PR metadata / dependency hygiene.
+    prSize: { enabled: true, maxFiles: 50, maxLines: 1000 },
+    commitlint: { enabled: true },
+    // Dependencies you want to forbid. Example: { "name": "moment", "message": "use date-fns" }.
+    bannedImports: [],
+    // License/copyright header on new source files. Opt-in — set enabled + pattern.
+    licenseHeader: { enabled: false, pattern: '', lines: 10 },
+    outdatedDeps: { enabled: true, ignore: [] },
+    // Per-language checks. Bundled (no client install): TypeScript, Python (Ruff),
+    // C++ (clang-format). Runner-dependency (need the tool on the runner, skip
+    // gracefully if absent): Swift, Kotlin, Go, Rust, C#, Ruby, PHP.
+    python: { enabled: true, typecheck: true },
+    cpp: { enabled: true },
+    swift: { enabled: true },
+    kotlin: { enabled: true },
+    go: { enabled: true },
+    rust: { enabled: true },
+    csharp: { enabled: true },
+    ruby: { enabled: true },
+    php: { enabled: true },
     documentation: config_1.documentation,
 };
 const MANUAL_ENTRY = 'Enter manually';
@@ -90,7 +167,8 @@ async function promptSourcePath() {
             type: 'list',
             name: 'sourcePath',
             message: 'Where is your project source code?',
-            choices: ['src', 'app', MANUAL_ENTRY],
+            default: '.',
+            choices: [{ name: '. (entire repo — recommended)', value: '.' }, 'src', 'app', MANUAL_ENTRY],
         },
         {
             type: 'input',

package/dist/interfaces/index.d.ts

@@ -21,8 +21,19 @@ export interface CspellConfig {
     ignoreRegExpList: string[];
 }
 export interface PRCheckMateConfig {
-    sourcePath: string;
+    sourcePath: string | string[];
+    ignoreDirs?: string[];
     languages?: Language[];
+    customRules?: Array<{
+        name: string;
+        pattern: string;
+        message?: string;
+        severity?: 'error' | 'warn';
+        include?: string[];
+        exclude?: string[];
+        flags?: string;
+    }>;
+    severity?: Record<string, 'error' | 'warn' | 'off'>;
     lint?: {
         rules?: Record<string, any>;
         ignorePatterns?: string[];
@@ -59,10 +70,52 @@ export interface PRCheckMateConfig {
             lint?: boolean;
             format?: boolean;
         };
+        typecheck?: boolean;
+        typeChecker?: 'mypy' | 'pyright';
     };
     diffSmell?: {
         enabled?: boolean;
     };
+    prSize?: {
+        enabled?: boolean;
+        maxFiles?: number;
+        maxLines?: number;
+    };
+    leftoverDebug?: {
+        enabled?: boolean;
+        severity?: 'error' | 'warn';
+    };
+    todoFixme?: {
+        enabled?: boolean;
+        severity?: 'error' | 'warn';
+        requireTicket?: boolean;
+        keywords?: string[];
+    };
+    lockfileDrift?: {
+        enabled?: boolean;
+        severity?: 'error' | 'warn';
+    };
+    missingTests?: {
+        enabled?: boolean;
+        severity?: 'error' | 'warn';
+        ignore?: string[];
+    };
+    migrationSafety?: {
+        enabled?: boolean;
+        severity?: 'error' | 'warn';
+        paths?: string[];
+    };
+    coverage?: {
+        enabled?: boolean;
+        severity?: 'error' | 'warn';
+        reportPath?: string | string[];
+    };
+    largeFiles?: {
+        enabled?: boolean;
+        severity?: 'error' | 'warn';
+        maxSizeKb?: number;
+        allow?: string[];
+    };
     prBody?: {
         enabled?: boolean;
         minLength?: number;
@@ -121,6 +174,38 @@ export interface PRCheckMateConfig {
     };
     diffSecurity?: {
         enabled?: boolean;
+        ignore?: string[];
+    };
+    mergeConflict?: {
+        enabled?: boolean;
+        severity?: 'error' | 'warn';
+    };
+    workflowSecurity?: {
+        enabled?: boolean;
+        ignore?: string[];
+    };
+    dockerfileSecurity?: {
+        enabled?: boolean;
+        ignore?: string[];
+    };
+    caseCollision?: {
+        enabled?: boolean;
+    };
+    configValidation?: {
+        enabled?: boolean;
+    };
+    vulnScan?: {
+        enabled?: boolean;
+    };
+    bannedImports?: Array<{
+        name: string;
+        message?: string;
+        severity?: 'error' | 'warn';
+    }>;
+    licenseHeader?: {
+        enabled?: boolean;
+        pattern?: string;
+        lines?: number;
     };
     sensitiveFileGuard?: {
         enabled?: boolean;
@@ -131,6 +216,21 @@ export interface PRCheckMateConfig {
     kotlin?: {
         enabled?: boolean;
     };
+    go?: {
+        enabled?: boolean;
+    };
+    rust?: {
+        enabled?: boolean;
+    };
+    csharp?: {
+        enabled?: boolean;
+    };
+    ruby?: {
+        enabled?: boolean;
+    };
+    php?: {
+        enabled?: boolean;
+    };
     deadCode?: {
         enabled?: boolean;
         /**

package/dist/scripts/copy-configs.js

@@ -7,12 +7,17 @@ const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const utils_1 = require("../utils");
 const configFiles = [
-    { source: 'src/config/eslint.config.mjs', dest: 'eslint.config.mjs' },
+    // Source is named so ESLint's auto-discovery does NOT treat it as a nested
+    // config for files under src/config/ — it ships to the package root as the
+    // canonical `eslint.config.mjs`.
+    { source: 'src/config/eslint-flat-config.mjs', dest: 'eslint.config.mjs' },
+    { source: 'src/config/eslint-default-rules.json', dest: 'eslint-default-rules.json' },
     { source: 'src/config/.eslintrc.js', dest: '.eslintrc.js' },
     { source: 'src/config/.prettierrc', dest: '.prettierrc' },
     { source: 'src/config/cspell.json', dest: 'cspell.json' },
     { source: 'tsconfig.json', dest: 'tsconfig.json' },
     { source: 'src/config/pr-checkmate-workflow.yml', dest: 'dist/config/pr-checkmate-workflow.yml' },
+    { source: 'src/config/pr-checkmate.schema.json', dest: 'pr-checkmate.schema.json' },
 ];
 /**
  *

package/dist/utils/detect-language.d.ts

@@ -1,4 +1,4 @@
-export type Language = 'typescript' | 'javascript' | 'python' | 'cpp' | 'swift' | 'kotlin';
+export type Language = 'typescript' | 'javascript' | 'python' | 'cpp' | 'swift' | 'kotlin' | 'go' | 'rust' | 'csharp' | 'ruby' | 'php';
 /**
  * Detects which languages a repository uses, combining marker files (definitive)
  * with tracked source-file counts (breadth). A language is reported when it has a

package/dist/utils/detect-language.js

@@ -7,6 +7,7 @@ exports.detectLanguages = detectLanguages;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const execa_1 = require("./execa");
+const glob_1 = require("./glob");
 const logger_1 = require("./logger");
 /**
  * Marker files that unambiguously indicate a language's presence, independent of
@@ -26,6 +27,13 @@ const MARKER_FILES = {
         'settings.gradle.kts',
         'AndroidManifest.xml',
     ],
+    go: ['go.mod'],
+    rust: ['Cargo.toml'],
+    // Glob markers (`*.csproj`/`*.sln`) — matched against root dir entries, since
+    // C# projects have no single fixed marker filename.
+    csharp: ['*.csproj', '*.sln'],
+    ruby: ['Gemfile', '.rubocop.yml'],
+    php: ['composer.json'],
 };
 /**
  * Source extensions per language, used to count tracked files via `git ls-files`.
@@ -37,9 +45,25 @@ const EXTENSIONS = {
     cpp: ['.cpp', '.cc', '.cxx', '.c++', '.hpp', '.hh', '.hxx'],
     swift: ['.swift'],
     kotlin: ['.kt', '.kts', '.java'],
+    go: ['.go'],
+    rust: ['.rs'],
+    csharp: ['.cs'],
+    ruby: ['.rb', '.rake'],
+    php: ['.php'],
 };
 function hasMarker(root, lang) {
-    return MARKER_FILES[lang].some(name => node_fs_1.default.existsSync(node_path_1.default.join(root, name)));
+    return MARKER_FILES[lang].some(name => {
+        if (!name.includes('*'))
+            return node_fs_1.default.existsSync(node_path_1.default.join(root, name));
+        // Glob marker (e.g. `*.csproj`): match against root-directory entries.
+        try {
+            const re = (0, glob_1.globToRegExp)(name);
+            return node_fs_1.default.readdirSync(root).some(entry => re.test(entry));
+        }
+        catch {
+            return false;
+        }
+    });
 }
 /**
  * Counts tracked files per language using `git ls-files`. Returns an empty map
@@ -54,6 +78,11 @@ async function countTrackedFiles(root) {
         cpp: 0,
         swift: 0,
         kotlin: 0,
+        go: 0,
+        rust: 0,
+        csharp: 0,
+        ruby: 0,
+        php: 0,
     };
     try {
         const { stdout } = await (0, execa_1.execa)('git', ['ls-files'], { cwd: root });
@@ -87,7 +116,7 @@ async function detectLanguages(root = process.cwd()) {
     const counts = await countTrackedFiles(root);
     const detected = Object.keys(EXTENSIONS).filter(lang => hasMarker(root, lang) || counts[lang] > 0);
     detected.sort((a, b) => counts[b] - counts[a]);
-    logger_1.logger.info(`[detectLanguages]: Detected ${detected.length ? detected.join(', ') : 'none'} ` +
-        `(counts: ts=${counts.typescript}, js=${counts.javascript}, py=${counts.python}, cpp=${counts.cpp}, swift=${counts.swift}, kt=${counts.kotlin})`);
+    const countStr = Object.keys(counts).map(l => `${l}=${counts[l]}`).join(', ');
+    logger_1.logger.info(`[detectLanguages]: Detected ${detected.length ? detected.join(', ') : 'none'} (counts: ${countStr})`);
     return detected;
 }

package/dist/utils/glob.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Minimal glob → RegExp for path matching against config patterns. Supports `*`
+ * (matches within a path segment), `**` (across segments), and a leading `** /`
+ * that also matches the repo root (zero segments). Anchored to the whole path.
+ * Not a full glob implementation — enough for the allow/ignore lists in
+ * pr-checkmate.json (e.g. "assets/**", "*.png", "** / *.d.ts").
+ */
+export declare function globToRegExp(glob: string): RegExp;
+/** True when `file` matches any of the glob `patterns`. */
+export declare function matchesAnyGlob(file: string, patterns: string[]): boolean;

package/dist/utils/glob.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.globToRegExp = globToRegExp;
+exports.matchesAnyGlob = matchesAnyGlob;
+/**
+ * Minimal glob → RegExp for path matching against config patterns. Supports `*`
+ * (matches within a path segment), `**` (across segments), and a leading `** /`
+ * that also matches the repo root (zero segments). Anchored to the whole path.
+ * Not a full glob implementation — enough for the allow/ignore lists in
+ * pr-checkmate.json (e.g. "assets/**", "*.png", "** / *.d.ts").
+ */
+function globToRegExp(glob) {
+    const re = glob
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&') // escape regex specials (not * or /)
+        .replace(/\*\*\//g, ' dir ') // `**/` → optional leading dirs (matches root too)
+        .replace(/\*\*/g, ' any ') // bare `**` → across segments
+        .replace(/\*/g, '[^/]*') // `*` → within a segment
+        .replace(/ dir /g, '(?:.*/)?')
+        .replace(/ any /g, '.*');
+    return new RegExp(`^${re}$`);
+}
+/** True when `file` matches any of the glob `patterns`. */
+function matchesAnyGlob(file, patterns) {
+    return patterns.some(p => globToRegExp(p).test(file));
+}

package/dist/utils/index.d.ts

@@ -1,9 +1,9 @@
 export * from './logger';
-export * from './delta';
 export * from './result-collector';
 export * from './resolve-bin';
 export * from './own-deps';
 export * from './detect-language';
+export * from './glob';
 /**
  *
  */

package/dist/utils/index.js

@@ -21,11 +21,11 @@ exports.cleanupTempFile = cleanupTempFile;
 const node_fs_1 = __importDefault(require("node:fs"));
 const logger_1 = require("./logger");
 __exportStar(require("./logger"), exports);
-__exportStar(require("./delta"), exports);
 __exportStar(require("./result-collector"), exports);
 __exportStar(require("./resolve-bin"), exports);
 __exportStar(require("./own-deps"), exports);
 __exportStar(require("./detect-language"), exports);
+__exportStar(require("./glob"), exports);
 /**
  *
  */