knip 6.27.0 → 6.29.0

package/dist/util/create-options.d.ts

@@ -460,6 +460,11 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        openclaw?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         orval?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -1373,6 +1378,11 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
                 entry?: string | string[] | undefined;
                 project?: string | string[] | undefined;
             } | undefined;
+            openclaw?: string | boolean | string[] | {
+                config?: string | string[] | undefined;
+                entry?: string | string[] | undefined;
+                project?: string | string[] | undefined;
+            } | undefined;
             orval?: string | boolean | string[] | {
                 config?: string | string[] | undefined;
                 entry?: string | string[] | undefined;

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

@@ -1,3 +1,4 @@
+import type { FSLike } from 'fdir';
 export declare const initGlobCache: (cacheLocation: string) => void;
 export declare const isGlobCacheEnabled: () => boolean;
 export declare const flushGlobCache: () => void;
@@ -7,6 +8,11 @@ export declare const computeGlobCacheKey: (input: {
     cwd: string;
     dir: string;
     gitignore: boolean;
+    gitignoreFingerprint: string;
 }) => string;
 export declare const getCachedGlob: (key: string) => string[] | undefined;
-export declare const setCachedGlob: (key: string, paths: string[], baseDir: string) => void;
+export declare const createDirTracker: () => {
+    dirs: Set<string>;
+    fs: Partial<FSLike>;
+};
+export declare const setCachedGlob: (key: string, paths: string[], baseDir: string, dirs?: Iterable<string>) => void;

package/dist/util/glob-cache.js

@@ -1,12 +1,18 @@
 import { createHash } from 'node:crypto';
 import fs from 'node:fs';
-import { createDiskCache, mtimeMatches } from './disk-cache.js';
-import { dirname } from './path.js';
+import { createDiskCache } from './disk-cache.js';
 const store = createDiskCache('glob');
-export const initGlobCache = store.init;
+const dirMtimeCache = new Map();
+export const initGlobCache = (cacheLocation) => {
+    dirMtimeCache.clear();
+    store.init(cacheLocation);
+};
 export const isGlobCacheEnabled = store.isEnabled;
 export const flushGlobCache = store.flush;
-export const clearGlobCache = store.clear;
+export const clearGlobCache = () => {
+    dirMtimeCache.clear();
+    store.clear();
+};
 export const computeGlobCacheKey = (input) => {
     const h = createHash('sha1');
     h.update(input.cwd);
@@ -15,15 +21,31 @@ export const computeGlobCacheKey = (input) => {
     h.update('\0');
     h.update(input.gitignore ? '1' : '0');
     h.update('\0');
+    h.update(input.gitignoreFingerprint);
+    h.update('\0');
     for (const p of input.patterns) {
         h.update(p);
         h.update('\0');
     }
     return h.digest('base64url');
 };
+const statDirMtime = (dir) => {
+    let mtime = dirMtimeCache.get(dir);
+    if (mtime === undefined) {
+        try {
+            const stat = fs.statSync(dir);
+            mtime = stat.isDirectory() ? stat.mtimeMs : Number.NaN;
+        }
+        catch {
+            mtime = Number.NaN;
+        }
+        dirMtimeCache.set(dir, mtime);
+    }
+    return mtime;
+};
 const validateEntry = (entry) => {
     for (const dir in entry.dirMtimes) {
-        if (!mtimeMatches(dir, entry.dirMtimes[dir]))
+        if (statDirMtime(dir) !== entry.dirMtimes[dir])
             return false;
     }
     return true;
@@ -38,33 +60,34 @@ export const getCachedGlob = (key) => {
     }
     return entry.paths;
 };
-const captureDirMtimes = (paths, baseDir) => {
+const trackReads = (native, dirs) => {
+    const tracked = function (path, ...rest) {
+        if (typeof path === 'string')
+            dirs.add(path);
+        return native.call(this, path, ...rest);
+    };
+    return tracked;
+};
+export const createDirTracker = () => {
     const dirs = new Set();
-    dirs.add(baseDir);
-    for (const p of paths) {
-        let d = dirname(p);
-        while (d.length >= baseDir.length) {
-            if (dirs.has(d))
-                break;
-            dirs.add(d);
-            const parent = dirname(d);
-            if (parent === d)
-                break;
-            d = parent;
-        }
-    }
+    return { dirs, fs: { readdir: trackReads(fs.readdir, dirs), readdirSync: trackReads(fs.readdirSync, dirs) } };
+};
+const stripTrailingSlash = (dir) => (dir.length > 1 && dir.endsWith('/') ? dir.slice(0, -1) : dir);
+const captureDirMtimes = (dirs, baseDir) => {
     const result = {};
-    for (const d of dirs) {
-        try {
-            const stat = fs.statSync(d);
-            if (stat.isDirectory())
-                result[d] = stat.mtimeMs;
-        }
-        catch {
-        }
+    const baseMtime = statDirMtime(baseDir);
+    if (!Number.isNaN(baseMtime))
+        result[baseDir] = baseMtime;
+    for (const dir of dirs) {
+        const d = stripTrailingSlash(dir);
+        if (d in result)
+            continue;
+        const mtime = statDirMtime(d);
+        if (!Number.isNaN(mtime))
+            result[d] = mtime;
     }
     return result;
 };
-export const setCachedGlob = (key, paths, baseDir) => {
-    store.set(key, { paths, dirMtimes: captureDirMtimes(paths, baseDir) });
+export const setCachedGlob = (key, paths, baseDir, dirs = []) => {
+    store.set(key, { paths, dirMtimes: captureDirMtimes(dirs, baseDir) });
 };

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);
             }
         }
     }
@@ -233,7 +258,12 @@ export async function glob(_patterns, options) {
         cachedGlobIgnores.set(options.dir, compact(_ignore));
     }
     const ignorePatterns = (cachedIgnores ?? _ignore).concat(negatedPatterns.map(pattern => pattern.slice(1)));
-    const { dir, label, ...fgOptions } = { ...options, ignore: ignorePatterns, expandDirectories: false };
+    const { dir, label, ...fgOptions } = {
+        ...options,
+        ignore: ignorePatterns,
+        expandDirectories: false,
+        followSymbolicLinks: false,
+    };
     const paths = await tinyGlob(patterns, fgOptions);
     debugLogObject(relative(options.cwd, dir), label ? `Finding ${label}` : 'Finding paths', () => ({
         patterns,
@@ -245,11 +275,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 +303,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/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/version.d.ts

@@ -1 +1 @@
-export declare const version = "6.27.0";
+export declare const version = "6.29.0";

package/dist/version.js

@@ -1 +1 @@
-export const version = '6.27.0';
+export const version = '6.29.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "6.27.0",
+  "version": "6.29.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"