knip 0.1.2 → 0.3.0

package/README.md

@@ -1,22 +1,25 @@
 # ✂️ Knip
 
-Knip scans your TypeScript projects for **unused files and exports**. For comparison, ESLint finds unused variables
-inside files in isolation, but this will not be flagged:
+Knip scans your JavaScript and TypeScript projects for **unused files, dependencies and exports**. Things that should be
+eliminated. Less code means better performance and less to maintain, important for both UX and DX!
+
+For comparison, ESLint finds unused variables inside files in isolation, but this will not be flagged:
 
 ```ts
 export const myVar = true;
 ```
 
-Unused files will also not be detected by ESLint. So how do you know which files and exports are no longer used? This
-requires an analysis of all the right files in the project.
+Unused files will also not be detected by ESLint. So how do you know which files, dependencies and exports are no longer
+used? This requires an analysis of all the right files in the project.
 
 This is where Knip comes in:
 
-- [x] Resolves all (unused) files in your project and reports **unused files and exports**.
+- [x] Resolves all (unused) files in your project and reports **unused files, dependencies and exports**.
 - [x] Verifies that exported symbols are actually used in other files, even when part of an imported namespace.
+- [x] Finds dependencies not listed in `package.json`.
 - [x] Finds duplicate exports of the same symbol.
 - [x] Supports JavaScript inside TypeScript projects (`"allowJs": true`)
-- [ ] Supports JavaScript-only projects with CommonJS and ESM (no `tsconfig.json`) - TODO
+- [x] Supports JavaScript-only projects using ESM (without a `tsconfig.json`)
 
 Knip really shines in larger projects where you have non-production files (such as `/docs`, `/tools` and `/scripts`).
 The `includes` setting in `tsconfig.json` is often too broad, resulting in too many false negatives. Similar projects
@@ -54,21 +57,20 @@ npx knip
 
 This will analyze the project and output unused files, exports, types and duplicate exports.
 
-Use `--only files` when configuring knip for faster initial results.
+Use `--include files` when configuring knip the first time for faster initial results.
 
 ## How It Works
 
-knip works by creating two sets of files:
+Knip works by creating two sets of files:
 
 1. Production code is the set of files resolved from the `entryFiles`.
 2. They are matched against the set of `projectFiles`.
-3. The subset of project files that are not production code will be reported as unused files (in red).
+3. The subset of project files that is not production code will be reported as unused files (in red).
 4. Then the production code (in blue) will be scanned for unused exports.
 
 ![How it works](./assets/how-it-works.drawio.svg)
 
-Clean and actionable reports are achieved when non-production code such as tests are excluded from the `projectFiles`
-(using negation patterns such as `!**/*.test.ts`).
+Please read on if you think you have too many results: [too many false positives?](#too-many-false-positives)
 
 ## Options
 
@@ -78,79 +80,117 @@ knip [options]
 
 Options:
   -c/--config [file]   Configuration file path (default: ./knip.json or package.json#knip)
-  --cwd                Working directory (default: current working directory)
-  --max-issues         Maximum number of unreferenced files until non-zero exit code (default: 1)
-  --only               Report only listed issue group(s): files, exports, types, nsExports, nsTypes, duplicates
-  --exclude            Exclude issue group(s) from report: files, exports, types, nsExports, nsTypes, duplicates
+  -t/--tsConfig [file] TypeScript configuration path (default: ./tsconfig.json)
+  --dir                Working directory (default: current working directory)
+  --include            Report only listed issue group(s) (see below)
+  --exclude            Exclude issue group(s) from report (see below)
+  --dev                Include `devDependencies` in report(s) (default: false)
   --no-progress        Don't show dynamic progress updates
+  --max-issues         Maximum number of issues before non-zero exit code (default: 0)
   --reporter           Select reporter: symbols, compact (default: symbols)
   --jsdoc              Enable JSDoc parsing, with options: public (default: disabled)
 
+Issue groups: files, dependencies, unlisted, exports, nsExports, types, nsTypes, duplicates
+
 Examples:
 
 $ knip
-$ knip --cwd packages/client --only files
+$ knip --dir packages/client --include files
 $ knip -c ./knip.js --reporter compact --jsdoc public
 
 More info: https://github.com/webpro/knip
 ```
 
+🚀 Knip is considerably faster when only the `files` and/or `duplicates` groups are included.
+
 ## Reading the report
 
 After analyzing all the files resolved from the `entryFiles` against the `projectFiles`, the report contains the
 following groups of issues:
 
-- Unused **files**: no references to this file have been found
-- Unused **exports**: unable to find references to this exported variable
-- Unused exports in namespaces (1): unable to find references to this exported variable, and it has become a member of a
-  re-exported namespace (**nsExports**)
-- Unused types: no references to this exported type have been found
-- Unused types in namespaces (1): this exported variable is not directly referenced, and it has become a member a
-  re-exported namespace (**nsTypes**)
-- Duplicate exports - the same thing is exported more than once with different names (**duplicates**)
+- `files` - Unused files: did not find references to this file
+- `dependencies` - Unused dependencies: did not find references to this dependency
+- `unlisted` - Unlisted dependencies: this dependency is used, but not listed in package.json (1)
+- `exports` - Unused exports: did not find references to this exported variable
+- `nsExports` - Unused exports in namespaces: did not find direct references to this exported variable (2)
+- `types` - Unused types: did not find references to this exported type
+- `nsTypes` - Unused types in namespaces: did not find direct references to this exported variable (2)
+- `duplicates` - Duplicate exports: the same thing is exported more than once with different names
 
-Each group type (in **bold**) can be used in the `--only` and `--exclude` arguments to slice & dice the report to your
-needs.
+Each group type can be an `--include` or `--exclude` to slice & dice the report to your needs.
 
-🚀 The process is considerably faster when reporting only the `files` and/or `duplicates` groups.
+1. This may also include dependencies that could not be resolved properly, such as `local/dir/file.ts`.
+2. The variable or type is not referenced directly, and has become a member of a namespace. That's why Knip is not sure
+   whether this export can be removed, so please look into it:
 
 ## Now what?
 
-After verifying that files reported as unused are indeed not referenced anywhere, they can be deleted.
+As always, make sure to backup files or use Git before deleting files or making changes. Run tests to verify results.
 
-Remove the `export` keyword in front of unused exports. Then you (or tools such as ESLint) can see whether the variable
-or type is used within its own file. If this is not the case, it can be removed completely.
+- Unused files can be deleted.
+- Unused dependencies can be removed from `package.json`.
+- Unlisted dependencies should be added to `package.json`.
+- Unused exports and types: remove the `export` keyword in front of unused exports. Then you (or tools such as ESLint)
+  can see whether the variable or type is used within its own file. If this is not the case, it can be removed.
 
 🔁 Repeat the process to reveal new unused files and exports. Sometimes it's so liberating to delete things.
 
-## More configuration examples
+## Too many false positives?
+
+The default configuration for Knip is very strict and targets production code. For best results, it is recommended to
+exclude files such as tests from the project files. Here's why: when including tests and other non-production files,
+they may prevent production files from being reported as unused.
 
-### Test files
+Excluding non-production files from the `projectFiles` allows Knip to understand what production code can be removed
+(including dependent files!).
 
-For best results, it is recommended to exclude files such as tests from the project files. When including tests and
-other non-production files, they may prevent production files from being reported as unused. Not including them will
-make it clear what production files can be removed (including dependent files!).
+Non-production code includes files such as end-to-end tests, tooling, scripts, Storybook stories, etc.
 
-The same goes for any type of non-production files, such as Storybook stories or end-to-end tests.
+Think of it the same way as you would split `dependencies` and `devDependencies` in `package.json`.
 
-To report dangling files and exports that are not used by any of the production or test files, include both to the set
-of `entryFiles`:
+To include both production and test files to analyze the project as a whole, include both sets of files to `entryFiles`,
+and add `dev: true` to a file named such as `knip.dev.json`:
 
 ```json
 {
-  "entryFiles": ["src/index.ts", "src/**/*.spec.ts"],
-  "projectFiles": ["src/**/*.ts", "!**/*.e2e.ts"]
+  "dev": true,
+  "entryFiles": ["src/index.ts", "src/**/*.spec.ts", "src/**/*.e2e.ts"],
+  "projectFiles": ["src/**/*.ts"]
 }
 ```
 
-In theory this idea could be extended to report some kind of test coverage.
+Use `-c knip.dev.json` and unused files and exports for the combined set of files as configured in `entryFiles` will be
+reported.
+
+An alternative way to store `dev` configuration is in this example `package.json`:
+
+```json
+{
+  "name": "my-package",
+  "scripts": {
+    "knip": "knip"
+  },
+  "knip": {
+    "entryFiles": ["src/index.ts"],
+    "projectFiles": ["src/**/*.ts", "!**/*.spec.ts"],
+    "dev": {
+      "entryFiles": ["src/index.ts", "src/**/*.spec.ts", "src/**/*.e2e.ts"],
+      "projectFiles": ["src/**/*.ts"]
+    }
+  }
+}
+```
+
+This way, the `--dev` flag will use the `dev` options (and also add `devDependencies` to the `dependencies` report).
+
+## More configuration examples
 
 ### Monorepos
 
 #### Separate packages
 
-In repos with multiple packages, the `--cwd` option comes in handy. With similar package structures, the packages can be
-configured using globs:
+In repos with multiple (published) packages, the `--cwd` option comes in handy. With similar package structures, the
+packages can be configured using globs:
 
 ```json
 {
@@ -166,15 +206,15 @@ Packages can also be explicitly configured per package directory.
 To scan the packages separately, using the first match from the configuration file:
 
 ```
-knip --cwd packages/client --config knip.json
-knip --cwd packages/services --config knip.json
+knip --cwd packages/client
+knip --cwd packages/services
 ```
 
 #### Connected projects
 
 A good example of a large project setup is a monorepo, such as created with Nx. Let's take an example project
-configuration for an Nx project using Next.js, Jest and Storybook. This can also be a JavaScript file, which allows to
-add logic and/or comments:
+configuration for an Nx project using Next.js, Jest and Storybook. This configuration file can also be a JavaScript
+file, which allows to add logic and/or comments (e.g. `knip.js`):
 
 ```js
 const entryFiles = ['apps/**/pages/**/*.{js,ts,tsx}'];
@@ -204,10 +244,14 @@ can be tweaked further to the project structure.
 ### Default reporter
 
 ```
-$ knip --config ./knip.json
+$ knip
 --- UNUSED FILES (2)
 src/chat/helpers.ts
 src/components/SideBar.tsx
+--- UNUSED DEPENDENCIES (1)
+moment
+--- UNLISTED DEPENDENCIES (1)
+react
 --- UNUSED EXPORTS (5)
 lowercaseFirstLetter  src/common/src/string/index.ts
 RegistrationBox       src/components/Registration.tsx
@@ -227,10 +271,14 @@ ProductsList, default  src/components/Products.tsx
 ### Compact
 
 ```
-$ knip --config ./knip.json --reporter compact
+$ knip --reporter compact
 --- UNUSED FILES (2)
 src/chat/helpers.ts
 src/components/SideBar.tsx
+--- UNUSED DEPENDENCIES (1)
+moment
+--- UNLISTED DEPENDENCIES (1)
+react
 --- UNUSED EXPORTS (4)
 src/common/src/string/index.ts: lowercaseFirstLetter
 src/components/Registration.tsx: RegistrationBox

package/dist/cli.js

@@ -6,52 +6,92 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const node_path_1 = __importDefault(require("node:path"));
 const node_util_1 = require("node:util");
+const typescript_1 = __importDefault(require("typescript"));
 const help_1 = require("./help");
 const config_1 = require("./util/config");
+const path_1 = require("./util/path");
 const reporters_1 = __importDefault(require("./reporters"));
 const _1 = require(".");
-const { values: { help, cwd: cwdArg, config = 'knip.json', only = [], exclude = [], 'no-progress': noProgress = false, reporter = 'symbols', jsdoc = [], 'max-issues': maxIssues = '1', }, } = (0, node_util_1.parseArgs)({
+const { values: { help, dir, config: configFilePath = 'knip.json', tsConfig: tsConfigFilePath, include = [], exclude = [], dev: isDev = false, 'no-progress': noProgress = false, reporter = 'symbols', jsdoc = [], 'max-issues': maxIssues = '0', }, } = (0, node_util_1.parseArgs)({
     options: {
         help: { type: 'boolean' },
-        cwd: { type: 'string' },
         config: { type: 'string', short: 'c' },
-        only: { type: 'string', multiple: true },
+        tsConfig: { type: 'string', short: 't' },
+        dir: { type: 'string' },
+        include: { type: 'string', multiple: true },
         exclude: { type: 'string', multiple: true },
+        dev: { type: 'boolean' },
+        'max-issues': { type: 'string' },
         'no-progress': { type: 'boolean' },
         reporter: { type: 'string' },
         jsdoc: { type: 'string', multiple: true },
-        'max-issues': { type: 'string' },
     },
 });
 if (help) {
     (0, help_1.printHelp)();
     process.exit(0);
 }
-const cwd = cwdArg ? node_path_1.default.resolve(cwdArg) : process.cwd();
-const configuration = (0, config_1.importConfig)(cwd, config);
-if (!configuration) {
-    (0, help_1.printHelp)();
-    process.exit(1);
-}
-const isShowProgress = noProgress !== false || (process.stdout.isTTY && typeof process.stdout.cursorTo === 'function');
-const report = reporter in reporters_1.default ? reporters_1.default[reporter] : require(node_path_1.default.join(cwd, reporter));
+const cwd = process.cwd();
+const workingDir = dir ? node_path_1.default.resolve(dir) : cwd;
+const isShowProgress = noProgress === false ? process.stdout.isTTY && typeof process.stdout.cursorTo === 'function' : !noProgress;
+const printReport = reporter in reporters_1.default ? reporters_1.default[reporter] : require(node_path_1.default.join(workingDir, reporter));
 const main = async () => {
-    const resolvedConfig = (0, config_1.resolveConfig)(configuration, cwdArg);
+    const localConfigurationPath = await (0, path_1.findFile)(workingDir, configFilePath);
+    const manifestPath = await (0, path_1.findFile)(workingDir, 'package.json');
+    const localConfiguration = localConfigurationPath && require(localConfigurationPath);
+    const manifest = manifestPath && require(manifestPath);
+    if (!localConfigurationPath && !manifest.knip) {
+        const location = workingDir === cwd ? 'current directory' : `${node_path_1.default.relative(cwd, workingDir)} or up.`;
+        console.error(`Unable to find ${configFilePath} or package.json#knip in ${location}\n`);
+        (0, help_1.printHelp)();
+        process.exit(1);
+    }
+    const resolvedConfig = (0, config_1.resolveConfig)(manifest.knip ?? localConfiguration, { workingDir: dir, isDev });
     if (!resolvedConfig) {
         (0, help_1.printHelp)();
         process.exit(1);
     }
-    const config = Object.assign({}, resolvedConfig, {
-        cwd,
-        include: (0, config_1.resolveIncludedFromArgs)(only, exclude),
+    const report = (0, config_1.resolveIncludedIssueGroups)(include, exclude, resolvedConfig);
+    let tsConfigPaths = [];
+    const tsConfigPath = await (0, path_1.findFile)(workingDir, tsConfigFilePath ?? 'tsconfig.json');
+    if (tsConfigFilePath && !tsConfigPath) {
+        console.error(`Unable to find ${tsConfigFilePath}\n`);
+        (0, help_1.printHelp)();
+        process.exit(1);
+    }
+    if (tsConfigPath) {
+        const tsConfig = typescript_1.default.readConfigFile(tsConfigPath, typescript_1.default.sys.readFile);
+        tsConfigPaths = tsConfig.config.compilerOptions?.paths
+            ? Object.keys(tsConfig.config.compilerOptions.paths).map(p => p.replace(/\*/g, '**'))
+            : [];
+        if (tsConfig.error) {
+            console.error(`An error occured when reading ${node_path_1.default.relative(cwd, tsConfigPath)}.\n`);
+            (0, help_1.printHelp)();
+            process.exit(1);
+        }
+    }
+    const config = {
+        workingDir,
+        report,
+        dependencies: Object.keys(manifest.dependencies ?? {}),
+        devDependencies: Object.keys(manifest.devDependencies ?? {}),
+        isDev: typeof resolvedConfig.dev === 'boolean' ? resolvedConfig.dev : isDev,
+        tsConfigFilePath,
+        tsConfigPaths,
         isShowProgress,
         jsDocOptions: {
             isReadPublicTag: jsdoc.includes('public'),
         },
-    });
+        ...resolvedConfig,
+    };
     const { issues, counters } = await (0, _1.run)(config);
-    report({ issues, cwd, config });
-    if (counters.files > Number(maxIssues))
-        process.exit(counters.files);
+    printReport({ issues, workingDir, config });
+    const reportGroup = report.files ? 'files' : Object.keys(report).find(key => report[key]);
+    const counterGroup = reportGroup === 'unlisted' ? 'unresolved' : reportGroup;
+    if (counterGroup) {
+        const count = counters[counterGroup];
+        if (count > Number(maxIssues))
+            process.exit(count);
+    }
 };
 main();

package/dist/help.js

@@ -6,18 +6,22 @@ const printHelp = () => {
 
 Options:
   -c/--config [file]   Configuration file path (default: ./knip.json or package.json#knip)
-  --cwd                Working directory (default: current working directory)
-  --max-issues         Maximum number of unreferenced files until non-zero exit code (default: 1)
-  --only               Report only listed issue group(s): files, exports, types, nsExports, nsTypes, duplicates
-  --exclude            Exclude issue group(s) from report: files, exports, types, nsExports, nsTypes, duplicates
+  -t/--tsConfig [file] TypeScript configuration path (default: ./tsconfig.json)
+  --dir                Working directory (default: current working directory)
+  --include            Report only listed issue group(s) (see below)
+  --exclude            Exclude issue group(s) from report (see below)
+  --dev                Include \`devDependencies\` in report(s) (default: false)
   --no-progress        Don't show dynamic progress updates
+  --max-issues         Maximum number of issues before non-zero exit code (default: 0)
   --reporter           Select reporter: symbols, compact (default: symbols)
   --jsdoc              Enable JSDoc parsing, with options: public (default: disabled)
 
+Issue groups: files, dependencies, unlisted, exports, nsExports, types, nsTypes, duplicates
+
 Examples:
 
 $ knip
-$ knip --cwd packages/client --only files
+$ knip --dir packages/client --include files
 $ knip -c ./knip.js --reporter compact --jsdoc public
 
 More info: https://github.com/webpro/knip`);

package/dist/index.d.ts

@@ -3,6 +3,9 @@ export declare function run(configuration: Configuration): Promise<{
     issues: Issues;
     counters: {
         files: number;
+        dependencies: number;
+        devDependencies: number;
+        unresolved: number;
         exports: number;
         types: number;
         nsExports: number;

package/dist/index.js

@@ -7,21 +7,27 @@ exports.run = void 0;
 const node_path_1 = __importDefault(require("node:path"));
 const ts_morph_1 = require("ts-morph");
 const ts_morph_helpers_1 = require("ts-morph-helpers");
-const util_1 = require("./util");
+const project_1 = require("./util/project");
+const type_1 = require("./util/type");
+const dependencies_1 = require("./util/dependencies");
 const log_1 = require("./log");
 const lineRewriter = new log_1.LineRewriter();
 async function run(configuration) {
-    const { cwd, isShowProgress, include, jsDocOptions } = configuration;
-    const production = await (0, util_1.createProject)(cwd, configuration.entryFiles);
+    const { workingDir, isShowProgress, report, isDev, jsDocOptions } = configuration;
+    const { getUnresolvedDependencies, getUnusedDependencies, getUnusedDevDependencies } = (0, dependencies_1.getDependencyAnalyzer)(configuration);
+    const production = await (0, project_1.createProject)(configuration, configuration.entryFiles);
     const entryFiles = production.getSourceFiles();
     production.resolveSourceFileDependencies();
     const productionFiles = production.getSourceFiles();
-    const project = await (0, util_1.createProject)(cwd, configuration.projectFiles);
+    const project = await (0, project_1.createProject)(configuration, configuration.projectFiles);
     const projectFiles = project.getSourceFiles();
-    const [usedProductionFiles, unreferencedProductionFiles] = (0, util_1.partitionSourceFiles)(projectFiles, productionFiles);
-    const [, usedNonEntryFiles] = (0, util_1.partitionSourceFiles)(usedProductionFiles, entryFiles);
+    const [usedProductionFiles, unreferencedProductionFiles] = (0, project_1.partitionSourceFiles)(projectFiles, productionFiles);
+    const [usedEntryFiles, usedNonEntryFiles] = (0, project_1.partitionSourceFiles)(usedProductionFiles, entryFiles);
     const issues = {
         files: new Set(unreferencedProductionFiles.map(file => file.getFilePath())),
+        dependencies: new Set(),
+        devDependencies: new Set(),
+        unresolved: {},
         exports: {},
         types: {},
         nsExports: {},
@@ -30,6 +36,9 @@ async function run(configuration) {
     };
     const counters = {
         files: issues.files.size,
+        dependencies: issues.dependencies.size,
+        devDependencies: issues.dependencies.size,
+        unresolved: 0,
         exports: 0,
         types: 0,
         nsExports: 0,
@@ -44,48 +53,72 @@ async function run(configuration) {
         const total = unreferencedProductionFiles.length + usedNonEntryFiles.length;
         const percentage = Math.floor((counter / total) * 100);
         const messages = [(0, log_1.getLine)(`${percentage}%`, `of files processed (${counter} of ${total})`)];
-        include.files && messages.push((0, log_1.getLine)(unreferencedProductionFiles.length, 'unused files'));
-        include.exports && messages.push((0, log_1.getLine)(counters.exports, 'unused exports'));
-        include.nsExports && messages.push((0, log_1.getLine)(counters.nsExports, 'unused exports in namespace'));
-        include.types && messages.push((0, log_1.getLine)(counters.types, 'unused types'));
-        include.nsTypes && messages.push((0, log_1.getLine)(counters.nsTypes, 'unused types in namespace'));
-        include.duplicates && messages.push((0, log_1.getLine)(counters.duplicates, 'duplicate exports'));
+        report.files && messages.push((0, log_1.getLine)(unreferencedProductionFiles.length, 'unused files'));
+        report.unlisted && messages.push((0, log_1.getLine)(counters.unresolved, 'unlisted dependencies'));
+        report.exports && messages.push((0, log_1.getLine)(counters.exports, 'unused exports'));
+        report.nsExports && messages.push((0, log_1.getLine)(counters.nsExports, 'unused exports in namespace'));
+        report.types && messages.push((0, log_1.getLine)(counters.types, 'unused types'));
+        report.nsTypes && messages.push((0, log_1.getLine)(counters.nsTypes, 'unused types in namespace'));
+        report.duplicates && messages.push((0, log_1.getLine)(counters.duplicates, 'duplicate exports'));
         if (counter < total) {
             messages.push('');
-            messages.push(`Processing: ${node_path_1.default.relative(cwd, item.filePath)}`);
+            messages.push(`Processing: ${node_path_1.default.relative(workingDir, item.filePath)}`);
         }
         lineRewriter.update(messages);
     };
-    const addIssue = (issueType, issue) => {
+    const addSymbolIssue = (issueType, issue) => {
         const { filePath, symbol } = issue;
-        const key = node_path_1.default.relative(cwd, filePath);
+        const key = node_path_1.default.relative(workingDir, filePath);
         issues[issueType][key] = issues[issueType][key] ?? {};
         issues[issueType][key][symbol] = issue;
         counters[issueType]++;
         updateProcessingOutput(issue);
     };
-    if (include.exports || include.types || include.nsExports || include.nsTypes || include.duplicates) {
+    const addProjectIssue = (issueType, issue) => {
+        if (!issues[issueType].has(issue.symbol)) {
+            issues[issueType].add(issue.symbol);
+            counters[issueType]++;
+        }
+        updateProcessingOutput(issue);
+    };
+    if (report.dependencies || report.unlisted) {
+        usedEntryFiles.forEach(sourceFile => {
+            const unresolvedDependencies = getUnresolvedDependencies(sourceFile);
+            unresolvedDependencies.forEach(issue => addSymbolIssue('unresolved', issue));
+        });
+    }
+    if (report.dependencies ||
+        report.unlisted ||
+        report.exports ||
+        report.types ||
+        report.nsExports ||
+        report.nsTypes ||
+        report.duplicates) {
         usedNonEntryFiles.forEach(sourceFile => {
             const filePath = sourceFile.getFilePath();
+            if (report.dependencies || report.unlisted) {
+                const unresolvedDependencies = getUnresolvedDependencies(sourceFile);
+                unresolvedDependencies.forEach(issue => addSymbolIssue('unresolved', issue));
+            }
             const exportDeclarations = sourceFile.getExportedDeclarations();
-            if (include.duplicates) {
+            if (report.duplicates) {
                 const duplicateExports = (0, ts_morph_helpers_1.findDuplicateExportedNames)(sourceFile);
                 duplicateExports.forEach(symbols => {
                     const symbol = symbols.join('|');
-                    addIssue('duplicates', { filePath, symbol, symbols });
+                    addSymbolIssue('duplicates', { filePath, symbol, symbols });
                 });
             }
-            if (include.exports || include.types || include.nsExports || include.nsTypes) {
+            if (report.exports || report.types || report.nsExports || report.nsTypes) {
                 const uniqueExportedSymbols = new Set([...exportDeclarations.values()].flat());
                 if (uniqueExportedSymbols.size === 1)
                     return;
                 exportDeclarations.forEach(declarations => {
                     declarations.forEach(declaration => {
-                        const type = (0, util_1.getType)(declaration);
-                        if (!include.nsExports && !include.nsTypes) {
-                            if (!include.types && type)
+                        const type = (0, type_1.getType)(declaration);
+                        if (!report.nsExports && !report.nsTypes) {
+                            if (!report.types && type)
                                 return;
-                            if (!include.exports && !type)
+                            if (!report.exports && !type)
                                 return;
                         }
                         if (jsDocOptions.isReadPublicTag && ts_morph_1.ts.getJSDocPublicTag(declaration.compilerNode))
@@ -94,6 +127,8 @@ async function run(configuration) {
                         if (declaration.isKind(ts_morph_1.ts.SyntaxKind.Identifier)) {
                             identifier = declaration;
                         }
+                        else if (declaration.isKind(ts_morph_1.ts.SyntaxKind.ArrowFunction)) {
+                        }
                         else if (declaration.isKind(ts_morph_1.ts.SyntaxKind.FunctionDeclaration) ||
                             declaration.isKind(ts_morph_1.ts.SyntaxKind.ClassDeclaration) ||
                             declaration.isKind(ts_morph_1.ts.SyntaxKind.TypeAliasDeclaration) ||
@@ -109,36 +144,36 @@ async function run(configuration) {
                         }
                         if (identifier) {
                             const identifierText = identifier.getText();
-                            if (include.exports && issues.exports[filePath]?.[identifierText])
+                            if (report.exports && issues.exports[filePath]?.[identifierText])
                                 return;
-                            if (include.types && issues.types[filePath]?.[identifierText])
+                            if (report.types && issues.types[filePath]?.[identifierText])
                                 return;
-                            if (include.nsExports && issues.nsExports[filePath]?.[identifierText])
+                            if (report.nsExports && issues.nsExports[filePath]?.[identifierText])
                                 return;
-                            if (include.nsTypes && issues.nsTypes[filePath]?.[identifierText])
+                            if (report.nsTypes && issues.nsTypes[filePath]?.[identifierText])
                                 return;
                             const refs = identifier.findReferences();
                             if (refs.length === 0) {
-                                addIssue('exports', { filePath, symbol: identifierText });
+                                addSymbolIssue('exports', { filePath, symbol: identifierText });
                             }
                             else {
                                 const refFiles = new Set(refs.map(r => r.compilerObject.references.map(r => r.fileName)).flat());
-                                const isReferencedOnlyBySelf = refFiles.size === 1 && [...refFiles][0] === sourceFile.getFilePath();
+                                const isReferencedOnlyBySelf = refFiles.size === 1 && [...refFiles][0] === filePath;
                                 if (!isReferencedOnlyBySelf)
                                     return;
                                 if ((0, ts_morph_helpers_1.findReferencingNamespaceNodes)(sourceFile).length > 0) {
                                     if (type) {
-                                        addIssue('nsTypes', { filePath, symbol: identifierText, symbolType: type });
+                                        addSymbolIssue('nsTypes', { filePath, symbol: identifierText, symbolType: type });
                                     }
                                     else {
-                                        addIssue('nsExports', { filePath, symbol: identifierText });
+                                        addSymbolIssue('nsExports', { filePath, symbol: identifierText });
                                     }
                                 }
                                 else if (type) {
-                                    addIssue('types', { filePath, symbol: identifierText, symbolType: type });
+                                    addSymbolIssue('types', { filePath, symbol: identifierText, symbolType: type });
                                 }
                                 else {
-                                    addIssue('exports', { filePath, symbol: identifierText });
+                                    addSymbolIssue('exports', { filePath, symbol: identifierText });
                                 }
                             }
                         }
@@ -148,6 +183,14 @@ async function run(configuration) {
             counters.processed++;
         });
     }
+    if (report.dependencies) {
+        const unusedDependencies = getUnusedDependencies();
+        unusedDependencies.forEach(symbol => addProjectIssue('dependencies', { filePath: '', symbol }));
+        if (isDev) {
+            const unusedDevDependencies = getUnusedDevDependencies();
+            unusedDevDependencies.forEach(symbol => addProjectIssue('devDependencies', { filePath: '', symbol }));
+        }
+    }
     if (isShowProgress)
         lineRewriter.resetLines();
     return { issues, counters };

package/dist/reporters/compact.d.ts

@@ -1,7 +1,7 @@
 import type { Issues, Configuration } from '../types';
-declare const _default: ({ issues, config, cwd }: {
+declare const _default: ({ issues, config, workingDir }: {
     issues: Issues;
     config: Configuration;
-    cwd: string;
+    workingDir: string;
 }) => void;
 export default _default;

package/dist/reporters/compact.js

@@ -4,67 +4,82 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const node_path_1 = __importDefault(require("node:path"));
-const logIssueLine = (cwd, filePath, symbols) => {
-    console.log(`${node_path_1.default.relative(cwd, filePath)}${symbols ? `: ${symbols.join(', ')}` : ''}`);
+const logIssueLine = (workingDir, filePath, symbols) => {
+    console.log(`${node_path_1.default.relative(workingDir, filePath)}${symbols ? `: ${symbols.join(', ')}` : ''}`);
 };
-const logIssueGroupResult = (issues, cwd, title) => {
+const logIssueGroupResult = (issues, workingDir, title) => {
     title && console.log(`--- ${title} (${issues.length})`);
     if (issues.length) {
-        issues.sort().forEach(filePath => logIssueLine(cwd, filePath));
+        issues.sort().forEach(value => console.log(value.startsWith('/') ? node_path_1.default.relative(workingDir, value) : value));
     }
     else {
-        console.log('N/A');
+        console.log('Not found');
     }
 };
-const logIssueGroupResults = (issues, cwd, title) => {
+const logIssueGroupResults = (issues, workingDir, title) => {
     title && console.log(`--- ${title} (${issues.length})`);
     if (issues.length) {
         const sortedByFilePath = issues.sort((a, b) => (a.filePath > b.filePath ? 1 : -1));
-        sortedByFilePath.forEach(({ filePath, symbols }) => logIssueLine(cwd, filePath, symbols));
+        sortedByFilePath.forEach(({ filePath, symbols }) => logIssueLine(workingDir, filePath, symbols));
     }
     else {
-        console.log('N/A');
+        console.log('Not found');
     }
 };
-exports.default = ({ issues, config, cwd }) => {
-    const { include } = config;
-    const reportMultipleGroups = Object.values(include).filter(Boolean).length > 1;
-    if (include.files) {
+exports.default = ({ issues, config, workingDir }) => {
+    const { report, isDev } = config;
+    const reportMultipleGroups = Object.values(report).filter(Boolean).length > 1;
+    if (report.files) {
         const unreferencedFiles = Array.from(issues.files);
-        logIssueGroupResult(unreferencedFiles, cwd, reportMultipleGroups && 'UNREFERENCED FILES');
+        logIssueGroupResult(unreferencedFiles, workingDir, reportMultipleGroups && 'UNUSED FILES');
     }
-    if (include.exports) {
+    if (report.dependencies) {
+        const unreferencedDependencies = Array.from(issues.dependencies);
+        logIssueGroupResult(unreferencedDependencies, workingDir, reportMultipleGroups && 'UNUSED DEPENDENCIES');
+    }
+    if (report.dependencies && isDev) {
+        const unreferencedDevDependencies = Array.from(issues.devDependencies);
+        logIssueGroupResult(unreferencedDevDependencies, workingDir, 'UNUSED DEV DEPENDENCIES');
+    }
+    if (report.unlisted) {
+        const unreferencedDependencies = Object.values(issues.unresolved).map(issues => {
+            const items = Object.values(issues);
+            return { ...items[0], symbols: items.map(i => i.symbol) };
+        });
+        logIssueGroupResults(unreferencedDependencies, workingDir, reportMultipleGroups && 'UNLISTED DEPENDENCIES');
+    }
+    if (report.exports) {
         const unreferencedExports = Object.values(issues.exports).map(issues => {
             const items = Object.values(issues);
             return { ...items[0], symbols: items.map(i => i.symbol) };
         });
-        logIssueGroupResults(unreferencedExports, cwd, reportMultipleGroups && 'UNREFERENCED EXPORTS');
+        logIssueGroupResults(unreferencedExports, workingDir, reportMultipleGroups && 'UNUSED EXPORTS');
     }
-    if (include.nsExports) {
+    if (report.nsExports) {
         const unreferencedNsExports = Object.values(issues.nsExports).map(issues => {
             const items = Object.values(issues);
             return { ...items[0], symbols: items.map(i => i.symbol) };
         });
-        logIssueGroupResults(unreferencedNsExports, cwd, reportMultipleGroups && 'UNREFERENCED EXPORTS IN NAMESPACE');
+        logIssueGroupResults(unreferencedNsExports, workingDir, reportMultipleGroups && 'UNUSED EXPORTS IN NAMESPACE');
     }
-    if (include.types) {
+    if (report.types) {
         const unreferencedTypes = Object.values(issues.types).map(issues => {
             const items = Object.values(issues);
             return { ...items[0], symbols: items.map(i => i.symbol) };
         });
-        logIssueGroupResults(unreferencedTypes, cwd, reportMultipleGroups && 'UNREFERENCED TYPES');
+        logIssueGroupResults(unreferencedTypes, workingDir, reportMultipleGroups && 'UNUSED TYPES');
     }
-    if (include.nsTypes) {
+    if (report.nsTypes) {
         const unreferencedNsTypes = Object.values(issues.nsTypes).map(issues => {
             const items = Object.values(issues);
             return { ...items[0], symbols: items.map(i => i.symbol) };
         });
-        logIssueGroupResults(unreferencedNsTypes, cwd, reportMultipleGroups && 'UNREFERENCED TYPES IN NAMESPACE');
+        logIssueGroupResults(unreferencedNsTypes, workingDir, reportMultipleGroups && 'UNUSED TYPES IN NAMESPACE');
     }
-    if (include.duplicates) {
+    if (report.duplicates) {
         const unreferencedDuplicates = Object.values(issues.duplicates)
             .map(issues => Object.values(issues))
             .flat();
-        logIssueGroupResults(unreferencedDuplicates, cwd, reportMultipleGroups && 'DUPLICATE EXPORTS');
+        logIssueGroupResults(unreferencedDuplicates, workingDir, reportMultipleGroups && 'DUPLICATE EXPORTS');
     }
 };

package/dist/reporters/index.d.ts

@@ -1,13 +1,13 @@
 declare const _default: {
-    symbols: ({ issues, config, cwd }: {
+    symbols: ({ issues, config, workingDir }: {
         issues: import("../types").Issues;
         config: import("../types").Configuration;
-        cwd: string;
+        workingDir: string;
     }) => void;
-    compact: ({ issues, config, cwd }: {
+    compact: ({ issues, config, workingDir }: {
         issues: import("../types").Issues;
         config: import("../types").Configuration;
-        cwd: string;
+        workingDir: string;
     }) => void;
 };
 export default _default;

package/dist/reporters/symbols.d.ts

@@ -1,7 +1,7 @@
 import type { Issues, Configuration } from '../types';
-declare const _default: ({ issues, config, cwd }: {
+declare const _default: ({ issues, config, workingDir }: {
     issues: Issues;
     config: Configuration;
-    cwd: string;
+    workingDir: string;
 }) => void;
 export default _default;

package/dist/reporters/symbols.js

@@ -4,55 +4,67 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const node_path_1 = __importDefault(require("node:path"));
-const logIssueLine = ({ issue, cwd, padding }) => {
+const logIssueLine = ({ issue, workingDir, padding }) => {
     const symbols = issue.symbols ? issue.symbols.join(', ') : issue.symbol;
-    console.log(`${symbols.padEnd(padding + 2)}${issue.symbolType?.padEnd(11) || ''}${node_path_1.default.relative(cwd, issue.filePath)}`);
+    console.log(`${symbols.padEnd(padding + 2)}${issue.symbolType?.padEnd(11) || ''}${node_path_1.default.relative(workingDir, issue.filePath)}`);
 };
-const logIssueGroupResult = (issues, cwd, title) => {
+const logIssueGroupResult = (issues, workingDir, title) => {
     title && console.log(`--- ${title} (${issues.length})`);
     if (issues.length) {
-        issues.sort().forEach(filePath => console.log(node_path_1.default.relative(cwd, filePath)));
+        issues.sort().forEach(value => console.log(value.startsWith('/') ? node_path_1.default.relative(workingDir, value) : value));
     }
     else {
-        console.log('N/A');
+        console.log('Not found');
     }
 };
-const logIssueGroupResults = (issues, cwd, title) => {
+const logIssueGroupResults = (issues, workingDir, title) => {
     title && console.log(`--- ${title} (${issues.length})`);
     if (issues.length) {
         const sortedByFilePath = issues.sort((a, b) => (a.filePath > b.filePath ? 1 : -1));
         const padding = [...issues].sort((a, b) => b.symbol.length - a.symbol.length)[0].symbol.length;
-        sortedByFilePath.forEach(issue => logIssueLine({ issue, cwd, padding }));
+        sortedByFilePath.forEach(issue => logIssueLine({ issue, workingDir, padding }));
     }
     else {
-        console.log('N/A');
+        console.log('Not found');
     }
 };
-exports.default = ({ issues, config, cwd }) => {
-    const { include } = config;
-    const reportMultipleGroups = Object.values(include).filter(Boolean).length > 1;
-    if (include.files) {
+exports.default = ({ issues, config, workingDir }) => {
+    const { report, isDev } = config;
+    const reportMultipleGroups = Object.values(report).filter(Boolean).length > 1;
+    if (report.files) {
         const unreferencedFiles = Array.from(issues.files);
-        logIssueGroupResult(unreferencedFiles, cwd, reportMultipleGroups && 'UNUSED FILES');
+        logIssueGroupResult(unreferencedFiles, workingDir, reportMultipleGroups && 'UNUSED FILES');
     }
-    if (include.exports) {
+    if (report.dependencies) {
+        const unreferencedDependencies = Array.from(issues.dependencies);
+        logIssueGroupResult(unreferencedDependencies, workingDir, reportMultipleGroups && 'UNUSED DEPENDENCIES');
+    }
+    if (report.dependencies && isDev) {
+        const unreferencedDevDependencies = Array.from(issues.devDependencies);
+        logIssueGroupResult(unreferencedDevDependencies, workingDir, 'UNUSED DEV DEPENDENCIES');
+    }
+    if (report.unlisted) {
+        const unresolvedDependencies = Object.values(issues.unresolved).map(Object.values).flat();
+        logIssueGroupResults(unresolvedDependencies, workingDir, reportMultipleGroups && 'UNLISTED DEPENDENCIES');
+    }
+    if (report.exports) {
         const unreferencedExports = Object.values(issues.exports).map(Object.values).flat();
-        logIssueGroupResults(unreferencedExports, cwd, reportMultipleGroups && 'UNUSED EXPORTS');
+        logIssueGroupResults(unreferencedExports, workingDir, reportMultipleGroups && 'UNUSED EXPORTS');
     }
-    if (include.nsExports) {
+    if (report.nsExports) {
         const unreferencedNsExports = Object.values(issues.nsExports).map(Object.values).flat();
-        logIssueGroupResults(unreferencedNsExports, cwd, reportMultipleGroups && 'UNUSED EXPORTS IN NAMESPACE');
+        logIssueGroupResults(unreferencedNsExports, workingDir, reportMultipleGroups && 'UNUSED EXPORTS IN NAMESPACE');
     }
-    if (include.types) {
+    if (report.types) {
         const unreferencedTypes = Object.values(issues.types).map(Object.values).flat();
-        logIssueGroupResults(unreferencedTypes, cwd, reportMultipleGroups && 'UNUSED TYPES');
+        logIssueGroupResults(unreferencedTypes, workingDir, reportMultipleGroups && 'UNUSED TYPES');
     }
-    if (include.nsTypes) {
+    if (report.nsTypes) {
         const unreferencedNsTypes = Object.values(issues.nsTypes).map(Object.values).flat();
-        logIssueGroupResults(unreferencedNsTypes, cwd, reportMultipleGroups && 'UNUSED TYPES IN NAMESPACE');
+        logIssueGroupResults(unreferencedNsTypes, workingDir, reportMultipleGroups && 'UNUSED TYPES IN NAMESPACE');
     }
-    if (include.duplicates) {
+    if (report.duplicates) {
         const unreferencedDuplicates = Object.values(issues.duplicates).map(Object.values).flat();
-        logIssueGroupResults(unreferencedDuplicates, cwd, reportMultipleGroups && 'DUPLICATE EXPORTS');
+        logIssueGroupResults(unreferencedDuplicates, workingDir, reportMultipleGroups && 'DUPLICATE EXPORTS');
     }
 };

package/dist/types.d.ts

@@ -1,15 +1,19 @@
-declare type FilePath = string;
 declare type SymbolType = 'type' | 'interface' | 'enum';
-declare type UnusedFileIssues = Set<FilePath>;
+declare type UnusedFileIssues = Set<string>;
 declare type UnusedExportIssues = Record<string, Record<string, Issue>>;
+declare type UnresolvedDependencyIssues = Record<string, Record<string, Issue>>;
+declare type UnusedDependencyIssues = Set<string>;
 export declare type Issue = {
-    filePath: FilePath;
+    filePath: string;
     symbol: string;
     symbols?: string[];
     symbolType?: SymbolType;
 };
 export declare type Issues = {
     files: UnusedFileIssues;
+    dependencies: UnusedDependencyIssues;
+    devDependencies: UnusedDependencyIssues;
+    unresolved: UnresolvedDependencyIssues;
     exports: UnusedExportIssues;
     types: UnusedExportIssues;
     nsExports: UnusedExportIssues;
@@ -17,19 +21,34 @@ export declare type Issues = {
     duplicates: UnusedExportIssues;
 };
 export declare type IssueType = keyof Issues;
-declare type LocalConfiguration = {
+export declare type ProjectIssueType = Extract<IssueType, 'files' | 'dependencies' | 'devDependencies'>;
+export declare type SymbolIssueType = Exclude<IssueType, ProjectIssueType>;
+export declare type IssueGroup = 'files' | 'dependencies' | 'unlisted' | 'exports' | 'nsExports' | 'types' | 'nsTypes' | 'duplicates';
+export declare type BaseLocalConfiguration = {
     entryFiles: string[];
     projectFiles: string[];
 };
+export declare type LocalConfiguration = BaseLocalConfiguration & {
+    dev?: boolean | BaseLocalConfiguration;
+    entryFiles: string[];
+    projectFiles: string[];
+    include?: string[];
+    exclude?: string[];
+};
+export declare type ImportedConfiguration = LocalConfiguration | Record<string, LocalConfiguration>;
 export declare type Configuration = LocalConfiguration & {
-    cwd: string;
-    include: {
-        [key in IssueType]: boolean;
+    workingDir: string;
+    report: {
+        [key in IssueGroup]: boolean;
     };
+    dependencies: string[];
+    devDependencies: string[];
+    isDev: boolean;
+    tsConfigFilePath: undefined | string;
+    tsConfigPaths: string[];
     isShowProgress: boolean;
     jsDocOptions: {
         isReadPublicTag: boolean;
     };
 };
-export declare type ImportedConfiguration = LocalConfiguration | Record<string, LocalConfiguration>;
 export {};

package/dist/util/config.d.ts

@@ -1,14 +1,15 @@
-import type { ImportedConfiguration } from '../types';
-export declare const importConfig: (cwd: string, configArg: string) => any;
-export declare const resolveConfig: (importedConfiguration: ImportedConfiguration, cwdArg?: string) => {
-    entryFiles: string[];
-    projectFiles: string[];
-} | undefined;
-export declare const resolveIncludedFromArgs: (onlyArg: string[], excludeArg: string[]) => {
+import type { ImportedConfiguration, LocalConfiguration } from '../types';
+export declare const resolveConfig: (importedConfiguration: ImportedConfiguration, options?: {
+    workingDir?: string;
+    isDev?: boolean;
+}) => LocalConfiguration | undefined;
+export declare const resolveIncludedIssueGroups: (includeArg: string[], excludeArg: string[], resolvedConfig?: LocalConfiguration) => {
     files: boolean;
+    dependencies: boolean;
     exports: boolean;
     types: boolean;
     nsExports: boolean;
     nsTypes: boolean;
     duplicates: boolean;
+    unlisted: boolean;
 };

package/dist/util/config.js

@@ -3,47 +3,49 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveIncludedFromArgs = exports.resolveConfig = exports.importConfig = void 0;
-const node_path_1 = __importDefault(require("node:path"));
+exports.resolveIncludedIssueGroups = exports.resolveConfig = void 0;
 const micromatch_1 = __importDefault(require("micromatch"));
-const importConfig = (cwd, configArg) => {
-    try {
-        const manifest = require(node_path_1.default.join(cwd, 'package.json'));
-        if ('knip' in manifest)
-            return manifest.knip;
-        else
-            throw new Error('Unable to find `knip` key in package.json');
-    }
-    catch (error) {
-        try {
-            return require(node_path_1.default.resolve(configArg));
-        }
-        catch (error) {
-            console.error(`Unable to find configuration at ${node_path_1.default.join(cwd, configArg)}\n`);
-        }
-    }
-};
-exports.importConfig = importConfig;
-const resolveConfig = (importedConfiguration, cwdArg) => {
-    if (cwdArg && !('projectFiles' in importedConfiguration)) {
-        const importedConfigKey = Object.keys(importedConfiguration).find(pattern => micromatch_1.default.isMatch(cwdArg, pattern));
+const resolveConfig = (importedConfiguration, options) => {
+    let resolvedConfig = importedConfiguration;
+    const { workingDir, isDev } = options ?? {};
+    const configKeys = Object.keys(importedConfiguration);
+    if (workingDir && !('projectFiles' in importedConfiguration)) {
+        const importedConfigKey = configKeys.find(pattern => micromatch_1.default.isMatch(workingDir.replace(/\/$/, ''), pattern));
         if (importedConfigKey) {
-            return importedConfiguration[importedConfigKey];
+            resolvedConfig = importedConfiguration[importedConfigKey];
         }
     }
-    if (!cwdArg && (!importedConfiguration.entryFiles || !importedConfiguration.projectFiles)) {
+    if (isDev && typeof resolvedConfig.dev === 'object' && 'projectFiles' in resolvedConfig.dev) {
+        resolvedConfig = resolvedConfig.dev;
+    }
+    if (!resolvedConfig.entryFiles || !resolvedConfig.projectFiles) {
         console.error('Unable to find `entryFiles` and/or `projectFiles` in configuration.');
-        console.info('Add it at root level, or use the --cwd argument with a matching configuration.\n');
+        console.info(`Add these properties at root level, or use --cwd and match one of: ${configKeys.join(', ')}\n`);
         return;
     }
-    return importedConfiguration;
+    return resolvedConfig;
 };
 exports.resolveConfig = resolveConfig;
-const resolveIncludedFromArgs = (onlyArg, excludeArg) => {
-    const groups = ['files', 'exports', 'types', 'nsExports', 'nsTypes', 'duplicates'];
-    const only = onlyArg.map(value => value.split(',')).flat();
-    const exclude = excludeArg.map(value => value.split(',')).flat();
-    const includes = (only.length > 0 ? only : groups).filter((group) => !exclude.includes(group));
+const resolveIncludedIssueGroups = (includeArg, excludeArg, resolvedConfig) => {
+    const groups = [
+        'files',
+        'dependencies',
+        'unlisted',
+        'exports',
+        'types',
+        'nsExports',
+        'nsTypes',
+        'duplicates',
+    ];
+    const include = [includeArg, resolvedConfig?.include ?? []]
+        .flat()
+        .map(value => value.split(','))
+        .flat();
+    const exclude = [excludeArg, resolvedConfig?.exclude ?? []]
+        .flat()
+        .map(value => value.split(','))
+        .flat();
+    const includes = (include.length > 0 ? include : groups).filter((group) => !exclude.includes(group));
     return groups.reduce((r, group) => ((r[group] = includes.includes(group)), r), {});
 };
-exports.resolveIncludedFromArgs = resolveIncludedFromArgs;
+exports.resolveIncludedIssueGroups = resolveIncludedIssueGroups;

package/dist/util/dependencies.d.ts

@@ -0,0 +1,7 @@
+import type { SourceFile } from 'ts-morph';
+import type { Configuration, Issue } from '../types';
+export declare const getDependencyAnalyzer: (configuration: Configuration) => {
+    getUnresolvedDependencies: (sourceFile: SourceFile) => Set<Issue>;
+    getUnusedDependencies: () => string[];
+    getUnusedDevDependencies: () => string[];
+};

package/dist/util/dependencies.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDependencyAnalyzer = void 0;
+const ts_morph_1 = require("ts-morph");
+const is_builtin_module_1 = __importDefault(require("is-builtin-module"));
+const micromatch_1 = __importDefault(require("micromatch"));
+const compact = (collection) => Array.from(new Set(collection)).filter((value) => Boolean(value));
+const getDependencyAnalyzer = (configuration) => {
+    const { dependencies, devDependencies, tsConfigPaths } = configuration;
+    const referencedDependencies = new Set();
+    const getUnresolvedDependencies = (sourceFile) => {
+        const unresolvedDependencies = new Set();
+        const importLiterals = sourceFile.getImportStringLiterals();
+        const requires = sourceFile
+            .getDescendantsOfKind(ts_morph_1.ts.SyntaxKind.CallExpression)
+            .filter(callExpression => callExpression.getExpression().getText() === 'require')
+            .map(expression => expression.getFirstDescendantByKind(ts_morph_1.ts.SyntaxKind.StringLiteral));
+        const literals = compact([importLiterals, requires].flat());
+        literals.forEach(importLiteral => {
+            const moduleSpecifier = importLiteral.getLiteralText();
+            if (moduleSpecifier.startsWith('.'))
+                return;
+            if ((0, is_builtin_module_1.default)(moduleSpecifier))
+                return;
+            if (tsConfigPaths.length > 0 && micromatch_1.default.isMatch(moduleSpecifier, tsConfigPaths))
+                return;
+            const parts = moduleSpecifier.split('/').slice(0, 2);
+            const packageName = moduleSpecifier.startsWith('@') ? parts.join('/') : parts[0];
+            if (!dependencies.includes(packageName) && !devDependencies.includes(packageName)) {
+                unresolvedDependencies.add({ filePath: sourceFile.getFilePath(), symbol: moduleSpecifier });
+            }
+            if (dependencies.includes(packageName) || devDependencies.includes(packageName)) {
+                referencedDependencies.add(packageName);
+            }
+        });
+        return unresolvedDependencies;
+    };
+    const getUnusedDependencies = () => dependencies.filter(dependency => !referencedDependencies.has(dependency));
+    const getUnusedDevDependencies = () => devDependencies.filter(dependency => !referencedDependencies.has(dependency));
+    return { getUnresolvedDependencies, getUnusedDependencies, getUnusedDevDependencies };
+};
+exports.getDependencyAnalyzer = getDependencyAnalyzer;

package/dist/util/path.d.ts

@@ -0,0 +1 @@
+export declare const findFile: (cwd: string, fileName: string) => Promise<string | undefined>;

package/dist/util/path.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findFile = void 0;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const isFile = async (filePath) => {
+    try {
+        const stats = await promises_1.default.stat(filePath);
+        return stats.isFile();
+    }
+    catch {
+        return false;
+    }
+};
+const findFile = async (cwd, fileName) => {
+    const filePath = node_path_1.default.join(cwd, fileName);
+    if (await isFile(filePath)) {
+        return filePath;
+    }
+    else {
+        const parentDir = node_path_1.default.resolve(cwd, '..');
+        return parentDir === '/' ? undefined : (0, exports.findFile)(parentDir, fileName);
+    }
+};
+exports.findFile = findFile;

package/dist/util/project.d.ts

@@ -0,0 +1,5 @@
+import { Project } from 'ts-morph';
+import type { SourceFile } from 'ts-morph';
+import type { Configuration } from '../types';
+export declare const createProject: (configuration: Configuration, paths?: string | string[]) => Promise<Project>;
+export declare const partitionSourceFiles: (projectFiles: SourceFile[], productionFiles: SourceFile[]) => SourceFile[][];

package/dist/{util.js → util/project.js}

@@ -3,25 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getType = exports.partitionSourceFiles = exports.createProject = void 0;
-const promises_1 = __importDefault(require("node:fs/promises"));
+exports.partitionSourceFiles = exports.createProject = void 0;
 const node_path_1 = __importDefault(require("node:path"));
 const ts_morph_1 = require("ts-morph");
-const isFile = async (filePath) => {
-    try {
-        const stats = await promises_1.default.stat(filePath);
-        return stats.isFile();
-    }
-    catch {
-        return false;
-    }
-};
-const findFile = async (cwd, fileName) => {
-    const filePath = node_path_1.default.join(cwd, fileName);
-    if (await isFile(filePath))
-        return filePath;
-    return findFile(node_path_1.default.resolve(cwd, '..'), fileName);
-};
 const resolvePaths = (cwd, patterns) => {
     return [patterns].flat().map(pattern => {
         if (pattern.startsWith('!'))
@@ -29,15 +13,16 @@ const resolvePaths = (cwd, patterns) => {
         return node_path_1.default.join(cwd, pattern);
     });
 };
-const createProject = async (cwd, paths) => {
-    const tsConfigFilePath = await findFile(cwd, 'tsconfig.json');
+const createProject = async (configuration, paths) => {
+    const { tsConfigFilePath, workingDir } = configuration;
+    const tsConfig = tsConfigFilePath ? { tsConfigFilePath } : { compilerOptions: { allowJs: true } };
     const workspace = new ts_morph_1.Project({
-        tsConfigFilePath,
+        ...tsConfig,
         skipAddingFilesFromTsConfig: true,
         skipFileDependencyResolution: true,
     });
     if (paths)
-        workspace.addSourceFilesAtPaths(resolvePaths(cwd, paths));
+        workspace.addSourceFilesAtPaths(resolvePaths(workingDir, paths));
     return workspace;
 };
 exports.createProject = createProject;
@@ -56,12 +41,3 @@ const partitionSourceFiles = (projectFiles, productionFiles) => {
     return [usedFiles, unusedFiles];
 };
 exports.partitionSourceFiles = partitionSourceFiles;
-const getType = (declaration) => {
-    if (declaration.isKind(ts_morph_1.ts.SyntaxKind.TypeAliasDeclaration))
-        return 'type';
-    if (declaration.isKind(ts_morph_1.ts.SyntaxKind.InterfaceDeclaration))
-        return 'interface';
-    if (declaration.isKind(ts_morph_1.ts.SyntaxKind.EnumDeclaration))
-        return 'enum';
-};
-exports.getType = getType;

package/dist/util/type.d.ts

@@ -0,0 +1,2 @@
+import type { ExportedDeclarations } from 'ts-morph';
+export declare const getType: (declaration: ExportedDeclarations) => "type" | "interface" | "enum" | undefined;

package/dist/util/type.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getType = void 0;
+const ts_morph_1 = require("ts-morph");
+const getType = (declaration) => {
+    if (declaration.isKind(ts_morph_1.ts.SyntaxKind.TypeAliasDeclaration))
+        return 'type';
+    if (declaration.isKind(ts_morph_1.ts.SyntaxKind.InterfaceDeclaration))
+        return 'interface';
+    if (declaration.isKind(ts_morph_1.ts.SyntaxKind.EnumDeclaration))
+        return 'enum';
+};
+exports.getType = getType;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "0.1.2",
+  "version": "0.3.0",
   "description": "Find unused files and exports in your TypeScript project",
   "keywords": [
     "find",
@@ -38,6 +38,7 @@
   },
   "license": "ISC",
   "dependencies": {
+    "is-builtin-module": "3.2.0",
     "micromatch": "4.0.5",
     "ts-morph": "16.0.0",
     "ts-morph-helpers": "0.5.0"

package/dist/util.d.ts

@@ -1,5 +0,0 @@
-import { Project } from 'ts-morph';
-import type { SourceFile, ExportedDeclarations } from 'ts-morph';
-export declare const createProject: (cwd: string, paths?: string | string[]) => Promise<Project>;
-export declare const partitionSourceFiles: (projectFiles: SourceFile[], productionFiles: SourceFile[]) => SourceFile[][];
-export declare const getType: (declaration: ExportedDeclarations) => "type" | "interface" | "enum" | undefined;