knip 0.0.0-graph.3 → 0.0.0-node-types.0

package/dist/WorkspaceWorker.js

@@ -1,11 +1,12 @@
-import { TEST_FILE_PATTERNS } from './constants.js';
 import * as npm from './manifest/index.js';
 import * as plugins from './plugins/index.js';
 import { debugLogArray, debugLogObject } from './util/debug.js';
 import { _pureGlob, negate, hasProductionSuffix, hasNoProductionSuffix, prependDirToPattern } from './util/glob.js';
-import { getKeysByValue } from './util/object.js';
+import { FAKE_PATH } from './util/loader.js';
+import { get, getKeysByValue } from './util/object.js';
 import { join, toPosix } from './util/path.js';
-const negatedTestFilePatterns = TEST_FILE_PATTERNS.map(negate);
+import { fromEntryPattern, fromProductionEntryPattern, isEntryPattern, isProductionEntryPattern, } from './util/protocols.js';
+const nullConfig = { config: null, entry: null, project: null };
 export class WorkspaceWorker {
     name;
     dir;
@@ -23,6 +24,8 @@ export class WorkspaceWorker {
     hostDependencies = new Map();
     installedBinaries = new Map();
     hasTypesIncluded = new Set();
+    entryFilePatterns = new Set();
+    productionEntryFilePatterns = new Set();
     constructor({ name, dir, cwd, config, manifest, isProduction, isStrict, rootIgnore, negatedWorkspacePatterns, enabledPluginsInAncestors, }) {
         this.name = name;
         this.dir = dir;
@@ -49,6 +52,10 @@ export class WorkspaceWorker {
         for (const [pluginName, plugin] of pluginEntries) {
             if (this.config[pluginName] === false)
                 continue;
+            if (this.config[pluginName]) {
+                this.enabled[pluginName] = true;
+                continue;
+            }
             const isEnabledInAncestor = this.enabledPluginsInAncestors.includes(pluginName);
             if (isEnabledInAncestor ||
                 (await plugin.isEnabled({ cwd: this.dir, manifest, dependencies, config: this.config }))) {
@@ -57,7 +64,7 @@ export class WorkspaceWorker {
         }
         this.enabledPlugins = getKeysByValue(this.enabled, true);
         const enabledPluginNames = this.enabledPlugins.map(name => plugins[name].NAME);
-        debugLogObject(`Enabled plugins (${this.name})`, enabledPluginNames);
+        debugLogObject(this.name, `Enabled plugins (${this.name})`, enabledPluginNames);
     }
     async initReferencedDependencies() {
         const { dependencies, hostDependencies, installedBinaries, hasTypesIncluded } = await npm.findDependencies({
@@ -72,61 +79,41 @@ export class WorkspaceWorker {
         this.hostDependencies = hostDependencies;
         this.installedBinaries = installedBinaries;
         this.hasTypesIncluded = hasTypesIncluded;
+        this.hasTypesIncluded = hasTypesIncluded;
     }
     getConfigForPlugin(pluginName) {
-        return this.config[pluginName] ?? { config: null, entry: null, project: null };
+        const config = this.config[pluginName];
+        return typeof config === 'undefined' || typeof config === 'boolean' ? nullConfig : config;
     }
     getEntryFilePatterns() {
         const { entry } = this.config;
         if (entry.length === 0)
             return [];
-        return [entry, TEST_FILE_PATTERNS, this.negatedWorkspacePatterns].flat();
+        const excludeProductionNegations = entry.filter(pattern => !(pattern.startsWith('!') && pattern.endsWith('!')));
+        return [excludeProductionNegations, this.negatedWorkspacePatterns].flat();
     }
-    getProjectFilePatterns() {
+    getProjectFilePatterns(testFilePatterns) {
         const { project } = this.config;
         if (project.length === 0)
             return [];
+        const excludeProductionNegations = project.filter(pattern => !(pattern.startsWith('!') && pattern.endsWith('!')));
         const negatedPluginConfigPatterns = this.getPluginConfigPatterns().map(negate);
-        const negatedPluginEntryFilePatterns = this.getPluginEntryFilePatterns(false).map(negate);
         const negatedPluginProjectFilePatterns = this.getPluginProjectFilePatterns().map(negate);
         return [
-            project,
+            excludeProductionNegations,
             negatedPluginConfigPatterns,
-            negatedPluginEntryFilePatterns,
             negatedPluginProjectFilePatterns,
-            TEST_FILE_PATTERNS,
+            testFilePatterns,
             this.negatedWorkspacePatterns,
         ].flat();
     }
-    getPluginEntryFilePatterns(isIncludeProductionEntryFiles = true) {
-        const patterns = [];
-        for (const [pluginName, plugin] of Object.entries(plugins)) {
-            const pluginConfig = this.getConfigForPlugin(pluginName);
-            if (this.enabled[pluginName] && pluginConfig) {
-                const { entry } = pluginConfig;
-                const defaultEntryFiles = 'ENTRY_FILE_PATTERNS' in plugin ? plugin.ENTRY_FILE_PATTERNS : [];
-                patterns.push(...(entry ?? defaultEntryFiles));
-                if (isIncludeProductionEntryFiles) {
-                    const entry = 'PRODUCTION_ENTRY_FILE_PATTERNS' in plugin ? plugin.PRODUCTION_ENTRY_FILE_PATTERNS : [];
-                    patterns.push(...entry);
-                }
-            }
-        }
-        return [patterns, this.negatedWorkspacePatterns].flat();
-    }
     getPluginProjectFilePatterns() {
         const patterns = [];
         for (const [pluginName, plugin] of Object.entries(plugins)) {
             const pluginConfig = this.getConfigForPlugin(pluginName);
-            if (this.enabled[pluginName] && pluginConfig) {
+            if (this.enabled[pluginName]) {
                 const { entry, project } = pluginConfig;
-                patterns.push(...(project ??
-                    entry ??
-                    ('PROJECT_FILE_PATTERNS' in plugin
-                        ? plugin.PROJECT_FILE_PATTERNS
-                        : 'ENTRY_FILE_PATTERNS' in plugin
-                            ? plugin.ENTRY_FILE_PATTERNS
-                            : [])));
+                patterns.push(...(project ?? entry ?? ('PROJECT_FILE_PATTERNS' in plugin ? plugin.PROJECT_FILE_PATTERNS : [])));
             }
         }
         return [patterns, this.negatedWorkspacePatterns].flat();
@@ -143,17 +130,17 @@ export class WorkspaceWorker {
         }
         return patterns;
     }
-    getProductionEntryFilePatterns() {
+    getProductionEntryFilePatterns(negatedTestFilePatterns) {
         const entry = this.config.entry.filter(hasProductionSuffix);
         if (entry.length === 0)
             return [];
         const negatedEntryFiles = this.config.entry.filter(hasNoProductionSuffix).map(negate);
         return [entry, negatedEntryFiles, negatedTestFilePatterns, this.negatedWorkspacePatterns].flat();
     }
-    getProductionProjectFilePatterns() {
+    getProductionProjectFilePatterns(negatedTestFilePatterns) {
         const project = this.config.project;
         if (project.length === 0)
-            return this.getProductionEntryFilePatterns();
+            return this.getProductionEntryFilePatterns(negatedTestFilePatterns);
         const _project = this.config.project.map(pattern => {
             if (!pattern.endsWith('!') && !pattern.startsWith('!'))
                 return negate(pattern);
@@ -161,32 +148,16 @@ export class WorkspaceWorker {
         });
         const negatedEntryFiles = this.config.entry.filter(hasNoProductionSuffix).map(negate);
         const negatedPluginConfigPatterns = this.getPluginConfigPatterns().map(negate);
-        const negatedPluginEntryFilePatterns = this.getPluginEntryFilePatterns(false).map(negate);
         const negatedPluginProjectFilePatterns = this.getPluginProjectFilePatterns().map(negate);
         return [
             _project,
             negatedEntryFiles,
             negatedPluginConfigPatterns,
-            negatedPluginEntryFilePatterns,
             negatedPluginProjectFilePatterns,
             negatedTestFilePatterns,
             this.negatedWorkspacePatterns,
         ].flat();
     }
-    getProductionPluginEntryFilePatterns() {
-        const patterns = [];
-        for (const [pluginName, plugin] of Object.entries(plugins)) {
-            const pluginConfig = this.getConfigForPlugin(pluginName);
-            if (this.enabled[pluginName] && pluginConfig) {
-                if ('PRODUCTION_ENTRY_FILE_PATTERNS' in plugin) {
-                    patterns.push(...(pluginConfig.entry ?? plugin.PRODUCTION_ENTRY_FILE_PATTERNS));
-                }
-            }
-        }
-        if (patterns.length === 0)
-            return [];
-        return [patterns.flat(), negatedTestFilePatterns].flat();
-    }
     getConfigurationFilePatterns(pluginName) {
         const plugin = plugins[pluginName];
         const pluginConfig = this.getConfigForPlugin(pluginName);
@@ -200,21 +171,23 @@ export class WorkspaceWorker {
         return [...this.rootIgnore, ...this.config.ignore.map(pattern => prependDirToPattern(this.name, pattern))];
     }
     async findDependenciesByPlugins() {
+        const name = this.name;
         const cwd = this.dir;
         const ignore = this.getIgnorePatterns();
         for (const [pluginName, plugin] of Object.entries(plugins)) {
-            const isIncludePlugin = this.isProduction ? `PRODUCTION_ENTRY_FILE_PATTERNS` in plugin : true;
-            if (this.enabled[pluginName] && isIncludePlugin) {
+            if (this.enabled[pluginName]) {
                 const hasDependencyFinder = 'findDependencies' in plugin && typeof plugin.findDependencies === 'function';
                 if (hasDependencyFinder) {
                     const pluginConfig = this.getConfigForPlugin(pluginName);
                     if (!pluginConfig)
                         continue;
                     const patterns = this.getConfigurationFilePatterns(pluginName);
-                    const configFilePaths = await _pureGlob({ patterns, cwd, ignore, gitignore: false });
-                    debugLogArray(`Found ${plugin.NAME} config file paths`, configFilePaths);
+                    const allConfigFilePaths = await _pureGlob({ patterns, cwd, ignore, gitignore: false });
+                    const configFilePaths = allConfigFilePaths.filter(filePath => !filePath.endsWith('package.json') ||
+                        get(this.manifest, 'PACKAGE_JSON_PATH' in plugin ? plugin.PACKAGE_JSON_PATH : pluginName));
+                    debugLogArray([name, plugin.NAME], 'config file paths', configFilePaths);
                     if (configFilePaths.length === 0)
-                        continue;
+                        configFilePaths.push(FAKE_PATH);
                     const pluginDependencies = new Set();
                     for (const configFilePath of configFilePaths) {
                         const dependencies = await plugin.findDependencies(configFilePath, {
@@ -223,13 +196,20 @@ export class WorkspaceWorker {
                             config: pluginConfig,
                             isProduction: this.isProduction,
                         });
-                        dependencies.map(toPosix).forEach(specifier => {
+                        dependencies.forEach(specifier => {
                             pluginDependencies.add(specifier);
-                            this.referencedDependencies.add([configFilePath, specifier]);
+                            if (isEntryPattern(specifier)) {
+                                this.entryFilePatterns.add(fromEntryPattern(specifier));
+                            }
+                            else if (isProductionEntryPattern(specifier)) {
+                                this.productionEntryFilePatterns.add(fromProductionEntryPattern(specifier));
+                            }
+                            else {
+                                this.referencedDependencies.add([configFilePath, toPosix(specifier)]);
+                            }
                         });
-                        dependencies.forEach(dependency => pluginDependencies.add(dependency));
                     }
-                    debugLogArray(`Dependencies referenced in ${plugin.NAME}`, pluginDependencies);
+                    debugLogArray([name, plugin.NAME], 'dependencies', pluginDependencies);
                 }
             }
         }
@@ -242,6 +222,8 @@ export class WorkspaceWorker {
             referencedDependencies: this.referencedDependencies,
             hasTypesIncluded: this.hasTypesIncluded,
             enabledPlugins: this.enabledPlugins,
+            entryFilePatterns: Array.from(this.entryFilePatterns),
+            productionEntryFilePatterns: Array.from(this.productionEntryFilePatterns),
         };
     }
 }

package/dist/binaries/bash-parser.js

@@ -52,7 +52,7 @@ export const getBinariesFromScript = (script, { cwd, manifest, knownGlobalsOnly
         return parsed?.commands ? getBinariesFromNodes(parsed.commands) : [];
     }
     catch (error) {
-        debugLogObject('Bash parser error', error);
+        debugLogObject('*', 'Bash parser error', error);
         return [];
     }
 };

package/dist/binaries/index.js

@@ -1,17 +1,26 @@
+import { IGNORED_FILE_EXTENSIONS } from '../constants.js';
 import { compact } from '../util/array.js';
 import { getPackageNameFromModuleSpecifier } from '../util/modules.js';
-import { isInternal } from '../util/path.js';
+import { extname, isInternal } from '../util/path.js';
 import { timerify } from '../util/Performance.js';
+import { isBinary } from '../util/protocols.js';
 import { getBinariesFromScript } from './bash-parser.js';
-import { isBinary } from './util.js';
 const defaultCwd = process.cwd();
 const getDependenciesFromScripts = (npmScripts, options = {}) => {
     const { cwd = defaultCwd, manifest = {}, knownGlobalsOnly = false } = options;
     const scripts = typeof npmScripts === 'string' ? [npmScripts] : [...npmScripts];
     const results = scripts.flatMap(script => getBinariesFromScript(script, { cwd, manifest, knownGlobalsOnly }));
     return compact(results.map(identifier => {
-        if (isBinary(identifier) || isInternal(identifier))
+        if (identifier.startsWith('http'))
+            return;
+        if (isBinary(identifier))
             return identifier;
+        if (isInternal(identifier)) {
+            const ext = extname(identifier);
+            if (ext && IGNORED_FILE_EXTENSIONS.includes(ext))
+                return;
+            return identifier;
+        }
         return getPackageNameFromModuleSpecifier(identifier);
     }));
 };

package/dist/binaries/resolvers/c8.js

@@ -1,5 +1,6 @@
 import parseArgs from 'minimist';
-import { toBinary, argsFrom } from '../util.js';
+import { toBinary } from '../../util/protocols.js';
+import { argsFrom } from '../util.js';
 export const resolve = (binary, args, { fromArgs }) => {
     const parsed = parseArgs(args, {
         boolean: ['all', 'check-coverage', 'clean', 'exclude-after-remap', 'per-file', 'skip-full'],

package/dist/binaries/resolvers/dotenv.js

@@ -1,5 +1,6 @@
 import parseArgs from 'minimist';
-import { toBinary, argsFrom } from '../util.js';
+import { toBinary } from '../../util/protocols.js';
+import { argsFrom } from '../util.js';
 export const resolve = (binary, args, { fromArgs }) => {
     const parsed = parseArgs(args);
     return [toBinary(binary), ...fromArgs(argsFrom(args, parsed._[0]))];

package/dist/binaries/resolvers/fallback.js

@@ -1,15 +1,17 @@
 import parseArgs from 'minimist';
 import { compact } from '../../util/array.js';
-import { toBinary, tryResolveFilePath, tryResolveSpecifiers } from '../util.js';
+import { toBinary } from '../../util/protocols.js';
+import { tryResolveFilePath, tryResolveSpecifiers } from '../util.js';
 const withPositional = parsed => [parsed._[0], parsed.require].flat();
 const withoutPositional = parsed => [parsed.require].flat();
+const withoutRequire = () => [];
 const argFilters = {
+    adb: withoutRequire,
     'babel-node': withPositional,
     esbuild: withPositional,
     execa: withPositional,
     'ts-node': withPositional,
     zx: withPositional,
-    tsx: parsed => parsed._.filter(p => p !== 'watch'),
     default: withoutPositional,
 };
 const spawningBinaries = ['cross-env', 'retry-cli'];

package/dist/binaries/resolvers/index.d.ts

@@ -6,4 +6,5 @@ export * as npx from './npx.js';
 export * as nx from './nx.js';
 export * as pnpm from './pnpm.js';
 export * as rollup from './rollup.js';
+export * as tsx from './tsx.js';
 export * as yarn from './yarn.js';

package/dist/binaries/resolvers/index.js

@@ -6,4 +6,5 @@ export * as npx from './npx.js';
 export * as nx from './nx.js';
 export * as pnpm from './pnpm.js';
 export * as rollup from './rollup.js';
+export * as tsx from './tsx.js';
 export * as yarn from './yarn.js';

package/dist/binaries/resolvers/node.js

@@ -4,7 +4,7 @@ import { tryResolveFilePath, tryResolveSpecifiers } from '../util.js';
 export const resolve = (binary, args, { cwd }) => {
     const parsed = parseArgs(args, {
         string: ['r'],
-        alias: { require: ['r', 'loader', 'experimental-loader', 'test-reporter'] },
+        alias: { require: ['r', 'loader', 'experimental-loader', 'test-reporter', 'watch', 'import'] },
     });
     return compact([tryResolveFilePath(cwd, parsed._[0]), ...tryResolveSpecifiers(cwd, [parsed.require].flat())]);
 };

package/dist/binaries/resolvers/nodemon.js

@@ -1,6 +1,7 @@
 import parseArgs from 'minimist';
 import { compact } from '../../util/array.js';
-import { toBinary, tryResolveFilePath, tryResolveSpecifiers } from '../util.js';
+import { toBinary } from '../../util/protocols.js';
+import { tryResolveFilePath, tryResolveSpecifiers } from '../util.js';
 export const resolve = (binary, args, { cwd, fromArgs }) => {
     const parsed = parseArgs(args, {
         string: ['r', 'exec'],

package/dist/binaries/resolvers/npx.js

@@ -1,7 +1,8 @@
 import parseArgs from 'minimist';
 import { isInternal } from '../../util/path.js';
+import { toBinary } from '../../util/protocols.js';
 import { getBinariesFromScript } from '../bash-parser.js';
-import { argsFrom, stripVersionFromSpecifier, toBinary } from '../util.js';
+import { argsFrom, stripVersionFromSpecifier } from '../util.js';
 export const resolve = (binary, args, { cwd, fromArgs, manifest }) => {
     const parsed = parseArgs(args, {
         boolean: ['yes', 'no'],

package/dist/binaries/resolvers/nx.js

@@ -1,5 +1,5 @@
 import parseArgs from 'minimist';
-import { toBinary } from '../util.js';
+import { toBinary } from '../../util/protocols.js';
 export const resolve = (binary, args, { fromArgs }) => {
     const parsed = parseArgs(args);
     const [command] = parsed._;

package/dist/binaries/resolvers/pnpm.js

@@ -1,5 +1,5 @@
 import parseArgs from 'minimist';
-import { toBinary } from '../util.js';
+import { toBinary } from '../../util/protocols.js';
 const commands = [
     'add',
     'audit',

package/dist/binaries/resolvers/rollup.js

@@ -1,6 +1,7 @@
 import parseArgs from 'minimist';
 import { compact } from '../../util/array.js';
-import { toBinary, tryResolveSpecifiers } from '../util.js';
+import { toBinary } from '../../util/protocols.js';
+import { tryResolveSpecifiers } from '../util.js';
 export const resolve = (binary, args, { cwd, fromArgs }) => {
     const safeArgs = args.filter(arg => arg !== '--watch');
     const parsed = parseArgs(safeArgs, { alias: { plugin: 'p' } });

package/dist/binaries/resolvers/tsx.d.ts

@@ -0,0 +1,2 @@
+import type { Resolver } from '../types.js';
+export declare const resolve: Resolver;

package/dist/binaries/resolvers/tsx.js

@@ -0,0 +1,6 @@
+import { toBinary } from '../../util/protocols.js';
+import { resolve as resolveNode } from './node.js';
+export const resolve = (binary, args, options) => {
+    args = args.map(a => (a === 'watch' ? '--watch' : a));
+    return [toBinary(binary), ...resolveNode(binary, args, options)];
+};

package/dist/binaries/resolvers/yarn.js

@@ -1,5 +1,5 @@
 import parseArgs from 'minimist';
-import { toBinary } from '../util.js';
+import { toBinary } from '../../util/protocols.js';
 const commands = [
     'add',
     'bin',

package/dist/binaries/util.d.ts

@@ -1,8 +1,5 @@
 export declare const tryResolveFilePath: (cwd: string, specifier: string, acceptModuleSpecifier?: boolean) => string | undefined;
 export declare const tryResolveSpecifiers: (cwd: string, specifiers: string[]) => (string | undefined)[];
-export declare const toBinary: (specifier: string) => string;
-export declare const fromBinary: (specifier: string) => string;
-export declare const isBinary: (specifier: string) => boolean;
 export declare const stripVersionFromSpecifier: (specifier: string) => string;
 export declare const stripBinaryPath: (command: string) => string;
 export declare const argsFrom: (args: string[], from: string) => string[];

package/dist/binaries/util.js

@@ -1,5 +1,6 @@
 import { getPackageNameFromFilePath, getPackageNameFromModuleSpecifier } from '../util/modules.js';
 import { isInNodeModules, join } from '../util/path.js';
+import { toBinary } from '../util/protocols.js';
 import { _tryResolve } from '../util/require.js';
 export const tryResolveFilePath = (cwd, specifier, acceptModuleSpecifier) => {
     if (specifier) {
@@ -22,9 +23,6 @@ export const tryResolveFilePath = (cwd, specifier, acceptModuleSpecifier) => {
     }
 };
 export const tryResolveSpecifiers = (cwd, specifiers) => specifiers.map(specifier => tryResolveFilePath(cwd, specifier, true));
-export const toBinary = (specifier) => specifier.replace(/^(bin:)?/, 'bin:');
-export const fromBinary = (specifier) => specifier.replace(/^(bin:)?/, '');
-export const isBinary = (specifier) => specifier.startsWith('bin:');
 export const stripVersionFromSpecifier = (specifier) => specifier.replace(/(\S+)@.*/, '$1');
 const stripNodeModulesFromPath = (command) => command.replace(/^(\.\/)?node_modules\//, '');
 export const stripBinaryPath = (command) => stripVersionFromSpecifier(stripNodeModulesFromPath(command)

package/dist/cli.d.ts

@@ -1,2 +1 @@
-#!/usr/bin/env node
 import './util/register.js';

package/dist/cli.js

@@ -1,4 +1,3 @@
-#!/usr/bin/env node
 import './util/register.js';
 import prettyMilliseconds from 'pretty-ms';
 import parsedArgValues, { helpText } from './util/cli-arguments.js';
@@ -8,7 +7,7 @@ import { Performance } from './util/Performance.js';
 import { runPreprocessors, runReporters } from './util/reporter.js';
 import { version } from './version.js';
 import { main } from './index.js';
-const { debug: isDebug = false, help: isHelp, 'max-issues': maxIssues = '0', 'no-config-hints': noConfigHints = false, 'no-exit-code': noExitCode = false, 'no-gitignore': isNoGitIgnore = false, 'no-progress': isNoProgress = false, 'ignore-internal': isIgnoreInternal = false, 'include-entry-exports': isIncludeEntryExports = false, performance: isObservePerf = false, production: isProduction = false, 'reporter-options': reporterOptions = '', 'preprocessor-options': preprocessorOptions = '', strict: isStrict = false, tsConfig, version: isVersion, } = parsedArgValues;
+const { debug: isDebug = false, help: isHelp, 'max-issues': maxIssues = '0', 'no-config-hints': noConfigHints = false, 'no-exit-code': noExitCode = false, 'no-gitignore': isNoGitIgnore = false, 'no-progress': isNoProgress = false, 'include-entry-exports': isIncludeEntryExports = false, 'isolate-workspaces': isIsolateWorkspaces = false, performance: isObservePerf = false, production: isProduction = false, 'reporter-options': reporterOptions = '', 'preprocessor-options': preprocessorOptions = '', strict: isStrict = false, tsConfig, version: isVersion, } = parsedArgValues;
 if (isHelp) {
     console.log(helpText);
     process.exit(0);
@@ -27,13 +26,14 @@ const run = async () => {
             gitignore: !isNoGitIgnore,
             isProduction,
             isStrict,
-            isIgnoreInternal,
             isShowProgress,
             isIncludeEntryExports,
+            isIsolateWorkspaces,
         });
         const initialData = {
             report,
             issues,
+            counters,
             configurationHints,
             noConfigHints,
             cwd,
@@ -44,9 +44,9 @@ const run = async () => {
         };
         const finalData = await runPreprocessors(initialData);
         await runReporters(finalData);
-        const totalErrorCount = Object.keys(report)
-            .filter(reportGroup => report[reportGroup] && rules[reportGroup] === 'error')
-            .reduce((errorCount, reportGroup) => errorCount + counters[reportGroup], 0);
+        const totalErrorCount = Object.keys(finalData.report)
+            .filter(reportGroup => finalData.report[reportGroup] && rules[reportGroup] === 'error')
+            .reduce((errorCount, reportGroup) => errorCount + finalData.counters[reportGroup], 0);
         if (isObservePerf) {
             await perfObserver.finalize();
             console.log('\n' + perfObserver.getTable());
@@ -54,18 +54,19 @@ const run = async () => {
             perfObserver.reset();
         }
         if (!noExitCode && totalErrorCount > Number(maxIssues)) {
-            process.exit(totalErrorCount);
+            process.exit(1);
         }
     }
     catch (error) {
-        if (error instanceof Error && isKnownError(error)) {
+        process.exitCode = 2;
+        if (!isDebug && error instanceof Error && isKnownError(error)) {
             const knownError = getKnownError(error);
             console.error(knownError.message);
             if (hasCause(knownError))
                 console.error('Reason:', knownError.cause.message);
             if (isConfigurationError(knownError))
                 console.log('\n' + helpText);
-            process.exit(1);
+            process.exit(2);
         }
         throw error;
     }

package/dist/constants.d.ts

@@ -2,7 +2,6 @@ import type { IssueType } from './types/issues.js';
 export declare const ROOT_WORKSPACE_NAME = ".";
 export declare const KNIP_CONFIG_LOCATIONS: string[];
 export declare const DEFAULT_EXTENSIONS: string[];
-export declare const TEST_FILE_PATTERNS: string[];
 export declare const GLOBAL_IGNORE_PATTERNS: string[];
 export declare const IGNORED_GLOBAL_BINARIES: string[];
 export declare const IGNORED_DEPENDENCIES: string[];

package/dist/constants.js

@@ -1,21 +1,20 @@
 export const ROOT_WORKSPACE_NAME = '.';
 export const KNIP_CONFIG_LOCATIONS = ['knip.json', 'knip.jsonc', '.knip.json', '.knip.jsonc', 'knip.ts', 'knip.js'];
 export const DEFAULT_EXTENSIONS = ['.js', '.mjs', '.cjs', '.jsx', '.ts', '.tsx', '.mts', '.cts'];
-export const TEST_FILE_PATTERNS = [
-    '**/*{.,-}{test,spec}.{js,jsx,ts,tsx,mjs,cjs}',
-    '**/{test,__tests__}/**/*.{js,jsx,ts,tsx,mjs,cjs}',
-];
 export const GLOBAL_IGNORE_PATTERNS = ['**/node_modules/**', '.yarn'];
 export const IGNORED_GLOBAL_BINARIES = [
     'bash',
     'bun',
+    'bunx',
     'cat',
     'cd',
     'chmod',
+    'corepack',
     'cp',
     'curl',
     'deno',
     'dirname',
+    'docker',
     'echo',
     'exec',
     'exit',
@@ -41,6 +40,7 @@ export const IGNORED_FILE_EXTENSIONS = [
     '.css',
     '.eot',
     '.gif',
+    '.html',
     '.ico',
     '.jpeg',
     '.jpg',
@@ -48,6 +48,7 @@ export const IGNORED_FILE_EXTENSIONS = [
     '.png',
     '.sass',
     '.scss',
+    '.sh',
     '.svg',
     '.ttf',
     '.webp',