knip 2.0.0-alpha.6 → 2.0.0-alpha.8

package/README.md

@@ -40,7 +40,7 @@ for the full story.
 ## Issues
 
 Are you seeing false positives? Please report them by [opening an issue in this repo][9]. Bonus points for linking to a
-public repository using Knip, or even opening a pull request with a directory and example files in `test/fixtures`.
+public repository using Knip, or even opening a pull request with a directory and example files in `tests/fixtures`.
 Correctness and bug fixes have priority over performance and new features.
 
 Also see the [FAQ][10].
@@ -309,10 +309,11 @@ Knip contains a growing list of plugins:
 - [Sentry][37]
 - [Storybook][38]
 - [Stryker][39]
-- [TypeDoc][40]
-- [TypeScript][41]
-- [Vitest][42]
-- [Webpack][43]
+- [Svelte][40]
+- [TypeDoc][41]
+- [TypeScript][42]
+- [Vitest][43]
+- [Webpack][44]
 
 Plugins are automatically activated. Each plugin is automatically enabled based on simple heuristics. Most of them check
 whether one or one of a few (dev) dependencies are listed in `package.json`. Once enabled, they add a set of
@@ -320,7 +321,7 @@ configuration and/or entry files for Knip to analyze. These defaults can be over
 
 Most plugins use one or both of the following file types:
 
-- `config` - custom dependency resolvers are applied to the [config files][44]
+- `config` - custom dependency resolvers are applied to the [config files][45]
 - `entry` - files to include with the analysis of the rest of the source code
 
 See each plugin's documentation for its default values.
@@ -351,7 +352,7 @@ For plugins related to test files, it's good to know that the following glob pat
 - `**/__tests__/**/*.{js,jsx,ts,tsx,mjs,cjs}`
 - `**/test/**/*.{js,jsx,ts,tsx,mjs,cjs}`
 
-Files matching these patterns are excluded in [production mode][45].
+Files matching these patterns are excluded in [production mode][46].
 
 ### Disable a plugin
 
@@ -411,10 +412,10 @@ Here's what's included in production mode analysis:
 
 Additionally, the `--strict` flag can be used to:
 
-- Consider only `dependencies` (not `devDependencies`) when finding unused or unlisted dependencies.
-- Consider only non-type imports (i.e. ignore `import type {}`).
-- Assume each workspace is self-contained: they have their own `dependencies` (and not rely on packages of ancestor
-  workspaces).
+- Consider `dependencies` (not `devDependencies`) when finding unused or unlisted dependencies.
+- Include `peerDependencies` when finding unused or unlisted dependencies.
+- Ignore type-only imports (`import type {}`).
+- Verify each workspace is self-contained: have their own `dependencies` (and not use packages of ancestor workspaces).
 
 ### Plugins
 
@@ -478,7 +479,7 @@ type ReporterOptions = {
 
 The data can then be used to write issues to `stdout`, a JSON or CSV file, or sent to a service.
 
-Find more details and ideas in [custom reporters][46].
+Find more details and ideas in [custom reporters][47].
 
 ## Public exports
 
@@ -535,7 +536,7 @@ When unused dependencies are related to dependencies having a Knip [plugin][1],
 for that dependency are at custom locations. The default values are at the plugin's documentation, and can be overridden
 to match the custom location(s).
 
-When the dependencies don't have a Knip plugin yet, please file an issue or [create a new plugin][47].
+When the dependencies don't have a Knip plugin yet, please file an issue or [create a new plugin][48].
 
 #### Too many unused exports
 
@@ -543,7 +544,7 @@ When the project is a library and the exports are meant to be used by consumers
 
 1.  By default, unused exports of `entry` files are not reported. You could re-export from an existing entry file, or
     add the containing file to the `entry` array in the configuration.
-2.  The exported values or types can be marked [using the JSDoc `@public` tag][48]
+2.  The exported values or types can be marked [using the JSDoc `@public` tag][49]
 
 ### How to start using Knip in CI while having too many issues to sort out?
 
@@ -563,7 +564,7 @@ All of this is hiding problems, so please make sure to plan for fixing them and/
 
 This table is an ongoing comparison. Based on their docs (please report any mistakes):
 
-| Feature                           | **knip** | [depcheck][49] | [unimported][50] | [ts-unused-exports][51] | [ts-prune][52] |
+| Feature                           | **knip** | [depcheck][50] | [unimported][51] | [ts-unused-exports][52] | [ts-prune][53] |
 | :-------------------------------- | :------: | :------------: | :--------------: | :---------------------: | :------------: |
 | Unused files                      |    ✅    |       -        |        ✅        |            -            |       -        |
 | Unused dependencies               |    ✅    |       ✅       |        ✅        |            -            |       -        |
@@ -661,16 +662,17 @@ for the job. I'm motivated to make knip perfectly suited for the job of cutting
 [37]: ./src/plugins/sentry
 [38]: ./src/plugins/storybook
 [39]: ./src/plugins/stryker
-[40]: ./src/plugins/typedoc
-[41]: ./src/plugins/typescript
-[42]: ./src/plugins/vitest
-[43]: ./src/plugins/webpack
-[44]: #config
-[45]: #production-mode
-[46]: ./docs/custom-reporters.md
-[47]: #create-a-new-plugin
-[48]: #public-exports
-[49]: https://github.com/depcheck/depcheck
-[50]: https://github.com/smeijer/unimported
-[51]: https://github.com/pzavolinsky/ts-unused-exports
-[52]: https://github.com/nadeesha/ts-prune
+[40]: ./src/plugins/svelte
+[41]: ./src/plugins/typedoc
+[42]: ./src/plugins/typescript
+[43]: ./src/plugins/vitest
+[44]: ./src/plugins/webpack
+[45]: #config
+[46]: #production-mode
+[47]: ./docs/custom-reporters.md
+[48]: #create-a-new-plugin
+[49]: #public-exports
+[50]: https://github.com/depcheck/depcheck
+[51]: https://github.com/smeijer/unimported
+[52]: https://github.com/pzavolinsky/ts-unused-exports
+[53]: https://github.com/nadeesha/ts-prune

package/dist/binaries/bash-parser.d.ts

@@ -0,0 +1,6 @@
+import type { PackageJson } from 'type-fest';
+export declare const getBinariesFromScript: (script: string, { cwd, manifest, knownGlobalsOnly }: {
+    cwd: string;
+    manifest: PackageJson;
+    knownGlobalsOnly?: boolean | undefined;
+}) => string[];

package/dist/binaries/bash-parser.js

@@ -0,0 +1,57 @@
+import parse from 'bash-parser';
+import parseArgs from 'minimist';
+import * as FallbackResolver from './resolvers/fallback.js';
+import * as KnownResolvers from './resolvers/index.js';
+const spawningBinaries = ['cross-env', 'dotenv'];
+export const getBinariesFromScript = (script, { cwd, manifest, knownGlobalsOnly = false }) => {
+    if (!script)
+        return [];
+    const fromArgs = (args) => getBinariesFromScript(args.join(' '), { cwd, manifest });
+    const getBinariesFromNodes = (nodes) => nodes.flatMap(node => {
+        switch (node.type) {
+            case 'Command': {
+                const binary = node.name?.text;
+                const commandExpansions = node.prefix?.flatMap(prefix => prefix.expansion?.filter(expansion => expansion.type === 'CommandExpansion') ?? []) ?? [];
+                if (commandExpansions.length > 0) {
+                    return commandExpansions.flatMap(expansion => getBinariesFromNodes(expansion.commandAST.commands)) ?? [];
+                }
+                if (!binary || binary === '.' || binary === 'source')
+                    return [];
+                if (binary.startsWith('-') || binary.startsWith('"') || binary.startsWith('..'))
+                    return [];
+                if (['bun', 'deno'].includes(binary))
+                    return [];
+                const args = node.suffix?.map(arg => arg.text) ?? [];
+                if (['!', 'test'].includes(binary))
+                    return fromArgs(args);
+                if (binary in KnownResolvers) {
+                    return KnownResolvers[binary].resolve(binary, args, { cwd, manifest, fromArgs });
+                }
+                if (knownGlobalsOnly)
+                    return [];
+                if (spawningBinaries.includes(binary)) {
+                    const parsedArgs = parseArgs(args);
+                    const [spawnedBinary] = parsedArgs._;
+                    if (spawnedBinary) {
+                        const restArgs = args.slice(args.indexOf(spawnedBinary));
+                        return [binary, ...fromArgs(restArgs)];
+                    }
+                    else {
+                        return [];
+                    }
+                }
+                return FallbackResolver.resolve(binary, args, { cwd, manifest, fromArgs });
+            }
+            case 'LogicalExpression':
+                return getBinariesFromNodes([node.left, node.right]);
+            case 'If':
+                return getBinariesFromNodes([...node.clause.commands, ...node.then.commands]);
+            case 'For':
+                return getBinariesFromNodes(node.do.commands);
+            default:
+                return [];
+        }
+    });
+    const parsed = parse(script);
+    return parsed?.commands ? getBinariesFromNodes(parsed.commands) : [];
+};

package/dist/binaries/index.d.ts

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

package/dist/binaries/index.js

@@ -0,0 +1,22 @@
+import { IGNORED_GLOBAL_BINARIES } from '../constants.js';
+import { compact } from '../util/array.js';
+import { partition } from '../util/array.js';
+import { getPackageNameFromModuleSpecifier, stripBinary } from '../util/modules.js';
+import { isInternal } from '../util/path.js';
+import { timerify } from '../util/performance.js';
+import { getBinariesFromScript } from './bash-parser.js';
+const defaultCwd = process.cwd();
+const getReferencesFromScripts = (npmScripts, options = {}) => {
+    const { cwd = defaultCwd, manifest = {}, ignore = [], knownGlobalsOnly = false } = options;
+    const scripts = [npmScripts].flat();
+    const results = scripts.flatMap(script => getBinariesFromScript(script, { cwd, manifest, knownGlobalsOnly }));
+    const [entryFiles, binaries] = partition(compact(results), isInternal);
+    return {
+        entryFiles,
+        binaries: binaries
+            .map(stripBinary)
+            .map(getPackageNameFromModuleSpecifier)
+            .filter(binaryName => !IGNORED_GLOBAL_BINARIES.includes(binaryName) && !ignore.includes(binaryName)),
+    };
+};
+export const _getReferencesFromScripts = timerify(getReferencesFromScripts);

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

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

package/dist/binaries/resolvers/fallback.js

@@ -0,0 +1,14 @@
+import parseArgs from 'minimist';
+import { tryResolveFilePaths } from './node.js';
+const argResolvers = {
+    'babel-node': parsed => [parsed._[0], parsed.require].flat(),
+    'ts-node': parsed => [parsed._[0], parsed.require].flat(),
+    tsx: parsed => parsed._.filter(p => p !== 'watch'),
+    default: parsed => [parsed.require].flat(),
+};
+export const resolve = (binary, args, { cwd }) => {
+    const parsed = parseArgs(args, { string: ['r'], alias: { require: ['r', 'loader'] } });
+    const resolver = argResolvers[binary] ?? argResolvers.default;
+    const resolve = resolver(parsed);
+    return [binary, ...tryResolveFilePaths(cwd, resolve)];
+};

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

@@ -0,0 +1,4 @@
+export * as node from './node.js';
+export * as npx from './npx.js';
+export * as pnpm from './pnpm.js';
+export * as yarn from './yarn.js';

package/dist/binaries/resolvers/index.js

@@ -0,0 +1,4 @@
+export * as node from './node.js';
+export * as npx from './npx.js';
+export * as pnpm from './pnpm.js';
+export * as yarn from './yarn.js';

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

@@ -0,0 +1,3 @@
+import type { Resolver } from '../types.js';
+export declare const tryResolveFilePaths: (cwd: string, specifiers: string[]) => string[];
+export declare const resolve: Resolver;

package/dist/binaries/resolvers/node.js

@@ -0,0 +1,20 @@
+import parseArgs from 'minimist';
+import { isInNodeModules, join } from '../../util/path.js';
+import { tryResolve } from '../../util/require.js';
+const tryResolveFilePath = (cwd, specifier, fallback) => {
+    if (specifier) {
+        const filePath = join(cwd, specifier);
+        if (!isInNodeModules(filePath)) {
+            const resolvedFilePath = tryResolve(filePath);
+            if (resolvedFilePath)
+                return [resolvedFilePath];
+        }
+        return fallback ? [fallback] : [];
+    }
+    return [];
+};
+export const tryResolveFilePaths = (cwd, specifiers) => specifiers.flatMap(specifier => tryResolveFilePath(cwd, specifier, specifier));
+export const resolve = (binary, args, { cwd }) => {
+    const parsed = parseArgs(args, { string: ['r'], alias: { require: ['r', 'loader', 'experimental-loader'] } });
+    return [...tryResolveFilePath(cwd, parsed._[0]), ...tryResolveFilePaths(cwd, [parsed.require].flat())];
+};

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

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

package/dist/binaries/resolvers/npx.js

@@ -0,0 +1,5 @@
+import parseArgs from 'minimist';
+export const resolve = (binary, args, { fromArgs }) => {
+    const parsed = parseArgs(args, { '--': true, stopEarly: true, boolean: ['yes', 'no'], alias: { yes: 'y', no: 'n' } });
+    return [...(parsed.yes ? [] : fromArgs(parsed._)), ...(parsed['--'] ? fromArgs(parsed['--']) : [])];
+};

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

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

package/dist/binaries/resolvers/pnpm.js

@@ -0,0 +1,45 @@
+import parseArgs from 'minimist';
+const commands = [
+    'add',
+    'dlx',
+    'run',
+    'i',
+    'install',
+    'up',
+    'update',
+    'upgrade',
+    'remove',
+    'rm',
+    'uninstall',
+    'un',
+    'link',
+    'ln',
+    'unlink',
+    'import',
+    'rebuild',
+    'rb',
+    'prune',
+    'fetch',
+    'install-test',
+    'it',
+    'patch',
+    'patch-commit',
+    'audit',
+    'list',
+    'ls',
+    'outdated',
+    'why',
+    'test',
+    't',
+    'tst',
+];
+export const resolve = (binary, args, { manifest }) => {
+    const scripts = manifest.scripts ? Object.keys(manifest.scripts) : [];
+    const parsed = parseArgs(args, {});
+    const [command, result] = parsed._;
+    if (scripts.includes(command) || commands.includes(command))
+        return [];
+    if (command === 'exec')
+        return [result];
+    return command ? [command] : [];
+};

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

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

package/dist/binaries/resolvers/yarn.js

@@ -0,0 +1,46 @@
+import parseArgs from 'minimist';
+const commands = [
+    'add',
+    'bin',
+    'cache',
+    'config',
+    'constraints',
+    'dedupe',
+    'dlx',
+    'explain',
+    'info',
+    'init',
+    'install',
+    'link',
+    'pack',
+    'patch',
+    'patch-commit',
+    'plugin',
+    'rebuild',
+    'remove',
+    'search',
+    'set',
+    'stage',
+    'unlink',
+    'unplug',
+    'up',
+    'upgrade-interactive',
+    'version',
+    'why',
+    'workspace',
+    'workspaces',
+];
+export const resolve = (binary, args, { manifest, fromArgs }) => {
+    const scripts = manifest.scripts ? Object.keys(manifest.scripts) : [];
+    const parsed = parseArgs(args, {});
+    const [command, result] = parsed._;
+    if (scripts.includes(command) || commands.includes(command))
+        return [];
+    if (command === 'run' && scripts.includes(result))
+        return [];
+    if (command === 'run' || command === 'exec')
+        return [result];
+    if (command === 'node')
+        return fromArgs(parsed._);
+    return command ? [command] : [];
+};

package/dist/binaries/types.d.ts

@@ -0,0 +1,18 @@
+import type { PackageJson } from 'type-fest';
+type Options = {
+    cwd?: string;
+    manifest?: PackageJson;
+    ignore?: string[];
+    knownGlobalsOnly?: boolean;
+};
+export type GetReferencesFromScripts = (npmScripts: string | string[], options?: Options) => {
+    entryFiles: string[];
+    binaries: string[];
+};
+type FromArgs = (args: string[]) => string[];
+export type Resolver = (binary: string, args: string[], options: {
+    cwd: string;
+    manifest: PackageJson;
+    fromArgs: FromArgs;
+}) => string[];
+export {};

package/dist/binaries/types.js

@@ -0,0 +1 @@
+export {};

package/dist/configuration-chief.js

@@ -120,8 +120,8 @@ export class ConfigurationChief {
                     project,
                     paths,
                     ignore: arrayify(workspaceConfig.ignore),
-                    ignoreBinaries: [...ignoreBinaries, ...arrayify(workspaceConfig.ignoreBinaries)],
-                    ignoreDependencies: [...ignoreDependencies, ...arrayify(workspaceConfig.ignoreDependencies)],
+                    ignoreBinaries: compact([...ignoreBinaries, ...arrayify(workspaceConfig.ignoreBinaries)]),
+                    ignoreDependencies: compact([...ignoreDependencies, ...arrayify(workspaceConfig.ignoreDependencies)]),
                 };
                 for (const [name, pluginConfig] of Object.entries(workspaceConfig)) {
                     const pluginName = toCamelCase(name);

package/dist/dependency-deputy.js

@@ -36,7 +36,12 @@ export class DependencyDeputy {
         return this._manifests.get(workspaceName);
     }
     getProductionDependencies(workspaceName) {
-        return this._manifests.get(workspaceName)?.dependencies ?? [];
+        const manifest = this._manifests.get(workspaceName);
+        if (!manifest)
+            return [];
+        if (this.isStrict)
+            return [...manifest.dependencies, ...manifest.peerDependencies];
+        return manifest.dependencies;
     }
     getDevDependencies(workspaceName) {
         return this._manifests.get(workspaceName)?.devDependencies ?? [];
@@ -87,7 +92,9 @@ export class DependencyDeputy {
     }
     isInDependencies(workspaceName, packageName) {
         const manifest = this._manifests.get(workspaceName);
-        const dependencies = manifest ? (this.isStrict ? manifest.dependencies : manifest.allDependencies) : [];
+        if (!manifest)
+            return false;
+        const dependencies = this.isStrict ? this.getProductionDependencies(workspaceName) : manifest.allDependencies;
         return dependencies.includes(packageName);
     }
     settleDependencyIssues() {

package/dist/index.js

@@ -48,6 +48,7 @@ export const main = async (unresolvedConfiguration) => {
             config,
             manifest,
             isProduction,
+            isStrict,
             rootIgnore: chief.config.ignore,
             negatedWorkspacePatterns: chief.getNegatedWorkspacePatterns(name),
             enabledPluginsInAncestors: ancestors.flatMap(ancestor => enabledPluginsStore.get(ancestor) ?? []),

package/dist/manifest/index.d.ts

@@ -5,10 +5,11 @@ type Options = {
     config: WorkspaceConfiguration;
     manifest: PackageJson;
     isProduction: boolean;
+    isStrict: boolean;
     dir: string;
     cwd: string;
 };
-export declare const findDependencies: ({ config, manifest, isProduction, dir, cwd }: Options) => Promise<{
+export declare const findDependencies: ({ config, manifest, isProduction, isStrict, dir, cwd }: Options) => Promise<{
     dependencies: string[];
     peerDependencies: PeerDependencies;
     installedBinaries: InstalledBinaries;

package/dist/manifest/index.js

@@ -1,13 +1,13 @@
-import { _getReferencesFromScripts } from '../util/binaries/index.js';
+import { _getReferencesFromScripts } from '../binaries/index.js';
 import { timerify } from '../util/performance.js';
 import { getPackageManifest } from './helpers.js';
-const findManifestDependencies = async ({ config, manifest, isProduction, dir, cwd }) => {
+const findManifestDependencies = async ({ config, manifest, isProduction, isStrict, dir, cwd }) => {
     const { ignoreBinaries } = config;
     const scriptFilter = isProduction ? ['start', 'postinstall'] : [];
     const referencedDependencies = new Set();
     const peerDependencies = new Map();
     const scripts = Object.entries(manifest.scripts ?? {}).reduce((scripts, [scriptName, script]) => {
-        if (script && (scriptFilter.length === 0 || (scriptFilter.length > 0 && scriptFilter.includes(scriptName)))) {
+        if (script && (scriptFilter.length === 0 || scriptFilter.includes(scriptName))) {
             return [...scripts, script];
         }
         return scripts;
@@ -18,7 +18,11 @@ const findManifestDependencies = async ({ config, manifest, isProduction, dir, c
         ignore: ignoreBinaries,
     });
     const installedBinaries = new Map();
-    const packageNames = [...Object.keys(manifest.dependencies ?? {}), ...Object.keys(manifest.devDependencies ?? {})];
+    const packageNames = [
+        ...Object.keys(manifest.dependencies ?? {}),
+        ...(isStrict ? Object.keys(manifest.peerDependencies ?? {}) : []),
+        ...(isProduction ? [] : Object.keys(manifest.devDependencies ?? {})),
+    ];
     for (const packageName of packageNames) {
         const manifest = await getPackageManifest({ dir, packageName, cwd });
         if (manifest) {
@@ -45,8 +49,8 @@ const findManifestDependencies = async ({ config, manifest, isProduction, dir, c
     for (const binaryName of referencedBinaries) {
         if (installedBinaries.has(binaryName)) {
             const packageNames = Array.from(installedBinaries.get(binaryName) ?? []);
-            const packageName = packageNames.length === 1 ? packageNames[0] : undefined;
-            referencedDependencies.add(packageName ?? binaryName);
+            const packageName = packageNames.length === 1 ? packageNames[0] : binaryName;
+            referencedDependencies.add(packageName);
         }
         else {
             referencedDependencies.add(binaryName);

package/dist/plugins/ava/index.d.ts

@@ -0,0 +1,6 @@
+import type { IsPluginEnabledCallback, GenericPluginCallback } from '../../types/plugins.js';
+export declare const NAME = "Ava";
+export declare const ENABLERS: string[];
+export declare const isEnabled: IsPluginEnabledCallback;
+export declare const CONFIG_FILE_PATTERNS: string[];
+export declare const findDependencies: GenericPluginCallback;

package/dist/plugins/ava/index.js

@@ -0,0 +1,22 @@
+import { _getReferencesFromScripts } from '../../binaries/index.js';
+import { _load } from '../../util/loader.js';
+import { timerify } from '../../util/performance.js';
+import { hasDependency } from '../../util/plugin.js';
+export const NAME = 'Ava';
+export const ENABLERS = ['ava'];
+export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
+export const CONFIG_FILE_PATTERNS = ['ava.config.{js,cjs,mjs}', 'package.json'];
+const findPluginDependencies = async (configFilePath, { cwd, manifest, workspaceConfig }) => {
+    const config = configFilePath.endsWith('package.json') ? manifest.ava : await _load(configFilePath);
+    const requireArgs = (config?.require ?? []).map(require => `--require ${require}`);
+    const otherArgs = config?.nodeArguments ?? [];
+    const cmd = `node ${otherArgs.join(' ') + ' '}${requireArgs.join(' ')}`;
+    const { binaries } = _getReferencesFromScripts([cmd], {
+        cwd,
+        manifest,
+        ignore: workspaceConfig.ignoreBinaries,
+        knownGlobalsOnly: true,
+    });
+    return binaries;
+};
+export const findDependencies = timerify(findPluginDependencies);

package/dist/plugins/ava/types.d.ts

@@ -0,0 +1,4 @@
+export type PluginConfig = {
+    require?: string[];
+    nodeArguments?: string[];
+};

package/dist/plugins/ava/types.js

@@ -0,0 +1 @@
+export {};

package/dist/plugins/commitlint/index.js

@@ -4,9 +4,16 @@ import { hasDependency } from '../../util/plugin.js';
 export const NAME = 'commitlint';
 export const ENABLERS = ['@commitlint/cli'];
 export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
-export const CONFIG_FILE_PATTERNS = ['commitlint.config.{js,ts}'];
-const findCommitLintDependencies = async (configFilePath) => {
-    const config = await _load(configFilePath);
+export const CONFIG_FILE_PATTERNS = [
+    '.commitlintrc',
+    '.commitlintrc.{json,yaml,yml,js,cjs,ts,cts}',
+    'commitlint.config.{js,cjs,ts,cts}',
+    'package.json',
+];
+const findCommitLintDependencies = async (configFilePath, { manifest }) => {
+    const config = configFilePath.endsWith('package.json')
+        ? manifest.commitlint
+        : await _load(configFilePath);
     return config?.extends ? [config.extends].flat() : [];
 };
 export const findDependencies = timerify(findCommitLintDependencies);

package/dist/plugins/cspell/index.d.ts

@@ -0,0 +1,6 @@
+import type { IsPluginEnabledCallback, GenericPluginCallback } from '../../types/plugins.js';
+export declare const NAME = "cspell";
+export declare const ENABLERS: string[];
+export declare const isEnabled: IsPluginEnabledCallback;
+export declare const CONFIG_FILE_PATTERNS: string[];
+export declare const findDependencies: GenericPluginCallback;

package/dist/plugins/cspell/index.js

@@ -0,0 +1,18 @@
+import { _load } from '../../util/loader.js';
+import { timerify } from '../../util/performance.js';
+import { hasDependency } from '../../util/plugin.js';
+export const NAME = 'cspell';
+export const ENABLERS = ['cspell'];
+export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
+export const CONFIG_FILE_PATTERNS = [
+    'cspell.config.{js,cjs,json,yaml,yml}',
+    'cspell.{json,yaml,yml}',
+    '.c{s,S}pell.json',
+    'cSpell.json',
+];
+const findPluginDependencies = async (configFilePath) => {
+    const config = await _load(configFilePath);
+    const imports = config?.import ?? [];
+    return imports;
+};
+export const findDependencies = timerify(findPluginDependencies);

package/dist/plugins/cspell/types.d.ts

@@ -0,0 +1,3 @@
+export type PluginConfig = {
+    import?: string[];
+};

package/dist/plugins/cspell/types.js

@@ -0,0 +1 @@
+export {};

package/dist/plugins/github-actions/index.js

@@ -1,4 +1,4 @@
-import { _getReferencesFromScripts } from '../../util/binaries/index.js';
+import { _getReferencesFromScripts } from '../../binaries/index.js';
 import { _firstGlob } from '../../util/glob.js';
 import { _load } from '../../util/loader.js';
 import { getValuesByKeyDeep } from '../../util/object.js';

package/dist/plugins/husky/index.js

@@ -1,5 +1,5 @@
 import { readFileSync } from 'fs';
-import { _getReferencesFromScripts } from '../../util/binaries/index.js';
+import { _getReferencesFromScripts } from '../../binaries/index.js';
 import { timerify } from '../../util/performance.js';
 import { hasDependency } from '../../util/plugin.js';
 export const NAME = 'husky';