pr-checkmate 1.21.9 → 1.21.11

package/cspell.json

@@ -274,7 +274,276 @@
     "פילינגים",
     "פיניש",
     "קלאסי",
-    "רטינול"
+    "רטינול",
+    "accesscode",
+    "adminsdk",
+    "akia",
+    "AKID",
+    "myorg",
+    "androidpublisher",
+    "apikey",
+    "apinick",
+    "cnick",
+    "ghactor",
+    "atts",
+    "apkg",
+    "BEHAVIOUR",
+    "appclinical",
+    "graphify",
+    "graphifyy",
+    "DTENSORFLOW",
+    "realtag",
+    "appoperator",
+    "appreglaur",
+    "apprequest",
+    "appsales",
+    "appstoreconnect",
+    "archs",
+    "artur",
+    "Ashwini",
+    "atlassian",
+    "auditq",
+    "avdmanager",
+    "avds",
+    "awscli",
+    "awscliv",
+    "pubspec",
+    "nios",
+    "awsconfiguration",
+    "baprs",
+    "bepkg",
+    "bioeye",
+    "bioeyesdkswift",
+    "bitbucket",
+    "bosb",
+    "braineye",
+    "braineyeandroid",
+    "braineyecore",
+    "braineyesdk",
+    "bscanf",
+    "buildx",
+    "CALVER",
+    "cdxgen",
+    "Cdxgen",
+    "ededed",
+    "ccache",
+    "centralised",
+    "chan",
+    "checkifemailexists",
+    "checkpointing",
+    "claudecode",
+    "cmdline",
+    "cmdtools",
+    "cocoapods",
+    "codeartifact",
+    "cognitogroup",
+    "completesession",
+    "completetest",
+    "confirmemail",
+    "confirmpassword",
+    "containerregistry",
+    "cpiav",
+    "createsession",
+    "createtest",
+    "ctest",
+    "customfield",
+    "cyclonedx",
+    "DBUILD",
+    "DCMAKE",
+    "dedup",
+    "deintegrate",
+    "Deintegrating",
+    "deleteuser",
+    "devuser",
+    "DFETCHCONTENT",
+    "disableuser",
+    "dockerization",
+    "Dorg",
+    "DTFLITE",
+    "dtypes",
+    "DTYPES",
+    "dumpsys",
+    "eigen",
+    "EIGEN",
+    "enableuser",
+    "eoilist",
+    "eyecon",
+    "eyetracking",
+    "eympact",
+    "farmhash",
+    "FARMHASH",
+    "FETCHCONTENT",
+    "ffprobe",
+    "fgets",
+    "filehistory",
+    "fixedname",
+    "flatbuffers",
+    "FLATBUFFERS",
+    "forgotpassword",
+    "Fsub",
+    "gemmlowp",
+    "GEMMLOWP",
+    "genkey",
+    "germany",
+    "getprop",
+    "ghsa",
+    "gnupg",
+    "Gowtham",
+    "gradlew",
+    "Hamou",
+    "Harel",
+    "hflip",
+    "Hossein",
+    "initialised",
+    "iphoneos",
+    "iphonesimulator",
+    "issuetype",
+    "johnsmith",
+    "jsqr",
+    "Jsqr",
+    "junitxml",
+    "jvmargs",
+    "keyalg",
+    "keypass",
+    "keysize",
+    "keytool",
+    "Khaing",
+    "konsultamd",
+    "lelvni",
+    "libexec",
+    "libopencv",
+    "libtensorflow",
+    "listapps",
+    "localised",
+    "logcat",
+    "lproj",
+    "lxgksa",
+    "Meaghan",
+    "metadatalist",
+    "Metaspace",
+    "mhvhic",
+    "mydir",
+    "myimage",
+    "mylib",
+    "myprefix",
+    "myrepo",
+    "mytoken",
+    "Naing",
+    "Namayeshi",
+    "nbraineye",
+    "NFIX",
+    "noprompt",
+    "noslash",
+    "oneline",
+    "Ooura",
+    "otherws",
+    "pagelen",
+    "Palaniswamy",
+    "pbxproj",
+    "pcodeartifact",
+    "Pickery",
+    "pipenv",
+    "podfile",
+    "poland",
+    "posthog",
+    "pthreadpool",
+    "pullrequests",
+    "pyproject",
+    "qscale",
+    "Ramesh",
+    "rawvideo",
+    "resendcode",
+    "samd",
+    "Sandino",
+    "Saurabh",
+    "sbom",
+    "sboms",
+    "scanf",
+    "sdkmanager",
+    "sess",
+    "setpassword",
+    "somerepo",
+    "Shani",
+    "simctl",
+    "stagingeu",
+    "storepass",
+    "retcode",
+    "Tukey",
+    "VIRTUALENVS",
+    "Δangle",
+    "strncpy",
+    "subjectid",
+    "subscriptionlist",
+    "swiftshader",
+    "Syncer",
+    "Talaiee",
+    "Tayebeh",
+    "tcwf",
+    "temurin",
+    "tensorflow",
+    "testsuite",
+    "testsuites",
+    "testuser",
+    "tfcommit",
+    "tflite",
+    "tocken",
+    "Turakhia",
+    "Tzionit",
+    "ubgjg",
+    "udid",
+    "unparseable",
+    "unrecognised",
+    "updateemail",
+    "userfound",
+    "myregistry",
+    "userid",
+    "userinfo",
+    "usermetadata",
+    "userproperty",
+    "uuids",
+    "vfrzk",
+    "vuhftgasouc",
+    "vulns",
+    "workdir",
+    "xcframework",
+    "xcodeproj",
+    "xcresult",
+    "xcresulttool",
+    "xcrun",
+    "xcstrings",
+    "xcworkspace",
+    "XNNPACK",
+    "DYLD",
+    "qreader",
+    "xoxb",
+    "bbox",
+    "Degs",
+    "Kanade",
+    "neighbours",
+    "unsharp",
+    "imgproc",
+    "highgui",
+    "imgcodecs",
+    "videoio",
+    "gapi",
+    "objdetect",
+    "behaviour",
+    "softfloat",
+    "CUDA",
+    "OPENCL",
+    "OPENNI",
+    "GSTREAMER",
+    "DWITH",
+    "DINSTALL",
+    "DPARALLEL",
+    "libavcodec",
+    "libavformat",
+    "libavutil",
+    "libswscale",
+    "Makefiles",
+    "dpdm",
+    "commitlintrc",
+    "shortstat"
   ],
   "ignorePaths": [
     "**/node_modules/**",

package/dist/cli.js

@@ -1,9 +1,33 @@
 #!/usr/bin/env node
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const scripts_1 = require("./scripts");
+const core_1 = require("./core");
 const init_1 = require("./init");
 const utils_1 = require("./utils");
+/** Maps short CLI command names to their registry check names. */
+const COMMAND_TO_CHECK = {
+    lint: 'ESLint',
+    deps: 'Dependencies',
+    dependencies: 'Dependencies',
+    'npm-audit': 'NPM Audit',
+    prettier: 'Prettier',
+    spellcheck: 'Spellcheck',
+    security: 'Security Scan',
+    circular: 'Circular Deps',
+    license: 'License Check',
+    'pr-size': 'PR Size',
+    'pr-title': 'PR Title',
+    outdated: 'Outdated Deps',
+    markdown: 'Markdown',
+    typecheck: 'TypeScript',
+    'diff-smell': 'Diff Smells',
+    'diff-security': 'Diff Security',
+    'sensitive-files': 'Sensitive Files',
+    'pr-body': 'PR Body',
+    duplicate: 'Duplicate Code',
+    commitlint: 'Commitlint',
+    'cpp-format': 'C++ Format',
+};
 const cmd = process.argv[2];
 void (async () => {
     try {
@@ -11,8 +35,18 @@ void (async () => {
             await (0, init_1.init)();
             process.exit(0);
         }
-        await (0, scripts_1.runJob)(cmd ?? 'all');
-        process.exit(0);
+        // Full run: post a GitHub summary comment and allow formatters to write.
+        if (!cmd || cmd === 'all') {
+            const report = await (0, core_1.runChecks)({ reporter: 'github', write: true });
+            process.exit(report.ok ? 0 : 1);
+        }
+        const checkName = COMMAND_TO_CHECK[cmd];
+        if (!checkName) {
+            utils_1.logger.warn(`[cli]: Unknown command "${cmd}". Available: all, init, ${Object.keys(COMMAND_TO_CHECK).join(', ')}`);
+            process.exit(1);
+        }
+        const report = await (0, core_1.runChecks)({ only: [checkName], reporter: 'stdout', write: true });
+        process.exit(report.ok ? 0 : 1);
     }
     catch (err) {
         utils_1.logger.error(`❌ CLI failed: ${err}`);

package/dist/config/constants.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CONFIG_FILE = exports.documentation = exports.DEFAULT_COMMANDS = exports.SOURCE_EXTENSIONS = exports.CONFIG_FILE_PATTERNS = exports.IGNORE_PATTERNS = void 0;
+exports.CONFIG_FILE = exports.documentation = exports.DEFAULT_ALLOW_PACKAGES = exports.DEFAULT_COMMANDS = exports.SOURCE_EXTENSIONS = exports.CONFIG_FILE_PATTERNS = exports.IGNORE_PATTERNS = void 0;
 const node_path_1 = __importDefault(require("node:path"));
 /**
  * Common patterns to ignore in all checks
@@ -89,6 +89,20 @@ exports.DEFAULT_COMMANDS = {
     'npx pr-checkmate pr-body': 'Validate PR description',
     'npx pr-checkmate duplicate': 'Detect duplicate code blocks (jscpd)',
 };
+/**
+ * Packages allow-listed for the license check by default.
+ *
+ * These are pr-checkmate's own bundled cspell dictionaries. Some ship under
+ * copyleft licenses (GPL/LGPL), but they are pr-checkmate dependencies — not
+ * the consumer's — so clients should never have to allow-list them manually.
+ */
+exports.DEFAULT_ALLOW_PACKAGES = [
+    '@cspell/dict-es-es',
+    '@cspell/dict-fr-fr',
+    '@cspell/dict-he',
+    '@cspell/dict-ru_ru',
+    '@cspell/dict-uk-ua',
+];
 exports.documentation = {
     eslint: 'https://eslint.org/docs/latest/rules/',
     typescriptEslint: 'https://typescript-eslint.io/rules/',

package/dist/config/loader.js

@@ -9,6 +9,7 @@ exports.getDefaultConfig = getDefaultConfig;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const utils_1 = require("../utils");
+const constants_1 = require("./constants");
 /**
  * Load project configuration from pr-checkmate.json
  * Falls back to defaults if not found
@@ -55,6 +56,11 @@ function mergeWithDefaults(userConfig) {
         },
         security: userConfig.security || defaults.security,
         typecheck: { ...defaults.typecheck, ...userConfig.typecheck },
+        cpp: {
+            ...defaults.cpp,
+            ...userConfig.cpp,
+            clangFormat: { ...defaults.cpp?.clangFormat, ...userConfig.cpp?.clangFormat },
+        },
         diffSmell: { ...defaults.diffSmell, ...userConfig.diffSmell },
         prBody: { ...defaults.prBody, ...userConfig.prBody },
         duplicate: { ...defaults.duplicate, ...userConfig.duplicate },
@@ -126,6 +132,7 @@ function getDefaultConfig() {
             'npm-audit': { enabled: true, auditLevel: 'moderate' },
         },
         typecheck: { enabled: true },
+        cpp: { enabled: true, clangFormat: { style: 'LLVM' } },
         diffSmell: { enabled: true },
         prBody: { enabled: true, minLength: 20, requireTicket: true },
         duplicate: { enabled: true, minLines: 5, minTokens: 50 },
@@ -145,6 +152,10 @@ function getDefaultConfig() {
                 'build',
             ],
         },
+        licenseCheck: {
+            allowPackages: [...constants_1.DEFAULT_ALLOW_PACKAGES],
+            allowLicenses: [],
+        },
     };
 }
 /**

package/dist/core/checks/circular-deps.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.circularDepsCheck = void 0;
+const execa_1 = require("execa");
+const node_path_1 = __importDefault(require("node:path"));
+const utils_1 = require("../../utils");
+const config_1 = require("../../config");
+const types_1 = require("../types");
+exports.circularDepsCheck = {
+    name: 'Circular Deps',
+    phase: 'blocking',
+    applies(ctx) {
+        return ctx.languages.includes('typescript') || ctx.languages.includes('javascript');
+    },
+    async run(ctx) {
+        const pattern = node_path_1.default.join(ctx.cwd, (0, config_1.getSourcePath)(), '**/*.{ts,tsx,js,jsx}');
+        const result = await (0, execa_1.execa)('npx', ['dpdm', '--no-warning', '--no-tree', '--circular', pattern], {
+            cwd: ctx.cwd,
+            reject: false,
+        });
+        const output = (result.stdout + result.stderr).trim();
+        // dpdm's success message also contains "circular" — match only its error shapes:
+        // the "Circular Dependencies:" header or a numbered entry "[1] src/a.ts -> src/b.ts".
+        const hasCircular = /circular dependencies:/i.test(output) || /^\s*\[\d+\]/m.test(output);
+        if (hasCircular) {
+            utils_1.logger.error(`[Circular Deps]: ❌ circular dependencies detected:\n${output}`);
+            return (0, types_1.fail)('circular dependencies found');
+        }
+        return (0, types_1.pass)();
+    },
+};

package/dist/core/checks/commitlint.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commitlintCheck = void 0;
+const execa_1 = require("execa");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_os_1 = __importDefault(require("node:os"));
+const utils_1 = require("../../utils");
+const config_1 = require("../../config");
+const types_1 = require("../types");
+const LOCAL_CONFIG_FILES = [
+    'commitlint.config.cjs',
+    'commitlint.config.js',
+    'commitlint.config.mjs',
+    'commitlint.config.ts',
+    '.commitlintrc',
+    '.commitlintrc.json',
+    '.commitlintrc.yaml',
+    '.commitlintrc.yml',
+    '.commitlintrc.js',
+    '.commitlintrc.cjs',
+];
+const DEFAULT_TYPES = [
+    'feat',
+    'fix',
+    'docs',
+    'chore',
+    'ci',
+    'refactor',
+    'perf',
+    'style',
+    'revert',
+    'test',
+    'build',
+];
+function buildTempConfig(types) {
+    const config = {
+        // Resolve via Node module resolution — robust to npm hoisting in the client.
+        extends: [require.resolve('@commitlint/config-conventional')],
+        rules: { 'type-enum': [2, 'always', types] },
+    };
+    const tmpFile = node_path_1.default.join(node_os_1.default.tmpdir(), `.commitlint-${process.pid}.json`);
+    node_fs_1.default.writeFileSync(tmpFile, JSON.stringify(config, null, 2));
+    return tmpFile;
+}
+exports.commitlintCheck = {
+    name: 'Commitlint',
+    phase: 'informational',
+    applies(ctx) {
+        return ctx.config.commitlint?.enabled !== false;
+    },
+    async run(ctx) {
+        const commitlintBin = (0, utils_1.resolvePackageBin)('@commitlint/cli', 'cli.js');
+        const hasLocal = (0, config_1.hasLocalConfig)(LOCAL_CONFIG_FILES);
+        let tempConfigFile = null;
+        const from = ctx.baseSha ?? 'HEAD~1';
+        const to = ctx.headSha ?? 'HEAD';
+        const args = ['--from', from, '--to', to, '--verbose'];
+        try {
+            if (hasLocal) {
+                utils_1.logger.info('[Commitlint]: Using local config');
+            }
+            else {
+                const types = ctx.config.commitlint?.types ?? DEFAULT_TYPES;
+                tempConfigFile = buildTempConfig(types);
+                args.push('--config', tempConfigFile);
+            }
+            const result = await (0, execa_1.execa)(process.execPath, [commitlintBin, ...args], {
+                cwd: ctx.cwd,
+                reject: false,
+                stdio: 'inherit',
+            });
+            return result.exitCode === 0 ? (0, types_1.pass)() : (0, types_1.warn)('commit message violations found');
+        }
+        finally {
+            if (tempConfigFile && node_fs_1.default.existsSync(tempConfigFile))
+                node_fs_1.default.unlinkSync(tempConfigFile);
+        }
+    },
+};

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

@@ -0,0 +1,120 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cppFormatCheck = void 0;
+const execa_1 = require("execa");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const utils_1 = require("../../utils");
+const types_1 = require("../types");
+/**
+ * C/C++ source & header extensions clang-format understands. `.h` is intentionally
+ * included even though it is ambiguous with C — clang-format handles both.
+ */
+const CPP_GLOBS = ['*.c', '*.cc', '*.cpp', '*.cxx', '*.c++', '*.h', '*.hh', '*.hpp', '*.hxx'];
+const DEFAULT_STYLE = 'LLVM';
+/**
+ * Resolves the clang-format style argument. Prefers the project's own `.clang-format`
+ * (via `--style=file`) so pr-checkmate never overrides a repo's established rules;
+ * falls back to the configured style, then LLVM.
+ */
+function resolveStyleArg(ctx) {
+    if (node_fs_1.default.existsSync(node_path_1.default.join(ctx.cwd, '.clang-format'))) {
+        return '--style=file';
+    }
+    const style = ctx.config.cpp?.clangFormat?.style ?? DEFAULT_STYLE;
+    return `--style=${style}`;
+}
+/**
+ * Returns the C/C++ files to check. Uses the PR diff range when available
+ * (delta mode), else scans all tracked C/C++ files. Returns an empty array
+ * when there is nothing to check, `null` when git is unusable.
+ */
+async function resolveTargets(ctx) {
+    try {
+        if (ctx.baseSha) {
+            const { stdout } = await (0, execa_1.execa)('git', [
+                'diff',
+                '--name-only',
+                '--diff-filter=ACMR',
+                ctx.baseSha,
+                ctx.headSha ?? 'HEAD',
+                '--',
+                ...CPP_GLOBS,
+            ], { cwd: ctx.cwd, reject: false });
+            const files = stdout
+                .split('\n')
+                .map(f => f.trim())
+                .filter(Boolean);
+            utils_1.logger.info(`[C++ Format]: 📂 Delta mode: ${files.length} changed C/C++ file(s)`);
+            return files;
+        }
+        const { stdout } = await (0, execa_1.execa)('git', ['ls-files', ...CPP_GLOBS], {
+            cwd: ctx.cwd,
+            reject: false,
+        });
+        const files = stdout
+            .split('\n')
+            .map(f => f.trim())
+            .filter(Boolean);
+        utils_1.logger.info(`[C++ Format]: Full scan: ${files.length} tracked C/C++ file(s)`);
+        return files;
+    }
+    catch (err) {
+        utils_1.logger.warn(`[C++ Format]: ⚠️ Could not list C/C++ files\n${err}`);
+        return null;
+    }
+}
+/** Counts distinct files flagged in clang-format's `--dry-run --Werror` diagnostics. */
+function countOffendingFiles(stderr) {
+    const files = new Set();
+    for (const line of stderr.split('\n')) {
+        const match = line.match(/^(.+?):\d+:\d+: (?:error|warning):/);
+        if (match)
+            files.add(match[1]);
+    }
+    return files.size;
+}
+/**
+ * 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
+ * clang install. Read-only in check mode; rewrites files in place when `write`.
+ */
+exports.cppFormatCheck = {
+    name: 'C++ Format',
+    phase: 'format',
+    applies(ctx) {
+        return ctx.config.cpp?.enabled !== false && ctx.languages.includes('cpp');
+    },
+    async run(ctx) {
+        const targets = await resolveTargets(ctx);
+        if (targets === null)
+            return (0, types_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');
+        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 });
+        if (dry.exitCode === 0)
+            return (0, types_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)`);
+        }
+        // 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], {
+            cwd: ctx.cwd,
+            reject: false,
+        });
+        if (fix.exitCode !== 0) {
+            utils_1.logger.warn(`[C++ Format]: ⚠️ clang-format -i failed\n${fix.stderr}`);
+            return (0, types_1.warn)('clang-format failed to rewrite files');
+        }
+        utils_1.logger.info(`[C++ Format]: ✅ Reformatted ${offending} C/C++ file(s)`);
+        return (0, types_1.pass)(`reformatted ${offending} file(s)`);
+    },
+};

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

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dependencyCheck = void 0;
+const execa_1 = require("execa");
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const utils_1 = require("../../utils");
+const types_1 = require("../types");
+exports.dependencyCheck = {
+    name: 'Dependencies',
+    phase: 'blocking',
+    applies(ctx) {
+        return node_fs_1.default.existsSync(node_path_1.default.join(ctx.cwd, 'package.json'));
+    },
+    async run(ctx) {
+        let stdout;
+        try {
+            ({ stdout } = await (0, execa_1.execa)('npx', ['depcheck', '--json'], { cwd: ctx.cwd }));
+        }
+        catch (err) {
+            // depcheck exits non-zero when it finds issues but still emits JSON on stdout.
+            if (err instanceof execa_1.ExecaError && err.stdout) {
+                stdout = err.stdout;
+            }
+            else {
+                throw err;
+            }
+        }
+        const start = stdout.indexOf('{');
+        const end = stdout.lastIndexOf('}');
+        const json = start !== -1 && end !== -1 ? stdout.slice(start, end + 1) : stdout;
+        let result;
+        try {
+            result = JSON.parse(json);
+        }
+        catch {
+            return (0, types_1.fail)('depcheck produced invalid JSON');
+        }
+        const unused = result.dependencies ?? [];
+        const missing = Object.keys(result.missing ?? {});
+        if (missing.length > 0) {
+            missing.forEach(dep => utils_1.logger.error(`[Dependencies]: ❌ missing ${dep} (used in: ${result.missing[dep]?.join(', ')})`));
+            return (0, types_1.fail)(`missing: ${missing.join(', ')}`);
+        }
+        if (unused.length > 0) {
+            unused.forEach(dep => utils_1.logger.warn(`[Dependencies]: ⚠️ unused ${dep}`));
+            return (0, types_1.warn)(`${unused.length} unused dependency(ies)`);
+        }
+        return (0, types_1.pass)();
+    },
+};