knip 6.24.0 → 6.25.0

package/dist/ConfigurationChief.d.ts

@@ -207,6 +207,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        eve?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         execa?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -227,6 +232,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        fumadocs?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         gatsby?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -852,7 +862,7 @@ export declare class ConfigurationChief {
         ignoreMembers?: (string | RegExp)[] | undefined;
         ignoreUnresolved?: (string | RegExp)[] | undefined;
         ignoreExportsUsedInFile?: boolean | Record<string, boolean | undefined> | undefined;
-        ignoreIssues?: Record<string, ("binaries" | "catalog" | "dependencies" | "devDependencies" | "duplicates" | "enumMembers" | "exports" | "files" | "namespaceMembers" | "nsExports" | "nsTypes" | "optionalPeerDependencies" | "types" | "unlisted" | "unresolved")[]> | undefined;
+        ignoreIssues?: Record<string, ("binaries" | "catalog" | "cycles" | "dependencies" | "devDependencies" | "duplicates" | "enumMembers" | "exports" | "files" | "namespaceMembers" | "nsExports" | "nsTypes" | "optionalPeerDependencies" | "types" | "unlisted" | "unresolved")[]> | undefined;
         includeEntryExports?: boolean | undefined;
     };
     getIgnores(workspaceName: string): {
@@ -899,10 +909,12 @@ export declare class ConfigurationChief {
         drizzle?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         eleventy?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         eslint?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
+        eve?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         execa?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         expo?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         "expressive-code"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         fast?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
+        fumadocs?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         gatsby?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         "github-action"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         "github-actions"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;

package/dist/ConfigurationChief.js

@@ -34,6 +34,7 @@ const defaultConfig = {
     ignoreBinaries: [],
     ignoreDependencies: [],
     ignoreFiles: [],
+    cycles: {},
     ignoreIssues: {},
     ignoreMembers: [],
     ignoreUnresolved: [],
@@ -103,6 +104,7 @@ export class ConfigurationChief {
         const ignoreMembers = rawConfig.ignoreMembers ?? [];
         const ignoreUnresolved = rawConfig.ignoreUnresolved ?? [];
         const ignoreExportsUsedInFile = rawConfig.ignoreExportsUsedInFile ?? false;
+        const cycles = rawConfig.cycles ?? {};
         const ignoreIssues = rawConfig.ignoreIssues ?? {};
         const ignoreWorkspaces = rawConfig.ignoreWorkspaces ?? defaultConfig.ignoreWorkspaces;
         const isIncludeEntryExports = rawConfig.includeEntryExports ?? this.isIncludeEntryExports;
@@ -116,6 +118,7 @@ export class ConfigurationChief {
         return {
             ignore,
             ignoreFiles,
+            cycles,
             ignoreBinaries,
             ignoreDependencies,
             ignoreMembers,

package/dist/ProjectPrincipal.d.ts

@@ -4,6 +4,7 @@ import type { AsyncCompilers, SyncCompilers } from './compilers/types.ts';
 import type { GetImportsAndExportsOptions, IgnoreExportsUsedInFile, PluginVisitorContext, PluginVisitorObject } from './types/config.ts';
 import type { FileNode, ModuleGraph } from './types/module-graph.ts';
 import type { Paths } from './types/project.ts';
+import type { ResolveGlobPattern } from './typescript/resolve-module-names.ts';
 import { SourceFileManager } from './typescript/SourceFileManager.ts';
 import type { MainOptions } from './util/create-options.ts';
 import type { ToSourceFilePath, WorkspaceManifestHandler } from './util/to-source-path.ts';
@@ -27,6 +28,7 @@ export declare class ProjectPrincipal {
     private findWorkspaceManifestImports;
     fileManager: SourceFileManager;
     private resolveModule;
+    resolveGlobPattern: ResolveGlobPattern;
     resolvedFiles: Set<string>;
     deletedFiles: Set<string>;
     private onPathAdded;

package/dist/ProjectPrincipal.js

@@ -6,7 +6,7 @@ import { DEFAULT_EXTENSIONS } from './constants.js';
 import { _getImportsAndExports } from './typescript/get-imports-and-exports.js';
 import { createBunShellVisitor } from './typescript/visitors/script-visitors.js';
 import { buildVisitor } from './typescript/visitors/walk.js';
-import { createCustomModuleResolver } from './typescript/resolve-module-names.js';
+import { createCustomModuleResolver, createGlobAliasResolver } from './typescript/resolve-module-names.js';
 import { SourceFileManager } from './typescript/SourceFileManager.js';
 import { compact } from './util/array.js';
 import { timerify } from './util/Performance.js';
@@ -21,6 +21,7 @@ export class ProjectPrincipal {
         sourceText: '',
         addScript: () => { },
         addImport: () => { },
+        addImportGlob: () => { },
         markExportRegistered: () => { },
     };
     pluginVisitorObjects = [];
@@ -37,6 +38,7 @@ export class ProjectPrincipal {
     findWorkspaceManifestImports;
     fileManager;
     resolveModule = () => undefined;
+    resolveGlobPattern = pattern => [pattern];
     resolvedFiles = new Set();
     deletedFiles = new Set();
     onPathAdded;
@@ -90,6 +92,7 @@ export class ProjectPrincipal {
         const scopedPaths = this.paths.size > 0 ? Array.from(this.paths, ([scope, paths]) => ({ scope, paths })) : undefined;
         const scopedRootDirs = this.rootDirs.size > 0 ? Array.from(this.rootDirs, ([scope, rootDirs]) => ({ scope, rootDirs })) : undefined;
         this.resolveModule = createCustomModuleResolver({ scopedPaths, scopedRootDirs }, customCompilerExtensions, this.toSourceFilePath, this.findWorkspaceManifestImports, this.tsConfigFile);
+        this.resolveGlobPattern = createGlobAliasResolver(scopedPaths);
     }
     readFile(filePath) {
         return this.fileManager.readFile(filePath);

package/dist/binaries/bash-parser.js

@@ -5,6 +5,7 @@ import { toBinary, toDeferResolve } from '../util/input.js';
 import { extractBinary, isValidBinary } from '../util/modules.js';
 import { relative } from '../util/path.js';
 import { truncate } from '../util/string.js';
+import { walkCommands } from '../util/scripts.js';
 import { resolve as fallbackResolve } from './fallback.js';
 import KnownResolvers from './resolvers/index.js';
 import { resolve as resolverFromPlugins } from './plugins.js';
@@ -46,93 +47,64 @@ export const getDependenciesFromScript = (script, options) => {
     const processScript = (s) => {
         collectFunctionNames(s.commands);
         const pending = [];
-        const mainDeps = getDependenciesFromStatements(s.commands, pending);
+        const mainDeps = [];
+        for (const statement of s.commands) {
+            for (const command of walkCommands(statement.command))
+                mainDeps.push(...processCommand(command, pending));
+        }
         const expansionDeps = pending.flatMap(inner => processScript(inner));
         return [...mainDeps, ...expansionDeps];
     };
-    const getDependenciesFromStatements = (statements, pending) => statements.flatMap(stmt => getDependenciesFromNode(stmt.command, pending));
-    const getDependenciesFromNode = (node, pending) => {
-        switch (node.type) {
-            case 'Command': {
-                const text = node.name?.value;
-                const binary = text ? extractBinary(text) : text;
-                if (node.name)
-                    collectExpansionScripts(node.name, pending);
-                for (const prefix of node.prefix)
-                    if (prefix.value)
-                        collectExpansionScripts(prefix.value, pending);
-                for (const suffix of node.suffix)
-                    collectExpansionScripts(suffix, pending);
-                if (!binary || binary === '.' || binary === 'source' || binary === '[')
-                    return [];
-                if (binary.startsWith('-') || binary.startsWith('..'))
-                    return [];
-                if (definedFunctions.has(binary))
-                    return [];
-                const args = node.suffix.map(w => w.value);
-                if (['!', 'test'].includes(binary))
-                    return fromArgs(args);
-                const fromNodeOptions = node.prefix
-                    .filter(a => a.name === 'NODE_OPTIONS' && a.value)
-                    .map(a => a.value.value)
-                    .map(arg => parseNodeArgs(arg.split(' ')))
-                    .filter(args => args.require)
-                    .flatMap(arg => arg.require)
-                    .map(id => toDeferResolve(id));
-                if (binary in KnownResolvers) {
-                    const resolver = KnownResolvers[binary];
-                    return resolver(binary, args, { ...options, fromArgs });
-                }
-                if (pluginArgsMap.has(binary)) {
-                    return [...resolverFromPlugins(binary, args, { ...options, fromArgs }), ...fromNodeOptions];
-                }
-                if (spawningBinaries.includes(binary)) {
-                    const rest = node.suffix
-                        .filter(w => w.text !== '--')
-                        .map(w => w.text)
-                        .join(' ');
-                    return [toBinary(binary), ...getDependenciesFromScript(rest, options)];
-                }
-                if (binary in Plugins) {
-                    const inputs = fallbackResolve(binary, args, { ...options, fromArgs });
-                    if (options.knownBinsOnly)
-                        for (const input of inputs)
-                            input.optional = true;
-                    return [...inputs, ...fromNodeOptions];
-                }
-                if (options.knownBinsOnly && !text?.startsWith('.'))
-                    return [];
-                return [...fallbackResolve(binary, args, { ...options, fromArgs }), ...fromNodeOptions];
-            }
-            case 'AndOr':
-            case 'Pipeline':
-                return node.commands.flatMap(n => getDependenciesFromNode(n, pending));
-            case 'If':
-                return [
-                    ...getDependenciesFromStatements(node.clause.commands, pending),
-                    ...getDependenciesFromStatements(node.then.commands, pending),
-                    ...(node.else ? getDependenciesFromNode(node.else, pending) : []),
-                ];
-            case 'While':
-                return [
-                    ...getDependenciesFromStatements(node.clause.commands, pending),
-                    ...getDependenciesFromStatements(node.body.commands, pending),
-                ];
-            case 'For':
-            case 'Select':
-            case 'Subshell':
-            case 'BraceGroup':
-                return getDependenciesFromStatements(node.body.commands, pending);
-            case 'CompoundList':
-                return getDependenciesFromStatements(node.commands, pending);
-            case 'Function':
-            case 'Coproc':
-                return getDependenciesFromNode(node.body, pending);
-            case 'Statement':
-                return getDependenciesFromNode(node.command, pending);
-            default:
-                return [];
+    const processCommand = (node, pending) => {
+        const text = node.name?.value;
+        const binary = text ? extractBinary(text) : text;
+        if (node.name)
+            collectExpansionScripts(node.name, pending);
+        for (const prefix of node.prefix)
+            if (prefix.value)
+                collectExpansionScripts(prefix.value, pending);
+        for (const suffix of node.suffix)
+            collectExpansionScripts(suffix, pending);
+        if (!binary || binary === '.' || binary === 'source' || binary === '[')
+            return [];
+        if (binary.startsWith('-') || binary.startsWith('..'))
+            return [];
+        if (definedFunctions.has(binary))
+            return [];
+        const args = node.suffix.map(w => w.value);
+        if (['!', 'test'].includes(binary))
+            return fromArgs(args);
+        const fromNodeOptions = node.prefix
+            .filter(a => a.name === 'NODE_OPTIONS' && a.value)
+            .map(a => a.value.value)
+            .map(arg => parseNodeArgs(arg.split(' ')))
+            .filter(args => args.require)
+            .flatMap(arg => arg.require)
+            .map(id => toDeferResolve(id));
+        if (binary in KnownResolvers) {
+            const resolver = KnownResolvers[binary];
+            return resolver(binary, args, { ...options, fromArgs });
         }
+        if (pluginArgsMap.has(binary)) {
+            return [...resolverFromPlugins(binary, args, { ...options, fromArgs }), ...fromNodeOptions];
+        }
+        if (spawningBinaries.includes(binary)) {
+            const rest = node.suffix
+                .filter(w => w.text !== '--')
+                .map(w => w.text)
+                .join(' ');
+            return [toBinary(binary), ...getDependenciesFromScript(rest, options)];
+        }
+        if (binary in Plugins) {
+            const inputs = fallbackResolve(binary, args, { ...options, fromArgs });
+            if (options.knownBinsOnly)
+                for (const input of inputs)
+                    input.optional = true;
+            return [...inputs, ...fromNodeOptions];
+        }
+        if (options.knownBinsOnly && !text?.startsWith('.'))
+            return [];
+        return [...fallbackResolve(binary, args, { ...options, fromArgs }), ...fromNodeOptions];
     };
     try {
         const parsed = parse(script);

package/dist/binaries/index.js

@@ -1,3 +1,4 @@
+import { SCRIPT_INTERPOLATION } from '../constants.js';
 import { fromBinary, isBinary, isDependency } from '../util/input.js';
 import { timerify } from '../util/Performance.js';
 import { getDependenciesFromScript } from './bash-parser.js';
@@ -8,6 +9,8 @@ const getInputsFromScripts = (npmScripts, options) => {
     for (const input of results) {
         if (!input.specifier)
             continue;
+        if (input.specifier.includes(SCRIPT_INTERPOLATION))
+            continue;
         if (isDependency(input) && input.specifier.startsWith('http'))
             continue;
         if (isBinary(input) && !/^\b/.test(fromBinary(input)))

package/dist/compilers/index.d.ts

@@ -153,6 +153,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     } | undefined;
+    eve?: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    } | undefined;
     execa?: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;
@@ -173,6 +178,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     } | undefined;
+    fumadocs?: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    } | undefined;
     gatsby?: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;
@@ -789,7 +799,7 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         project?: string | string[] | undefined;
     } | undefined;
     $schema?: string | undefined;
-    rules?: Partial<Record<"binaries" | "catalog" | "dependencies" | "devDependencies" | "duplicates" | "enumMembers" | "exports" | "files" | "namespaceMembers" | "nsExports" | "nsTypes" | "optionalPeerDependencies" | "types" | "unlisted" | "unresolved", "error" | "off" | "warn">> | undefined;
+    rules?: Partial<Record<"binaries" | "catalog" | "cycles" | "dependencies" | "devDependencies" | "duplicates" | "enumMembers" | "exports" | "files" | "namespaceMembers" | "nsExports" | "nsTypes" | "optionalPeerDependencies" | "types" | "unlisted" | "unresolved", "error" | "off" | "warn">> | undefined;
     entry?: string | string[] | undefined;
     project?: string | string[] | undefined;
     paths?: Record<string, string[]> | undefined;
@@ -800,15 +810,19 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
     ignoreMembers?: (string | RegExp)[] | undefined;
     ignoreUnresolved?: (string | RegExp)[] | undefined;
     ignoreExportsUsedInFile?: boolean | Record<string, boolean | undefined> | undefined;
-    ignoreIssues?: Record<string, ("binaries" | "catalog" | "dependencies" | "devDependencies" | "duplicates" | "enumMembers" | "exports" | "files" | "namespaceMembers" | "nsExports" | "nsTypes" | "optionalPeerDependencies" | "types" | "unlisted" | "unresolved")[]> | undefined;
+    ignoreIssues?: Record<string, ("binaries" | "catalog" | "cycles" | "dependencies" | "devDependencies" | "duplicates" | "enumMembers" | "exports" | "files" | "namespaceMembers" | "nsExports" | "nsTypes" | "optionalPeerDependencies" | "types" | "unlisted" | "unresolved")[]> | undefined;
+    cycles?: {
+        allow?: string[][] | undefined;
+        dynamicImports?: boolean | undefined;
+    } | undefined;
     ignoreWorkspaces?: string[] | undefined;
     includeEntryExports?: boolean | undefined;
     compilers?: Record<string, true | CompilerAsync | CompilerSync> | undefined;
     tags?: string[] | undefined;
     treatConfigHintsAsErrors?: boolean | undefined;
     treatTagHintsAsErrors?: boolean | undefined;
-    include?: ("binaries" | "catalog" | "dependencies" | "devDependencies" | "duplicates" | "enumMembers" | "exports" | "files" | "namespaceMembers" | "nsExports" | "nsTypes" | "optionalPeerDependencies" | "types" | "unlisted" | "unresolved")[] | undefined;
-    exclude?: ("binaries" | "catalog" | "dependencies" | "devDependencies" | "duplicates" | "enumMembers" | "exports" | "files" | "namespaceMembers" | "nsExports" | "nsTypes" | "optionalPeerDependencies" | "types" | "unlisted" | "unresolved")[] | undefined;
+    include?: ("binaries" | "catalog" | "cycles" | "dependencies" | "devDependencies" | "duplicates" | "enumMembers" | "exports" | "files" | "namespaceMembers" | "nsExports" | "nsTypes" | "optionalPeerDependencies" | "types" | "unlisted" | "unresolved")[] | undefined;
+    exclude?: ("binaries" | "catalog" | "cycles" | "dependencies" | "devDependencies" | "duplicates" | "enumMembers" | "exports" | "files" | "namespaceMembers" | "nsExports" | "nsTypes" | "optionalPeerDependencies" | "types" | "unlisted" | "unresolved")[] | undefined;
     workspaces?: Record<string, {
         angular?: string | boolean | string[] | {
             config?: string | string[] | undefined;
@@ -960,6 +974,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        eve?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         execa?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -980,6 +999,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        fumadocs?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         gatsby?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -1605,7 +1629,7 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         ignoreMembers?: (string | RegExp)[] | undefined;
         ignoreUnresolved?: (string | RegExp)[] | undefined;
         ignoreExportsUsedInFile?: boolean | Record<string, boolean | undefined> | undefined;
-        ignoreIssues?: Record<string, ("binaries" | "catalog" | "dependencies" | "devDependencies" | "duplicates" | "enumMembers" | "exports" | "files" | "namespaceMembers" | "nsExports" | "nsTypes" | "optionalPeerDependencies" | "types" | "unlisted" | "unresolved")[]> | undefined;
+        ignoreIssues?: Record<string, ("binaries" | "catalog" | "cycles" | "dependencies" | "devDependencies" | "duplicates" | "enumMembers" | "exports" | "files" | "namespaceMembers" | "nsExports" | "nsTypes" | "optionalPeerDependencies" | "types" | "unlisted" | "unresolved")[]> | undefined;
         includeEntryExports?: boolean | undefined;
     }> | undefined;
     syncCompilers: Record<string, true | CompilerSync>;

package/dist/constants.d.ts

@@ -16,7 +16,7 @@ export declare const IGNORED_DEPENDENCIES: Set<string>;
 export declare const IGNORED_RUNTIME_DEPENDENCIES: Set<string>;
 export declare const FOREIGN_FILE_EXTENSIONS: Set<string>;
 export declare const IGNORE_DEFINITELY_TYPED: Set<string>;
-export declare const ISSUE_TYPES: readonly ['files', 'dependencies', 'devDependencies', 'optionalPeerDependencies', 'unlisted', 'binaries', 'unresolved', 'exports', 'nsExports', 'types', 'nsTypes', 'enumMembers', 'namespaceMembers', 'duplicates', 'catalog'];
+export declare const ISSUE_TYPES: readonly ['files', 'dependencies', 'devDependencies', 'optionalPeerDependencies', 'unlisted', 'binaries', 'unresolved', 'exports', 'nsExports', 'types', 'nsTypes', 'enumMembers', 'namespaceMembers', 'duplicates', 'catalog', 'cycles'];
 export declare const ISSUE_TYPE_TITLE: {
     readonly files: 'Unused files';
     readonly dependencies: 'Unused dependencies';
@@ -33,6 +33,7 @@ export declare const ISSUE_TYPE_TITLE: {
     readonly namespaceMembers: 'Unused exported namespace members';
     readonly duplicates: 'Duplicate exports';
     readonly catalog: 'Unused catalog entries';
+    readonly cycles: 'Circular dependencies';
 };
 export declare const SYMBOL_TYPE: {
     readonly CLASS: 'class';
@@ -53,6 +54,7 @@ export declare const FIX_FLAGS: {
 };
 export declare const SIDE_EFFECTS = "__side-effects";
 export declare const OPAQUE = "__opaque";
+export declare const SCRIPT_INTERPOLATION = "$__knip__";
 export declare const IMPORT_FLAGS: {
     readonly NONE: 0;
     readonly RE_EXPORT: number;
@@ -62,4 +64,6 @@ export declare const IMPORT_FLAGS: {
     readonly OPTIONAL: number;
     readonly SIDE_EFFECTS: number;
     readonly OPAQUE: number;
+    readonly AUGMENT: number;
+    readonly DYNAMIC: number;
 };

package/dist/constants.js

@@ -186,6 +186,7 @@ export const ISSUE_TYPES = [
     'namespaceMembers',
     'duplicates',
     'catalog',
+    'cycles',
 ];
 export const ISSUE_TYPE_TITLE = {
     files: 'Unused files',
@@ -203,6 +204,7 @@ export const ISSUE_TYPE_TITLE = {
     namespaceMembers: 'Unused exported namespace members',
     duplicates: 'Duplicate exports',
     catalog: 'Unused catalog entries',
+    cycles: 'Circular dependencies',
 };
 export const SYMBOL_TYPE = {
     CLASS: 'class',
@@ -223,6 +225,7 @@ export const FIX_FLAGS = {
 };
 export const SIDE_EFFECTS = '__side-effects';
 export const OPAQUE = '__opaque';
+export const SCRIPT_INTERPOLATION = '$__knip__';
 export const IMPORT_FLAGS = {
     NONE: 0,
     RE_EXPORT: 1 << 0,
@@ -232,4 +235,6 @@ export const IMPORT_FLAGS = {
     OPTIONAL: 1 << 4,
     SIDE_EFFECTS: 1 << 5,
     OPAQUE: 1 << 6,
+    AUGMENT: 1 << 7,
+    DYNAMIC: 1 << 8,
 };

package/dist/graph/analyze.js

@@ -1,12 +1,27 @@
 import { createGraphExplorer } from '../graph-explorer/explorer.js';
-import { getIssueType, hasStrictlyEnumReferences } from '../graph-explorer/utils.js';
+import { getIgnoredCycleImportFlags, getIssueType, getRuntimeImport, hasStrictlyEnumReferences, } from '../graph-explorer/utils.js';
 import traceReporter from '../reporters/trace.js';
 import { shouldCountRefs } from '../typescript/ast-nodes.js';
 import { getPackageNameFromModuleSpecifier } from '../util/modules.js';
-import { perfObserver } from '../util/Performance.js';
+import { relative } from '../util/path.js';
+import { perfObserver, timerify } from '../util/Performance.js';
 import { findMatch } from '../util/regex.js';
 import { getShouldIgnoreHandler, getShouldIgnoreTagHandler, isAlwaysIgnored } from '../util/tag.js';
 import { INTERNAL_TAG } from '../constants.js';
+const toCyclePathKey = (path) => {
+    const length = path.length > 1 && path[0] === path[path.length - 1] ? path.length - 1 : path.length;
+    return path.slice(0, length).join('\0');
+};
+const getAllowedCyclePaths = (cycles) => {
+    if (!cycles.allow?.length)
+        return;
+    const paths = new Set();
+    for (const path of cycles.allow)
+        if (path.length > 0)
+            paths.add(toCyclePathKey(path));
+    return paths;
+};
+const isAllowedCycle = (symbols, paths) => paths?.has(toCyclePathKey(symbols.map(s => s.symbol))) ?? false;
 export const analyze = async ({ analyzedFiles, counselor, chief, collector, deputy, entryPaths, graph, streamer, unreferencedFiles, options, }) => {
     const shouldIgnore = getShouldIgnoreHandler(options.isProduction);
     const shouldIgnoreTags = getShouldIgnoreTagHandler(options.tags);
@@ -210,6 +225,26 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                 }
             }
         }
+        if (options.isReportCycles) {
+            const cyclesConfig = chief.config.cycles;
+            const allowedCyclePaths = getAllowedCyclePaths(cyclesConfig);
+            const ignoredFlags = getIgnoredCycleImportFlags(cyclesConfig.dynamicImports ?? false);
+            for (const cycle of timerify(explorer.findAllCycles, 'findAllCycles')(ignoredFlags)) {
+                const filePath = cycle[0];
+                const ws = chief.findWorkspaceByFilePath(filePath);
+                if (!ws)
+                    continue;
+                const symbols = cycle.slice(0, -1).map((file, index) => {
+                    const node = graph.get(file);
+                    const edge = node && getRuntimeImport(node, cycle[index + 1], ignoredFlags);
+                    return edge ? { symbol: relative(options.cwd, file), ...edge } : { symbol: relative(options.cwd, file) };
+                });
+                if (isAllowedCycle(symbols, allowedCyclePaths))
+                    continue;
+                const symbol = symbols.map(s => s.symbol).join(' → ');
+                collector.addIssue({ type: 'cycles', filePath, workspace: ws.name, symbol, symbols, fixes: [] });
+            }
+        }
         const unusedFiles = options.isReportFiles
             ? [...unreferencedFiles].filter(filePath => !analyzedFiles.has(filePath))
             : [];

package/dist/graph/build.js

@@ -10,6 +10,7 @@ import { tryRealpath } from '../util/fs.js';
 import { createManifest } from '../util/package-json.js';
 import { _glob, _syncGlob, negate, prependDirToPattern as prependDir } from '../util/glob.js';
 import { isAlias, isConfig, isDeferResolveEntry, isDeferResolveProductionEntry, isEntry, isIgnore, isProductionEntry, isProject, toProductionEntry, } from '../util/input.js';
+import { resolveImportGlobs } from '../typescript/glob-imports.js';
 import { loadTSConfig } from '../util/load-tsconfig.js';
 import { createFileNode, updateImportMap } from '../util/module-graph.js';
 import { getPackageNameFromModuleSpecifier, isStartsLikePackageName, sanitizeSpecifier } from '../util/modules.js';
@@ -382,6 +383,13 @@ export async function build({ chief, collector, counselor, deputy, principal, is
                         pp.addEntryPath(specifierFilePath, { skipExportsAnalysis: true });
                 }
             }
+            if (file.importGlobs.length > 0) {
+                const globbed = resolveImportGlobs(file.importGlobs, filePath, pp.resolveGlobPattern, workspace.dir);
+                for (const importedFilePath of globbed) {
+                    if (!isGitIgnored(importedFilePath))
+                        pp.addEntryPath(importedFilePath, { skipExportsAnalysis: true });
+                }
+            }
             file.imports.unresolved = unresolvedImports;
             const pluginRefs = externalRefsFromInputs?.get(filePath);
             if (pluginRefs)
@@ -393,6 +401,7 @@ export async function build({ chief, collector, counselor, deputy, principal, is
                 node.exports = file.exports;
                 node.duplicates = file.duplicates;
                 node.scripts = file.scripts;
+                node.importGlobs = file.importGlobs;
                 updateImportMap(node, file.imports.internal, graph);
                 node.internalImportCache = file.imports.internal;
             }

package/dist/graph-explorer/explorer.d.ts

@@ -13,6 +13,7 @@ export declare const createGraphExplorer: (graph: ModuleGraph, entryPaths: Set<s
     resolveDefinition: (filePath: string, identifier: string) => import("./operations/resolve-definition.ts").DefinitionResult | null;
     getUsage: (filePath: string, identifier: string) => import("./operations/get-usage.ts").UsageResult;
     findCycles: (filePath: string, maxDepth?: number) => import("../session/types.ts").Cycle[];
+    findAllCycles: (ignoredFlags?: number) => import("../session/types.ts").Cycle[];
     getContention: (filePath: string) => Map<string, import("../session/types.ts").ContentionDetails>;
     invalidateCache: () => void;
 };

package/dist/graph-explorer/explorer.js

@@ -1,5 +1,6 @@
 import { invalidateCache as invalidateCacheInternal } from './cache.js';
 import { buildExportsTree } from './operations/build-exports-tree.js';
+import { findAllCycles } from './operations/find-all-cycles.js';
 import { findCycles } from './operations/find-cycles.js';
 import { getContention } from './operations/get-contention.js';
 import { getDependencyUsage } from './operations/get-dependency-usage.js';
@@ -16,6 +17,7 @@ export const createGraphExplorer = (graph, entryPaths) => {
         resolveDefinition: (filePath, identifier) => resolveDefinition(graph, filePath, identifier),
         getUsage: (filePath, identifier) => getUsage(graph, entryPaths, filePath, identifier),
         findCycles: (filePath, maxDepth) => findCycles(graph, filePath, maxDepth),
+        findAllCycles: (ignoredFlags) => findAllCycles(graph, ignoredFlags),
         getContention: (filePath) => getContention(graph, filePath),
         invalidateCache: () => invalidateCacheInternal(graph),
     };

package/dist/graph-explorer/operations/find-all-cycles.d.ts

@@ -0,0 +1,3 @@
+import type { Cycle } from '../../session/types.ts';
+import type { ModuleGraph } from '../../types/module-graph.ts';
+export declare const findAllCycles: (graph: ModuleGraph, ignoredFlags?: number) => Cycle[];

package/dist/graph-explorer/operations/find-all-cycles.js

@@ -0,0 +1,43 @@
+import { getRuntimeSuccessors } from '../utils.js';
+const UNVISITED = undefined;
+const ON_STACK = 1;
+const DONE = 2;
+export const findAllCycles = (graph, ignoredFlags) => {
+    const cycles = [];
+    const state = new Map();
+    for (const root of graph.keys()) {
+        if (state.get(root) !== UNVISITED)
+            continue;
+        const path = [];
+        const indexOnPath = new Map();
+        const successorsStack = [];
+        const push = (filePath) => {
+            state.set(filePath, ON_STACK);
+            indexOnPath.set(filePath, path.length);
+            path.push(filePath);
+            const node = graph.get(filePath);
+            successorsStack.push((node ? getRuntimeSuccessors(node, ignoredFlags) : new Set()).values());
+        };
+        push(root);
+        while (path.length > 0) {
+            const current = path[path.length - 1];
+            const next = successorsStack[successorsStack.length - 1].next();
+            if (next.done) {
+                state.set(current, DONE);
+                indexOnPath.delete(current);
+                path.pop();
+                successorsStack.pop();
+                continue;
+            }
+            const successor = next.value;
+            const successorState = state.get(successor);
+            if (successorState === ON_STACK) {
+                cycles.push([...path.slice(indexOnPath.get(successor)), successor]);
+            }
+            else if (successorState === UNVISITED) {
+                push(successor);
+            }
+        }
+    }
+    return cycles;
+};

package/dist/graph-explorer/operations/find-cycles.js

@@ -1,3 +1,4 @@
+import { getRuntimeSuccessors } from '../utils.js';
 export const findCycles = (graph, filePath, maxDepth = 16) => {
     const cycles = [];
     const visited = new Set();
@@ -7,16 +8,9 @@ export const findCycles = (graph, filePath, maxDepth = 16) => {
         if (path.length > maxDepth)
             return;
         const node = graph.get(currentPath);
-        if (!node?.imports?.internal)
+        if (!node)
             return;
-        const nonTypeOnlyImports = new Set();
-        for (const _import of node.imports.imports) {
-            if (_import.filePath && !_import.isTypeOnly)
-                nonTypeOnlyImports.add(_import.filePath);
-        }
-        for (const [importedPath] of node.imports.internal) {
-            if (!nonTypeOnlyImports.has(importedPath))
-                continue;
+        for (const importedPath of getRuntimeSuccessors(node)) {
             if (importedPath === filePath) {
                 cycles.push([...path, importedPath]);
                 continue;