knip 6.26.0 → 6.28.0

package/dist/util/glob-core.d.ts

@@ -13,11 +13,13 @@ export type Gitignores = {
     ignores: Set<string>;
     unignores: Set<string>;
 };
+export declare const getGitignoreFingerprint: () => string;
 export declare const findAndParseGitignores: (cwd: string, workspaceDirs?: Set<string>) => Promise<{
     gitignoreFiles: string[];
     ignores: Set<string>;
     unignores: Set<string>;
 }>;
 export declare function glob(_patterns: string[], options: GlobOptions): Promise<string[]>;
+export declare function reconcileGitignoredPaths(paths: string[], cwd: string): string[];
 export declare function getGitIgnoredHandler(options: Options, workspaceDirs?: Set<string>): Promise<(path: string) => boolean>;
 export {};

package/dist/util/glob-core.js

@@ -1,3 +1,4 @@
+import { createHash } from 'node:crypto';
 import { readFileSync } from 'node:fs';
 import { basename } from 'node:path';
 import { fdir } from 'fdir';
@@ -10,9 +11,25 @@ import { isDirectory, isFile } from './fs.js';
 import { getCachedGitignore, isGitignoreCacheEnabled, setCachedGitignore } from './gitignore-cache.js';
 import { timerify } from './Performance.js';
 import { expandIgnorePatterns, parseAndConvertGitignorePatterns } from './parse-and-convert-gitignores.js';
-import { dirname, join, relative, toPosix } from './path.js';
+import { dirname, isAbsolute, join, relative, toPosix } from './path.js';
 const cachedGitIgnores = new Map();
 const cachedGlobIgnores = new Map();
+let gitignoreReconciler;
+let gitignoreFingerprint = '';
+export const getGitignoreFingerprint = () => gitignoreFingerprint;
+const hashIgnores = (ignores, unignores) => {
+    const h = createHash('sha1');
+    for (const p of [...ignores].sort()) {
+        h.update(p);
+        h.update('\0');
+    }
+    h.update('\u0001');
+    for (const p of [...unignores].sort()) {
+        h.update(p);
+        h.update('\0');
+    }
+    return h.digest('base64url');
+};
 const isGitRoot = (dir) => isDirectory(dir, '.git') || isFile(dir, '.git');
 const getGitDir = (cwd) => {
     const dotGit = join(cwd, '.git');
@@ -194,15 +211,23 @@ export const findAndParseGitignores = async (cwd, workspaceDirs) => {
                 p = parent;
             }
         }
+        const isShadowed = new Map();
         for (const cacheForDir of cachedGitIgnores.values()) {
             for (const pattern of cacheForDir.ignores) {
-                const match = picomatch(pattern);
-                for (const p of unignorePaths) {
-                    if (match(p)) {
-                        cacheForDir.ignores.delete(pattern);
-                        break;
+                let shadowed = isShadowed.get(pattern);
+                if (shadowed === undefined) {
+                    const match = picomatch(pattern);
+                    shadowed = false;
+                    for (const p of unignorePaths) {
+                        if (match(p)) {
+                            shadowed = true;
+                            break;
+                        }
                     }
+                    isShadowed.set(pattern, shadowed);
                 }
+                if (shadowed)
+                    cacheForDir.ignores.delete(pattern);
             }
         }
     }
@@ -245,11 +270,24 @@ export async function glob(_patterns, options) {
     }));
     return paths;
 }
+export function reconcileGitignoredPaths(paths, cwd) {
+    if (!gitignoreReconciler || paths.length === 0)
+        return paths;
+    const isGitIgnored = gitignoreReconciler;
+    const result = [];
+    for (const path of paths)
+        if (!isGitIgnored(isAbsolute(path) ? path : join(cwd, path)))
+            result.push(path);
+    return result;
+}
 export async function getGitIgnoredHandler(options, workspaceDirs) {
     cachedGitIgnores.clear();
+    gitignoreReconciler = undefined;
+    gitignoreFingerprint = '';
     if (options.gitignore === false)
         return () => false;
     const { ignores, unignores } = await _parseFindGitignores(options.cwd, workspaceDirs);
+    gitignoreFingerprint = hashIgnores(ignores, unignores);
     const matcher = picomatch(expandIgnorePatterns(ignores), { ignore: expandIgnorePatterns(unignores) });
     const cache = new Map();
     const isGitIgnored = (filePath) => {
@@ -260,5 +298,7 @@ export async function getGitIgnoredHandler(options, workspaceDirs) {
         }
         return result;
     };
+    if (unignores.size > 0)
+        gitignoreReconciler = isGitIgnored;
     return isGitIgnored;
 }

package/dist/util/glob.d.ts

@@ -11,10 +11,13 @@ export declare const prependDirToPattern: (dir: string, pattern: string) => stri
 export declare const negate: (pattern: string) => string;
 export declare const hasProductionSuffix: (pattern: string) => boolean;
 export declare const hasNoProductionSuffix: (pattern: string) => boolean;
-export declare const _glob: ({ cwd, dir, patterns, gitignore, label }: GlobOptions) => Promise<string[]>;
-export declare const _syncGlob: ({ cwd, patterns }: {
+declare const defaultGlob: ({ cwd, dir, patterns, gitignore, label }: GlobOptions) => Promise<string[]>;
+declare const syncGlob: ({ cwd, patterns }: {
     cwd: string;
     patterns: string | string[];
 }) => string[];
-export declare const _dirGlob: ({ cwd, patterns, gitignore }: GlobOptions) => Promise<string[]>;
+declare const dirGlob: ({ cwd, patterns, gitignore }: GlobOptions) => Promise<string[]>;
+export declare const _glob: typeof defaultGlob;
+export declare const _syncGlob: typeof syncGlob;
+export declare const _dirGlob: typeof dirGlob;
 export {};

package/dist/util/glob.js

@@ -1,7 +1,7 @@
 import { globSync } from 'tinyglobby';
 import { compact } from './array.js';
-import { computeGlobCacheKey, getCachedGlob, isGlobCacheEnabled, setCachedGlob } from './glob-cache.js';
-import { glob } from './glob-core.js';
+import { computeGlobCacheKey, createDirTracker, getCachedGlob, isGlobCacheEnabled, setCachedGlob, } from './glob-cache.js';
+import { getGitignoreFingerprint, glob, reconcileGitignoredPaths } from './glob-core.js';
 import { timerify } from './Performance.js';
 import { isAbsolute, join, relative } from './path.js';
 const prepend = (pattern, relativePath) => isAbsolute(pattern.replace(/^!/, '')) ? pattern : prependDirToPattern(relativePath, pattern);
@@ -23,12 +23,16 @@ const defaultGlob = async ({ cwd, dir = cwd, patterns, gitignore = true, label }
     if (globPatterns[0].startsWith('!'))
         return [];
     const cacheEnabled = isGlobCacheEnabled();
-    const cacheKey = cacheEnabled ? computeGlobCacheKey({ patterns: globPatterns, cwd, dir, gitignore }) : '';
+    const gitignoreFingerprint = gitignore ? getGitignoreFingerprint() : '';
+    const cacheKey = cacheEnabled
+        ? computeGlobCacheKey({ patterns: globPatterns, cwd, dir, gitignore, gitignoreFingerprint })
+        : '';
     if (cacheEnabled) {
         const cached = getCachedGlob(cacheKey);
         if (cached)
-            return cached;
+            return gitignore ? reconcileGitignoredPaths(cached, cwd) : cached;
     }
+    const tracker = cacheEnabled ? createDirTracker() : undefined;
     const paths = await glob(globPatterns, {
         cwd,
         dir,
@@ -36,23 +40,33 @@ const defaultGlob = async ({ cwd, dir = cwd, patterns, gitignore = true, label }
         absolute: true,
         dot: true,
         label,
+        fs: tracker?.fs,
     });
     if (cacheEnabled && paths.length > 0)
-        setCachedGlob(cacheKey, paths, dir);
-    return paths;
+        setCachedGlob(cacheKey, paths, dir, tracker?.dirs);
+    return gitignore ? reconcileGitignoredPaths(paths, cwd) : paths;
 };
 const syncGlob = ({ cwd, patterns }) => {
     const cacheEnabled = isGlobCacheEnabled();
     const patternList = Array.isArray(patterns) ? patterns : [patterns];
-    const cacheKey = cacheEnabled ? computeGlobCacheKey({ patterns: patternList, cwd, dir: cwd, gitignore: false }) : '';
+    const cacheKey = cacheEnabled
+        ? computeGlobCacheKey({ patterns: patternList, cwd, dir: cwd, gitignore: false, gitignoreFingerprint: '' })
+        : '';
     if (cacheEnabled) {
         const cached = getCachedGlob(cacheKey);
         if (cached)
             return cached;
     }
-    const paths = globSync(patterns, { cwd, absolute: true, followSymbolicLinks: false, expandDirectories: false });
+    const tracker = cacheEnabled ? createDirTracker() : undefined;
+    const paths = globSync(patterns, {
+        cwd,
+        absolute: true,
+        followSymbolicLinks: false,
+        expandDirectories: false,
+        fs: tracker?.fs,
+    });
     if (cacheEnabled && paths.length > 0)
-        setCachedGlob(cacheKey, paths, cwd);
+        setCachedGlob(cacheKey, paths, cwd, tracker?.dirs);
     return paths;
 };
 const dirGlob = async ({ cwd, patterns, gitignore = true }) => glob(patterns, {

package/dist/util/loader.d.ts

@@ -1 +1,3 @@
-export declare const _load: (filePath: string) => Promise<any>;
+declare const load: (filePath: string) => Promise<any>;
+export declare const _load: typeof load;
+export {};

package/dist/util/package-json.d.ts

@@ -5,6 +5,13 @@ interface ExtendedPackageJson extends PackageJson {
     [INDENT]?: string;
     [NEWLINE]?: string;
 }
+export declare const getPackageMapTarget: (map: unknown, key: string) => {
+    target: any;
+    patternMatch?: undefined;
+} | {
+    target: unknown;
+    patternMatch: string;
+} | undefined;
 export declare const load: (filePath: string) => Promise<ExtendedPackageJson>;
 export declare const save: (filePath: string, content: ExtendedPackageJson) => Promise<void>;
 export declare const getEntrySpecifiersFromManifest: (manifest: PackageJson) => Set<string>;

package/dist/util/package-json.js

@@ -35,6 +35,43 @@ const getEntriesFromExports = (obj) => {
     }
     return values;
 };
+export const getPackageMapTarget = (map, key) => {
+    if (!map || typeof map !== 'object' || Array.isArray(map))
+        return key === '.' ? { target: map } : undefined;
+    const entries = Object.entries(map);
+    let hasSubpaths = false;
+    for (const [subpath, target] of entries) {
+        if (!subpath.startsWith('.') && !subpath.startsWith('#'))
+            continue;
+        hasSubpaths = true;
+        if (subpath === key)
+            return { target };
+    }
+    if (!hasSubpaths)
+        return key === '.' ? { target: map } : undefined;
+    let best;
+    for (const [subpath, target] of entries) {
+        const starIndex = subpath.indexOf('*');
+        if (starIndex < 0)
+            continue;
+        const prefix = subpath.slice(0, starIndex);
+        const suffix = subpath.slice(starIndex + 1);
+        if (!key.startsWith(prefix) || !key.endsWith(suffix) || key.length < prefix.length + suffix.length)
+            continue;
+        if (!best ||
+            prefix.length > best.prefixLength ||
+            (prefix.length === best.prefixLength && subpath.length > best.subpathLength)) {
+            best = {
+                target,
+                patternMatch: key.slice(prefix.length, key.length - suffix.length),
+                prefixLength: prefix.length,
+                subpathLength: subpath.length,
+            };
+        }
+    }
+    if (best)
+        return { target: best.target, patternMatch: best.patternMatch };
+};
 export const load = async (filePath) => {
     const file = await readFile(filePath, 'utf8');
     return parseJson(file);

package/dist/util/parse-and-convert-gitignores.d.ts

@@ -1,5 +1,5 @@
-export declare const toExtendedIgnorePattern: (pattern: string) => string;
-export declare const expandIgnorePatterns: (patterns: Iterable<string>) => string[];
+export declare const toExtendedIgnorePattern: (pattern: string, shallow?: boolean) => string;
+export declare const expandIgnorePatterns: (patterns: Iterable<string>, shallow?: boolean) => string[];
 export declare const convertGitignoreToPicomatchIgnorePatterns: (pattern: string) => {
     negated: boolean;
     pattern: string;

package/dist/util/parse-and-convert-gitignores.js

@@ -1,15 +1,15 @@
-export const toExtendedIgnorePattern = (pattern) => {
+export const toExtendedIgnorePattern = (pattern, shallow = false) => {
     if (pattern === '*' || pattern === '**')
         return pattern;
-    if (pattern.endsWith('/*'))
+    if (shallow && pattern.endsWith('/*'))
         return pattern;
     return `${pattern}/**`;
 };
-export const expandIgnorePatterns = (patterns) => {
+export const expandIgnorePatterns = (patterns, shallow = false) => {
     const result = [];
     for (const p of patterns) {
         result.push(p);
-        const ext = toExtendedIgnorePattern(p);
+        const ext = toExtendedIgnorePattern(p, shallow);
         if (ext !== p)
             result.push(ext);
     }

package/dist/util/reporter.js

@@ -3,9 +3,10 @@ import { _load } from './loader.js';
 import { isAbsolute, isInternal, resolve } from './path.js';
 export const runPreprocessors = async (processors, data) => {
     const preprocessors = await Promise.all(processors.map(proc => _load(isInternal(proc) && !isAbsolute(proc) ? resolve(proc) : proc)));
-    return preprocessors.length === 0
-        ? Promise.resolve(data)
-        : runPreprocessors(preprocessors.slice(1), preprocessors[0](data));
+    let result = data;
+    for (const preprocessor of preprocessors)
+        result = await preprocessor(result);
+    return result;
 };
 export const runReporters = async (reporter, options) => {
     const reporters = await Promise.all(reporter.map(async (reporter) => {

package/dist/util/resolve.d.ts

@@ -1,3 +1,4 @@
+export declare const extensionAlias: Record<string, string[]>;
 export declare const _resolveModuleSync: (specifier: string, basePath: string) => string | undefined;
 export declare const _createSyncModuleResolver: (extensions: string[], tsConfigFile?: string) => (specifier: string, basePath: string) => string | undefined;
 export declare function clearResolverCache(): void;

package/dist/util/resolve.js

@@ -2,7 +2,7 @@ import { ResolverFactory } from 'oxc-resolver';
 import { DEFAULT_EXTENSIONS, DTS_EXTENSIONS } from '../constants.js';
 import { timerify } from './Performance.js';
 import { toPosix } from './path.js';
-const extensionAlias = {
+export const extensionAlias = {
     '.js': ['.js', '.ts', '.tsx', '.d.ts'],
     '.jsx': ['.jsx', '.tsx'],
     '.mjs': ['.mjs', '.mts', '.d.mts'],

package/dist/util/to-source-path.d.ts

@@ -2,11 +2,12 @@ import type { SourceMap } from '../types/config.ts';
 import type { CompilerOptions } from '../types/project.ts';
 import type { ConfigurationChief, Workspace } from '../ConfigurationChief.ts';
 export declare const augmentWorkspace: (workspace: Workspace, dir: string, compilerOptions: CompilerOptions | undefined, pluginSourceMaps?: SourceMap[]) => void;
-export type WorkspaceManifestHandler = (filePath: string) => {
+export type WorkspacePackageTargetHandler = (specifier: string, filePath: string) => {
     dir: string;
-    imports: unknown;
+    target: unknown;
+    patternMatch?: string;
 } | undefined;
-export declare const getWorkspaceManifestHandler: (chief: ConfigurationChief) => WorkspaceManifestHandler;
+export declare const getWorkspacePackageTargetHandler: (chief: ConfigurationChief) => WorkspacePackageTargetHandler;
 export declare const getModuleSourcePathHandler: (chief: ConfigurationChief) => (filePath: string) => string | undefined;
 export declare const getToSourcePathsHandler: (chief: ConfigurationChief) => (specifiers: Set<string>, dir: string, extensions: string | undefined, label: string) => Promise<string[]>;
 export declare const toSourceMappedSpecifiers: (ws: Workspace | undefined, absSpecifier: string, extensions?: string) => string[];

package/dist/util/to-source-path.js

@@ -2,6 +2,8 @@ import { DEFAULT_EXTENSIONS } from '../constants.js';
 import { debugLog, debugLogArray } from './debug.js';
 import { findFileWithExtensions, isDirectory } from './fs.js';
 import { _glob, prependDirToPattern } from './glob.js';
+import { getPackageNameFromModuleSpecifier } from './modules.js';
+import { getPackageMapTarget } from './package-json.js';
 import { isAbsolute, isInternal, join, toRelative } from './path.js';
 const defaultExtensions = `.{${[...DEFAULT_EXTENSIONS].map(ext => ext.slice(1)).join(',')}}`;
 const hasTSExt = /(?<!\.d)\.(m|c)?tsx?$/;
@@ -41,15 +43,30 @@ const rewritePattern = (sourceMaps, absSpecifier, extensions) => {
             return r;
     }
 };
-export const getWorkspaceManifestHandler = (chief) => {
-    return (filePath) => {
-        const workspace = chief.findWorkspaceByFilePath(filePath);
+export const getWorkspacePackageTargetHandler = (chief) => {
+    return (specifier, filePath) => {
+        const isImports = specifier.startsWith('#');
+        let workspace;
+        let key = specifier;
+        if (isImports) {
+            workspace = chief.findWorkspaceByFilePath(filePath);
+        }
+        else {
+            const packageName = getPackageNameFromModuleSpecifier(specifier);
+            if (!packageName)
+                return;
+            workspace = chief.workspacesByPkgName.get(packageName);
+            key = packageName === specifier ? '.' : `.${specifier.slice(packageName.length)}`;
+        }
         if (!workspace)
             return;
         const manifest = chief.workspacePackages.get(workspace.name)?.manifest;
-        if (!manifest?.imports)
+        const map = isImports ? manifest?.imports : manifest?.exports;
+        if (!manifest || !map)
             return;
-        return { dir: workspace.dir, imports: manifest.imports };
+        const result = getPackageMapTarget(map, key);
+        if (result)
+            return { dir: workspace.dir, ...result };
     };
 };
 export const getModuleSourcePathHandler = (chief) => {

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "6.26.0";
+export declare const version = "6.28.0";

package/dist/version.js

@@ -1 +1 @@
-export const version = '6.26.0';
+export const version = '6.28.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "6.26.0",
+  "version": "6.28.0",
   "description": "Find and fix unused dependencies, exports and files in your TypeScript and JavaScript projects",
   "keywords": [
     "analysis",
@@ -81,25 +81,25 @@
     "formatly": "^0.3.0",
     "get-tsconfig": "4.14.0",
     "jiti": "^2.7.0",
-    "oxc-parser": "^0.137.0",
-    "oxc-resolver": "11.21.3",
-    "picomatch": "^4.0.4",
-    "smol-toml": "^1.6.1",
+    "oxc-parser": "^0.140.0",
+    "oxc-resolver": "11.24.2",
+    "picomatch": "^4.0.5",
+    "smol-toml": "^1.7.0",
     "strip-json-comments": "5.0.3",
     "tinyglobby": "^0.2.17",
-    "unbash": "^4.0.1",
+    "unbash": "^4.0.3",
     "yaml": "^2.9.0",
-    "zod": "^4.1.11"
+    "zod": "^4.4.3"
   },
   "devDependencies": {
     "@jest/types": "^30.4.1",
     "@types/bun": "^1.3.14",
     "@types/picomatch": "^4.0.3",
     "@types/webpack": "^5.28.5",
-    "@typescript/native-preview": "7.0.0-dev.20260619.1",
     "codeclimate-types": "^0.3.1",
-    "prettier": "^3.8.4",
-    "tsx": "^4.22.4"
+    "prettier": "^3.9.5",
+    "tsx": "^4.23.1",
+    "typescript": "7.0.2"
   },
   "engines": {
     "node": "^20.19.0 || >=22.12.0"
@@ -112,7 +112,7 @@
     "fmt": "oxfmt -c ../../.oxfmtrc.json --ignore-path ../../.prettierignore",
     "test": "node scripts/run-test.js",
     "prebuild": "pnpm run generate-plugin-defs && node rmdir.js dist",
-    "build": "tsgo",
+    "build": "tsc",
     "qa": "pnpm lint && pnpm build && pnpm knip && pnpm knip:production && pnpm test",
     "release": "NODE_OPTIONS=--no-deprecation release-it",
     "create-plugin": "node ./scripts/create-new-plugin.ts",

package/schema.json

@@ -726,6 +726,10 @@
           "title": "openapi-ts plugin configuration (https://knip.dev/reference/plugins/openapi-ts)",
           "$ref": "#/definitions/plugin"
         },
+        "openclaw": {
+          "title": "openclaw plugin configuration (https://knip.dev/reference/plugins/openclaw)",
+          "$ref": "#/definitions/plugin"
+        },
         "orval": {
           "title": "orval plugin configuration (https://knip.dev/reference/plugins/orval)",
           "$ref": "#/definitions/plugin"
@@ -942,6 +946,10 @@
           "title": "tauri plugin configuration (https://knip.dev/reference/plugins/tauri)",
           "$ref": "#/definitions/plugin"
         },
+        "temporal": {
+          "title": "temporal plugin configuration (https://knip.dev/reference/plugins/temporal)",
+          "$ref": "#/definitions/plugin"
+        },
         "travis": {
           "title": "travis plugin configuration (https://knip.dev/reference/plugins/travis)",
           "$ref": "#/definitions/plugin"