knip 0.1.2

package/README.md

@@ -0,0 +1,260 @@
+# ✂️ 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:
+
+```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.
+
+This is where Knip comes in:
+
+- [x] Resolves all (unused) files in your project and reports **unused files and exports**.
+- [x] Verifies that exported symbols are actually used in other files, even when part of an imported namespace.
+- [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
+
+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
+either detect only unimported files, or only unused exports. Most of them don't work by configuring entry files, an
+essential feature to produce good results. This also allows to unleash knip on a specific part of your project, and work
+these separately.
+
+✂️ Knip is another fresh take on keeping your projects clean & tidy!
+
+## Installation
+
+```
+npm install -D knip
+```
+
+## Usage
+
+Create a configuration file, let's give it the default name `knip.json` with these contents:
+
+```json
+{
+  "entryFiles": ["src/index.ts"],
+  "projectFiles": ["src/**/*.ts", "!**/*.spec.ts"]
+}
+```
+
+The `entryFiles` target the starting point(s) to resolve production code dependencies. The `projectFiles` should contain
+all files it should match them against, including potentially unused files.
+
+Then run the checks:
+
+```
+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.
+
+## How It Works
+
+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).
+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`).
+
+## Options
+
+```
+❯ npx knip
+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
+  --no-progress        Don't show dynamic progress updates
+  --reporter           Select reporter: symbols, compact (default: symbols)
+  --jsdoc              Enable JSDoc parsing, with options: public (default: disabled)
+
+Examples:
+
+$ knip
+$ knip --cwd packages/client --only files
+$ knip -c ./knip.js --reporter compact --jsdoc public
+
+More info: https://github.com/webpro/knip
+```
+
+## 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**)
+
+Each group type (in **bold**) can be used in the `--only` and `--exclude` arguments to slice & dice the report to your
+needs.
+
+🚀 The process is considerably faster when reporting only the `files` and/or `duplicates` groups.
+
+## Now what?
+
+After verifying that files reported as unused are indeed not referenced anywhere, they can be deleted.
+
+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.
+
+🔁 Repeat the process to reveal new unused files and exports. Sometimes it's so liberating to delete things.
+
+## More configuration examples
+
+### Test 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!).
+
+The same goes for any type of non-production files, such as Storybook stories or end-to-end tests.
+
+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`:
+
+```json
+{
+  "entryFiles": ["src/index.ts", "src/**/*.spec.ts"],
+  "projectFiles": ["src/**/*.ts", "!**/*.e2e.ts"]
+}
+```
+
+In theory this idea could be extended to report some kind of test coverage.
+
+### 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:
+
+```json
+{
+  "packages/*": {
+    "entryFiles": ["src/index.ts"],
+    "projectFiles": ["src/**/*.{ts,tsx}", "!**/*.spec.{ts,tsx}"]
+  }
+}
+```
+
+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
+```
+
+#### 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:
+
+```js
+const entryFiles = ['apps/**/pages/**/*.{js,ts,tsx}'];
+
+const projectFiles = [
+  '{apps,libs}/**/*.{ts,tsx}',
+  // Next.js
+  '!**/next.config.js',
+  '!**/apps/**/public/**',
+  '!**/apps/**/next-env.d.ts'
+  // Jest
+  '!**/jest.config.ts',
+  '!**/*.spec.{ts,tsx}',
+  // Storybook
+  '!**/.storybook/**',
+  '!**/*.stories.tsx',
+];
+
+module.exports = { entryFiles, projectFiles };
+```
+
+This should give good results about unused files and exports for the monorepo. After the first run, the configuration
+can be tweaked further to the project structure.
+
+## Example Output
+
+### Default reporter
+
+```
+$ knip --config ./knip.json
+--- UNUSED FILES (2)
+src/chat/helpers.ts
+src/components/SideBar.tsx
+--- UNUSED EXPORTS (5)
+lowercaseFirstLetter  src/common/src/string/index.ts
+RegistrationBox       src/components/Registration.tsx
+clamp                 src/css.ts
+restoreSession        src/services/authentication.ts
+PREFIX                src/services/authentication.ts
+--- UNUSED TYPES (4)
+enum RegistrationServices  src/components/Registration/registrationMachine.ts
+type RegistrationAction    src/components/Registration/registrationMachine.ts
+type ComponentProps        src/components/Registration.tsx
+interface ProductDetail    src/types/Product.ts
+--- DUPLICATE EXPORTS (2)
+Registration, default  src/components/Registration.tsx
+ProductsList, default  src/components/Products.tsx
+```
+
+### Compact
+
+```
+$ knip --config ./knip.json --reporter compact
+--- UNUSED FILES (2)
+src/chat/helpers.ts
+src/components/SideBar.tsx
+--- UNUSED EXPORTS (4)
+src/common/src/string/index.ts: lowercaseFirstLetter
+src/components/Registration.tsx: RegistrationBox
+src/css.ts: clamp
+src/services/authentication.ts: restoreSession, PREFIX
+--- UNUSED TYPES (3)
+src/components/Registration/registrationMachine.ts: RegistrationServices, RegistrationAction
+src/components/Registration.tsx: ComponentProps
+src/types/Product.ts: ProductDetail
+--- DUPLICATE EXPORTS (2)
+src/components/Registration.tsx: Registration, default
+src/components/Products.tsx: ProductsList, default
+```
+
+## Why Yet Another unused file/export finder?
+
+There are some fine modules available in the same category:
+
+- [unimported](https://github.com/smeijer/unimported)
+- [ts-unused-exports](https://github.com/pzavolinsky/ts-unused-exports)
+- [no-unused-export](https://github.com/plantain-00/no-unused-export)
+- [ts-prune](https://github.com/nadeesha/ts-prune)
+- [find-unused-exports](https://github.com/jaydenseric/find-unused-exports)
+
+However, the results where not always accurate, and none of them tick my boxes to find both unused files and exports. Or
+let me configure entry files and scope the project files for clean results. Especially for larger projects this kind of
+configuration is necessary. That's why I took another stab at it.

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_path_1 = __importDefault(require("node:path"));
+const node_util_1 = require("node:util");
+const help_1 = require("./help");
+const config_1 = require("./util/config");
+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)({
+    options: {
+        help: { type: 'boolean' },
+        cwd: { type: 'string' },
+        config: { type: 'string', short: 'c' },
+        only: { type: 'string', multiple: true },
+        exclude: { type: 'string', multiple: true },
+        '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 main = async () => {
+    const resolvedConfig = (0, config_1.resolveConfig)(configuration, cwdArg);
+    if (!resolvedConfig) {
+        (0, help_1.printHelp)();
+        process.exit(1);
+    }
+    const config = Object.assign({}, resolvedConfig, {
+        cwd,
+        include: (0, config_1.resolveIncludedFromArgs)(only, exclude),
+        isShowProgress,
+        jsDocOptions: {
+            isReadPublicTag: jsdoc.includes('public'),
+        },
+    });
+    const { issues, counters } = await (0, _1.run)(config);
+    report({ issues, cwd, config });
+    if (counters.files > Number(maxIssues))
+        process.exit(counters.files);
+};
+main();

package/dist/help.d.ts

@@ -0,0 +1 @@
+export declare const printHelp: () => void;

package/dist/help.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printHelp = void 0;
+const printHelp = () => {
+    console.log(`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
+  --no-progress        Don't show dynamic progress updates
+  --reporter           Select reporter: symbols, compact (default: symbols)
+  --jsdoc              Enable JSDoc parsing, with options: public (default: disabled)
+
+Examples:
+
+$ knip
+$ knip --cwd packages/client --only files
+$ knip -c ./knip.js --reporter compact --jsdoc public
+
+More info: https://github.com/webpro/knip`);
+};
+exports.printHelp = printHelp;

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+import type { Configuration, Issues } from './types';
+export declare function run(configuration: Configuration): Promise<{
+    issues: Issues;
+    counters: {
+        files: number;
+        exports: number;
+        types: number;
+        nsExports: number;
+        nsTypes: number;
+        duplicates: number;
+        processed: number;
+    };
+}>;

package/dist/index.js

@@ -0,0 +1,155 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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 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 entryFiles = production.getSourceFiles();
+    production.resolveSourceFileDependencies();
+    const productionFiles = production.getSourceFiles();
+    const project = await (0, util_1.createProject)(cwd, configuration.projectFiles);
+    const projectFiles = project.getSourceFiles();
+    const [usedProductionFiles, unreferencedProductionFiles] = (0, util_1.partitionSourceFiles)(projectFiles, productionFiles);
+    const [, usedNonEntryFiles] = (0, util_1.partitionSourceFiles)(usedProductionFiles, entryFiles);
+    const issues = {
+        files: new Set(unreferencedProductionFiles.map(file => file.getFilePath())),
+        exports: {},
+        types: {},
+        nsExports: {},
+        nsTypes: {},
+        duplicates: {},
+    };
+    const counters = {
+        files: issues.files.size,
+        exports: 0,
+        types: 0,
+        nsExports: 0,
+        nsTypes: 0,
+        duplicates: 0,
+        processed: issues.files.size,
+    };
+    const updateProcessingOutput = (item) => {
+        if (!isShowProgress)
+            return;
+        const counter = unreferencedProductionFiles.length + counters.processed;
+        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'));
+        if (counter < total) {
+            messages.push('');
+            messages.push(`Processing: ${node_path_1.default.relative(cwd, item.filePath)}`);
+        }
+        lineRewriter.update(messages);
+    };
+    const addIssue = (issueType, issue) => {
+        const { filePath, symbol } = issue;
+        const key = node_path_1.default.relative(cwd, 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) {
+        usedNonEntryFiles.forEach(sourceFile => {
+            const filePath = sourceFile.getFilePath();
+            const exportDeclarations = sourceFile.getExportedDeclarations();
+            if (include.duplicates) {
+                const duplicateExports = (0, ts_morph_helpers_1.findDuplicateExportedNames)(sourceFile);
+                duplicateExports.forEach(symbols => {
+                    const symbol = symbols.join('|');
+                    addIssue('duplicates', { filePath, symbol, symbols });
+                });
+            }
+            if (include.exports || include.types || include.nsExports || include.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)
+                                return;
+                            if (!include.exports && !type)
+                                return;
+                        }
+                        if (jsDocOptions.isReadPublicTag && ts_morph_1.ts.getJSDocPublicTag(declaration.compilerNode))
+                            return;
+                        let identifier;
+                        if (declaration.isKind(ts_morph_1.ts.SyntaxKind.Identifier)) {
+                            identifier = declaration;
+                        }
+                        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) ||
+                            declaration.isKind(ts_morph_1.ts.SyntaxKind.InterfaceDeclaration) ||
+                            declaration.isKind(ts_morph_1.ts.SyntaxKind.EnumDeclaration)) {
+                            identifier = declaration.getFirstChildByKindOrThrow(ts_morph_1.ts.SyntaxKind.Identifier);
+                        }
+                        else if (declaration.isKind(ts_morph_1.ts.SyntaxKind.PropertyAccessExpression)) {
+                            identifier = declaration.getLastChildByKindOrThrow(ts_morph_1.ts.SyntaxKind.Identifier);
+                        }
+                        else {
+                            identifier = declaration.getFirstDescendantByKind(ts_morph_1.ts.SyntaxKind.Identifier);
+                        }
+                        if (identifier) {
+                            const identifierText = identifier.getText();
+                            if (include.exports && issues.exports[filePath]?.[identifierText])
+                                return;
+                            if (include.types && issues.types[filePath]?.[identifierText])
+                                return;
+                            if (include.nsExports && issues.nsExports[filePath]?.[identifierText])
+                                return;
+                            if (include.nsTypes && issues.nsTypes[filePath]?.[identifierText])
+                                return;
+                            const refs = identifier.findReferences();
+                            if (refs.length === 0) {
+                                addIssue('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();
+                                if (!isReferencedOnlyBySelf)
+                                    return;
+                                if ((0, ts_morph_helpers_1.findReferencingNamespaceNodes)(sourceFile).length > 0) {
+                                    if (type) {
+                                        addIssue('nsTypes', { filePath, symbol: identifierText, symbolType: type });
+                                    }
+                                    else {
+                                        addIssue('nsExports', { filePath, symbol: identifierText });
+                                    }
+                                }
+                                else if (type) {
+                                    addIssue('types', { filePath, symbol: identifierText, symbolType: type });
+                                }
+                                else {
+                                    addIssue('exports', { filePath, symbol: identifierText });
+                                }
+                            }
+                        }
+                    });
+                });
+            }
+            counters.processed++;
+        });
+    }
+    if (isShowProgress)
+        lineRewriter.resetLines();
+    return { issues, counters };
+}
+exports.run = run;

package/dist/log.d.ts

@@ -0,0 +1,7 @@
+export declare const getLine: (value: number | string, text: string) => string;
+export declare class LineRewriter {
+    private lines;
+    private clearLines;
+    resetLines(): void;
+    update(messages: string[]): void;
+}

package/dist/log.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LineRewriter = exports.getLine = void 0;
+const getLine = (value, text) => `${String(value).padStart(5)} ${text}`;
+exports.getLine = getLine;
+class LineRewriter {
+    lines = 0;
+    clearLines(count) {
+        if (count > 0) {
+            for (let i = 0; i < count; i++) {
+                process.stdout.moveCursor(0, -1);
+                process.stdout.clearLine(1);
+            }
+        }
+        process.stdout.cursorTo(0);
+    }
+    resetLines() {
+        this.clearLines(this.lines);
+    }
+    update(messages) {
+        this.resetLines();
+        process.stdout.write(messages.join('\n') + '\n');
+        this.lines = messages.length;
+    }
+}
+exports.LineRewriter = LineRewriter;

package/dist/reporters/compact.d.ts

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

package/dist/reporters/compact.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": 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 logIssueGroupResult = (issues, cwd, title) => {
+    title && console.log(`--- ${title} (${issues.length})`);
+    if (issues.length) {
+        issues.sort().forEach(filePath => logIssueLine(cwd, filePath));
+    }
+    else {
+        console.log('N/A');
+    }
+};
+const logIssueGroupResults = (issues, cwd, 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));
+    }
+    else {
+        console.log('N/A');
+    }
+};
+exports.default = ({ issues, config, cwd }) => {
+    const { include } = config;
+    const reportMultipleGroups = Object.values(include).filter(Boolean).length > 1;
+    if (include.files) {
+        const unreferencedFiles = Array.from(issues.files);
+        logIssueGroupResult(unreferencedFiles, cwd, reportMultipleGroups && 'UNREFERENCED FILES');
+    }
+    if (include.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');
+    }
+    if (include.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');
+    }
+    if (include.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');
+    }
+    if (include.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');
+    }
+    if (include.duplicates) {
+        const unreferencedDuplicates = Object.values(issues.duplicates)
+            .map(issues => Object.values(issues))
+            .flat();
+        logIssueGroupResults(unreferencedDuplicates, cwd, reportMultipleGroups && 'DUPLICATE EXPORTS');
+    }
+};

package/dist/reporters/index.d.ts

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

package/dist/reporters/index.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const symbols_1 = __importDefault(require("./symbols"));
+const compact_1 = __importDefault(require("./compact"));
+exports.default = {
+    symbols: symbols_1.default,
+    compact: compact_1.default,
+};

package/dist/reporters/symbols.d.ts

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

package/dist/reporters/symbols.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_path_1 = __importDefault(require("node:path"));
+const logIssueLine = ({ issue, cwd, 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)}`);
+};
+const logIssueGroupResult = (issues, cwd, title) => {
+    title && console.log(`--- ${title} (${issues.length})`);
+    if (issues.length) {
+        issues.sort().forEach(filePath => console.log(node_path_1.default.relative(cwd, filePath)));
+    }
+    else {
+        console.log('N/A');
+    }
+};
+const logIssueGroupResults = (issues, cwd, 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 }));
+    }
+    else {
+        console.log('N/A');
+    }
+};
+exports.default = ({ issues, config, cwd }) => {
+    const { include } = config;
+    const reportMultipleGroups = Object.values(include).filter(Boolean).length > 1;
+    if (include.files) {
+        const unreferencedFiles = Array.from(issues.files);
+        logIssueGroupResult(unreferencedFiles, cwd, reportMultipleGroups && 'UNUSED FILES');
+    }
+    if (include.exports) {
+        const unreferencedExports = Object.values(issues.exports).map(Object.values).flat();
+        logIssueGroupResults(unreferencedExports, cwd, reportMultipleGroups && 'UNUSED EXPORTS');
+    }
+    if (include.nsExports) {
+        const unreferencedNsExports = Object.values(issues.nsExports).map(Object.values).flat();
+        logIssueGroupResults(unreferencedNsExports, cwd, reportMultipleGroups && 'UNUSED EXPORTS IN NAMESPACE');
+    }
+    if (include.types) {
+        const unreferencedTypes = Object.values(issues.types).map(Object.values).flat();
+        logIssueGroupResults(unreferencedTypes, cwd, reportMultipleGroups && 'UNUSED TYPES');
+    }
+    if (include.nsTypes) {
+        const unreferencedNsTypes = Object.values(issues.nsTypes).map(Object.values).flat();
+        logIssueGroupResults(unreferencedNsTypes, cwd, reportMultipleGroups && 'UNUSED TYPES IN NAMESPACE');
+    }
+    if (include.duplicates) {
+        const unreferencedDuplicates = Object.values(issues.duplicates).map(Object.values).flat();
+        logIssueGroupResults(unreferencedDuplicates, cwd, reportMultipleGroups && 'DUPLICATE EXPORTS');
+    }
+};

package/dist/types.d.ts

@@ -0,0 +1,35 @@
+declare type FilePath = string;
+declare type SymbolType = 'type' | 'interface' | 'enum';
+declare type UnusedFileIssues = Set<FilePath>;
+declare type UnusedExportIssues = Record<string, Record<string, Issue>>;
+export declare type Issue = {
+    filePath: FilePath;
+    symbol: string;
+    symbols?: string[];
+    symbolType?: SymbolType;
+};
+export declare type Issues = {
+    files: UnusedFileIssues;
+    exports: UnusedExportIssues;
+    types: UnusedExportIssues;
+    nsExports: UnusedExportIssues;
+    nsTypes: UnusedExportIssues;
+    duplicates: UnusedExportIssues;
+};
+export declare type IssueType = keyof Issues;
+declare type LocalConfiguration = {
+    entryFiles: string[];
+    projectFiles: string[];
+};
+export declare type Configuration = LocalConfiguration & {
+    cwd: string;
+    include: {
+        [key in IssueType]: boolean;
+    };
+    isShowProgress: boolean;
+    jsDocOptions: {
+        isReadPublicTag: boolean;
+    };
+};
+export declare type ImportedConfiguration = LocalConfiguration | Record<string, LocalConfiguration>;
+export {};

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/util/config.d.ts

@@ -0,0 +1,14 @@
+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[]) => {
+    files: boolean;
+    exports: boolean;
+    types: boolean;
+    nsExports: boolean;
+    nsTypes: boolean;
+    duplicates: boolean;
+};

package/dist/util/config.js

@@ -0,0 +1,49 @@
+"use strict";
+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"));
+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));
+        if (importedConfigKey) {
+            return importedConfiguration[importedConfigKey];
+        }
+    }
+    if (!cwdArg && (!importedConfiguration.entryFiles || !importedConfiguration.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');
+        return;
+    }
+    return importedConfiguration;
+};
+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));
+    return groups.reduce((r, group) => ((r[group] = includes.includes(group)), r), {});
+};
+exports.resolveIncludedFromArgs = resolveIncludedFromArgs;

package/dist/util.d.ts

@@ -0,0 +1,5 @@
+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;

package/dist/util.js

@@ -0,0 +1,67 @@
+"use strict";
+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"));
+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('!'))
+            return '!' + node_path_1.default.join(cwd, pattern.slice(1));
+        return node_path_1.default.join(cwd, pattern);
+    });
+};
+const createProject = async (cwd, paths) => {
+    const tsConfigFilePath = await findFile(cwd, 'tsconfig.json');
+    const workspace = new ts_morph_1.Project({
+        tsConfigFilePath,
+        skipAddingFilesFromTsConfig: true,
+        skipFileDependencyResolution: true,
+    });
+    if (paths)
+        workspace.addSourceFilesAtPaths(resolvePaths(cwd, paths));
+    return workspace;
+};
+exports.createProject = createProject;
+const partitionSourceFiles = (projectFiles, productionFiles) => {
+    const productionFilePaths = productionFiles.map(file => file.getFilePath());
+    const usedFiles = [];
+    const unusedFiles = [];
+    projectFiles.forEach(projectFile => {
+        if (productionFilePaths.includes(projectFile.getFilePath())) {
+            usedFiles.push(projectFile);
+        }
+        else {
+            unusedFiles.push(projectFile);
+        }
+    });
+    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/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "knip",
+  "version": "0.1.2",
+  "description": "Find unused files and exports in your TypeScript project",
+  "keywords": [
+    "find",
+    "detect",
+    "unused",
+    "files",
+    "exports",
+    "types",
+    "duplicates",
+    "typescript",
+    "maintenance",
+    "unimported"
+  ],
+  "repository": "github:webpro/knip",
+  "homepage": "https://github.com/webpro/knip",
+  "bugs": "https://github.com/webpro/knip/issues",
+  "main": "dist/index.js",
+  "bin": {
+    "knip": "dist/cli.js"
+  },
+  "scripts": {
+    "knip": "node ./dist/cli.js",
+    "test": "node --loader tsx --test test/*.spec.ts",
+    "watch": "tsc --watch",
+    "build": "rm -rf dist && tsc",
+    "prepublishOnly": "npm test && npm run build && npm run knip",
+    "release": "release-it"
+  },
+  "files": [
+    "dist"
+  ],
+  "author": {
+    "name": "Lars Kappert",
+    "email": "lars@webpro.nl"
+  },
+  "license": "ISC",
+  "dependencies": {
+    "micromatch": "4.0.5",
+    "ts-morph": "16.0.0",
+    "ts-morph-helpers": "0.5.0"
+  },
+  "devDependencies": {
+    "@types/micromatch": "4.0.2",
+    "@types/node": "18.8.1",
+    "prettier": "2.7.1",
+    "release-it": "15.5.0",
+    "tsx": "3.9.0",
+    "typescript": "4.8.4"
+  },
+  "release-it": {
+    "github": {
+      "release": true
+    }
+  },
+  "engines": {
+    "node": ">=16.17.0"
+  },
+  "engineStrict": true
+}