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

package/dist/typescript/getImportsAndExports.js

@@ -3,7 +3,7 @@ import ts from 'typescript';
 import { getOrSet } from '../util/map.js';
 import { isMaybePackageName, sanitizeSpecifier } from '../util/modules.js';
 import { isInNodeModules } from '../util/path.js';
-import { isDeclarationFileExtension, isAccessExpression, getAccessExpressionName, getJSDocTags, } from './ast-helpers.js';
+import { isDeclarationFileExtension, isAccessExpression, getAccessExpressionName, getJSDocTags, getLineAndCharacterOfPosition, } from './ast-helpers.js';
 import getExportVisitors from './visitors/exports/index.js';
 import { getJSXImplicitImportBase } from './visitors/helpers.js';
 import getImportVisitors from './visitors/imports/index.js';
@@ -13,12 +13,12 @@ const getVisitors = (sourceFile) => ({
     import: getImportVisitors(sourceFile),
     script: getScriptVisitors(sourceFile),
 });
-export const getImportsAndExports = (sourceFile, options) => {
+export const getImportsAndExports = (sourceFile, getResolvedModule, options) => {
     const internalImports = new Map();
     const externalImports = new Set();
     const unresolvedImports = new Set();
     const exports = new Map();
-    const aliasedExports = {};
+    const aliasedExports = new Map();
     const scripts = new Set();
     const importedInternalSymbols = new Map();
     const jsxImport = getJSXImplicitImportBase(sourceFile);
@@ -47,10 +47,10 @@ export const getImportsAndExports = (sourceFile, options) => {
             importedInternalSymbols.set(symbol, filePath);
     };
     const addImport = (options) => {
-        const { specifier, symbol, identifier = '__anonymous', isReExport = false } = options;
+        const { specifier, symbol, identifier = '__anonymous', isReExport = false, pos } = options;
         if (isBuiltin(specifier))
             return;
-        const module = sourceFile.resolvedModules?.get(specifier, undefined);
+        const module = getResolvedModule(specifier);
         if (module?.resolvedModule) {
             const filePath = module.resolvedModule.resolvedFileName;
             if (filePath) {
@@ -74,7 +74,13 @@ export const getImportsAndExports = (sourceFile, options) => {
             }
         }
         else {
-            unresolvedImports.add(specifier);
+            if (typeof pos === 'number') {
+                const { line, character } = sourceFile.getLineAndCharacterOfPosition(pos);
+                unresolvedImports.add({ specifier, pos, line: line + 1, col: character + 1 });
+            }
+            else {
+                unresolvedImports.add({ specifier });
+            }
         }
     };
     const maybeAddNamespaceAccessAsImport = ({ namespace, member }) => {
@@ -87,7 +93,7 @@ export const getImportsAndExports = (sourceFile, options) => {
             }
         }
     };
-    const addExport = ({ node, identifier, type, pos, members = [] }) => {
+    const addExport = ({ node, identifier, type, pos, posDecl, members = [] }) => {
         if (options.skipExports)
             return;
         const jsDocTags = getJSDocTags(node);
@@ -95,10 +101,10 @@ export const getImportsAndExports = (sourceFile, options) => {
             const item = exports.get(identifier);
             const crew = [...item.members, ...members];
             const tags = new Set([...item.jsDocTags, ...jsDocTags]);
-            exports.set(identifier, { ...item, node, type, pos, members: crew, jsDocTags: tags });
+            exports.set(identifier, { ...item, members: crew, jsDocTags: tags });
         }
         else {
-            exports.set(identifier, { node, type, pos, members, jsDocTags });
+            exports.set(identifier, { node, type, members, jsDocTags, pos, posDecl: posDecl ?? pos });
         }
         if (!jsDocTags.has('@alias')) {
             if (ts.isExportAssignment(node))
@@ -109,9 +115,17 @@ export const getImportsAndExports = (sourceFile, options) => {
     };
     const maybeAddAliasedExport = (node, alias) => {
         const identifier = node?.getText();
-        if (identifier && sourceFile.symbol?.exports?.has(identifier)) {
-            aliasedExports[identifier] = aliasedExports[identifier] ?? [identifier];
-            aliasedExports[identifier].push(alias);
+        if (node && identifier) {
+            const exprt = sourceFile.symbol?.exports?.get(identifier);
+            if (exprt && exprt.valueDeclaration) {
+                if (!aliasedExports.has(identifier)) {
+                    const pos = getLineAndCharacterOfPosition(exprt.valueDeclaration, exprt.valueDeclaration.pos);
+                    aliasedExports.set(identifier, [{ symbol: identifier, ...pos }]);
+                }
+                const i = aliasedExports.get(identifier);
+                const pos = getLineAndCharacterOfPosition(node, node.pos);
+                i?.push({ symbol: alias, ...pos });
+            }
         }
     };
     const visit = (node) => {
@@ -122,11 +136,14 @@ export const getImportsAndExports = (sourceFile, options) => {
                     [results].flat().forEach(addImport);
             }
         }
-        for (const visitor of visitors.export) {
-            if (visitor) {
-                const results = visitor(node, options);
-                if (results)
-                    [results].flat().forEach(addExport);
+        const isTopLevel = node.parent === sourceFile || node.parent?.parent === sourceFile;
+        if (isTopLevel) {
+            for (const visitor of visitors.export) {
+                if (visitor) {
+                    const results = visitor(node, options);
+                    if (results)
+                        [results].flat().forEach(addExport);
+                }
             }
         }
         for (const visitor of visitors.script) {
@@ -153,7 +170,7 @@ export const getImportsAndExports = (sourceFile, options) => {
         },
         exports: {
             exported: exports,
-            duplicate: Object.values(aliasedExports),
+            duplicate: [...aliasedExports.values()],
         },
         scripts,
     };

package/dist/typescript/resolveModuleNames.d.ts

@@ -1,2 +1,2 @@
 import ts from 'typescript';
-export declare function createCustomModuleResolver(customSys: typeof ts.sys, compilerOptions: ts.CompilerOptions, virtualFileExtensions: string[]): (moduleNames: string[], containingFile: string) => Array<ts.ResolvedModule | undefined>;
+export declare function createCustomModuleResolver(customSys: typeof ts.sys, compilerOptions: ts.CompilerOptions, virtualFileExtensions: string[]): (moduleNames: string[], containingFile: string) => Array<ts.ResolvedModuleFull | undefined>;

package/dist/typescript/resolveModuleNames.js

@@ -1,29 +1,55 @@
 import { existsSync } from 'node:fs';
+import { isBuiltin } from 'node:module';
 import ts from 'typescript';
 import { sanitizeSpecifier } from '../util/modules.js';
-import { dirname, extname, isInternal, join } from '../util/path.js';
+import { dirname, extname, isAbsolute, isInternal, join } from '../util/path.js';
+import { isDeclarationFileExtension } from './ast-helpers.js';
 import { ensureRealFilePath, isVirtualFilePath } from './utils.js';
+const resolutionCache = new Map();
+const fileExists = (name, containingFile) => {
+    const resolvedFileName = isAbsolute(name) ? name : join(dirname(containingFile), name);
+    if (existsSync(resolvedFileName)) {
+        return {
+            resolvedFileName,
+            extension: extname(name),
+            isExternalLibraryImport: false,
+            resolvedUsingTsExtension: false,
+        };
+    }
+};
 export function createCustomModuleResolver(customSys, compilerOptions, virtualFileExtensions) {
     function resolveModuleNames(moduleNames, containingFile) {
-        return moduleNames.map(moduleName => resolveModuleName(moduleName, containingFile));
+        return moduleNames.map(moduleName => {
+            const key = moduleName.startsWith('.')
+                ? join(dirname(containingFile), moduleName)
+                : `${containingFile}:${moduleName}`;
+            if (resolutionCache.has(key))
+                return resolutionCache.get(key);
+            const resolvedModule = resolveModuleName(moduleName, containingFile);
+            resolutionCache.set(key, resolvedModule);
+            return resolvedModule;
+        });
     }
     function resolveModuleName(name, containingFile) {
         const sanitizedSpecifier = sanitizeSpecifier(name);
+        if (isBuiltin(sanitizedSpecifier))
+            return undefined;
         const tsResolvedModule = ts.resolveModuleName(sanitizedSpecifier, containingFile, compilerOptions, ts.sys).resolvedModule;
         if (!tsResolvedModule) {
             const extension = extname(sanitizedSpecifier);
-            if (extension && isInternal(sanitizedSpecifier) && !virtualFileExtensions.includes(extension)) {
-                const resolvedFileName = join(dirname(containingFile), sanitizedSpecifier);
-                if (existsSync(resolvedFileName)) {
-                    return {
-                        resolvedFileName,
-                        extension,
-                        isExternalLibraryImport: false,
-                        resolvedUsingTsExtension: false,
-                    };
-                }
+            if (extension && !virtualFileExtensions.includes(extension)) {
+                const module = fileExists(sanitizedSpecifier, containingFile);
+                if (module)
+                    return module;
             }
         }
+        if (tsResolvedModule &&
+            isDeclarationFileExtension(tsResolvedModule?.extension) &&
+            isInternal(tsResolvedModule.resolvedFileName)) {
+            const module = fileExists(sanitizedSpecifier, containingFile);
+            if (module)
+                return module;
+        }
         if (virtualFileExtensions.length === 0)
             return tsResolvedModule;
         if (tsResolvedModule && !isVirtualFilePath(tsResolvedModule.resolvedFileName, virtualFileExtensions)) {

package/dist/typescript/visitors/exports/exportDeclaration.js

@@ -5,8 +5,21 @@ export default visit(() => true, node => {
     if (ts.isExportDeclaration(node)) {
         if (node.exportClause && ts.isNamedExports(node.exportClause)) {
             const type = node.isTypeOnly ? SymbolType.TYPE : SymbolType.UNKNOWN;
+            const sourceFile = node.getSourceFile();
+            const declarations = sourceFile.getNamedDeclarations?.();
             return node.exportClause.elements.map(element => {
-                return { node: element, identifier: element.name.getText(), type, pos: element.name.pos };
+                const identifier = String(element.name.escapedText);
+                const declaration = declarations?.get(identifier)?.find((d) => d !== element);
+                const pos = element.name.pos;
+                const name = ts.getNameOfDeclaration(declaration);
+                const posDecl = name?.pos ?? declaration?.pos ?? pos;
+                return {
+                    node: element,
+                    identifier,
+                    type,
+                    pos,
+                    posDecl,
+                };
             });
         }
     }

package/dist/typescript/visitors/exports/exportKeyword.js

@@ -1,7 +1,7 @@
 import ts from 'typescript';
 import { SymbolType } from '../../../types/issues.js';
 import { compact } from '../../../util/array.js';
-import { isPrivateMember, stripQuotes } from '../../ast-helpers.js';
+import { isGetOrSetAccessorDeclaration, isPrivateMember, stripQuotes } from '../../ast-helpers.js';
 import { exportVisitor as visit } from '../index.js';
 export default visit(() => true, node => {
     const modifierKinds = node.modifiers?.map(modifier => modifier.kind) ?? [];
@@ -47,7 +47,10 @@ export default visit(() => true, node => {
             const identifier = modifierKinds.includes(ts.SyntaxKind.DefaultKeyword) ? 'default' : node.name.getText();
             const pos = (node.name ?? node).getStart();
             const members = node.members
-                .filter((member) => (ts.isPropertyDeclaration(member) || ts.isMethodDeclaration(member)) && !isPrivateMember(member))
+                .filter((member) => (ts.isPropertyDeclaration(member) ||
+                ts.isMethodDeclaration(member) ||
+                isGetOrSetAccessorDeclaration(member)) &&
+                !isPrivateMember(member))
                 .map(member => ({
                 node: member,
                 identifier: member.name.getText(),

package/dist/typescript/visitors/exports/moduleExportsAccessExpression.js

@@ -1,30 +1,38 @@
 import ts from 'typescript';
 import { SymbolType } from '../../../types/issues.js';
-import { isModuleExportsAccessExpression, stripQuotes } from '../../ast-helpers.js';
+import { stripQuotes } from '../../ast-helpers.js';
 import { isJS } from '../helpers.js';
 import { exportVisitor as visit } from '../index.js';
+const isModuleExportsAccess = (node) => ts.isIdentifier(node.expression) && node.expression.escapedText === 'module' && node.name.escapedText === 'exports';
 export default visit(isJS, node => {
-    if (isModuleExportsAccessExpression(node)) {
-        const parent = node.parent;
-        if (ts.isPropertyAccessExpression(parent)) {
-            const identifier = parent.name.getText();
-            const pos = parent.name.getStart();
-            return { node, identifier, type: SymbolType.UNKNOWN, pos };
-        }
-        else if (ts.isElementAccessExpression(parent)) {
-            const identifier = stripQuotes(parent.argumentExpression.getText());
-            const pos = parent.argumentExpression.getStart();
-            return { node, identifier, type: SymbolType.UNKNOWN, pos };
-        }
-        else if (ts.isBinaryExpression(parent)) {
-            const expr = parent.right;
-            if (ts.isObjectLiteralExpression(expr) && expr.properties.every(ts.isShorthandPropertyAssignment)) {
-                return expr.properties.map(node => {
-                    return { node, identifier: node.getText(), type: SymbolType.UNKNOWN, pos: node.pos };
-                });
+    if (ts.isExpressionStatement(node)) {
+        if (ts.isBinaryExpression(node.expression)) {
+            if (ts.isPropertyAccessExpression(node.expression.left)) {
+                if (ts.isPropertyAccessExpression(node.expression.left.expression) &&
+                    isModuleExportsAccess(node.expression.left.expression)) {
+                    const identifier = node.expression.left.name.getText();
+                    const pos = node.expression.left.name.pos;
+                    return { node, identifier, type: SymbolType.UNKNOWN, pos };
+                }
+                else if (isModuleExportsAccess(node.expression.left)) {
+                    const expr = node.expression.right;
+                    if (ts.isObjectLiteralExpression(expr) && expr.properties.every(ts.isShorthandPropertyAssignment)) {
+                        return expr.properties.map(node => {
+                            return { node, identifier: node.getText(), type: SymbolType.UNKNOWN, pos: node.pos };
+                        });
+                    }
+                    else {
+                        return { node, identifier: 'default', type: SymbolType.UNKNOWN, pos: expr.pos };
+                    }
+                }
             }
-            else {
-                return { node, identifier: 'default', type: SymbolType.UNKNOWN, pos: node.getStart() };
+            else if (ts.isElementAccessExpression(node.expression.left) &&
+                ts.isPropertyAccessExpression(node.expression.left.expression) &&
+                ts.isIdentifier(node.expression.left.expression.name) &&
+                isModuleExportsAccess(node.expression.left.expression)) {
+                const identifier = stripQuotes(node.expression.left.argumentExpression.getText());
+                const pos = node.expression.left.argumentExpression.pos;
+                return { node, identifier, type: SymbolType.UNKNOWN, pos };
             }
         }
     }

package/dist/typescript/visitors/imports/importCall.js

@@ -5,7 +5,7 @@ export default visit(() => true, node => {
     if (isImportCall(node)) {
         if (node.arguments[0] && ts.isStringLiteralLike(node.arguments[0])) {
             const specifier = node.arguments[0].text;
-            return { specifier, identifier: 'default' };
+            return { specifier, identifier: 'default', pos: node.arguments[0].pos };
         }
     }
 });

package/dist/typescript/visitors/imports/importDeclaration.js

@@ -12,17 +12,17 @@ export default visit(() => true, (node, options) => {
                 return;
             const imports = [];
             if (isDefaultImport(node)) {
-                imports.push({ specifier, identifier: 'default' });
+                imports.push({ specifier, identifier: 'default', pos: node.moduleSpecifier.pos });
             }
             if (node.importClause?.namedBindings) {
                 if (ts.isNamespaceImport(node.importClause.namedBindings)) {
                     const symbol = node.importClause.namedBindings.symbol;
-                    imports.push({ symbol, specifier, identifier: '*' });
+                    imports.push({ symbol, specifier, identifier: '*', pos: symbol?.declarations[0]?.pos ?? node.pos });
                 }
                 if (ts.isNamedImports(node.importClause.namedBindings)) {
                     node.importClause.namedBindings.elements.forEach(element => {
                         const identifier = (element.propertyName ?? element.name).getText();
-                        imports.push({ symbol: element.symbol, specifier, identifier });
+                        imports.push({ symbol: element.symbol, specifier, identifier, pos: element.pos });
                     });
                 }
             }

package/dist/typescript/visitors/imports/importEqualsDeclaration.js

@@ -6,6 +6,6 @@ export default visit(isNotJS, node => {
         ts.isExternalModuleReference(node.moduleReference) &&
         ts.isStringLiteralLike(node.moduleReference.expression)) {
         const specifier = node.moduleReference.expression.text;
-        return { specifier, identifier: 'default' };
+        return { specifier, identifier: 'default', pos: node.moduleReference.expression.pos };
     }
 });

package/dist/typescript/visitors/imports/jsDocType.js

@@ -1,11 +1,43 @@
 import ts from 'typescript';
-import { isValidImportTypeNode } from '../../ast-helpers.js';
 import { importVisitor as visit } from '../index.js';
+const extractImportSpecifiers = (node) => {
+    const importSpecifiers = [];
+    function visit(node) {
+        if (ts.isJSDocTypeExpression(node)) {
+            const typeNode = node.type;
+            if (ts.isTypeReferenceNode(typeNode) && typeNode.typeArguments) {
+                typeNode.typeArguments.forEach(arg => {
+                    if (ts.isImportTypeNode(arg)) {
+                        const importClause = arg.argument;
+                        if (ts.isLiteralTypeNode(importClause) && ts.isStringLiteral(importClause.literal)) {
+                            importSpecifiers.push(importClause.literal.text);
+                        }
+                    }
+                });
+            }
+        }
+        if (ts.isJSDocTypeTag(node)) {
+            const typeNode = node.typeExpression?.type;
+            if (ts.isImportTypeNode(typeNode)) {
+                const importClause = typeNode.argument;
+                if (ts.isLiteralTypeNode(importClause) && ts.isStringLiteral(importClause.literal)) {
+                    importSpecifiers.push(importClause.literal.text);
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(node);
+    return importSpecifiers;
+};
 export default visit(() => true, node => {
-    if ('jsDoc' in node) {
-        const type = ts.getJSDocType(node);
-        if (type && isValidImportTypeNode(type)) {
-            return { specifier: type.argument.literal.text };
+    if ('jsDoc' in node && node.jsDoc) {
+        const jsDoc = node.jsDoc;
+        if (jsDoc.length > 0 && jsDoc[0].parent.parent === node.parent) {
+            return jsDoc
+                .flatMap(jsDoc => (jsDoc.tags ?? []).flatMap(extractImportSpecifiers))
+                .map(specifier => ({ specifier }));
         }
     }
+    return [];
 });

package/dist/typescript/visitors/imports/propertyAccessCall.js

@@ -6,7 +6,7 @@ export default visit(() => true, node => {
         if (node.arguments[0] && ts.isStringLiteralLike(node.arguments[0])) {
             const specifier = node.arguments[0].text;
             if (specifier)
-                return { specifier };
+                return { specifier, pos: node.arguments[0].pos };
         }
     }
 });

package/dist/typescript/visitors/imports/reExportDeclaration.js

@@ -4,16 +4,21 @@ export default visit(() => true, node => {
     if (ts.isExportDeclaration(node)) {
         if (node.moduleSpecifier && ts.isStringLiteralLike(node.moduleSpecifier)) {
             if (!node.exportClause) {
-                return { identifier: '*', specifier: node.moduleSpecifier.text, isReExport: true };
+                return { identifier: '*', specifier: node.moduleSpecifier.text, isReExport: true, pos: node.pos };
             }
             else if (node.exportClause.kind === ts.SyntaxKind.NamespaceExport) {
-                return { identifier: '*', specifier: node.moduleSpecifier.text, isReExport: true };
+                return {
+                    identifier: '*',
+                    specifier: node.moduleSpecifier.text,
+                    isReExport: true,
+                    pos: node.exportClause.name.pos,
+                };
             }
             else {
                 const specifier = node.moduleSpecifier;
                 return node.exportClause.elements.map(element => {
                     const identifier = (element.propertyName ?? element.name).getText();
-                    return { identifier, specifier: specifier.text, isReExport: true };
+                    return { identifier, specifier: specifier.text, isReExport: true, pos: element.pos };
                 });
             }
         }

package/dist/typescript/visitors/imports/requireCall.js

@@ -13,30 +13,30 @@ export default visit(() => true, node => {
                 });
                 if (propertyAccessExpression) {
                     const identifier = String(propertyAccessExpression.name.escapedText);
-                    return { identifier, specifier };
+                    return { identifier, specifier, pos: propertyAccessExpression.name.pos };
                 }
                 else {
                     const variableDeclaration = node.parent;
                     if (ts.isVariableDeclaration(variableDeclaration) &&
                         ts.isVariableDeclarationList(variableDeclaration.parent)) {
                         if (ts.isIdentifier(variableDeclaration.name)) {
-                            return { identifier: 'default', specifier };
+                            return { identifier: 'default', specifier, pos: node.arguments[0].pos };
                         }
                         else {
                             const bindings = findDescendants(variableDeclaration, ts.isBindingElement);
                             if (bindings.length > 0) {
                                 return bindings.map(element => {
                                     const identifier = (element.propertyName ?? element.name).getText();
-                                    return { identifier, specifier };
+                                    return { identifier, specifier, pos: element.pos };
                                 });
                             }
                             else {
-                                return { identifier: 'default', specifier };
+                                return { identifier: 'default', specifier, pos: node.arguments[0].pos };
                             }
                         }
                     }
                     else {
-                        return { identifier: 'default', specifier };
+                        return { identifier: 'default', specifier, pos: node.arguments[0].pos };
                     }
                 }
             }

package/dist/util/array.d.ts

@@ -1,2 +1,4 @@
-export declare const compact: <T>(collection: (T | undefined)[]) => T[];
+type Collection<T> = Array<T> | Set<T>;
+export declare const compact: <T>(collection: Collection<T | undefined>) => T[];
 export declare const arrayify: (value?: string[] | string) => string[];
+export {};

package/dist/util/cli-arguments.d.ts

@@ -1,15 +1,16 @@
-export declare const helpText = "\u2702\uFE0F  Find unused files, dependencies and exports in your JavaScript and TypeScript projects\n\nUsage: knip [options]\n\nOptions:\n  -c, --config [file]      Configuration file path (default: [.]knip.json[c], knip.js, knip.ts or package.json#knip)\n  -t, --tsConfig [file]    TypeScript configuration path (default: tsconfig.json)\n  --production             Analyze only production source files (e.g. no tests, devDependencies, exported types)\n  --strict                 Consider only direct dependencies of workspace (not devDependencies, not other workspaces)\n  --ignore-internal        Ignore exports with tag @internal (JSDoc/TSDoc)\n  -W, --workspace [dir]    Analyze a single workspace (default: analyze all configured workspaces)\n  --no-gitignore           Don't use .gitignore\n  --include                Report only provided issue type(s), can be comma-separated or repeated (1)\n  --exclude                Exclude provided issue type(s) from report, can be comma-separated or repeated (1)\n  --dependencies           Shortcut for --include dependencies,unlisted,unresolved\n  --exports                Shortcut for --include exports,nsExports,classMembers,types,nsTypes,enumMembers,duplicates\n  --include-entry-exports  Include entry files when reporting unused exports\n  -n, --no-progress        Don't show dynamic progress updates (automatically enabled in CI environments)\n  --preprocessor           Preprocess the results before providing it to the reporter(s), can be repeated\n  --preprocessor-options   Pass extra options to the preprocessor (as JSON string, see --reporter-options example)\n  --reporter               Select reporter: symbols, compact, codeowners, json, can be repeated (default: symbols)\n  --reporter-options       Pass extra options to the reporter (as JSON string, see example)\n  --no-config-hints        Suppress configuration hints\n  --no-exit-code           Always exit with code zero (0)\n  --max-issues             Maximum number of issues before non-zero exit code (default: 0)\n  -d, --debug              Show debug output\n  --debug-file-filter      Filter for files in debug output (regex as string)\n  --performance            Measure count and running time of expensive functions and display stats table\n  -h, --help               Print this help text\n  -V, --version            Print version\n\n(1) Issue types: files, dependencies, unlisted, unresolved, exports, nsExports, classMembers, types, nsTypes, enumMembers, duplicates\n\nExamples:\n\n$ knip\n$ knip --production\n$ knip --workspace packages/client --include files,dependencies\n$ knip -c ./config/knip.json --reporter compact\n$ knip --reporter codeowners --reporter-options '{\"path\":\".github/CODEOWNERS\"}'\n$ knip --debug --debug-file-filter '(specific|particular)-module'\n\nMore documentation and bug reports: https://github.com/webpro/knip";
+export declare const helpText = "\u2702\uFE0F  Find unused files, dependencies and exports in your JavaScript and TypeScript projects\n\nUsage: knip [options]\n\nOptions:\n  -c, --config [file]      Configuration file path (default: [.]knip.json[c], knip.js, knip.ts or package.json#knip)\n  -t, --tsConfig [file]    TypeScript configuration path (default: tsconfig.json)\n  --production             Analyze only production source files (e.g. no tests, devDependencies, exported types)\n  --strict                 Consider only direct dependencies of workspace (not devDependencies, not other workspaces)\n  -W, --workspace [dir]    Analyze a single workspace (default: analyze all configured workspaces)\n  --directory [dir]        Run process from a different directory (default: cwd)\n  --no-gitignore           Don't use .gitignore\n  --include                Report only provided issue type(s), can be comma-separated or repeated (1)\n  --exclude                Exclude provided issue type(s) from report, can be comma-separated or repeated (1)\n  --dependencies           Shortcut for --include dependencies,unlisted,binaries,unresolved\n  --exports                Shortcut for --include exports,nsExports,classMembers,types,nsTypes,enumMembers,duplicates\n  --include-entry-exports  Include entry files when reporting unused exports\n  --isolate-workspaces     Isolated workspaces in monorepo\n  -n, --no-progress        Don't show dynamic progress updates (automatically enabled in CI environments)\n  --preprocessor           Preprocess the results before providing it to the reporter(s), can be repeated\n  --preprocessor-options   Pass extra options to the preprocessor (as JSON string, see --reporter-options example)\n  --reporter               Select reporter: symbols, compact, codeowners, json, can be repeated (default: symbols)\n  --reporter-options       Pass extra options to the reporter (as JSON string, see example)\n  --no-config-hints        Suppress configuration hints\n  --no-exit-code           Always exit with code zero (0)\n  --max-issues             Maximum number of issues before non-zero exit code (default: 0)\n  -d, --debug              Show debug output\n  --performance            Measure count and running time of expensive functions and display stats table\n  -h, --help               Print this help text\n  -V, --version            Print version\n\n(1) Issue types: files, dependencies, unlisted, unresolved, exports, nsExports, classMembers, types, nsTypes, enumMembers, duplicates\n\nExamples:\n\n$ knip\n$ knip --production\n$ knip --workspace packages/client --include files,dependencies\n$ knip -c ./config/knip.json --reporter compact\n$ knip --reporter codeowners --reporter-options '{\"path\":\".github/CODEOWNERS\"}'\n\nMore documentation and bug reports: https://github.com/webpro/knip";
 declare const _default: {
     config: string | undefined;
     debug: boolean | undefined;
-    'debug-file-filter': string | undefined;
     dependencies: boolean | undefined;
+    directory: string | undefined;
     exclude: string[] | undefined;
     exports: boolean | undefined;
     help: boolean | undefined;
     'ignore-internal': boolean | undefined;
     include: string[] | undefined;
     'include-entry-exports': boolean | undefined;
+    'isolate-workspaces': boolean | undefined;
     'max-issues': string | undefined;
     'no-config-hints': boolean | undefined;
     'no-exit-code': boolean | undefined;

package/dist/util/cli-arguments.js

@@ -1,4 +1,4 @@
-import { parseArgs } from 'node:util';
+import { parseArgs } from './parse-args.js';
 export const helpText = `✂️  Find unused files, dependencies and exports in your JavaScript and TypeScript projects
 
 Usage: knip [options]
@@ -8,14 +8,15 @@ Options:
   -t, --tsConfig [file]    TypeScript configuration path (default: tsconfig.json)
   --production             Analyze only production source files (e.g. no tests, devDependencies, exported types)
   --strict                 Consider only direct dependencies of workspace (not devDependencies, not other workspaces)
-  --ignore-internal        Ignore exports with tag @internal (JSDoc/TSDoc)
   -W, --workspace [dir]    Analyze a single workspace (default: analyze all configured workspaces)
+  --directory [dir]        Run process from a different directory (default: cwd)
   --no-gitignore           Don't use .gitignore
   --include                Report only provided issue type(s), can be comma-separated or repeated (1)
   --exclude                Exclude provided issue type(s) from report, can be comma-separated or repeated (1)
-  --dependencies           Shortcut for --include dependencies,unlisted,unresolved
+  --dependencies           Shortcut for --include dependencies,unlisted,binaries,unresolved
   --exports                Shortcut for --include exports,nsExports,classMembers,types,nsTypes,enumMembers,duplicates
   --include-entry-exports  Include entry files when reporting unused exports
+  --isolate-workspaces     Isolated workspaces in monorepo
   -n, --no-progress        Don't show dynamic progress updates (automatically enabled in CI environments)
   --preprocessor           Preprocess the results before providing it to the reporter(s), can be repeated
   --preprocessor-options   Pass extra options to the preprocessor (as JSON string, see --reporter-options example)
@@ -25,7 +26,6 @@ Options:
   --no-exit-code           Always exit with code zero (0)
   --max-issues             Maximum number of issues before non-zero exit code (default: 0)
   -d, --debug              Show debug output
-  --debug-file-filter      Filter for files in debug output (regex as string)
   --performance            Measure count and running time of expensive functions and display stats table
   -h, --help               Print this help text
   -V, --version            Print version
@@ -39,7 +39,6 @@ $ knip --production
 $ knip --workspace packages/client --include files,dependencies
 $ knip -c ./config/knip.json --reporter compact
 $ knip --reporter codeowners --reporter-options '{"path":".github/CODEOWNERS"}'
-$ knip --debug --debug-file-filter '(specific|particular)-module'
 
 More documentation and bug reports: https://github.com/webpro/knip`;
 let parsedArgs;
@@ -48,14 +47,15 @@ try {
         options: {
             config: { type: 'string', short: 'c' },
             debug: { type: 'boolean', short: 'd' },
-            'debug-file-filter': { type: 'string' },
             dependencies: { type: 'boolean' },
+            directory: { type: 'string' },
             exclude: { type: 'string', multiple: true },
             exports: { type: 'boolean' },
             help: { type: 'boolean', short: 'h' },
             'ignore-internal': { type: 'boolean' },
             include: { type: 'string', multiple: true },
             'include-entry-exports': { type: 'boolean' },
+            'isolate-workspaces': { type: 'boolean' },
             'max-issues': { type: 'string' },
             'no-config-hints': { type: 'boolean' },
             'no-exit-code': { type: 'boolean' },