pr-checkmate 3.0.4 → 3.2.0

package/dist/{core → cjs/core}/checks/git/large-files.d.ts

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

package/dist/{core → cjs/core}/checks/git/large-files.js

@@ -6,11 +6,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.largeFilesCheck = void 0;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
-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 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 DEFAULT_MAX_KB = 500;
 /**
  * Lockfiles are legitimately large and always generated, never accidental — so
@@ -65,16 +65,16 @@ exports.largeFilesCheck = {
         // large files anywhere in the repo — a root-level asset is exactly the case
         // a narrowed `sourcePath` would miss — but still skip `ignoreDirs`
         // (dist/build/vendor), where large generated files are expected.
-        const files = await (0, targets_1.resolveTargetFiles)(ctx, ['*']);
+        const files = await (0, targets_js_1.resolveTargetFiles)(ctx, ['*']);
         if (files === null)
-            return (0, types_1.skip)('git unavailable');
+            return (0, types_js_1.skip)('git unavailable');
         if (files.length === 0)
-            return (0, types_1.pass)();
+            return (0, types_js_1.pass)();
         const maxKb = ctx.config.largeFiles?.maxSizeKb ?? DEFAULT_MAX_KB;
         const maxBytes = maxKb * 1024;
         const allow = [...LOCKFILE_ALLOW, ...(ctx.config.largeFiles?.allow ?? [])];
         if (!ctx.baseSha && ctx.config.run?.fullScanBehaviour === 'skip')
-            return (0, types_1.pass)();
+            return (0, types_js_1.pass)();
         let binary;
         try {
             // `--numstat` reports `-\t-` for binary files. With no range there is
@@ -83,16 +83,16 @@ exports.largeFilesCheck = {
             const args = ctx.baseSha
                 ? ['diff', '--numstat', '--diff-filter=ACM', ctx.baseSha, ctx.headSha ?? 'HEAD']
                 : null;
-            const { stdout } = args ? await (0, execa_1.execa)('git', args, { cwd: ctx.cwd }) : { stdout: '' };
+            const { stdout } = args ? await (0, execa_js_1.execa)('git', args, { cwd: ctx.cwd }) : { stdout: '' };
             binary = binaryPaths(stdout);
         }
         catch (err) {
-            utils_1.logger.warn(`[Large Files]: ⚠️ Could not analyze diff\n${err}`);
-            return (0, types_1.skip)('diff unavailable');
+            index_js_1.logger.warn(`[Large Files]: ⚠️ Could not analyze diff\n${err}`);
+            return (0, types_js_1.skip)('diff unavailable');
         }
         const findings = [];
         for (const file of files) {
-            if ((0, utils_1.matchesAnyGlob)(file, allow))
+            if ((0, index_js_1.matchesAnyGlob)(file, allow))
                 continue;
             let size;
             try {
@@ -110,8 +110,8 @@ exports.largeFilesCheck = {
                 findings.push(`${file} (${reasons.join(', ')})`);
         }
         if (findings.length === 0)
-            return (0, types_1.pass)();
-        const sev = (0, findings_1.severityEmitter)(ctx.config.largeFiles?.severity, 'warn');
+            return (0, types_js_1.pass)();
+        const sev = (0, findings_js_1.severityEmitter)(ctx.config.largeFiles?.severity, 'warn');
         findings.forEach(f => sev.log(`[Large Files]: ${sev.icon} ${f}`));
         return sev.emit(`${findings.length} large/binary file(s) added`);
     },

package/dist/{core → cjs/core}/checks/git/leftover-debug.d.ts

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

package/dist/{core → cjs/core}/checks/git/leftover-debug.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.leftoverDebugCheck = void 0;
-const utils_1 = require("../../../utils");
-const types_1 = require("../../types");
-const findings_1 = require("../findings");
+const index_js_1 = require("../../../utils/index.js");
+const types_js_1 = require("../../types.js");
+const findings_js_1 = require("../findings.js");
 /**
  * Debug statements for languages NOT already covered by the Diff Smells check
  * (which handles `console.*`/`debugger` for JS/TS). Kept separate so the two
@@ -35,7 +35,7 @@ function collect(stdout, patterns, findings, mode = 'language') {
     for (const line of stdout.split('\n')) {
         const header = DIFF_FILE_HEADER.exec(line);
         if (header) {
-            syntax = mode === 'language' ? (0, findings_1.commentSyntaxFor)(header[1]) : 'both';
+            syntax = mode === 'language' ? (0, findings_js_1.commentSyntaxFor)(header[1]) : 'both';
             continue;
         }
         // Honour an inline opt-out in any comment style (`// pr-checkmate-ignore`,
@@ -43,7 +43,7 @@ function collect(stdout, patterns, findings, mode = 'language') {
         if (line.includes('pr-checkmate-ignore'))
             continue;
         // Match on the comment-stripped line so `# print(x)` in a comment isn't flagged.
-        const scanned = mode === 'off' ? line : (0, findings_1.stripInlineComment)(line, syntax);
+        const scanned = mode === 'off' ? line : (0, findings_js_1.stripInlineComment)(line, syntax);
         for (const { pattern, label } of patterns) {
             if (pattern.test(scanned)) {
                 (findings[label] ?? (findings[label] = [])).push(line.slice(1).trim().substring(0, 100));
@@ -67,26 +67,26 @@ exports.leftoverDebugCheck = {
             let reviewed = true;
             if (ctx.languages.includes('python')) {
                 reviewed =
-                    (await (0, findings_1.reviewLines)(ctx, ['*.py'], out => collect(out, PYTHON_PATTERNS, findings, comments))) && reviewed;
+                    (await (0, findings_js_1.reviewLines)(ctx, ['*.py'], out => collect(out, PYTHON_PATTERNS, findings, comments))) && reviewed;
             }
             if (ctx.languages.includes('kotlin')) {
                 reviewed =
-                    (await (0, findings_1.reviewLines)(ctx, ['*.kt', '*.kts', '*.java'], out => collect(out, KOTLIN_PATTERNS, findings, comments))) && reviewed;
+                    (await (0, findings_js_1.reviewLines)(ctx, ['*.kt', '*.kts', '*.java'], out => collect(out, KOTLIN_PATTERNS, findings, comments))) && reviewed;
             }
             if (!reviewed)
-                return (0, types_1.skip)('git unavailable');
-            if ((0, findings_1.bucketTotal)(findings) === 0)
-                return (0, types_1.pass)();
+                return (0, types_js_1.skip)('git unavailable');
+            if ((0, findings_js_1.bucketTotal)(findings) === 0)
+                return (0, types_js_1.pass)();
             // Advisory by default; a repo may promote to a gate via
             // `leftoverDebug.severity: 'error'`.
-            return (0, findings_1.reportCountedFindings)(findings, ctx, {
+            return (0, findings_js_1.reportCountedFindings)(findings, ctx, {
                 prefix: 'Leftover Debug',
                 severity: ctx.config.leftoverDebug?.severity,
             });
         }
         catch (err) {
-            utils_1.logger.warn(`[Leftover Debug]: ⚠️ Could not analyze diff\n${err}`);
-            return (0, types_1.skip)('diff unavailable');
+            index_js_1.logger.warn(`[Leftover Debug]: ⚠️ Could not analyze diff\n${err}`);
+            return (0, types_js_1.skip)('diff unavailable');
         }
     },
 };

package/dist/{core → cjs/core}/checks/git/lockfile-drift.d.ts

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

package/dist/{core → cjs/core}/checks/git/lockfile-drift.js

@@ -6,11 +6,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.lockfileDriftCheck = void 0;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
-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 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");
 /**
  * Manifest → its lockfile(s). A change to the manifest's dependency set without
  * a corresponding lockfile update is drift: CI resolves versions the author
@@ -55,7 +55,7 @@ async function packageDepsChanged(ctx, manifestPath, base) {
         // Head file unreadable (e.g. deleted) — treat as changed so it surfaces.
         return true;
     }
-    const { stdout, exitCode } = await (0, execa_1.execa)('git', ['show', `${base}:${manifestPath}`], {
+    const { stdout, exitCode } = await (0, execa_js_1.execa)('git', ['show', `${base}:${manifestPath}`], {
         cwd: ctx.cwd,
         reject: false,
     });
@@ -78,14 +78,14 @@ exports.lockfileDriftCheck = {
             // `excludePaths` is still applied, below: not scoping is an argument about
             // WHERE these files live, not a licence to ignore a client who named one
             // (ticket 080). A vendored sub-project's lockfile is a real case.
-            const { stdout } = await (0, execa_1.execa)('git', [
+            const { stdout } = await (0, execa_js_1.execa)('git', [
                 'diff',
                 '--name-only',
                 '--diff-filter=ACMRD',
                 ctx.baseSha,
                 ctx.headSha ?? 'HEAD',
             ], { cwd: ctx.cwd });
-            const changed = new Set((0, targets_1.excludeClientPaths)(stdout.split('\n').filter(Boolean), ctx.cwd));
+            const changed = new Set((0, targets_js_1.excludeClientPaths)(stdout.split('\n').filter(Boolean), ctx.cwd));
             const warnings = [];
             for (const changedPath of changed) {
                 const pair = LOCK_PAIRS.find(p => p.manifest === node_path_1.default.basename(changedPath));
@@ -107,14 +107,14 @@ exports.lockfileDriftCheck = {
                 }
             }
             if (warnings.length === 0)
-                return (0, types_1.pass)();
-            const sev = (0, findings_1.severityEmitter)(ctx.config.lockfileDrift?.severity, 'warn');
+                return (0, types_js_1.pass)();
+            const sev = (0, findings_js_1.severityEmitter)(ctx.config.lockfileDrift?.severity, 'warn');
             warnings.forEach(w => sev.log(`[Lockfile Drift]: ${sev.icon} ${w}`));
             return sev.emit(`${warnings.length} manifest(s) changed without a lockfile update`);
         }
         catch (err) {
-            utils_1.logger.warn(`[Lockfile Drift]: ⚠️ Could not analyze diff\n${err}`);
-            return (0, types_1.skip)('diff unavailable');
+            index_js_1.logger.warn(`[Lockfile Drift]: ⚠️ Could not analyze diff\n${err}`);
+            return (0, types_js_1.skip)('diff unavailable');
         }
     },
 };

package/dist/{core → cjs/core}/checks/git/merge-conflict.d.ts

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

package/dist/{core → cjs/core}/checks/git/merge-conflict.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mergeConflictCheck = void 0;
-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 findings_1 = require("../findings");
+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");
+const findings_js_1 = require("../findings.js");
 /**
  * Git conflict markers, matched against the content of an added diff line
  * (the leading `+` already stripped). Each is exactly seven characters at the
@@ -82,26 +82,26 @@ exports.mergeConflictCheck = {
         // client's `ignoreDirs` and `sourcePath`), then diff only those files for
         // content. `['*']` matches every path since conflicts are language-agnostic;
         // scoping still keeps build/vendor/report dirs out, like every other check.
-        const files = await (0, targets_1.resolveScopedTargetFiles)(ctx, ['*'], (0, config_1.getSourcePaths)(ctx.cwd));
+        const files = await (0, targets_js_1.resolveScopedTargetFiles)(ctx, ['*'], (0, index_js_1.getSourcePaths)(ctx.cwd));
         if (files === null)
-            return (0, types_1.skip)('git unavailable');
+            return (0, types_js_1.skip)('git unavailable');
         if (files.length === 0)
-            return (0, types_1.pass)();
+            return (0, types_js_1.pass)();
         try {
             const hits = [];
             if (ctx.baseSha) {
-                const { stdout } = await (0, execa_1.execa)('git', ['diff', '--unified=0', ctx.baseSha, ctx.headSha ?? 'HEAD', '--', ...files], { cwd: ctx.cwd });
+                const { stdout } = await (0, execa_js_1.execa)('git', ['diff', '--unified=0', ctx.baseSha, ctx.headSha ?? 'HEAD', '--', ...files], { cwd: ctx.cwd });
                 hits.push(...scanDiff(stdout));
             }
             else if (ctx.config.run?.fullScanBehaviour !== 'skip') {
-                await (0, findings_1.scanTrackedFiles)(ctx, files, asDiff => hits.push(...scanDiff(asDiff)));
+                await (0, findings_js_1.scanTrackedFiles)(ctx, files, asDiff => hits.push(...scanDiff(asDiff)));
             }
             const found = filterHits(hits);
             if (found.length === 0)
-                return (0, types_1.pass)();
+                return (0, types_js_1.pass)();
             // Conflict markers are a hard error by default; a repo may downgrade to
             // `warn` via `mergeConflict.severity`.
-            const sev = (0, findings_1.severityEmitter)(ctx.config.mergeConflict?.severity, 'error');
+            const sev = (0, findings_js_1.severityEmitter)(ctx.config.mergeConflict?.severity, 'error');
             for (const h of found) {
                 sev.log(`[Merge Conflict]: ${sev.icon} ${h.file}:${h.line}`);
             }
@@ -113,8 +113,8 @@ exports.mergeConflictCheck = {
             return sev.emit(` unresolved conflict marker(s): ${sample}${more}`);
         }
         catch (err) {
-            utils_1.logger.warn(`[Merge Conflict]: ⚠️ Could not analyze diff\n${err}`);
-            return (0, types_1.skip)('diff unavailable');
+            index_js_2.logger.warn(`[Merge Conflict]: ⚠️ Could not analyze diff\n${err}`);
+            return (0, types_js_1.skip)('diff unavailable');
         }
     },
 };

package/dist/{core → cjs/core}/checks/git/missing-tests.d.ts

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

package/dist/{core → cjs/core}/checks/git/missing-tests.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.missingTestsCheck = void 0;
-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 findings_1 = require("../findings");
+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");
+const findings_js_1 = require("../findings.js");
 /** Source-file extensions across the supported languages. */
 const SOURCE_EXT = /\.(ts|tsx|js|jsx|mjs|cjs|py|kt|kts|java|swift|cpp|cc|cxx|c|h|hpp|go|rb)$/i;
 /** Test-file conventions across languages. */
@@ -45,14 +45,14 @@ exports.missingTestsCheck = {
     async run(ctx) {
         // Scope the same way lint does — a client's `sourcePath` and `ignoreDirs`
         // both apply, so generated/out-of-scope dirs never count as "new source".
-        const scopedList = await (0, targets_1.resolveScopedTargetFiles)(ctx, ['*'], (0, config_1.getSourcePaths)(ctx.cwd));
+        const scopedList = await (0, targets_js_1.resolveScopedTargetFiles)(ctx, ['*'], (0, index_js_1.getSourcePaths)(ctx.cwd));
         if (scopedList === null)
-            return (0, types_1.skip)('git unavailable');
+            return (0, types_js_1.skip)('git unavailable');
         const scoped = new Set(scopedList);
         const added = [];
         const touched = [];
         try {
-            const { stdout } = await (0, execa_1.execa)('git', [
+            const { stdout } = await (0, execa_js_1.execa)('git', [
                 'diff',
                 '--name-status',
                 '--diff-filter=ACM',
@@ -86,18 +86,18 @@ exports.missingTestsCheck = {
             }
         }
         catch (err) {
-            utils_1.logger.warn(`[Missing Tests]: ⚠️ Could not analyze diff\n${err}`);
-            return (0, types_1.skip)('diff unavailable');
+            index_js_2.logger.warn(`[Missing Tests]: ⚠️ Could not analyze diff\n${err}`);
+            return (0, types_js_1.skip)('diff unavailable');
         }
         const ignore = ctx.config.missingTests?.ignore ?? DEFAULT_IGNORE;
-        const addedSource = added.filter(f => SOURCE_EXT.test(f) && !isTestFile(f) && !(0, utils_1.matchesAnyGlob)(f, ignore));
+        const addedSource = added.filter(f => SOURCE_EXT.test(f) && !isTestFile(f) && !(0, index_js_2.matchesAnyGlob)(f, ignore));
         if (addedSource.length === 0)
-            return (0, types_1.pass)(); // no new source that would need a test
+            return (0, types_js_1.pass)(); // no new source that would need a test
         // A test added or modified anywhere in the diff satisfies the check —
         // `touched` only ever holds test files, collected without the source scope.
         if (touched.length > 0)
-            return (0, types_1.pass)();
-        const sev = (0, findings_1.severityEmitter)(ctx.config.missingTests?.severity, 'warn');
+            return (0, types_js_1.pass)();
+        const sev = (0, findings_js_1.severityEmitter)(ctx.config.missingTests?.severity, 'warn');
         addedSource
             .slice(0, 5)
             .forEach(f => sev.log(`[Missing Tests]: ${sev.icon} new source without tests: ${f}`));

package/dist/{core → cjs/core}/checks/git/todo-fixme.d.ts

@@ -1,4 +1,4 @@
-import { Check } from '../../types';
+import { Check } from '../../types.js';
 /**
  * Flags leftover TODO/FIXME/XXX/HACK markers in Python and Kotlin/Java comments.
  * JS/TS markers are already handled by the Diff Smells check, so this stays out

package/dist/{core → cjs/core}/checks/git/todo-fixme.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.todoFixmeCheck = void 0;
-const utils_1 = require("../../../utils");
-const types_1 = require("../../types");
-const findings_1 = require("../findings");
+const index_js_1 = require("../../../utils/index.js");
+const types_js_1 = require("../../types.js");
+const findings_js_1 = require("../findings.js");
 const DEFAULT_KEYWORDS = ['TODO', 'FIXME', 'XXX', 'HACK'];
 /** A ticket reference in the comment: `#123` or JIRA-style `PROJ-456`. */
 const TICKET_PATTERN = /#\d+|[A-Z][A-Z0-9]+-\d+/;
@@ -57,27 +57,27 @@ exports.todoFixmeCheck = {
             if (ctx.languages.includes('python')) {
                 const pattern = buildPattern('#', keywords);
                 reviewed =
-                    (await (0, findings_1.reviewLines)(ctx, ['*.py'], out => scan(out, pattern, requireTicket, findings))) &&
+                    (await (0, findings_js_1.reviewLines)(ctx, ['*.py'], out => scan(out, pattern, requireTicket, findings))) &&
                         reviewed;
             }
             if (ctx.languages.includes('kotlin')) {
                 const ktPattern = buildPattern('//|/\\*', keywords);
                 reviewed =
-                    (await (0, findings_1.reviewLines)(ctx, ['*.kt', '*.kts', '*.java'], out => scan(out, ktPattern, requireTicket, findings))) && reviewed;
+                    (await (0, findings_js_1.reviewLines)(ctx, ['*.kt', '*.kts', '*.java'], out => scan(out, ktPattern, requireTicket, findings))) && reviewed;
             }
             if (!reviewed)
-                return (0, types_1.skip)('git unavailable');
-            if ((0, findings_1.bucketTotal)(findings) === 0)
-                return (0, types_1.pass)();
-            return (0, findings_1.reportCountedFindings)(findings, ctx, {
+                return (0, types_js_1.skip)('git unavailable');
+            if ((0, findings_js_1.bucketTotal)(findings) === 0)
+                return (0, types_js_1.pass)();
+            return (0, findings_js_1.reportCountedFindings)(findings, ctx, {
                 prefix: 'TODO/FIXME',
                 severity: cfg?.severity,
                 suffix: requireTicket ? ' (no ticket reference)' : '',
             });
         }
         catch (err) {
-            utils_1.logger.warn(`[TODO/FIXME]: ⚠️ Could not analyze diff\n${err}`);
-            return (0, types_1.skip)('diff unavailable');
+            index_js_1.logger.warn(`[TODO/FIXME]: ⚠️ Could not analyze diff\n${err}`);
+            return (0, types_js_1.skip)('diff unavailable');
         }
     },
 };

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

@@ -1,4 +1,4 @@
-import { Check } from '../../types';
+import { Check } from '../../types.js';
 /**
  * Formats C/C++ code with clang-format, bundled as a self-contained WASM CLI
  * (`@wasm-fmt/clang-format`) so it runs on a bare Node image with no system

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

@@ -6,11 +6,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.cppFormatCheck = 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");
 /**
  * C/C++ source & header extensions clang-format understands. `.h` is intentionally
  * included even though it is ambiguous with C — clang-format handles both.
@@ -58,40 +58,40 @@ exports.cppFormatCheck = {
         // in `write` mode clang-format was rewriting third-party sources the client
         // does not own. It also crashed the WASM formatter, which is how this was
         // found.
-        const targets = await (0, targets_1.resolveScopedTargetFiles)(ctx, CPP_GLOBS, (0, config_1.getSourcePaths)(ctx.cwd));
+        const targets = await (0, targets_js_1.resolveScopedTargetFiles)(ctx, CPP_GLOBS, (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 C/C++ files changed');
-        const cfBin = (0, utils_1.resolvePackageBin)('@wasm-fmt/clang-format', 'clang-format-cli.cjs');
+            return (0, types_js_1.pass)('no C/C++ files changed');
+        const cfBin = (0, index_js_2.resolvePackageBin)('@wasm-fmt/clang-format', 'clang-format-cli.cjs');
         const styleArg = resolveStyleArg(ctx);
         // Detect unformatted files without mutating anything.
-        const dry = await (0, execa_1.execa)(process.execPath, [cfBin, '--dry-run', '--Werror', styleArg, ...targets], { cwd: ctx.cwd, reject: false });
+        const dry = await (0, execa_js_1.execa)(process.execPath, [cfBin, '--dry-run', '--Werror', styleArg, ...targets], { cwd: ctx.cwd, reject: false });
         if (dry.exitCode === 0)
-            return (0, types_1.pass)();
+            return (0, types_js_1.pass)();
         const offending = countOffendingFiles(dry.stderr) || targets.length;
         if (!ctx.write) {
-            utils_1.logger.warn(`[C++ Format]: ⚠️ ${offending} C/C++ file(s) need formatting`);
-            return (0, types_1.warn)(`${offending} file(s) need formatting (run with write to fix)`);
+            index_js_2.logger.warn(`[C++ Format]: ⚠️ ${offending} C/C++ file(s) need formatting`);
+            return (0, types_js_1.warn)(`${offending} file(s) need formatting (run with write to fix)`);
         }
         // write mode: rewrite the offending files in place so CI can auto-commit them.
-        const fix = await (0, execa_1.execa)(process.execPath, [cfBin, '-i', styleArg, ...targets], {
+        const fix = await (0, execa_js_1.execa)(process.execPath, [cfBin, '-i', styleArg, ...targets], {
             cwd: ctx.cwd,
             reject: false,
         });
         if (fix.exitCode !== 0) {
-            utils_1.logger.warn(`[C++ Format]: ⚠️ clang-format -i failed\n${fix.stderr}`);
+            index_js_2.logger.warn(`[C++ Format]: ⚠️ clang-format -i failed\n${fix.stderr}`);
             // A WASM runtime error is the formatter giving up on a file, not a verdict
             // about the code — and `-i` means whatever it managed before the crash is
             // already written, so the tree is half-formatted. Saying which it was
             // matters: "failed to rewrite files" sent people looking for a style
             // problem that does not exist.
             const crashed = /RuntimeError|memory access out of bounds|abort\(/.test(fix.stderr);
-            return (0, types_1.warn)(crashed
+            return (0, types_js_1.warn)(crashed
                 ? 'clang-format crashed on one of these files — some may already have been rewritten'
                 : `clang-format could not rewrite the files (exit ${fix.exitCode ?? 'killed'})`);
         }
-        utils_1.logger.info(`[C++ Format]: ✅ Reformatted ${offending} C/C++ file(s)`);
-        return (0, types_1.pass)(`reformatted ${offending} file(s)`);
+        index_js_2.logger.info(`[C++ Format]: ✅ Reformatted ${offending} C/C++ file(s)`);
+        return (0, types_js_1.pass)(`reformatted ${offending} file(s)`);
     },
 };

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

@@ -20,20 +20,20 @@
  * doubles as the Kotlin format signal). Uses the repo's own `.editorconfig`
  * when present.
  */
-export declare const kotlinLintCheck: import("../..").Check;
+export declare const kotlinLintCheck: import("../../types.js").Check;
 /**
  * Lints Swift with SwiftLint, which needs SourceKit and therefore a macOS
  * runner. Runs over the directory rather than a file list — SwiftLint resolves
  * 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.
  */
-export declare const swiftLintCheck: import("../..").Check;
+export declare const swiftLintCheck: import("../../types.js").Check;
 /**
  * Lints changed Ruby files with RuboCop, which covers layout as well as style,
  * so it doubles as the Ruby format signal. Uses the repo's own `.rubocop.yml`
  * when present.
  */
-export declare const rubyLintCheck: import("../..").Check;
+export declare const rubyLintCheck: import("../../types.js").Check;
 /**
  * Lints changed shell scripts with ShellCheck. `-f gcc` gives one line per
  * finding ending in an `[SC…]` code, which both a human and the count below can
@@ -42,36 +42,36 @@ export declare const rubyLintCheck: import("../..").Check;
  * 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.
  */
-export declare const shellcheckCheck: import("../..").Check;
+export declare const shellcheckCheck: import("../../types.js").Check;
 /**
  * Vets changed Go code with `go vet ./...`, which needs the Go toolchain (the
  * formatter next door no longer does — see `go-format.ts`). `go vet` operates
  * per package, so it runs over the module rather than a file list; the delta
  * only decides whether it runs.
  */
-export declare const goLintCheck: import("../..").Check;
+export declare const goLintCheck: import("../../types.js").Check;
 /**
  * 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.
  */
-export declare const rustLintCheck: import("../..").Check;
+export declare const rustLintCheck: import("../../types.js").Check;
 /**
  * Formats changed Rust with `cargo fmt`, not a bare `rustfmt`: cargo reads the
  * crate's edition from `Cargo.toml`, and rustfmt invoked directly does not —
  * which silently formats 2015-edition code by 2024 rules.
  */
-export declare const rustFormatCheck: import("../..").Check;
+export declare const rustFormatCheck: import("../../types.js").Check;
 /**
  * Verifies C# formatting with `dotnet format`, which also runs the project's
  * configured analyzers and style rules. It operates on the project or solution
  * (and expects a prior `dotnet restore`), so it runs over the whole project; the
  * delta only decides whether it runs.
  */
-export declare const csharpFormatCheck: import("../..").Check;
+export declare const csharpFormatCheck: import("../../types.js").Check;
 /**
  * Formats changed PHP with PHP-CS-Fixer, using the repo's own
  * `.php-cs-fixer.php` when present. `--using-cache=no` because the cache keys on
  * absolute paths, and a CI checkout directory that changes between runs makes a
  * stale cache report files as clean that were never examined.
  */
-export declare const phpFormatCheck: import("../..").Check;
+export declare const phpFormatCheck: import("../../types.js").Check;