@j0hanz/filesystem-mcp 1.14.0 → 1.15.0

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

@@ -1,12 +1,53 @@
-import * as fsp from 'node:fs/promises';
-import * as path from 'node:path';
+import { lstat, readdir, readlink, stat, } from 'node:fs';
+import { basename, join, parse, relative } from 'node:path';
+import { assertNotAborted, withAbort, withTimedAbortSignal } from '../abort.js';
 import { DEFAULT_EXCLUDE_PATTERNS, DEFAULT_LIST_MAX_ENTRIES, DEFAULT_MAX_DEPTH, DEFAULT_READ_MANY_MAX_TOTAL_SIZE, DEFAULT_SEARCH_TIMEOUT_MS, getMimeType, MAX_TEXT_FILE_SIZE, PARALLEL_CONCURRENCY, } from '../constants.js';
 import { isAbortError } from '../errors.js';
-import { assertNotAborted, getFileType, isHidden, processInParallel, readFile, readFileWithStats, withAbort, withTimedAbortSignal, } from '../fs-helpers.js';
+import { getFileType, isHidden, processInParallel, readFile, readFileWithStats, } from '../fs-helpers.js';
 import { assertSafeGlobPattern } from '../globs.js';
 import { assertAllowedFileAccess, isPathWithinDirectories, isSensitivePath, normalizePath, toPosixPath, validateExistingDirectory, validateExistingPath, validateExistingPathDetailed, } from '../paths.js';
 import { applyIndexedErrors, applyIndexedValues, isEntryAccessibleByType, isIgnoredByGitignore, loadRootGitignore, needsStatsForSort, resolveEntryType, resolveStopReason, withOptionalStoppedReason, } from './core.js';
 import { globEntries } from './traversal.js';
+function statAsync(filePath) {
+    return new Promise((resolve, reject) => {
+        stat(filePath, (err, stats) => {
+            if (err)
+                reject(err);
+            else
+                resolve(stats);
+        });
+    });
+}
+function readlinkAsync(filePath) {
+    return new Promise((resolve, reject) => {
+        readlink(filePath, (err, linkString) => {
+            if (err)
+                reject(err);
+            else
+                resolve(linkString);
+        });
+    });
+}
+function readdirAsync(dirPath, options) {
+    return new Promise((resolve, reject) => {
+        readdir(dirPath, options, (err, files) => {
+            if (err)
+                reject(err);
+            else
+                resolve(files);
+        });
+    });
+}
+function lstatAsync(filePath) {
+    return new Promise((resolve, reject) => {
+        lstat(filePath, (err, stats) => {
+            if (err)
+                reject(err);
+            else
+                resolve(stats);
+        });
+    });
+}
 const ACCESS_DEPS = {
     normalizePath,
     isPathWithinDirectories,
@@ -49,7 +90,7 @@ function buildFileInfoResult(name, requestedPath, isSymlink, stats, mimeType, sy
 async function getSymlinkTarget(pathToRead, signal) {
     assertNotAborted(signal);
     try {
-        return await withAbort(fsp.readlink(pathToRead), signal);
+        return await withAbort(readlinkAsync(pathToRead), signal);
     }
     catch (error) {
         if (isAbortError(error))
@@ -62,14 +103,14 @@ export async function getFileInfo(filePath, options = {}) {
     assertNotAborted(signal);
     const { requestedPath, resolvedPath, isSymlink } = await validateExistingPathDetailed(filePath, signal);
     assertAllowedFileAccess(requestedPath, resolvedPath);
-    const { base: name, ext: rawExt } = path.parse(requestedPath);
+    const { base: name, ext: rawExt } = parse(requestedPath);
     const ext = rawExt.toLowerCase();
     const includeMimeType = options.includeMimeType !== false;
     const mimeType = includeMimeType && ext.length > 0 ? getMimeType(ext) : undefined;
     const symlinkTarget = isSymlink
         ? await getSymlinkTarget(requestedPath, signal)
         : undefined;
-    const stats = await withAbort(fsp.stat(resolvedPath), signal);
+    const stats = await withAbort(statAsync(resolvedPath), signal);
     return buildFileInfoResult(name, requestedPath, isSymlink, stats, mimeType, symlinkTarget);
 }
 function buildEmptyResult() {
@@ -131,7 +172,7 @@ export async function getMultipleFileInfo(paths, options = {}) {
             : undefined,
         buildValue: (resolvedIndex, error) => ({
             path: paths[resolvedIndex] ?? UNKNOWN_PATH,
-            error: error.message,
+            error,
         }),
     });
     return {
@@ -168,12 +209,12 @@ function resolveMaxDepth(normalized) {
     return normalized.pattern ? normalized.maxDepth : 1;
 }
 async function* readDirectoryEntries(basePath, normalized, needsStats, signal) {
-    const dirents = await withAbort(fsp.readdir(basePath, { withFileTypes: true }), signal);
+    const dirents = await withAbort(readdirAsync(basePath, { withFileTypes: true }), signal);
     if (!needsStats) {
         for (const dirent of dirents) {
             if (!normalized.includeHidden && isHidden(dirent.name))
                 continue;
-            yield { path: path.join(basePath, dirent.name), dirent };
+            yield { path: join(basePath, dirent.name), dirent };
         }
         return;
     }
@@ -181,12 +222,12 @@ async function* readDirectoryEntries(basePath, normalized, needsStats, signal) {
     for (const dirent of dirents) {
         if (!normalized.includeHidden && isHidden(dirent.name))
             continue;
-        filtered.push({ dirent, entryPath: path.join(basePath, dirent.name) });
+        filtered.push({ dirent, entryPath: join(basePath, dirent.name) });
     }
     const { results, errors } = await processInParallel(filtered, async ({ entryPath, dirent }) => ({
         path: entryPath,
         dirent,
-        stats: await withAbort(fsp.lstat(entryPath), signal),
+        stats: await withAbort(lstatAsync(entryPath), signal),
     }), PARALLEL_CONCURRENCY, signal);
     if (errors.length > 0) {
         throw errors[0]?.error ?? new Error('Failed to read entry stats');
@@ -216,13 +257,13 @@ function shouldUseFastPath(normalized, maxDepth) {
         maxDepth === 1);
 }
 function resolveRelativePath(basePath, entryPath) {
-    return path.relative(basePath, entryPath) || path.basename(entryPath);
+    return relative(basePath, entryPath) || basename(entryPath);
 }
 async function resolveSymlinkTarget(entryType, includeSymlinkTargets, entryPath) {
     if (entryType !== 'symlink' || !includeSymlinkTargets) {
         return undefined;
     }
-    return fsp.readlink(entryPath).catch(() => undefined);
+    return readlinkAsync(entryPath).catch(() => undefined);
 }
 function updateTotals(entryType, totals) {
     if (entryType === 'file')
@@ -234,7 +275,7 @@ function buildDirectoryEntry(basePath, entry, entryType, needsStats, symlinkTarg
     const size = needsStats && entry.stats?.isFile() ? entry.stats.size : undefined;
     const modified = needsStats ? entry.stats?.mtime : undefined;
     return {
-        name: path.basename(entry.path),
+        name: basename(entry.path),
         path: entry.path,
         relativePath: resolveRelativePath(basePath, entry.path),
         type: entryType,
@@ -423,7 +464,7 @@ async function resolveTreeEntry(entry, root, rootDirectories, gitignoreMatcher,
         return null;
     }
     const relativePosix = toPosixPath(resolveRelativePath(root, entry.path));
-    const name = path.basename(entry.path);
+    const name = basename(entry.path);
     return { type, relativePosix, name };
 }
 function upsertChildNode(parent, nodeByPath, resolved, childPathIndexByParent) {
@@ -523,7 +564,7 @@ export async function treeDirectory(dirPath, options = {}) {
             ? null
             : await loadRootGitignore(root, signal);
         const rootNode = {
-            name: path.basename(root) || root,
+            name: basename(root) || root,
             type: 'directory',
             relativePath: '.',
             children: [],
@@ -675,7 +716,7 @@ function resolveNormalizedReadOptions(options) {
 }
 async function validateFile(filePath, index, signal) {
     const validPath = await validateExistingPath(filePath, signal);
-    const stats = await withAbort(fsp.stat(validPath), signal);
+    const stats = await withAbort(statAsync(validPath), signal);
     return { filePath, index, validPath, stats };
 }
 function markRemainingSkipped(startIndex, total, skippedBudget) {
@@ -810,7 +851,7 @@ function applySkippedBudget(output, skippedBudget, filePaths, maxTotalSize) {
             continue;
         output[index] = {
             path: filePath,
-            error: `Skipped: combined estimated read would exceed maxTotalSize (${maxTotalSize} bytes)`,
+            error: new Error(`Skipped: combined estimated read would exceed maxTotalSize (${maxTotalSize} bytes)`),
         };
     }
 }
@@ -829,7 +870,7 @@ export async function readMultipleFiles(filePaths, options = {}) {
         resolveIndex: (failureIndex) => resolveErrorOriginalIndex(failureIndex, filesToProcess, filePaths.length),
         buildValue: (resolvedIndex, error) => ({
             path: filePaths[resolvedIndex] ?? UNKNOWN_PATH,
-            error: error.message,
+            error,
         }),
     });
     applySkippedBudget(output, skippedBudget, filePaths, normalized.maxTotalSize);

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

@@ -50,22 +50,21 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
-import * as fsp from 'node:fs/promises';
-import * as path from 'node:path';
 import { AsyncResource } from 'node:async_hooks';
-import { existsSync } from 'node:fs';
-import { fileURLToPath, pathToFileURL } from 'node:url';
+import { open, stat } from 'node:fs/promises';
+import { basename, dirname } from 'node:path';
 import { debuglog } from 'node:util';
 import { parentPort, threadId, Worker, workerData } from 'node:worker_threads';
 import RE2 from 're2';
-import safeRegex from 'safe-regex2';
 import { z } from 'zod';
+import { assertNotAborted, withAbort, withTimedAbortSignal } from '../abort.js';
 import { DEFAULT_EXCLUDE_PATTERNS, DEFAULT_SEARCH_MAX_FILES, DEFAULT_SEARCH_TIMEOUT_MS, MAX_LINE_CONTENT_LENGTH, MAX_SEARCHABLE_FILE_SIZE, SEARCH_WORKERS, } from '../constants.js';
 import { ErrorCode, formatUnknownErrorMessage, isTimeoutLikeError, McpError, } from '../errors.js';
-import { assertNotAborted, isProbablyBinary, withAbort, withTimedAbortSignal, } from '../fs-helpers.js';
+import { isProbablyBinary } from '../fs-helpers.js';
+import { isSafeGlobPattern } from '../globs.js';
 import { startPerfMeasure } from '../observability.js';
 import { assertAllowedFileAccess, isPathWithinDirectories, isSensitivePath, normalizePath, validateExistingDirectory, validateExistingPathDetailed, } from '../paths.js';
-import { mergeOptions, omitOptionKeys, reportPeriodicProgress, } from '../utils.js';
+import { mergeOptions, omitOptionKeys } from '../utils.js';
 import { compareOptionalNumberDesc, compareStringValues, isEntryAccessibleByType, isIgnoredByGitignore, loadRootGitignore, needsStatsForSort, resolveEntryType, resolveStopReason, stableSortByDerivedString, withOptionalStoppedReason, } from './core.js';
 import { buildGlobOptions, globEntries } from './traversal.js';
 function countRegexLineMatches(regex, line) {
@@ -85,20 +84,10 @@ function buildRegexPattern(pattern, options) {
     const escaped = options.isLiteral ? escapeLiteral(pattern) : pattern;
     return options.wholeWord ? `\\b${escaped}\\b` : escaped;
 }
-function validatePattern(pattern, options) {
-    if (options.isLiteral && pattern.length === 0)
-        return;
-    if (options.isLiteral && !options.wholeWord)
-        return;
-    const final = buildRegexPattern(pattern, options);
-    if (!safeRegex(final)) {
-        throw new Error(`Potentially unsafe regular expression (ReDoS risk): ${pattern}`);
-    }
-}
 function buildLiteralMatcher(pattern, options) {
     if (!options.caseSensitive) {
         const final = escapeLiteral(pattern);
-        const regex = new RegExp(final, 'gi');
+        const regex = new RE2(final, 'gi');
         return (line) => countRegexLineMatches(regex, line);
     }
     // Fast path for case-sensitive literal
@@ -130,13 +119,19 @@ function buildMatcher(pattern, options) {
         return buildLiteralMatcher(pattern, options);
     }
     const final = buildRegexPattern(pattern, options);
-    validatePattern(pattern, options); // Re-validate to be safe
     return buildRegexMatcher(final, options.caseSensitive);
 }
 // --- Configuration & Schemas ---
 const SEARCH_CONTENT_MAX_RESULTS = 500;
+const SafeFilePatternSchema = z
+    .string()
+    .min(1, 'Pattern required')
+    .max(1000, 'Max 1000 chars')
+    .refine((value) => isSafeGlobPattern(value), {
+    error: 'Invalid glob or unsafe path (absolute/.. forbidden)',
+});
 const SearchOptionsSchema = z.strictObject({
-    filePattern: z.string().min(1),
+    filePattern: SafeFilePatternSchema,
     excludePatterns: z.array(z.string()),
     caseSensitive: z.boolean(),
     maxResults: z.int().min(0),
@@ -169,7 +164,6 @@ const DEFAULTS = {
 };
 const ERROR_SCAN_CANCELLED = 'Scan cancelled';
 const ERROR_WORKER_POOL_CLOSED = 'Worker pool closed';
-const SEARCH_PROGRESS_THROTTLE_MODULO = 25;
 const SEARCH_WORKER_NAME_PREFIX = 'filesystem-search';
 const SEARCH_WORKER_RESOURCE_TYPE = 'SearchWorkerTask';
 // --- Helpers ---
@@ -178,7 +172,7 @@ function resolveOptions(options) {
     const merged = mergeOptions(DEFAULTS, normalizedOptions);
     const result = SearchOptionsSchema.safeParse(merged);
     if (!result.success) {
-        throw new McpError(ErrorCode.E_INVALID_INPUT, `Invalid search options:\n${z.prettifyError(result.error)}`, undefined, { errors: z.treeifyError(result.error) });
+        throw new McpError(ErrorCode.INVALID_INPUT, `Invalid search options:\n${z.prettifyError(result.error)}`, undefined, { errors: z.treeifyError(result.error) });
     }
     return result.data;
 }
@@ -254,9 +248,31 @@ class ContextBuffer {
 }
 function trimContent(line) {
     return line.length > MAX_LINE_CONTENT_LENGTH
-        ? line.slice(0, MAX_LINE_CONTENT_LENGTH)
+        ? `${line.slice(0, MAX_LINE_CONTENT_LENGTH)}\u2026`
         : line;
 }
+function processLineMatch(matches, rawLine, lineNumber, matchCount, requestedPath, ctx) {
+    const trimmedLine = trimContent(rawLine);
+    if (ctx) {
+        matches.push({
+            file: requestedPath,
+            line: lineNumber,
+            content: trimmedLine,
+            matchCount,
+            contextBefore: ctx.snapshotBefore(),
+            contextAfter: ctx.scheduleAfter(),
+        });
+    }
+    else {
+        matches.push({
+            file: requestedPath,
+            line: lineNumber,
+            content: trimmedLine,
+            matchCount,
+        });
+    }
+    return trimmedLine;
+}
 async function readMatches(handle, requestedPath, matcher, options, maxMatches, isCancelled, signal) {
     if (maxMatches <= 0) {
         return [];
@@ -274,26 +290,12 @@ async function readMatches(handle, requestedPath, matcher, options, maxMatches,
             if (isCancelled())
                 break;
             const matchCount = matcher(rawLine);
-            const trimmedLine = hasContext || matchCount > 0 ? trimContent(rawLine) : '';
+            let trimmedLine = '';
             if (matchCount > 0) {
-                if (ctx) {
-                    matches.push({
-                        file: requestedPath,
-                        line: lineNumber,
-                        content: trimmedLine,
-                        matchCount,
-                        contextBefore: ctx.snapshotBefore(),
-                        contextAfter: ctx.scheduleAfter(),
-                    });
-                }
-                else {
-                    matches.push({
-                        file: requestedPath,
-                        line: lineNumber,
-                        content: trimmedLine,
-                        matchCount,
-                    });
-                }
+                trimmedLine = processLineMatch(matches, rawLine, lineNumber, matchCount, requestedPath, ctx);
+            }
+            else if (hasContext) {
+                trimmedLine = trimContent(rawLine);
             }
             if (ctx) {
                 ctx.add(trimmedLine);
@@ -315,7 +317,7 @@ async function scanFileResolved(resolvedPath, requestedPath, matcher, options, s
     const env_1 = { stack: [], error: void 0, hasError: false };
     try {
         assertNotAborted(signal);
-        const handle = __addDisposableResource(env_1, await withAbort(fsp.open(resolvedPath, 'r'), signal), true);
+        const handle = __addDisposableResource(env_1, await withAbort(open(resolvedPath, 'r'), signal), true);
         const stats = await withAbort(handle.stat(), signal);
         if (stats.size > options.maxFileSize) {
             return {
@@ -409,12 +411,9 @@ function buildSearchContentResult(root, pattern, filePattern, matches, summary)
         summary: withOptionalStoppedReason(baseSummary, summary.stoppedReason),
     };
 }
-const currentDir = path.dirname(fileURLToPath(import.meta.url));
-const isSourceContext = currentDir.endsWith('src\\lib\\file-operations') ||
-    currentDir.endsWith('src/lib/file-operations');
-const WORKER_SCRIPT_PATH = path.join(currentDir, isSourceContext ? 'search-worker.ts' : 'search-worker.js');
-const WORKER_SCRIPT_URL = pathToFileURL(WORKER_SCRIPT_PATH);
-const hasWorkerScript = existsSync(WORKER_SCRIPT_PATH);
+const isSourceContext = import.meta.url.endsWith('.ts');
+const WORKER_SCRIPT_URL = new URL(import.meta.url);
+const hasWorkerScript = true;
 class SearchWorkerTaskResource extends AsyncResource {
     #settled = false;
     constructor() {
@@ -518,9 +517,21 @@ class SearchWorkerPool {
         if (this.closed)
             throw new Error(ERROR_WORKER_POOL_CLOSED);
         const id = this.nextRequestId++;
-        const workerIndex = this.workerRoundRobin % this.size;
+        let workerIndex = 0;
+        const workerPendingCounts = new Array(this.size).fill(0);
+        for (const p of this.pending.values()) {
+            const idx = p.workerIndex;
+            workerPendingCounts[idx] = (workerPendingCounts[idx] ?? 0) + 1;
+        }
+        let minPending = workerPendingCounts[0] ?? 0;
+        for (let i = 1; i < this.size; i++) {
+            const pendingCount = workerPendingCounts[i] ?? 0;
+            if (pendingCount < minPending) {
+                minPending = pendingCount;
+                workerIndex = i;
+            }
+        }
         const worker = this.getWorker(workerIndex);
-        this.workerRoundRobin++;
         const promise = new Promise((resolve, reject) => {
             const resource = new SearchWorkerTaskResource();
             const pendingRequest = {
@@ -758,7 +769,7 @@ async function searchSingleFile(details, opts, pattern, signal) {
     }, signal, opts.maxResults);
     if (result.matched)
         summary.filesMatched = 1;
-    return buildSearchContentResult(path.dirname(details.resolvedPath), pattern, opts.filePattern, result.matches, summary);
+    return buildSearchContentResult(dirname(details.resolvedPath), pattern, opts.filePattern, result.matches, summary);
 }
 async function searchDirectory(details, opts, pattern, signal, onProgress) {
     const root = await validateExistingDirectory(details.resolvedPath, signal);
@@ -775,12 +786,12 @@ async function searchDirectory(details, opts, pattern, signal, onProgress) {
         stats: false,
         suppressErrors: true,
     }));
+    const summary = createScanSummary();
     async function* fileGenerator() {
-        let scanned = 0;
         for await (const entry of stream) {
             if (signal.aborted)
                 break;
-            if (scanned >= opts.maxFilesScanned)
+            if (summary.filesScanned >= opts.maxFilesScanned)
                 break;
             if (!entry.dirent.isFile())
                 continue;
@@ -789,36 +800,25 @@ async function searchDirectory(details, opts, pattern, signal, onProgress) {
                 continue;
             if (isSensitivePath(entry.path, normalized))
                 continue;
-            scanned++;
-            reportPeriodicProgress(onProgress, scanned, {
+            summary.filesScanned++;
+            onProgress?.({
+                current: summary.filesScanned,
                 total: opts.maxFilesScanned,
-                throttleModulo: SEARCH_PROGRESS_THROTTLE_MODULO,
             });
             yield { resolvedPath: normalized, requestedPath: entry.path };
         }
-        reportPeriodicProgress(onProgress, scanned, {
-            total: opts.maxFilesScanned,
-            throttleModulo: SEARCH_PROGRESS_THROTTLE_MODULO,
-            force: true,
-        });
-    }
-    const summary = createScanSummary();
-    const resolvedStream = fileGenerator();
-    async function* countingStream() {
-        for await (const f of resolvedStream) {
-            summary.filesScanned++;
-            yield f;
-        }
         if (summary.filesScanned >= opts.maxFilesScanned) {
             summary.truncated = true;
             summary.stoppedReason = 'maxFiles';
         }
+        onProgress?.({
+            current: summary.filesScanned,
+            total: opts.maxFilesScanned,
+        });
     }
-    const matcherOpts = buildMatcherOptions(opts);
-    validatePattern(pattern, matcherOpts);
     const matches = shouldUseWorkers()
-        ? await executeParallel(countingStream(), pattern, opts, signal, summary)
-        : await executeSequential(countingStream(), pattern, opts, signal, summary);
+        ? await executeParallel(fileGenerator(), pattern, opts, signal, summary)
+        : await executeSequential(fileGenerator(), pattern, opts, signal, summary);
     return buildSearchContentResult(root, pattern, opts.filePattern, matches, summary);
 }
 function buildTimeoutSearchResult(basePath, pattern, filePattern) {
@@ -828,19 +828,19 @@ function buildTimeoutSearchResult(basePath, pattern, filePattern) {
 }
 export async function searchContent(basePath, pattern, options = {}) {
     if (!basePath.trim())
-        throw new McpError(ErrorCode.E_INVALID_INPUT, 'basePath required');
+        throw new McpError(ErrorCode.INVALID_INPUT, 'basePath required');
     if (typeof pattern !== 'string')
-        throw new McpError(ErrorCode.E_INVALID_INPUT, 'pattern required');
+        throw new McpError(ErrorCode.INVALID_INPUT, 'pattern required');
     const opts = resolveOptions(options);
     try {
         return await withTimedAbortSignal(options.signal, opts.timeoutMs, async (signal) => {
             const details = await validateExistingPathDetailed(basePath, signal);
-            const stats = await withAbort(fsp.stat(details.resolvedPath), signal);
+            const stats = await withAbort(stat(details.resolvedPath), signal);
             if (stats.isFile()) {
                 return searchSingleFile(details, opts, pattern, signal);
             }
             if (!stats.isDirectory()) {
-                throw new McpError(ErrorCode.E_INVALID_INPUT, 'Path must be file or directory', basePath);
+                throw new McpError(ErrorCode.INVALID_INPUT, 'Path must be file or directory', basePath);
             }
             return searchDirectory(details, opts, pattern, signal, options.onProgress);
         });
@@ -955,9 +955,9 @@ async function collectFromStream(stream, signal, context) {
         if (shouldStopCollecting(state, normalized, signal))
             break;
         state.filesScanned++;
-        reportPeriodicProgress(onProgress, state.filesScanned, {
+        onProgress?.({
+            current: state.filesScanned,
             total: normalized.maxFilesScanned,
-            throttleModulo: SEARCH_PROGRESS_THROTTLE_MODULO,
         });
         if (isEntryIgnoredByGitignore(gitignoreMatcher, root, entry.path, entry.relativePath)) {
             continue;
@@ -975,10 +975,9 @@ async function collectFromStream(stream, signal, context) {
         if (state.truncated)
             break;
     }
-    reportPeriodicProgress(onProgress, state.filesScanned, {
+    onProgress?.({
+        current: state.filesScanned,
         total: normalized.maxFilesScanned,
-        throttleModulo: SEARCH_PROGRESS_THROTTLE_MODULO,
-        force: true,
     });
 }
 function isEntryIgnoredByGitignore(matcher, root, entryPath, relativePath) {
@@ -1041,7 +1040,7 @@ const SORT_COMPARATORS = {
 };
 function sortSearchResults(results, sortBy) {
     if (sortBy === 'name') {
-        stableSortByDerivedString(results, (item) => path.basename(item.path ?? ''), (left, right) => comparePathThenName(left, right));
+        stableSortByDerivedString(results, (item) => basename(item.path ?? ''), (left, right) => comparePathThenName(left, right));
         return;
     }
     const comparator = SORT_COMPARATORS[sortBy];

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

@@ -1,6 +1,5 @@
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-import { glob as fsGlob } from 'node:fs/promises';
+import { glob as fsGlob, lstat, stat } from 'node:fs/promises';
+import { isAbsolute, relative, resolve } from 'node:path';
 import { getToolContextSnapshot, publishOpsTraceEnd, publishOpsTraceError, publishOpsTraceStart, shouldPublishOpsTrace, startPerfMeasure, } from '../observability.js';
 import { toPosixPath } from '../paths.js';
 import { isRecord } from '../utils.js';
@@ -96,7 +95,7 @@ function assertOptionsShape(options) {
     }
 }
 function normalizeOptions(options) {
-    const cwd = path.resolve(options.cwd);
+    const cwd = resolve(options.cwd);
     const normalizedPattern = normalizePattern(options.pattern, options.baseNameMatch);
     const patterns = options.includeHidden
         ? buildHiddenPatterns(normalizedPattern, options.maxDepth ?? DEFAULT_MAX_HIDDEN_DEPTH)
@@ -136,18 +135,16 @@ function isGlobDirentLike(value) {
 function resolveDirentBase(cwd, parentPath) {
     if (!parentPath)
         return cwd;
-    return path.isAbsolute(parentPath)
-        ? parentPath
-        : path.resolve(cwd, parentPath);
+    return isAbsolute(parentPath) ? parentPath : resolve(cwd, parentPath);
 }
 function resolveStringMatchPath(cwd, match) {
-    return path.isAbsolute(match) ? match : path.resolve(cwd, match);
+    return isAbsolute(match) ? match : resolve(cwd, match);
 }
 function* processDirentMatch(match, cwd, maxDepth, seen, onlyFiles) {
     const base = resolveDirentBase(cwd, match.parentPath);
-    const absolutePath = path.resolve(base, match.name);
+    const absolutePath = resolve(base, match.name);
     if (maxDepth !== undefined) {
-        const rel = path.relative(cwd, absolutePath);
+        const rel = relative(cwd, absolutePath);
         if (getRelativeDepth(rel) > maxDepth)
             return;
     }
@@ -170,12 +167,12 @@ async function resolveStringMatch(match, cwd, maxDepth, seen, onlyFiles, followS
     seen.add(absolutePath);
     try {
         const stats = followSymlinks
-            ? await fs.stat(absolutePath)
-            : await fs.lstat(absolutePath);
+            ? await stat(absolutePath)
+            : await lstat(absolutePath);
         if (onlyFiles && !stats.isFile())
             return null;
         const entry = { path: absolutePath, dirent: stats };
-        if (!path.isAbsolute(match)) {
+        if (!isAbsolute(match)) {
             entry.relativePath = match;
         }
         if (returnStats)
@@ -190,12 +187,13 @@ async function resolveStringMatch(match, cwd, maxDepth, seen, onlyFiles, followS
 }
 async function* processIterable(iterable, context) {
     const { cwd, maxDepth, seen, onlyFiles, followSymlinks, returnStats, suppressErrors, } = context;
-    const buffer = [];
+    let buffer = [];
     const flush = async function* () {
         if (buffer.length === 0)
             return;
         // Process buffer concurrently
-        const currentBuffer = buffer.splice(0, buffer.length);
+        const currentBuffer = buffer;
+        buffer = [];
         const results = await Promise.all(currentBuffer.map((match) => resolveStringMatch(match, cwd, maxDepth, seen, onlyFiles, followSymlinks, returnStats, suppressErrors)));
         for (const entry of results) {
             if (entry !== null)

package/dist/lib/fs-helpers.d.ts

@@ -1,13 +1,7 @@
-import * as fsp from 'node:fs/promises';
 import type { Stats } from 'node:fs';
+import { type FileHandle } from 'node:fs/promises';
 import type { FileType } from '../config.js';
-export declare function assertNotAborted(signal?: AbortSignal, message?: string): void;
-export declare function withAbort<T>(promise: Promise<T>, signal?: AbortSignal): Promise<T>;
-export declare function createTimedAbortSignal(baseSignal: AbortSignal | undefined, timeoutMs?: number): {
-    signal: AbortSignal;
-    cleanup: () => void;
-};
-export declare function withTimedAbortSignal<T>(baseSignal: AbortSignal | undefined, timeoutMs: number | undefined, run: (signal: AbortSignal) => Promise<T>): Promise<T>;
+export { assertNotAborted, createTimedAbortSignal, withAbort, withTimedAbortSignal, } from './abort.js';
 interface ParallelResult<R> {
     results: R[];
     errors: {
@@ -18,7 +12,7 @@ interface ParallelResult<R> {
 export declare function processInParallel<T, R>(items: T[], processor: (item: T) => Promise<R>, concurrency?: number, signal?: AbortSignal): Promise<ParallelResult<R>>;
 export declare function getFileType(stats: Stats): FileType;
 export declare function isHidden(name: string): boolean;
-export declare function isProbablyBinary(filePath: string, existingHandle?: fsp.FileHandle, signal?: AbortSignal): Promise<boolean>;
+export declare function isProbablyBinary(filePath: string, existingHandle?: FileHandle, signal?: AbortSignal): Promise<boolean>;
 type ReadMode = 'head' | 'full' | 'range' | 'tail';
 interface ReadFileOptions {
     encoding?: BufferEncoding;
@@ -49,4 +43,3 @@ export declare function atomicWriteFile(filePath: string, content: string, optio
     encoding?: BufferEncoding;
     signal?: AbortSignal | undefined;
 }): Promise<void>;
-export {};