@j0hanz/fs-context-mcp 2.2.0 → 2.3.0

package/dist/config.d.ts

@@ -115,4 +115,3 @@ export declare function formatOperationSummary(summary: {
     truncated?: boolean;
     truncatedReason?: string;
 }): string;
-//# sourceMappingURL=config.d.ts.map

package/dist/config.js

@@ -28,4 +28,3 @@ export function formatOperationSummary(summary) {
         return '';
     return `\n[truncated: ${summary.truncatedReason ?? 'limit reached'}]`;
 }
-//# sourceMappingURL=config.js.map

package/dist/index.d.ts

@@ -1,3 +1,2 @@
 #!/usr/bin/env node
 export {};
-//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -69,4 +69,3 @@ main().catch((error) => {
     console.error('Fatal error:', error instanceof Error ? error.message : String(error));
     process.exit(1);
 });
-//# sourceMappingURL=index.js.map

package/dist/lib/constants.d.ts

@@ -20,4 +20,3 @@ export declare const SENSITIVE_FILE_ALLOWLIST: string[];
 export declare const KNOWN_BINARY_EXTENSIONS: Set<string>;
 export declare const DEFAULT_EXCLUDE_PATTERNS: string[];
 export declare function getMimeType(ext: string): string;
-//# sourceMappingURL=constants.d.ts.map

package/dist/lib/constants.js

@@ -211,4 +211,3 @@ export function getMimeType(ext) {
     const lowerExt = ext.toLowerCase();
     return MIME_TYPES.get(lowerExt) ?? 'application/octet-stream';
 }
-//# sourceMappingURL=constants.js.map

package/dist/lib/errors.d.ts

@@ -18,4 +18,3 @@ export declare class McpError extends Error {
 export declare function createDetailedError(error: unknown, path?: string, additionalDetails?: Record<string, unknown>): DetailedError;
 export declare function formatDetailedError(error: DetailedError): string;
 export declare function getSuggestion(code: ErrorCode): string;
-//# sourceMappingURL=errors.d.ts.map

package/dist/lib/errors.js

@@ -138,4 +138,3 @@ export function formatDetailedError(error) {
 export function getSuggestion(code) {
     return ERROR_SUGGESTIONS[code];
 }
-//# sourceMappingURL=errors.js.map

package/dist/lib/file-operations/file-info.d.ts

@@ -9,4 +9,3 @@ interface GetMultipleFileInfoOptions {
 }
 export declare function getMultipleFileInfo(paths: readonly string[], options?: GetMultipleFileInfoOptions): Promise<GetMultipleFileInfoResult>;
 export {};
-//# sourceMappingURL=file-info.d.ts.map

package/dist/lib/file-operations/file-info.js

@@ -157,4 +157,3 @@ export async function getMultipleFileInfo(paths, options = {}) {
         summary: calculateSummary(output),
     };
 }
-//# sourceMappingURL=file-info.js.map

package/dist/lib/file-operations/gitignore.d.ts

@@ -3,4 +3,3 @@ export declare function loadRootGitignore(root: string, signal?: AbortSignal): P
 export declare function isIgnoredByGitignore(matcher: Ignore, root: string, absolutePath: string, options?: {
     isDirectory?: boolean;
 }): boolean;
-//# sourceMappingURL=gitignore.d.ts.map

package/dist/lib/file-operations/gitignore.js

@@ -39,4 +39,3 @@ export function isIgnoredByGitignore(matcher, root, absolutePath, options = {})
     }
     return matcher.ignores(normalized);
 }
-//# sourceMappingURL=gitignore.js.map

package/dist/lib/file-operations/glob-engine.d.ts

@@ -24,4 +24,3 @@ export interface GlobEntriesOptions {
 }
 export declare function globEntries(options: GlobEntriesOptions): AsyncGenerator<GlobEntry>;
 export {};
-//# sourceMappingURL=glob-engine.d.ts.map

package/dist/lib/file-operations/glob-engine.js

@@ -2,6 +2,9 @@ import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import { glob as fsGlob } from 'node:fs/promises';
 import { publishOpsTraceEnd, publishOpsTraceError, publishOpsTraceStart, shouldPublishOpsTrace, } from '../observability.js';
+function normalizeToPosixPath(filePath) {
+    return filePath.replace(/\\/gu, '/');
+}
 function normalizePattern(pattern, baseNameMatch) {
     const normalized = pattern.replace(/\\/gu, '/');
     if (!baseNameMatch)
@@ -41,14 +44,12 @@ function splitPatternPrefix(normalizedPattern) {
         remainder: remainderSegments.join('/'),
     };
 }
-function normalizeToPosixPath(filePath) {
-    return filePath.replace(/\\/gu, '/');
-}
 function buildHiddenPatterns(normalizedPattern, maxDepth) {
     const patterns = new Set();
     patterns.add(normalizedPattern);
     const { prefix, remainder } = splitPatternPrefix(normalizedPattern);
     const remainderSegments = remainder.length > 0 ? remainder.split('/') : [];
+    // Dotfile candidate handling (e.g. foo/bar -> .foo/bar, foo/.bar)
     const dotfileSegments = [...remainderSegments];
     const firstCandidateIndex = dotfileSegments.findIndex((segment) => segment !== '**' && segment.length > 0);
     if (firstCandidateIndex !== -1) {
@@ -58,6 +59,7 @@ function buildHiddenPatterns(normalizedPattern, maxDepth) {
             patterns.add(`${prefix}${dotfileSegments.join('/')}`);
         }
     }
+    // Globstar handling (e.g. **/foo -> **/.*/**/foo, **/.foo)
     if (remainder.startsWith('**/')) {
         const afterGlobstar = remainder.slice('**/'.length);
         for (let depth = 0; depth <= maxDepth; depth += 1) {
@@ -70,6 +72,40 @@ function buildHiddenPatterns(normalizedPattern, maxDepth) {
     }
     return [...patterns];
 }
+function shouldUseGlobDirents(options) {
+    return !options.stats && !options.followSymbolicLinks;
+}
+function normalizeOptions(options) {
+    const normalized = normalizePattern(options.pattern, options.baseNameMatch);
+    const maxHiddenDepth = options.maxDepth ?? 10;
+    const patterns = options.includeHidden
+        ? buildHiddenPatterns(normalized, maxHiddenDepth)
+        : [normalized];
+    const result = {
+        cwd: options.cwd,
+        patterns,
+        exclude: normalizeIgnorePatterns(options.excludePatterns),
+        useDirents: shouldUseGlobDirents(options),
+        suppressErrors: options.suppressErrors ?? false,
+    };
+    if (options.maxDepth !== undefined) {
+        result.maxDepth = options.maxDepth;
+    }
+    return result;
+}
+function resolveDepth(cwd, entryPath) {
+    const relative = path.relative(cwd, entryPath);
+    if (relative.length === 0)
+        return 0;
+    const normalized = normalizeToPosixPath(relative);
+    const parts = normalized.split('/').filter((part) => part.length > 0);
+    return parts.length;
+}
+function isWithinDepthLimit(normalized, entryPath) {
+    if (normalized.maxDepth === undefined)
+        return true;
+    return resolveDepth(normalized.cwd, entryPath) <= normalized.maxDepth;
+}
 function toAbsolutePath(cwd, match) {
     return path.isAbsolute(match) ? match : path.resolve(cwd, match);
 }
@@ -78,124 +114,106 @@ function toAbsolutePathFromDirent(cwd, dirent) {
     return path.resolve(base, dirent.name);
 }
 function isGlobDirentLike(value) {
-    return (typeof value === 'object' &&
-        value !== null &&
-        'name' in value &&
-        typeof value.name === 'string');
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const v = value;
+    return (typeof v.name === 'string' &&
+        typeof v.isFile === 'function' &&
+        typeof v.isDirectory === 'function' &&
+        typeof v.isSymbolicLink === 'function');
 }
 function resolveAbsolutePathFromGlobMatch(cwd, match) {
     return typeof match === 'string'
         ? toAbsolutePath(cwd, match)
         : toAbsolutePathFromDirent(cwd, match);
 }
-function isWithinDepthLimit(options, entryPath) {
-    if (options.maxDepth === undefined)
-        return true;
-    return resolveDepth(options.cwd, entryPath) <= options.maxDepth;
+function passesOnlyFilesFilter(dirent, onlyFiles) {
+    return !onlyFiles || dirent.isFile();
+}
+function buildEntryFromGlobDirent(absolutePath, dirent, options) {
+    if (!passesOnlyFilesFilter(dirent, options.onlyFiles))
+        return null;
+    return { path: absolutePath, dirent };
+}
+async function buildEntry(entryPath, options) {
+    try {
+        const stats = options.followSymbolicLinks
+            ? await fs.stat(entryPath)
+            : await fs.lstat(entryPath);
+        if (!passesOnlyFilesFilter(stats, options.onlyFiles)) {
+            return null;
+        }
+        const result = { path: entryPath, dirent: stats };
+        if (options.stats)
+            result.stats = stats;
+        return result;
+    }
+    catch (error) {
+        if (options.suppressErrors)
+            return null;
+        throw error;
+    }
 }
-function createGlobIterator(pattern, cwd, exclude, withFileTypes, suppressErrors) {
+function tryCreateGlobIterable(pattern, normalized) {
     try {
         return fsGlob(pattern, {
-            cwd,
-            exclude,
-            withFileTypes,
+            cwd: normalized.cwd,
+            exclude: normalized.exclude,
+            withFileTypes: normalized.useDirents,
         });
     }
     catch (error) {
-        if (suppressErrors)
+        if (normalized.suppressErrors)
             return null;
         throw error;
     }
 }
-function shouldUseGlobDirents(options) {
-    return !options.stats && !options.followSymbolicLinks;
-}
-function buildEntryFromGlobDirent(absolutePath, dirent, options) {
-    if (options.onlyFiles && !dirent.isFile())
-        return null;
-    return { path: absolutePath, dirent };
-}
-async function processGlobMatch(match, options, seen, useDirents) {
-    const absolutePath = resolveAbsolutePathFromGlobMatch(options.cwd, match);
+function shouldYieldEntry(absolutePath, normalized, seen) {
     if (seen.has(absolutePath))
-        return null;
+        return false;
     seen.add(absolutePath);
-    if (!isWithinDepthLimit(options, absolutePath))
-        return null;
-    const entry = useDirents && isGlobDirentLike(match)
-        ? buildEntryFromGlobDirent(absolutePath, match, options)
-        : await buildEntry(absolutePath, options);
-    if (!entry)
-        return null;
-    if (options.onlyFiles && !entry.dirent.isFile())
+    if (!isWithinDepthLimit(normalized, absolutePath))
+        return false;
+    return true;
+}
+async function buildEntryFromMatch(match, options, normalized, seen) {
+    const absolutePath = resolveAbsolutePathFromGlobMatch(normalized.cwd, match);
+    if (!shouldYieldEntry(absolutePath, normalized, seen)) {
         return null;
-    return entry;
+    }
+    if (normalized.useDirents && isGlobDirentLike(match)) {
+        return buildEntryFromGlobDirent(absolutePath, match, options);
+    }
+    return await buildEntry(absolutePath, options);
 }
-async function* scanPattern(pattern, options, exclude, seen) {
-    const useDirents = shouldUseGlobDirents(options);
-    const iterator = createGlobIterator(pattern, options.cwd, exclude, useDirents, options.suppressErrors ?? false);
-    if (!iterator)
+async function* scanPattern(pattern, options, normalized, seen) {
+    const iterable = tryCreateGlobIterable(pattern, normalized);
+    if (!iterable)
         return;
     try {
-        for await (const match of iterator) {
-            const entry = await processGlobMatch(match, options, seen, useDirents);
+        for await (const match of iterable) {
+            const entry = await buildEntryFromMatch(match, options, normalized, seen);
             if (entry)
                 yield entry;
         }
     }
     catch (error) {
-        if (options.suppressErrors)
+        if (normalized.suppressErrors)
             return;
         throw error;
     }
 }
-function resolveDepth(cwd, entryPath) {
-    const relative = path.relative(cwd, entryPath);
-    if (relative.length === 0)
-        return 0;
-    const normalized = normalizeToPosixPath(relative);
-    const parts = normalized.split('/').filter((part) => part.length > 0);
-    return parts.length;
-}
-async function buildEntry(entryPath, options) {
-    try {
-        const stats = options.followSymbolicLinks
-            ? await fs.stat(entryPath)
-            : await fs.lstat(entryPath);
-        const result = {
-            path: entryPath,
-            dirent: stats,
-        };
-        if (options.stats)
-            result.stats = stats;
-        return result;
-    }
-    catch (error) {
-        if (options.suppressErrors) {
-            return null;
-        }
-        throw error;
-    }
-}
 async function* nativeGlobEntries(options) {
-    const normalized = normalizePattern(options.pattern, options.baseNameMatch);
-    const maxHiddenDepth = options.maxDepth ?? 10;
-    const patterns = options.includeHidden
-        ? buildHiddenPatterns(normalized, maxHiddenDepth)
-        : [normalized];
-    const exclude = normalizeIgnorePatterns(options.excludePatterns);
+    const normalized = normalizeOptions(options);
     const seen = new Set();
-    for (const pattern of patterns) {
-        yield* scanPattern(pattern, options, exclude, seen);
+    for (const pattern of normalized.patterns) {
+        yield* scanPattern(pattern, options, normalized, seen);
     }
 }
 export async function* globEntries(options) {
     const engine = 'node:fs/promises.glob';
     const traceContext = shouldPublishOpsTrace()
-        ? {
-            op: 'globEntries',
-            engine,
-        }
+        ? { op: 'globEntries', engine }
         : undefined;
     if (traceContext)
         publishOpsTraceStart(traceContext);
@@ -212,4 +230,3 @@ export async function* globEntries(options) {
             publishOpsTraceEnd(traceContext);
     }
 }
-//# sourceMappingURL=glob-engine.js.map

package/dist/lib/file-operations/list-directory.d.ts

@@ -11,4 +11,3 @@ export interface ListDirectoryOptions {
     signal?: AbortSignal;
 }
 export declare function listDirectory(dirPath: string, options?: ListDirectoryOptions): Promise<ListDirectoryResult>;
-//# sourceMappingURL=list-directory.d.ts.map

package/dist/lib/file-operations/list-directory.js

@@ -1,9 +1,9 @@
 import * as fsp from 'node:fs/promises';
 import * as path from 'node:path';
 import { DEFAULT_LIST_MAX_ENTRIES, DEFAULT_MAX_DEPTH, DEFAULT_SEARCH_TIMEOUT_MS, PARALLEL_CONCURRENCY, } from '../constants.js';
-import { createTimedAbortSignal, withAbort } from '../fs-helpers.js';
+import { createTimedAbortSignal, processInParallel, withAbort, } from '../fs-helpers.js';
 import { isSensitivePath } from '../path-policy.js';
-import { validateExistingDirectory, validateExistingPathDetailed, } from '../path-validation.js';
+import { isPathWithinDirectories, normalizePath, validateExistingDirectory, validateExistingPathDetailed, } from '../path-validation.js';
 import { globEntries } from './glob-engine.js';
 function normalizePattern(pattern) {
     if (!pattern || pattern.length === 0)
@@ -20,10 +20,8 @@ function normalizeOptions(options) {
         sortBy: options.sortBy ?? 'name',
         includeSymlinkTargets: options.includeSymlinkTargets ?? false,
         timeoutMs: options.timeoutMs ?? DEFAULT_SEARCH_TIMEOUT_MS,
+        ...(pattern !== undefined ? { pattern } : {}),
     };
-    if (pattern !== undefined) {
-        normalized.pattern = pattern;
-    }
     return normalized;
 }
 function sortEntries(entries, sortBy) {
@@ -44,31 +42,51 @@ function resolveMaxDepth(normalized) {
     }
     return normalized.maxDepth;
 }
-function shouldStopScan(signal, entryCount, maxEntries) {
-    if (signal.aborted) {
-        return { stop: true, reason: 'aborted' };
-    }
-    if (entryCount >= maxEntries) {
-        return { stop: true, reason: 'maxEntries' };
-    }
-    return { stop: false };
+function getStopReason(signal, acceptedCount, maxEntries) {
+    if (signal.aborted)
+        return 'aborted';
+    if (acceptedCount >= maxEntries)
+        return 'maxEntries';
+    return undefined;
 }
 async function* readDirectoryEntries(basePath, normalized, needsStats, signal) {
     const dirents = await withAbort(fsp.readdir(basePath, { withFileTypes: true }), signal);
+    const entries = [];
     for (const dirent of dirents) {
         if (!normalized.includeHidden && dirent.name.startsWith('.')) {
             continue;
         }
-        const entryPath = path.join(basePath, dirent.name);
-        let stats;
-        if (needsStats) {
-            stats = await withAbort(fsp.lstat(entryPath), signal);
+        entries.push({ dirent, entryPath: path.join(basePath, dirent.name) });
+    }
+    if (!needsStats) {
+        for (const entry of entries) {
+            yield {
+                path: entry.entryPath,
+                dirent: entry.dirent,
+            };
         }
+        return;
+    }
+    const { results, errors } = await processInParallel(entries.map((entry, index) => ({ entry, index })), async ({ entry, index }) => ({
+        index,
+        stats: await withAbort(fsp.lstat(entry.entryPath), signal),
+    }), PARALLEL_CONCURRENCY, signal);
+    if (errors.length > 0) {
+        throw errors[0]?.error ?? new Error('Failed to read entry stats');
+    }
+    const statsByIndex = new Map();
+    for (const result of results) {
+        statsByIndex.set(result.index, result.stats);
+    }
+    let index = 0;
+    for (const entry of entries) {
+        const stats = statsByIndex.get(index);
         yield {
-            path: entryPath,
-            dirent,
+            path: entry.entryPath,
+            dirent: entry.dirent,
             ...(stats ? { stats } : {}),
         };
+        index += 1;
     }
 }
 function createEntryStream(basePath, normalized, maxDepth, needsStats, signal) {
@@ -109,10 +127,10 @@ async function resolveSymlinkTarget(entryType, includeSymlinkTargets, entryPath)
     }
     return await fsp.readlink(entryPath).catch(() => undefined);
 }
-function updateTotals(type, totals) {
-    if (type === 'file')
+function updateTotals(entryType, totals) {
+    if (entryType === 'file')
         totals.files += 1;
-    if (type === 'directory')
+    if (entryType === 'directory')
         totals.directories += 1;
 }
 function buildDirectoryEntry(basePath, entry, entryType, needsStats, symlinkTarget) {
@@ -133,7 +151,19 @@ function trackSymlink(entryType, includeSymlinkTargets, counters) {
         counters.symlinksNotFollowed += 1;
     }
 }
-async function isEntryAccessible(entryPath, signal, counters) {
+async function isEntryAccessible(entryPath, entryType, basePath, signal, counters) {
+    if (entryType !== 'symlink') {
+        const normalized = normalizePath(entryPath);
+        if (!isPathWithinDirectories(normalized, [basePath])) {
+            counters.skippedInaccessible += 1;
+            return false;
+        }
+        if (isSensitivePath(entryPath, normalized)) {
+            counters.skippedInaccessible += 1;
+            return false;
+        }
+        return true;
+    }
     try {
         const validated = await validateExistingPathDetailed(entryPath, signal);
         if (isSensitivePath(validated.requestedPath, validated.resolvedPath)) {
@@ -147,24 +177,27 @@ async function isEntryAccessible(entryPath, signal, counters) {
         return false;
     }
 }
-async function appendEntryWithQueue(basePath, entry, normalized, needsStats, totals, entries, pending, flushPending) {
-    const task = appendEntry(basePath, entry, normalized, needsStats, totals, entries);
-    if (normalized.includeSymlinkTargets) {
-        pending.push(task);
-        if (pending.length >= PARALLEL_CONCURRENCY) {
-            await flushPending();
-        }
+function appendEntry(entry, entryType, symlinkTarget, ctx) {
+    updateTotals(entryType, ctx.totals);
+    ctx.entries.push(buildDirectoryEntry(ctx.basePath, entry, entryType, ctx.needsStats, symlinkTarget));
+}
+async function enqueueAppendEntry(entry, entryType, ctx, pending, flushPending) {
+    if (!ctx.includeSymlinkTargets) {
+        appendEntry(entry, entryType, undefined, ctx);
         return;
     }
-    await task;
-}
-async function appendEntry(basePath, entry, options, needsStats, totals, entries) {
-    const entryType = resolveEntryType(entry.dirent);
-    const symlinkTarget = await resolveSymlinkTarget(entryType, options.includeSymlinkTargets, entry.path);
-    updateTotals(entryType, totals);
-    entries.push(buildDirectoryEntry(basePath, entry, entryType, needsStats, symlinkTarget));
+    // Preserve the original behavior: resolve symlink targets in parallel
+    // when includeSymlinkTargets is enabled (bounded by PARALLEL_CONCURRENCY).
+    const task = (async () => {
+        const symlinkTarget = await resolveSymlinkTarget(entryType, ctx.includeSymlinkTargets, entry.path);
+        appendEntry(entry, entryType, symlinkTarget, ctx);
+    })();
+    pending.push(task);
+    if (pending.length >= PARALLEL_CONCURRENCY) {
+        await flushPending();
+    }
 }
-function buildSummary(entries, totals, maxDepth, truncated, stoppedReason, extra) {
+function buildSummary(entries, totals, maxDepth, truncated, stoppedReason, counters) {
     const baseSummary = {
         totalEntries: entries.length,
         entriesScanned: entries.length,
@@ -173,8 +206,8 @@ function buildSummary(entries, totals, maxDepth, truncated, stoppedReason, extra
         totalDirectories: totals.directories,
         maxDepthReached: maxDepth,
         truncated,
-        skippedInaccessible: extra.skippedInaccessible,
-        symlinksNotFollowed: extra.symlinksNotFollowed,
+        skippedInaccessible: counters.skippedInaccessible,
+        symlinksNotFollowed: counters.symlinksNotFollowed,
     };
     return {
         ...baseSummary,
@@ -184,56 +217,53 @@ function buildSummary(entries, totals, maxDepth, truncated, stoppedReason, extra
 async function collectEntries(basePath, normalized, signal, needsStats, maxDepth) {
     const entries = [];
     const totals = { files: 0, directories: 0 };
+    const counters = { skippedInaccessible: 0, symlinksNotFollowed: 0 };
     let truncated = false;
     let stoppedReason;
-    const counters = { skippedInaccessible: 0, symlinksNotFollowed: 0 };
     const pending = [];
-    let scheduledCount = 0;
+    let acceptedCount = 0;
     const stream = createEntryStream(basePath, normalized, maxDepth, needsStats, signal);
     const flushPending = async () => {
         if (pending.length === 0)
             return;
         await Promise.allSettled(pending.splice(0));
     };
+    const appendCtx = {
+        basePath,
+        needsStats,
+        includeSymlinkTargets: normalized.includeSymlinkTargets,
+        totals,
+        entries,
+    };
     for await (const entry of stream) {
-        const stop = shouldStopScan(signal, scheduledCount, normalized.maxEntries);
-        if (stop.stop) {
+        const stopReason = getStopReason(signal, acceptedCount, normalized.maxEntries);
+        if (stopReason) {
             truncated = true;
-            stoppedReason = stop.reason;
+            stoppedReason = stopReason;
             break;
         }
         const entryType = resolveEntryType(entry.dirent);
         trackSymlink(entryType, normalized.includeSymlinkTargets, counters);
-        const accessible = await isEntryAccessible(entry.path, signal, counters);
+        const accessible = await isEntryAccessible(entry.path, entryType, basePath, signal, counters);
         if (!accessible) {
             continue;
         }
-        scheduledCount += 1;
-        await appendEntryWithQueue(basePath, entry, normalized, needsStats, totals, entries, pending, flushPending);
+        acceptedCount += 1;
+        await enqueueAppendEntry(entry, entryType, appendCtx, pending, flushPending);
     }
     if (normalized.includeSymlinkTargets) {
         await flushPending();
     }
-    return {
-        entries,
-        totals,
-        truncated,
-        stoppedReason,
-        skippedInaccessible: counters.skippedInaccessible,
-        symlinksNotFollowed: counters.symlinksNotFollowed,
-    };
+    return { entries, totals, truncated, stoppedReason, counters };
 }
 async function executeListDirectory(basePath, normalized, signal) {
     const needsStats = needsStatsForSort(normalized.sortBy);
     const maxDepth = resolveMaxDepth(normalized);
-    const { entries, totals, truncated, stoppedReason, skippedInaccessible, symlinksNotFollowed, } = await collectEntries(basePath, normalized, signal, needsStats, maxDepth);
+    const { entries, totals, truncated, stoppedReason, counters } = await collectEntries(basePath, normalized, signal, needsStats, maxDepth);
     sortEntries(entries, normalized.sortBy);
     return {
         entries,
-        summary: buildSummary(entries, totals, maxDepth, truncated, stoppedReason, {
-            skippedInaccessible,
-            symlinksNotFollowed,
-        }),
+        summary: buildSummary(entries, totals, maxDepth, truncated, stoppedReason, counters),
     };
 }
 export async function listDirectory(dirPath, options = {}) {
@@ -248,4 +278,3 @@ export async function listDirectory(dirPath, options = {}) {
         cleanup();
     }
 }
-//# sourceMappingURL=list-directory.js.map

package/dist/lib/file-operations/read-multiple-files.d.ts

@@ -21,4 +21,3 @@ export interface ReadMultipleOptions {
     signal?: AbortSignal;
 }
 export declare function readMultipleFiles(filePaths: readonly string[], options?: ReadMultipleOptions): Promise<ReadMultipleResult[]>;
-//# sourceMappingURL=read-multiple-files.d.ts.map

package/dist/lib/file-operations/read-multiple-files.js

@@ -211,4 +211,3 @@ export async function readMultipleFiles(filePaths, options = {}) {
     applySkippedBudget(output, skippedBudget, filePaths, normalized.maxTotalSize);
     return output;
 }
-//# sourceMappingURL=read-multiple-files.js.map

package/dist/lib/file-operations/search-content.d.ts

@@ -70,4 +70,3 @@ export interface ScanError {
 export type WorkerResponse = ScanResult | ScanError;
 export declare function searchContent(basePath: string, pattern: string, options?: SearchContentOptions): Promise<SearchContentResult>;
 export {};
-//# sourceMappingURL=search-content.d.ts.map