knip 2.0.0-alpha.3 → 2.0.0-alpha.4

package/dist/configuration-chief.d.ts

@@ -26,7 +26,7 @@ export declare class ConfigurationChief {
     workspaces: Workspace[];
     resolvedConfigFilePath?: string;
     constructor({ cwd, isProduction }: ConfigurationManagerOptions);
-    loadLocalConfig(): Promise<void>;
+    init(): Promise<void>;
     getCompilers(): [SyncCompilers, AsyncCompilers];
     normalize(rawLocalConfig: RawConfiguration): {
         include: string[];
@@ -40,8 +40,8 @@ export declare class ConfigurationChief {
     setWorkspaces(): Promise<void>;
     private getManifestWorkspaces;
     private getAdditionalWorkspaces;
-    private getWorkspaces;
-    getActiveWorkspaces(): {
+    private getAllWorkspaces;
+    getEnabledWorkspaces(): {
         name: string;
         pkgName: string | undefined;
         dir: string;
@@ -54,7 +54,8 @@ export declare class ConfigurationChief {
     getNegatedWorkspacePatterns(name: string): string[];
     private getConfigKeyForWorkspace;
     getConfigForWorkspace(workspaceName: string): WorkspaceConfiguration;
-    resolveIncludedIssueTypes(): import("./types/issues.js").Report;
-    findWorkspace(filePath: string): Workspace | undefined;
+    getIssueTypesToReport(): import("./types/issues.js").Report;
+    findWorkspaceByFilePath(filePath: string): Workspace | undefined;
+    findWorkspaceByPackageName(packageName: string): Workspace | undefined;
 }
 export {};

package/dist/configuration-chief.js

@@ -8,11 +8,11 @@ import parsedArgs from './util/cli-arguments.js';
 import { partitionCompilers } from './util/compilers.js';
 import { ConfigurationError } from './util/errors.js';
 import { findFile, loadJSON } from './util/fs.js';
+import { getIncludedIssueTypes } from './util/get-included-issue-types.js';
 import { _dirGlob } from './util/glob.js';
 import { _load } from './util/loader.js';
 import { join, relative } from './util/path.js';
 import { toCamelCase } from './util/plugin.js';
-import { resolveIncludedIssueTypes } from './util/resolve-included-issue-types.js';
 import { byPathDepth } from './util/workspace.js';
 const { config: rawConfigArg, workspace: rawWorkspaceArg, include = [], exclude = [], dependencies = false, exports = false, } = parsedArgs.values;
 const getDefaultWorkspaceConfig = (extensions) => {
@@ -55,7 +55,7 @@ export class ConfigurationChief {
         this.isProduction = isProduction;
         this.config = defaultConfig;
     }
-    async loadLocalConfig() {
+    async init() {
         const manifestPath = findFile(this.cwd, 'package.json');
         const manifest = manifestPath && (await loadJSON(manifestPath));
         if (!manifestPath || !manifest) {
@@ -150,8 +150,8 @@ export class ConfigurationChief {
         this.ignoreWorkspaces = this.getIgnoredWorkspaces();
         this.manifestWorkspaces = await this.getManifestWorkspaces();
         this.additionalWorkspaces = await this.getAdditionalWorkspaces();
-        this.workspaces = this.getActiveWorkspaces();
-        this.workspaceDirs = this.getWorkspaces()
+        this.workspaces = this.getEnabledWorkspaces();
+        this.workspaceDirs = this.getAllWorkspaces()
             .sort(byPathDepth)
             .reverse()
             .map(dir => join(this.cwd, dir));
@@ -175,11 +175,11 @@ export class ConfigurationChief {
         const globbedDirs = await _dirGlob({ patterns, cwd: this.cwd });
         return new Set([...dirs, ...globbedDirs].filter(name => name !== ROOT_WORKSPACE_NAME && !this.manifestWorkspaces.has(name) && !this.ignoreWorkspaces.includes(name)));
     }
-    getWorkspaces() {
+    getAllWorkspaces() {
         return compact([ROOT_WORKSPACE_NAME, ...this.manifestWorkspaces.keys(), ...this.additionalWorkspaces]);
     }
-    getActiveWorkspaces() {
-        const allWorkspaces = this.getWorkspaces();
+    getEnabledWorkspaces() {
+        const allWorkspaces = this.getAllWorkspaces();
         const workspace = (rawWorkspaceArg ?? '').replace(/\/$/, '');
         const getAncestors = (name) => (ancestors, ancestorName) => {
             if (name === ancestorName)
@@ -193,14 +193,14 @@ export class ConfigurationChief {
             : allWorkspaces;
         return workspaces.sort(byPathDepth).map(name => ({
             name,
-            pkgName: this.manifestWorkspaces.get(name),
+            pkgName: this.manifestWorkspaces.get(name) ?? this.manifest?.name,
             dir: join(this.cwd, name),
             config: this.getConfigForWorkspace(name),
             ancestors: allWorkspaces.reduce(getAncestors(name), []),
         }));
     }
     getDescendentWorkspaces(name) {
-        return this.getWorkspaces()
+        return this.getAllWorkspaces()
             .filter(workspaceName => workspaceName !== name)
             .filter(workspaceName => name === ROOT_WORKSPACE_NAME || workspaceName.startsWith(name));
     }
@@ -238,17 +238,20 @@ export class ConfigurationChief {
             return this.config.workspaces[key];
         return getDefaultWorkspaceConfig();
     }
-    resolveIncludedIssueTypes() {
+    getIssueTypesToReport() {
         const cliArgs = { include, exclude, dependencies, exports };
         const config = {
             include: this.config.include ?? [],
             exclude: this.config.exclude ?? [],
             isProduction: this.isProduction,
         };
-        return resolveIncludedIssueTypes(cliArgs, config);
+        return getIncludedIssueTypes(cliArgs, config);
     }
-    findWorkspace(filePath) {
+    findWorkspaceByFilePath(filePath) {
         const workspaceDir = this.workspaceDirs.find(workspaceDir => filePath.startsWith(workspaceDir + '/'));
         return this.workspaces.find(workspace => workspace.dir === workspaceDir);
     }
+    findWorkspaceByPackageName(packageName) {
+        return this.workspaces.find(workspace => workspace.pkgName === packageName);
+    }
 }

package/dist/console-streamer.d.ts

@@ -0,0 +1,12 @@
+export declare class ConsoleStreamer {
+    isEnabled: boolean;
+    private lines;
+    constructor({ isEnabled }: {
+        isEnabled?: boolean | undefined;
+    });
+    private clearLines;
+    private resetLines;
+    private update;
+    cast(message: string): void;
+    clear(): void;
+}

package/dist/console-streamer.js

@@ -0,0 +1,34 @@
+export class ConsoleStreamer {
+    isEnabled = false;
+    lines = 0;
+    constructor({ isEnabled = false }) {
+        this.isEnabled = isEnabled;
+    }
+    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;
+    }
+    cast(message) {
+        if (!this.isEnabled)
+            return;
+        this.update([message]);
+    }
+    clear() {
+        if (!this.isEnabled)
+            return;
+        this.resetLines();
+    }
+}

package/dist/index.js

@@ -1,198 +1,142 @@
 import { ConfigurationChief } from './configuration-chief.js';
+import { ConsoleStreamer } from './console-streamer.js';
 import { ROOT_WORKSPACE_NAME, DEFAULT_EXTENSIONS } from './constants.js';
 import { DependencyDeputy } from './dependency-deputy.js';
 import { IssueCollector } from './issue-collector.js';
 import { PrincipalFactory } from './principal-factory.js';
-import { ProgressUpdater } from './progress-updater.js';
 import { compact } from './util/array.js';
 import { debugLogObject, debugLogArray } from './util/debug.js';
-import { findFile, loadJSON, findFileWithExtensions } from './util/fs.js';
+import { ConfigurationError } from './util/errors.js';
+import { findFile, findFileWithExtensions } from './util/fs.js';
 import { _glob } from './util/glob.js';
 import { join } from './util/path.js';
-import { loadTSConfig } from './util/tsconfig-loader.js';
+import { _require } from './util/require.js';
+import { loadTSConfig as loadCompilerOptions } from './util/tsconfig-loader.js';
 import { WorkspaceWorker } from './workspace-worker.js';
 export const main = async (unresolvedConfiguration) => {
     const { cwd, tsConfigFile, gitignore, isStrict, isProduction, isShowProgress } = unresolvedConfiguration;
-    const chief = new ConfigurationChief({ cwd, isProduction });
     debugLogObject('Unresolved configuration (from CLI arguments)', unresolvedConfiguration);
-    const collector = new IssueCollector({ cwd });
-    const progress = new ProgressUpdater({ isShowProgress });
-    progress.updateMessage('Reading configuration and manifest files...');
-    await chief.loadLocalConfig();
+    const chief = new ConfigurationChief({ cwd, isProduction });
     const deputy = new DependencyDeputy({ isStrict });
-    const workspaces = chief.getActiveWorkspaces();
-    debugLogObject('Included workspaces', workspaces);
-    const report = chief.resolveIncludedIssueTypes();
+    const factory = new PrincipalFactory();
+    const collector = new IssueCollector({ cwd });
+    const console = new ConsoleStreamer({ isEnabled: isShowProgress });
+    console.cast('Reading workspace configuration(s)...');
+    await chief.init();
     const compilers = chief.getCompilers();
+    const workspaces = chief.getEnabledWorkspaces();
+    const report = chief.getIssueTypesToReport();
+    debugLogObject('Included workspaces', workspaces);
     const enabledPluginsStore = new Map();
-    collector.setReport(report);
-    progress.updateMessage('Scanning workspaces...');
-    const factory = new PrincipalFactory();
     for (const workspace of workspaces) {
         const { name, dir, config, ancestors } = workspace;
+        const { paths, ignoreDependencies } = config;
         const isRoot = name === ROOT_WORKSPACE_NAME;
-        const suffix = isRoot ? '' : ` (${name})`;
+        console.cast(`Analyzing workspace (${name})...`);
         const manifestPath = isRoot ? chief.manifestPath : findFile(dir, 'package.json');
-        const manifest = isRoot ? chief.manifest : manifestPath && (await loadJSON(manifestPath));
+        const manifest = isRoot ? chief.manifest : manifestPath && _require(manifestPath);
         if (!manifestPath || !manifest)
-            continue;
-        const { ignoreDependencies } = chief.getConfigForWorkspace(name);
+            throw new ConfigurationError(`Unable to load package.json for ${name}`);
         deputy.addWorkspace({ name, dir, manifestPath, manifest, ignoreDependencies });
-        const tsConfigFilePath = join(dir, tsConfigFile ?? 'tsconfig.json');
-        const tsConfig = await loadTSConfig(tsConfigFilePath);
-        const principal = factory.getPrincipal({
-            cwd: dir,
-            compilerOptions: tsConfig?.compilerOptions,
-            paths: config.paths,
-            report,
-            compilers,
-        });
-        progress.updateMessage(`Resolving custom dependencies...${suffix}`);
-        const workspaceManifest = deputy.getWorkspaceManifest(name);
-        if (!workspaceManifest)
-            continue;
-        const negatedWorkspacePatterns = await chief.getNegatedWorkspacePatterns(name);
+        const compilerOptions = await loadCompilerOptions(join(dir, tsConfigFile ?? 'tsconfig.json'));
+        const principal = factory.getPrincipal({ cwd: dir, report: report, paths, compilerOptions, compilers });
         const worker = new WorkspaceWorker({
             name,
             dir,
+            cwd,
             config,
-            rootWorkspaceConfig: chief.getConfigForWorkspace(ROOT_WORKSPACE_NAME),
             manifest,
-            rootConfig: chief.config,
-            negatedWorkspacePatterns,
-            rootWorkspaceDir: cwd,
             isProduction,
+            rootIgnore: chief.config.ignore,
+            negatedWorkspacePatterns: chief.getNegatedWorkspacePatterns(name),
+            enabledPluginsInAncestors: ancestors.flatMap(ancestor => enabledPluginsStore.get(ancestor) ?? []),
         });
-        const enabledPluginsInAncestors = ancestors.flatMap(ancestor => enabledPluginsStore.get(ancestor) ?? []);
-        await worker.setEnabledPlugins(enabledPluginsInAncestors);
-        await worker.initReferencedDependencies();
-        progress.updateMessage(`Finding entry and project files${suffix}...`);
+        await worker.init();
+        const sharedGlobOptions = { cwd, workingDir: dir, gitignore, ignore: worker.getIgnorePatterns() };
         if (isProduction) {
             {
-                const workspaceEntryPaths = await _glob({
-                    cwd,
-                    workingDir: dir,
-                    patterns: worker.getProductionEntryFilePatterns(),
-                    ignore: worker.getWorkspaceIgnorePatterns(),
-                    gitignore,
-                });
-                debugLogArray(`Found entry paths${suffix}`, workspaceEntryPaths);
+                const patterns = worker.getProductionEntryFilePatterns();
+                const workspaceEntryPaths = await _glob({ ...sharedGlobOptions, patterns });
+                debugLogArray(`Found entry paths (${name})`, workspaceEntryPaths);
                 principal.addEntryPaths(workspaceEntryPaths);
                 principal.skipExportsAnalysisFor(workspaceEntryPaths);
             }
             {
-                const pluginWorkspaceEntryPaths = await _glob({
-                    cwd,
-                    workingDir: dir,
-                    patterns: worker.getProductionPluginEntryFilePatterns(),
-                    ignore: worker.getWorkspaceIgnorePatterns(),
-                    gitignore,
-                });
-                debugLogArray(`Found production plugin entry paths${suffix}`, pluginWorkspaceEntryPaths);
+                const patterns = worker.getProductionPluginEntryFilePatterns();
+                const pluginWorkspaceEntryPaths = await _glob({ ...sharedGlobOptions, patterns });
+                debugLogArray(`Found production plugin entry paths (${name})`, pluginWorkspaceEntryPaths);
                 principal.addEntryPaths(pluginWorkspaceEntryPaths);
                 principal.skipExportsAnalysisFor(pluginWorkspaceEntryPaths);
             }
             {
-                const workspaceProjectPaths = await _glob({
-                    cwd,
-                    workingDir: dir,
-                    patterns: worker.getProductionProjectFilePatterns(),
-                    ignore: worker.getWorkspaceIgnorePatterns(),
-                    gitignore,
-                });
-                debugLogArray(`Found project paths${suffix}`, workspaceProjectPaths);
+                const patterns = worker.getProductionProjectFilePatterns();
+                const workspaceProjectPaths = await _glob({ ...sharedGlobOptions, patterns });
+                debugLogArray(`Found project paths (${name})`, workspaceProjectPaths);
                 workspaceProjectPaths.forEach(projectPath => principal.addProjectPath(projectPath));
             }
         }
         else {
             {
-                const workspaceEntryPaths = await _glob({
-                    cwd,
-                    workingDir: dir,
-                    patterns: worker.getEntryFilePatterns(),
-                    ignore: worker.getWorkspaceIgnorePatterns(),
-                    gitignore,
-                });
-                debugLogArray(`Found entry paths${suffix}`, workspaceEntryPaths);
+                const patterns = worker.getEntryFilePatterns();
+                const workspaceEntryPaths = await _glob({ ...sharedGlobOptions, patterns });
+                debugLogArray(`Found entry paths (${name})`, workspaceEntryPaths);
                 principal.addEntryPaths(workspaceEntryPaths);
                 principal.skipExportsAnalysisFor(workspaceEntryPaths);
             }
             {
-                const workspaceProjectPaths = await _glob({
-                    cwd,
-                    workingDir: dir,
-                    patterns: worker.getProjectFilePatterns(),
-                    ignore: worker.getWorkspaceIgnorePatterns(),
-                    gitignore,
-                });
-                debugLogArray(`Found project paths${suffix}`, workspaceProjectPaths);
+                const patterns = worker.getProjectFilePatterns();
+                const workspaceProjectPaths = await _glob({ ...sharedGlobOptions, patterns });
+                debugLogArray(`Found project paths (${name})`, workspaceProjectPaths);
                 workspaceProjectPaths.forEach(projectPath => principal.addProjectPath(projectPath));
             }
             {
-                const pluginWorkspaceEntryPaths = await _glob({
-                    cwd,
-                    workingDir: dir,
-                    patterns: worker.getPluginEntryFilePatterns(),
-                    ignore: worker.getWorkspaceIgnorePatterns(),
-                    gitignore,
-                });
-                debugLogArray(`Found plugin entry paths${suffix}`, pluginWorkspaceEntryPaths);
+                const patterns = worker.getPluginEntryFilePatterns();
+                const pluginWorkspaceEntryPaths = await _glob({ ...sharedGlobOptions, patterns });
+                debugLogArray(`Found plugin entry paths (${name})`, pluginWorkspaceEntryPaths);
                 principal.addEntryPaths(pluginWorkspaceEntryPaths);
                 principal.skipExportsAnalysisFor(pluginWorkspaceEntryPaths);
             }
             {
-                const pluginWorkspaceProjectPaths = await _glob({
-                    cwd,
-                    workingDir: dir,
-                    patterns: worker.getPluginProjectFilePatterns(),
-                    ignore: worker.getWorkspaceIgnorePatterns(),
-                    gitignore,
-                });
-                debugLogArray(`Found plugin project paths${suffix}`, pluginWorkspaceProjectPaths);
+                const patterns = worker.getPluginProjectFilePatterns();
+                const pluginWorkspaceProjectPaths = await _glob({ ...sharedGlobOptions, patterns });
+                debugLogArray(`Found plugin project paths (${name})`, pluginWorkspaceProjectPaths);
                 pluginWorkspaceProjectPaths.forEach(projectPath => principal.addProjectPath(projectPath));
                 principal.skipExportsAnalysisFor(pluginWorkspaceProjectPaths);
             }
             {
-                const configurationEntryPaths = await _glob({
-                    cwd,
-                    workingDir: dir,
-                    patterns: compact(worker.getPluginConfigPatterns()),
-                    ignore: worker.getWorkspaceIgnorePatterns(),
-                    gitignore,
-                });
-                debugLogArray(`Found plugin configuration paths${suffix}`, configurationEntryPaths);
+                const patterns = compact(worker.getPluginConfigPatterns());
+                const configurationEntryPaths = await _glob({ ...sharedGlobOptions, patterns });
+                debugLogArray(`Found plugin configuration paths (${name})`, configurationEntryPaths);
                 principal.addEntryPaths(configurationEntryPaths);
                 principal.skipExportsAnalysisFor(configurationEntryPaths);
             }
         }
         if (chief.resolvedConfigFilePath)
             principal.addEntryPath(chief.resolvedConfigFilePath);
-        if (report.dependencies || report.unlisted || report.files) {
-            await worker.findDependenciesByPlugins();
-            const { referencedDependencies, peerDependencies, installedBinaries, entryFiles, enabledPlugins } = worker.getFinalDependencies();
-            deputy.addPeerDependencies(name, peerDependencies);
-            deputy.setInstalledBinaries(name, installedBinaries);
-            principal.addEntryPaths(entryFiles);
-            enabledPluginsStore.set(name, enabledPlugins);
-            referencedDependencies.forEach(([filePath, specifier]) => {
-                const [isAdded, packageName] = deputy.maybeAddReferencedExternalDependency(workspace, specifier);
-                if (!isAdded) {
-                    if (!ignoreDependencies.includes(specifier)) {
-                        collector.addIssue({ type: 'unlisted', filePath, symbol: specifier });
-                    }
+        const dependencies = await worker.findAllDependencies();
+        const { referencedDependencies, peerDependencies, installedBinaries, entryFiles, enabledPlugins } = dependencies;
+        deputy.addPeerDependencies(name, peerDependencies);
+        deputy.setInstalledBinaries(name, installedBinaries);
+        principal.addEntryPaths(entryFiles);
+        enabledPluginsStore.set(name, enabledPlugins);
+        referencedDependencies.forEach(([filePath, specifier]) => {
+            const [isAdded, packageName] = deputy.maybeAddReferencedExternalDependency(workspace, specifier);
+            if (!isAdded) {
+                if (!ignoreDependencies.includes(specifier)) {
+                    collector.addIssue({ type: 'unlisted', filePath, symbol: specifier });
                 }
-                else if (packageName && packageName !== specifier) {
-                    const workspace = workspaces.find(workspace => workspace.pkgName === packageName);
-                    if (workspace) {
-                        const relativeSpecifier = specifier.replace(new RegExp(`^${packageName}`), '.');
-                        const filePath = findFileWithExtensions(workspace.dir, relativeSpecifier, DEFAULT_EXTENSIONS);
-                        if (filePath) {
-                            principal.addEntryPath(filePath);
-                        }
+            }
+            else if (packageName && packageName !== specifier) {
+                const workspace = chief.findWorkspaceByPackageName(packageName);
+                if (workspace) {
+                    const relativeSpecifier = specifier.replace(new RegExp(`^${packageName}`), '.');
+                    const filePath = findFileWithExtensions(workspace.dir, relativeSpecifier, DEFAULT_EXTENSIONS);
+                    if (filePath) {
+                        principal.addEntryPath(filePath);
                     }
                 }
-            });
-        }
+            }
+        });
     }
     const principals = factory.getPrincipals();
     for (const principal of principals) {
@@ -200,46 +144,44 @@ export const main = async (unresolvedConfiguration) => {
         const importedSymbols = new Map();
         const analyzeSourceFile = (filePath) => {
             collector.counters.processed++;
-            if (report.files || report.dependencies || report.unlisted || report.unresolved) {
-                const workspace = chief.findWorkspace(filePath);
-                if (workspace) {
-                    const { internalImports, unresolvedImports, externalImports, exports, duplicateExports } = principal.analyzeSourceFile(filePath);
-                    if (exports.size > 0) {
-                        exportedSymbols.set(filePath, exports);
+            const workspace = chief.findWorkspaceByFilePath(filePath);
+            if (workspace) {
+                const { imports, exports, duplicateExports } = principal.analyzeSourceFile(filePath);
+                const { internal, external, unresolved } = imports;
+                if (exports.size > 0)
+                    exportedSymbols.set(filePath, exports);
+                for (const [specifierFilePath, importItems] of internal.entries()) {
+                    const importedWorkspace = chief.findWorkspaceByFilePath(specifierFilePath);
+                    if (importedWorkspace && importedWorkspace !== workspace) {
+                        external.add(importItems.specifier);
+                    }
+                    if (!importedSymbols.has(specifierFilePath)) {
+                        importedSymbols.set(specifierFilePath, importItems);
                     }
-                    for (const [specifierFilePath, importItems] of internalImports.entries()) {
-                        const importedWorkspace = chief.findWorkspace(specifierFilePath);
-                        if (importedWorkspace && importedWorkspace !== workspace) {
-                            externalImports.add(importItems.specifier);
+                    else {
+                        const importedModule = importedSymbols.get(specifierFilePath);
+                        for (const identifier of importItems.symbols) {
+                            importedModule.symbols.add(identifier);
                         }
-                        if (!importedSymbols.has(specifierFilePath)) {
-                            importedSymbols.set(specifierFilePath, importItems);
-                        }
-                        else {
-                            const importedModule = importedSymbols.get(specifierFilePath);
-                            for (const identifier of importItems.symbols) {
-                                importedModule.symbols.add(identifier);
-                            }
-                            if (importItems.isReExported) {
-                                importedModule.isReExported = importItems.isReExported;
-                                importedModule.isReExportedBy.add(filePath);
-                            }
+                        if (importItems.isReExported) {
+                            importedModule.isReExported = importItems.isReExported;
+                            importedModule.isReExportedBy.add(filePath);
                         }
                     }
-                    duplicateExports.forEach(symbols => {
-                        const symbol = symbols.join('|');
-                        collector.addIssue({ type: 'duplicates', filePath, symbol, symbols });
-                    });
-                    externalImports.forEach(specifier => {
-                        const [isAdded, packageName] = deputy.maybeAddReferencedExternalDependency(workspace, specifier);
-                        if (!isAdded && packageName) {
-                            collector.addIssue({ type: 'unlisted', filePath, symbol: specifier });
-                        }
-                    });
-                    unresolvedImports.forEach(moduleSpecifier => {
-                        collector.addIssue({ type: 'unresolved', filePath, symbol: moduleSpecifier });
-                    });
                 }
+                duplicateExports.forEach(symbols => {
+                    const symbol = symbols.join('|');
+                    collector.addIssue({ type: 'duplicates', filePath, symbol, symbols });
+                });
+                external.forEach(specifier => {
+                    const [isAdded, packageName] = deputy.maybeAddReferencedExternalDependency(workspace, specifier);
+                    if (!isAdded && packageName) {
+                        collector.addIssue({ type: 'unlisted', filePath, symbol: specifier });
+                    }
+                });
+                unresolved.forEach(moduleSpecifier => {
+                    collector.addIssue({ type: 'unresolved', filePath, symbol: moduleSpecifier });
+                });
             }
         };
         const isExportedInEntryFile = (importedModule) => {
@@ -250,9 +192,9 @@ export const main = async (unresolvedConfiguration) => {
             const hasFile = (file) => entryPaths.has(file) || isExportedInEntryFile(importedSymbols.get(file));
             return isReExported ? Array.from(isReExportedBy).some(hasFile) : false;
         };
-        progress.updateMessage('Running async compilers...');
+        console.cast('Running async compilers...');
         await principal.runAsyncCompilers();
-        progress.updateMessage('Connecting the dots...');
+        console.cast('Connecting the dots...');
         const analyzedFiles = new Set();
         let size = principal.entryPaths.size;
         let round = 0;
@@ -269,7 +211,7 @@ export const main = async (unresolvedConfiguration) => {
         const unusedFiles = principal.getUnreferencedFiles();
         collector.addFilesIssues(unusedFiles);
         collector.setTotalFileCount(analyzedFiles.size + unusedFiles.length);
-        progress.updateMessage('Analyzing source files...');
+        console.cast('Analyzing source files...');
         for (const [filePath, exportItems] of exportedSymbols.entries()) {
             const importedModule = importedSymbols.get(filePath);
             if (importedModule) {
@@ -318,6 +260,6 @@ export const main = async (unresolvedConfiguration) => {
             devDependencyIssues.forEach(issue => collector.addIssue(issue));
     }
     const { issues, counters } = collector.getIssues();
-    progress.removeProgress();
+    console.clear();
     return { report, issues, counters };
 };

package/dist/issue-collector.d.ts

@@ -1,24 +1,17 @@
-import { LineRewriter } from './util/log.js';
-import type { Issue, Report } from './types/issues.js';
+import type { Issue } from './types/issues.js';
 type IssueCollectorOptions = {
     cwd: string;
-    report?: Report;
 };
 export declare class IssueCollector {
-    report: Report;
+    cwd: string;
     issues: import("./types/issues.js").Issues;
     counters: import("./types/issues.js").Counters;
-    lineRewriter: LineRewriter;
-    pluginEntryFile: Set<string>;
     referencedFiles: Set<string>;
-    cwd: string;
-    constructor({ cwd, report }: IssueCollectorOptions);
+    constructor({ cwd }: IssueCollectorOptions);
     setTotalFileCount(count: number): void;
     addFilesIssues(filePaths: string[]): void;
     addIssue(issue: Issue): void;
-    setReport(report: Report): void;
     getIssues(): {
-        report: Report;
         issues: import("./types/issues.js").Issues;
         counters: import("./types/issues.js").Counters;
     };

package/dist/issue-collector.js

@@ -1,22 +1,12 @@
-import { initReport, initIssues, initCounters } from './issues/initializers.js';
-import { LineRewriter } from './util/log.js';
+import { initIssues, initCounters } from './issues/initializers.js';
 import { relative } from './util/path.js';
 export class IssueCollector {
-    report;
-    issues;
-    counters;
-    lineRewriter;
-    pluginEntryFile;
-    referencedFiles;
     cwd;
-    constructor({ cwd, report }) {
-        this.lineRewriter = new LineRewriter();
+    issues = initIssues();
+    counters = initCounters();
+    referencedFiles = new Set();
+    constructor({ cwd }) {
         this.cwd = cwd;
-        this.report = report ?? initReport();
-        this.issues = initIssues();
-        this.counters = initCounters();
-        this.pluginEntryFile = new Set();
-        this.referencedFiles = new Set();
     }
     setTotalFileCount(count) {
         this.counters.total = count;
@@ -38,12 +28,8 @@ export class IssueCollector {
             this.counters[issue.type]++;
         }
     }
-    setReport(report) {
-        this.report = report;
-    }
     getIssues() {
         return {
-            report: this.report,
             issues: this.issues,
             counters: this.counters,
         };

package/dist/issues/initializers.d.ts

@@ -1,4 +1,3 @@
-import { Issues, Counters, Report } from '../types/issues.js';
+import { Issues, Counters } from '../types/issues.js';
 export declare const initIssues: () => Issues;
 export declare const initCounters: () => Counters;
-export declare const initReport: () => Report;

package/dist/issues/initializers.js

@@ -8,4 +8,3 @@ export const initCounters = () => ({
     processed: 0,
     total: 0,
 });
-export const initReport = () => Object.fromEntries(ISSUE_TYPES.map(issueType => [issueType, true]));

package/dist/manifest/helpers.d.ts

@@ -1 +1,7 @@
-export declare const getPackageManifest: (workingDir: string, packageName: string, isRoot: boolean, cwd: string) => Promise<any>;
+type Options = {
+    dir: string;
+    packageName: string;
+    cwd: string;
+};
+export declare const getPackageManifest: ({ dir, packageName, cwd }: Options) => Promise<any>;
+export {};

package/dist/manifest/helpers.js

@@ -1,11 +1,11 @@
 import { join } from '../util/path.js';
 import { _require } from '../util/require.js';
-export const getPackageManifest = async (workingDir, packageName, isRoot, cwd) => {
+export const getPackageManifest = async ({ dir, packageName, cwd }) => {
     try {
-        return _require(join(workingDir, 'node_modules', packageName, 'package.json'));
+        return _require(join(dir, 'node_modules', packageName, 'package.json'));
     }
     catch (error) {
-        if (!isRoot) {
+        if (dir !== cwd) {
             try {
                 return _require(join(cwd, 'node_modules', packageName, 'package.json'));
             }

package/dist/manifest/index.d.ts

@@ -4,12 +4,11 @@ import type { PackageJson } from 'type-fest';
 type Options = {
     config: WorkspaceConfiguration;
     manifest: PackageJson;
-    isRoot: boolean;
     isProduction: boolean;
     dir: string;
     cwd: string;
 };
-export declare const findDependencies: ({ config, manifest, isRoot, isProduction, dir, cwd }: Options) => Promise<{
+export declare const findDependencies: ({ config, manifest, isProduction, dir, cwd }: Options) => Promise<{
     dependencies: string[];
     peerDependencies: PeerDependencies;
     installedBinaries: InstalledBinaries;

package/dist/manifest/index.js

@@ -1,7 +1,7 @@
 import { _getReferencesFromScripts } from '../util/binaries/index.js';
 import { timerify } from '../util/performance.js';
 import { getPackageManifest } from './helpers.js';
-const findManifestDependencies = async ({ config, manifest, isRoot, isProduction, dir, cwd }) => {
+const findManifestDependencies = async ({ config, manifest, isProduction, dir, cwd }) => {
     const { ignoreBinaries } = config;
     const scriptFilter = isProduction ? ['start', 'postinstall'] : [];
     const referencedDependencies = new Set();
@@ -20,7 +20,7 @@ const findManifestDependencies = async ({ config, manifest, isRoot, isProduction
     const installedBinaries = new Map();
     const packageNames = [...Object.keys(manifest.dependencies ?? {}), ...Object.keys(manifest.devDependencies ?? {})];
     for (const packageName of packageNames) {
-        const manifest = await getPackageManifest(dir, packageName, isRoot, cwd);
+        const manifest = await getPackageManifest({ dir, packageName, cwd });
         if (manifest) {
             const binaries = typeof manifest.bin === 'string' ? [packageName] : Object.keys(manifest.bin ?? {});
             binaries.forEach(binaryName => {

package/dist/progress-updater.d.ts

@@ -1,13 +1,12 @@
-import { LineRewriter } from './util/log.js';
-type ProgressUpdaterOptions = {
-    isShowProgress?: boolean;
-};
-export declare class ProgressUpdater {
-    lineRewriter: LineRewriter;
-    isShowProgress: boolean;
-    constructor({ isShowProgress }: ProgressUpdaterOptions);
-    setIsShowProgress(isShowProgress: boolean): void;
-    updateMessage(message: string): void;
-    removeProgress(): void;
+export declare class ConsoleStreamer {
+    isEnabled: boolean;
+    private lines;
+    constructor({ isEnabled }: {
+        isEnabled?: boolean | undefined;
+    });
+    private clearLines;
+    private resetLines;
+    private update;
+    cast(message: string): void;
+    clear(): void;
 }
-export {};

package/dist/progress-updater.js

@@ -1,22 +1,34 @@
-import { LineRewriter } from './util/log.js';
-export class ProgressUpdater {
-    lineRewriter;
-    isShowProgress = false;
-    constructor({ isShowProgress = false }) {
-        this.lineRewriter = new LineRewriter();
-        this.setIsShowProgress(isShowProgress);
+export class ConsoleStreamer {
+    isEnabled = false;
+    lines = 0;
+    constructor({ isEnabled = false }) {
+        this.isEnabled = isEnabled;
     }
-    setIsShowProgress(isShowProgress) {
-        this.isShowProgress = isShowProgress;
+    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);
     }
-    updateMessage(message) {
-        if (!this.isShowProgress)
+    resetLines() {
+        this.clearLines(this.lines);
+    }
+    update(messages) {
+        this.resetLines();
+        process.stdout.write(messages.join('\n') + '\n');
+        this.lines = messages.length;
+    }
+    cast(message) {
+        if (!this.isEnabled)
             return;
-        this.lineRewriter.update([message]);
+        this.update([message]);
     }
-    removeProgress() {
-        if (!this.isShowProgress)
+    clear() {
+        if (!this.isEnabled)
             return;
-        this.lineRewriter.resetLines();
+        this.resetLines();
     }
 }

package/dist/project-principal.d.ts

@@ -38,9 +38,11 @@ export declare class ProjectPrincipal {
     private getProgramSourceFiles;
     getUnreferencedFiles(): string[];
     analyzeSourceFile(filePath: string): {
-        internalImports: import("./types/ast.js").Imports;
-        unresolvedImports: Set<string>;
-        externalImports: Set<string>;
+        imports: {
+            internal: import("./types/ast.js").Imports;
+            unresolved: Set<string>;
+            external: Set<string>;
+        };
         exports: import("./types/ast.js").ExportItems;
         duplicateExports: string[][];
     };

package/dist/project-principal.js

@@ -107,17 +107,19 @@ export class ProjectPrincipal {
         const sourceFile = this.backend.program?.getSourceFile(filePath);
         if (!sourceFile)
             throw new Error(`Unable to find ${filePath}`);
-        const options = { skipTypeOnly: !this.isReportTypes, skipExports: this.skipExportsAnalysis.has(filePath) };
-        const { internalImports, unresolvedImports, externalImports, exports, duplicateExports } = getImportsAndExports(sourceFile, options);
-        const finalUnresolvedImports = new Set();
-        unresolvedImports.forEach(specifier => {
+        const skipTypeOnly = !this.isReportTypes;
+        const skipExports = this.skipExportsAnalysis.has(filePath);
+        const { imports, exports, duplicateExports } = getImportsAndExports(sourceFile, { skipTypeOnly, skipExports });
+        const { internal, unresolved, external } = imports;
+        const unresolvedImports = new Set();
+        unresolved.forEach(specifier => {
             if (specifier.startsWith('http')) {
                 return;
             }
             const resolvedModule = this.resolveModule(specifier, filePath);
             if (resolvedModule) {
                 if (resolvedModule.isExternalLibraryImport) {
-                    externalImports.add(specifier);
+                    external.add(specifier);
                 }
                 else {
                     this.addEntryPath(resolvedModule.resolvedFileName);
@@ -125,19 +127,27 @@ export class ProjectPrincipal {
             }
             else {
                 if (/^(@|[a-z])/.test(specifier)) {
-                    externalImports.add(specifier);
+                    external.add(specifier);
                 }
                 else {
                     const ext = extname(specifier);
                     if (!ext || (ext !== '.json' && !IGNORED_FILE_EXTENSIONS.includes(ext))) {
-                        finalUnresolvedImports.add(specifier);
+                        unresolvedImports.add(specifier);
                     }
                     else {
                     }
                 }
             }
         });
-        return { internalImports, unresolvedImports: finalUnresolvedImports, externalImports, exports, duplicateExports };
+        return {
+            imports: {
+                internal,
+                unresolved: unresolvedImports,
+                external,
+            },
+            exports,
+            duplicateExports,
+        };
     }
     resolveModule(specifier, filePath = specifier) {
         const module = ts.resolveModuleName(specifier, filePath, this.compilerOptions, this.backend.languageServiceHost);

package/dist/typescript/ast-walker.d.ts

@@ -5,9 +5,11 @@ type Options = {
     skipExports: boolean;
 };
 export declare const getImportsAndExports: (sourceFile: BoundSourceFile, options: Options) => {
-    internalImports: Imports;
-    externalImports: Set<string>;
-    unresolvedImports: Set<string>;
+    imports: {
+        internal: Imports;
+        external: Set<string>;
+        unresolved: Set<string>;
+    };
     exports: ExportItems;
     duplicateExports: string[][];
 };

package/dist/typescript/ast-walker.js

@@ -339,5 +339,13 @@ export const getImportsAndExports = (sourceFile, options) => {
     };
     visit(sourceFile);
     const duplicateExports = Object.values(aliasedExports);
-    return { internalImports, externalImports, unresolvedImports, exports, duplicateExports };
+    return {
+        imports: {
+            internal: internalImports,
+            external: externalImports,
+            unresolved: unresolvedImports,
+        },
+        exports,
+        duplicateExports,
+    };
 };

package/dist/util/get-included-issue-types.d.ts

@@ -0,0 +1,16 @@
+import type { Report } from '../types/issues.js';
+type CLIArguments = {
+    include: string[];
+    exclude: string[];
+    dependencies: boolean;
+    exports: boolean;
+};
+type Options = {
+    isProduction?: boolean;
+    include?: string[];
+    exclude?: string[];
+    dependencies?: boolean;
+    exports?: boolean;
+};
+export declare const getIncludedIssueTypes: (cliArgs: CLIArguments, { include, exclude, isProduction }?: Options) => Report;
+export {};

package/dist/util/get-included-issue-types.js

@@ -0,0 +1,30 @@
+import { ISSUE_TYPES } from '../constants.js';
+export const getIncludedIssueTypes = (cliArgs, { include = [], exclude = [], isProduction = false } = {}) => {
+    if (cliArgs.dependencies) {
+        cliArgs.include = [...cliArgs.include, 'dependencies', 'unlisted', 'unresolved'];
+    }
+    if (cliArgs.exports) {
+        const exports = ['exports', 'nsExports', 'classMembers', 'types', 'nsTypes', 'enumMembers', 'duplicates'];
+        cliArgs.include = [...cliArgs.include, ...exports];
+    }
+    const normalizedIncludesArg = cliArgs.include.map(value => value.split(',')).flat();
+    const normalizedExcludesArg = cliArgs.exclude.map(value => value.split(',')).flat();
+    const excludes = exclude.filter(exclude => !normalizedIncludesArg.includes(exclude));
+    const includes = include.filter(include => !normalizedExcludesArg.includes(include));
+    const _include = [normalizedIncludesArg, includes].flat();
+    const _exclude = [normalizedExcludesArg, excludes].flat();
+    if (isProduction) {
+        _exclude.push('types');
+        _exclude.push('nsTypes');
+        _exclude.push('enumMembers');
+        _exclude.push('devDependencies');
+    }
+    else {
+        if (_include.includes('dependencies'))
+            _include.push('devDependencies');
+        if (_exclude.includes('dependencies'))
+            _exclude.push('devDependencies');
+    }
+    const included = (_include.length > 0 ? _include : ISSUE_TYPES).filter(group => !_exclude.includes(group));
+    return ISSUE_TYPES.reduce((types, group) => ((types[group] = included.includes(group)), types), {});
+};

package/dist/util/resolve-included-issue-types.d.ts

@@ -1,4 +1,4 @@
-import type { Report } from '../types/issues.js';
+import type { IncludedIssueTypes } from '../types/issues.js';
 type CLIArguments = {
     include: string[];
     exclude: string[];
@@ -12,5 +12,5 @@ type Options = {
     dependencies?: boolean;
     exports?: boolean;
 };
-export declare const resolveIncludedIssueTypes: (cliArgs: CLIArguments, { include, exclude, isProduction }?: Options) => Report;
+export declare const getIncludedIssueTypes: (cliArgs: CLIArguments, { include, exclude, isProduction }?: Options) => IncludedIssueTypes;
 export {};

package/dist/util/resolve-included-issue-types.js

@@ -1,5 +1,5 @@
 import { ISSUE_TYPES } from '../constants.js';
-export const resolveIncludedIssueTypes = (cliArgs, { include = [], exclude = [], isProduction = false } = {}) => {
+export const getIncludedIssueTypes = (cliArgs, { include = [], exclude = [], isProduction = false } = {}) => {
     if (cliArgs.dependencies) {
         cliArgs.include = [...cliArgs.include, 'dependencies', 'unlisted', 'unresolved'];
     }

package/dist/util/tsconfig-loader.js

@@ -3,6 +3,6 @@ import { isFile } from './fs.js';
 export const loadTSConfig = async (tsConfigFilePath) => {
     if (isFile(tsConfigFilePath)) {
         const config = ts.readConfigFile(tsConfigFilePath, ts.sys.readFile);
-        return config.config;
+        return config.config.compilerOptions;
     }
 };

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "2.0.0-alpha.3";
+export declare const version = "2.0.0-alpha.4";

package/dist/version.js

@@ -1 +1 @@
-export const version = '2.0.0-alpha.3';
+export const version = '2.0.0-alpha.4';

package/dist/workspace-worker.d.ts

@@ -4,36 +4,36 @@ import type { PackageJson } from 'type-fest';
 type WorkspaceManagerOptions = {
     name: string;
     dir: string;
+    cwd: string;
     config: WorkspaceConfiguration;
     manifest: PackageJson;
-    rootWorkspaceConfig: WorkspaceConfiguration;
-    rootConfig: Configuration;
+    rootIgnore: Configuration['ignore'];
     negatedWorkspacePatterns: string[];
-    rootWorkspaceDir: string;
+    enabledPluginsInAncestors: string[];
     isProduction: boolean;
 };
 type ReferencedDependencies = Set<[string, string]>;
 export declare class WorkspaceWorker {
     name: string;
     dir: string;
+    cwd: string;
     config: WorkspaceConfiguration;
-    rootWorkspaceConfig: WorkspaceConfiguration;
-    rootConfig: Configuration;
     manifest: PackageJson;
-    rootWorkspaceDir: string;
+    isProduction: boolean;
+    rootIgnore: Configuration['ignore'];
+    negatedWorkspacePatterns: string[];
+    enabledPluginsInAncestors: string[];
+    enabled: Record<PluginName, boolean>;
+    enabledPlugins: PluginName[];
     referencedDependencies: ReferencedDependencies;
     peerDependencies: PeerDependencies;
     installedBinaries: InstalledBinaries;
     entryFiles: Set<string>;
-    negatedWorkspacePatterns: string[];
-    enabled: Record<PluginName, boolean>;
-    enabledPlugins: PluginName[];
-    isRoot: boolean;
-    isProduction: boolean;
-    constructor({ name, dir, config, rootWorkspaceConfig, rootConfig, negatedWorkspacePatterns, manifest, rootWorkspaceDir, isProduction, }: WorkspaceManagerOptions);
+    constructor({ name, dir, cwd, config, manifest, isProduction, rootIgnore, negatedWorkspacePatterns, enabledPluginsInAncestors, }: WorkspaceManagerOptions);
+    init(): Promise<void>;
+    private setEnabledPlugins;
+    private initReferencedDependencies;
     private getConfigForPlugin;
-    setEnabledPlugins(enabledPluginsInAncestors: string[]): Promise<void>;
-    initReferencedDependencies(): Promise<void>;
     getEntryFilePatterns(): string[];
     getProjectFilePatterns(): string[];
     getPluginEntryFilePatterns(isIncludeProductionEntryFiles?: boolean): string[];
@@ -43,14 +43,14 @@ export declare class WorkspaceWorker {
     getProductionProjectFilePatterns(): string[];
     getProductionPluginEntryFilePatterns(): string[];
     private getConfigurationEntryFilePattern;
-    getWorkspaceIgnorePatterns(): string[];
-    findDependenciesByPlugins(): Promise<void>;
-    getFinalDependencies(): {
+    getIgnorePatterns(): string[];
+    private findDependenciesByPlugins;
+    findAllDependencies(): Promise<{
         peerDependencies: PeerDependencies;
         installedBinaries: InstalledBinaries;
         referencedDependencies: ReferencedDependencies;
         entryFiles: Set<string>;
         enabledPlugins: ("typescript" | "babel" | "capacitor" | "changesets" | "commitlint" | "cypress" | "eslint" | "gatsby" | "husky" | "jest" | "markdownlint" | "mocha" | "next" | "nx" | "nyc" | "playwright" | "postcss" | "prettier" | "remark" | "remix" | "rollup" | "sentry" | "storybook" | "stryker" | "vitest" | "webpack" | "githubActions" | "lefthook" | "lintStaged" | "npmPackageJsonLint" | "releaseIt" | "typedoc")[];
-    };
+    }>;
 }
 export {};

package/dist/workspace-worker.js

@@ -1,4 +1,4 @@
-import { ROOT_WORKSPACE_NAME, TEST_FILE_PATTERNS } from './constants.js';
+import { TEST_FILE_PATTERNS } from './constants.js';
 import * as npm from './manifest/index.js';
 import * as plugins from './plugins/index.js';
 import { debugLogArray, debugLogObject } from './util/debug.js';
@@ -8,45 +8,48 @@ const negatedTestFilePatterns = TEST_FILE_PATTERNS.map(negate);
 export class WorkspaceWorker {
     name;
     dir;
+    cwd;
     config;
-    rootWorkspaceConfig;
-    rootConfig;
     manifest;
-    rootWorkspaceDir;
+    isProduction;
+    rootIgnore;
+    negatedWorkspacePatterns = [];
+    enabledPluginsInAncestors;
+    enabled;
+    enabledPlugins = [];
     referencedDependencies = new Set();
     peerDependencies = new Map();
     installedBinaries = new Map();
     entryFiles = new Set();
-    negatedWorkspacePatterns = [];
-    enabled;
-    enabledPlugins = [];
-    isRoot;
-    isProduction;
-    constructor({ name, dir, config, rootWorkspaceConfig, rootConfig, negatedWorkspacePatterns, manifest, rootWorkspaceDir, isProduction, }) {
+    constructor({ name, dir, cwd, config, manifest, isProduction, rootIgnore, negatedWorkspacePatterns, enabledPluginsInAncestors, }) {
         this.name = name;
         this.dir = dir;
+        this.cwd = cwd;
         this.config = config;
-        this.isRoot = name === ROOT_WORKSPACE_NAME;
+        this.manifest = manifest;
         this.isProduction = isProduction;
-        this.rootConfig = rootConfig;
-        this.rootWorkspaceConfig = rootWorkspaceConfig;
-        this.rootWorkspaceDir = rootWorkspaceDir;
+        this.rootIgnore = rootIgnore;
         this.negatedWorkspacePatterns = negatedWorkspacePatterns;
-        this.manifest = manifest;
+        this.enabledPluginsInAncestors = enabledPluginsInAncestors;
         this.enabled = Object.keys(plugins).reduce((enabled, pluginName) => ({ ...enabled, [pluginName]: false }), {});
     }
-    getConfigForPlugin(pluginName) {
-        return this.config[pluginName] ?? { config: null, entry: null, project: null };
+    async init() {
+        await this.setEnabledPlugins();
+        await this.initReferencedDependencies();
     }
-    async setEnabledPlugins(enabledPluginsInAncestors) {
-        const { manifest } = this;
-        const dependencies = new Set([Object.keys(manifest?.dependencies ?? {}), Object.keys(manifest?.devDependencies ?? {})].flat());
+    async setEnabledPlugins() {
+        const manifest = this.manifest;
+        const deps = Object.keys(manifest.dependencies ?? {});
+        const devDeps = Object.keys(manifest.devDependencies ?? {});
+        const dependencies = new Set([...deps, ...devDeps]);
         const pluginEntries = Object.entries(plugins);
         for (const [pluginName, plugin] of pluginEntries) {
-            const isEnabled = this.config[pluginName] !== false;
-            const isEnabledInAncestor = enabledPluginsInAncestors.includes(pluginName);
-            this.enabled[pluginName] =
-                isEnabled && (isEnabledInAncestor || (await plugin.isEnabled({ cwd: this.dir, manifest, dependencies })));
+            if (this.config[pluginName] === false)
+                continue;
+            const isEnabledInAncestor = this.enabledPluginsInAncestors.includes(pluginName);
+            if (isEnabledInAncestor || (await plugin.isEnabled({ cwd: this.dir, manifest, dependencies }))) {
+                this.enabled[pluginName] = true;
+            }
         }
         this.enabledPlugins = pluginEntries.filter(([name]) => this.enabled[name]).map(([name]) => name);
         const enabledPluginNames = this.enabledPlugins.map(name => plugins[name].NAME);
@@ -56,10 +59,9 @@ export class WorkspaceWorker {
         const { dependencies, peerDependencies, installedBinaries, entryFiles } = await npm.findDependencies({
             config: this.config,
             manifest: this.manifest,
-            isRoot: this.isRoot,
             isProduction: this.isProduction,
             dir: this.dir,
-            cwd: this.rootWorkspaceDir,
+            cwd: this.cwd,
         });
         const filePath = join(this.dir, 'package.json');
         dependencies.forEach(dependency => this.referencedDependencies.add([filePath, dependency]));
@@ -67,6 +69,9 @@ export class WorkspaceWorker {
         this.peerDependencies = peerDependencies;
         this.installedBinaries = installedBinaries;
     }
+    getConfigForPlugin(pluginName) {
+        return this.config[pluginName] ?? { config: null, entry: null, project: null };
+    }
     getEntryFilePatterns() {
         const { entry } = this.config;
         if (entry.length === 0)
@@ -187,10 +192,12 @@ export class WorkspaceWorker {
         }
         return [];
     }
-    getWorkspaceIgnorePatterns() {
-        return [...this.rootConfig.ignore, ...this.config.ignore.map(pattern => prependDirToPattern(this.name, pattern))];
+    getIgnorePatterns() {
+        return [...this.rootIgnore, ...this.config.ignore.map(pattern => prependDirToPattern(this.name, pattern))];
     }
     async findDependenciesByPlugins() {
+        const cwd = this.dir;
+        const ignore = this.getIgnorePatterns();
         for (const [pluginName, plugin] of Object.entries(plugins)) {
             const isIncludePlugin = this.isProduction ? `PRODUCTION_ENTRY_FILE_PATTERNS` in plugin : true;
             if (this.enabled[pluginName] && isIncludePlugin) {
@@ -200,8 +207,6 @@ export class WorkspaceWorker {
                     if (!pluginConfig)
                         continue;
                     const patterns = this.getConfigurationEntryFilePattern(pluginName);
-                    const cwd = this.dir;
-                    const ignore = this.getWorkspaceIgnorePatterns();
                     const configFilePaths = await _pureGlob({ patterns, cwd, ignore });
                     debugLogArray(`Found ${plugin.NAME} config file paths`, configFilePaths);
                     if (configFilePaths.length === 0)
@@ -224,13 +229,15 @@ export class WorkspaceWorker {
                         entryFiles.forEach(entryFile => pluginEntryFiles.add(entryFile));
                     }
                     debugLogArray(`Dependencies referenced in ${plugin.NAME}`, pluginDependencies);
-                    if (pluginEntryFiles.size > 0)
+                    if (pluginEntryFiles.size > 0) {
                         debugLogArray(`Entry files referenced in ${plugin.NAME}`, pluginEntryFiles);
+                    }
                 }
             }
         }
     }
-    getFinalDependencies() {
+    async findAllDependencies() {
+        await this.findDependenciesByPlugins();
         return {
             peerDependencies: this.peerDependencies,
             installedBinaries: this.installedBinaries,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "2.0.0-alpha.3",
+  "version": "2.0.0-alpha.4",
   "description": "Find unused files, dependencies and exports in your TypeScript and JavaScript projects",
   "homepage": "https://github.com/webpro/knip",
   "repository": "github:webpro/knip",