@j0hanz/filesystem-mcp 1.7.2 → 1.8.0

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

@@ -3,22 +3,19 @@ import * as path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { Worker } from 'node:worker_threads';
 import { z } from 'zod';
-import RE2 from 're2';
-import safeRegex from 'safe-regex2';
 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, createTimedAbortSignal, isProbablyBinary, withAbort, } from '../fs-helpers.js';
+import { assertNotAborted, isProbablyBinary, withAbort, withTimedAbortSignal, } from '../fs-helpers.js';
+import { mergeOptions, omitOptionKeys } from '../option-utils.js';
 import { assertAllowedFileAccess, isSensitivePath } from '../path-policy.js';
 import { isPathWithinDirectories, normalizePath, validateExistingDirectory, validateExistingPathDetailed, } from '../path-validation.js';
+import { reportPeriodicProgress } from '../progress-reporting.js';
 import { withOptionalStoppedReason } from './common.js';
 import { globEntries } from './glob-engine.js';
+import { buildGlobOptions } from './glob-helpers.js';
+import { buildMatcher, validatePattern } from './search-matcher.js';
 // --- Configuration & Schemas ---
 const INTERNAL_MAX_RESULTS = 500;
-export const MatcherOptionsSchema = z.strictObject({
-    caseSensitive: z.boolean(),
-    wholeWord: z.boolean(),
-    isLiteral: z.boolean(),
-});
 const SearchOptionsSchema = z.strictObject({
     filePattern: z.string().min(1),
     excludePatterns: z.array(z.string()),
@@ -55,80 +52,14 @@ const ERROR_SCAN_CANCELLED = 'Scan cancelled';
 const ERROR_WORKER_POOL_CLOSED = 'Worker pool closed';
 // --- Helpers ---
 function resolveOptions(options) {
-    const rest = { ...options };
-    delete rest.signal;
-    delete rest.onProgress;
-    const merged = { ...DEFAULTS, ...rest };
+    const normalizedOptions = omitOptionKeys(options, ['signal', 'onProgress']);
+    const merged = mergeOptions(DEFAULTS, normalizedOptions);
     const result = SearchOptionsSchema.safeParse(merged);
     if (!result.success) {
         throw new McpError(ErrorCode.E_INVALID_INPUT, `Invalid search options: ${result.error.message}`, undefined, { errors: z.treeifyError(result.error) });
     }
     return result.data;
 }
-function countRegexLineMatches(regex, line) {
-    regex.lastIndex = 0;
-    let count = 0;
-    while (regex.exec(line) !== null) {
-        count++;
-        if (regex.lastIndex === 0)
-            regex.lastIndex++;
-    }
-    return count;
-}
-function escapeLiteral(pattern) {
-    return pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-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');
-        return (line) => countRegexLineMatches(regex, line);
-    }
-    // Fast path for case-sensitive literal
-    const needle = pattern;
-    if (needle.length === 0)
-        return () => 0;
-    return (line) => {
-        if (line.length === 0)
-            return 0;
-        let count = 0;
-        let pos = line.indexOf(needle);
-        while (pos !== -1) {
-            count++;
-            pos = line.indexOf(needle, pos + needle.length);
-        }
-        return count;
-    };
-}
-function buildRegexMatcher(final, caseSensitive) {
-    const regex = new RE2(final, caseSensitive ? 'g' : 'gi');
-    return (line) => countRegexLineMatches(regex, line);
-}
-export function buildMatcher(pattern, options) {
-    if (options.isLiteral && pattern.length === 0)
-        return () => 0;
-    if (options.isLiteral && !options.wholeWord) {
-        // fast path for simple literal search
-        return buildLiteralMatcher(pattern, options);
-    }
-    const final = buildRegexPattern(pattern, options);
-    validatePattern(pattern, options); // Re-validate to be safe
-    return buildRegexMatcher(final, options.caseSensitive);
-}
 /**
  * Manages a sliding window of lines and pending context-after buffers.
  */
@@ -291,6 +222,25 @@ async function scanFileResolved(resolvedPath, requestedPath, matcher, options, s
         await handle.close();
     }
 }
+function buildScanFileOptions(opts) {
+    return {
+        maxFileSize: opts.maxFileSize,
+        skipBinary: opts.skipBinary,
+        contextLines: opts.contextLines,
+    };
+}
+function applyScanOutcome(summary, outcome) {
+    if (outcome.matched)
+        summary.filesMatched++;
+    if (outcome.skippedBinary)
+        summary.skippedBinary++;
+    if (outcome.skippedTooLarge)
+        summary.skippedTooLarge++;
+}
+function markTruncated(summary, reason) {
+    summary.truncated = true;
+    summary.stoppedReason = reason;
+}
 function createScanSummary() {
     return {
         filesScanned: 0,
@@ -474,32 +424,21 @@ function getPool() {
 async function executeSequential(files, pattern, opts, signal, summary) {
     const matches = [];
     const matcher = buildMatcher(pattern, opts);
-    const scanOpts = {
-        maxFileSize: opts.maxFileSize,
-        skipBinary: opts.skipBinary,
-        contextLines: opts.contextLines,
-    };
+    const scanOpts = buildScanFileOptions(opts);
     for await (const file of files) {
         if (signal.aborted) {
-            summary.truncated = true;
-            summary.stoppedReason = 'timeout';
+            markTruncated(summary, 'timeout');
             break;
         }
         if (matches.length >= opts.maxResults) {
-            summary.truncated = true;
-            summary.stoppedReason = 'maxResults';
+            markTruncated(summary, 'maxResults');
             break;
         }
         try {
             assertAllowedFileAccess(file.requestedPath, file.resolvedPath);
             const remaining = opts.maxResults - matches.length;
             const result = await scanFileResolved(file.resolvedPath, file.requestedPath, matcher, scanOpts, signal, remaining);
-            if (result.matched)
-                summary.filesMatched++;
-            if (result.skippedBinary)
-                summary.skippedBinary++;
-            if (result.skippedTooLarge)
-                summary.skippedTooLarge++;
+            applyScanOutcome(summary, result);
             matches.push(...result.matches);
         }
         catch {
@@ -542,12 +481,7 @@ function processScanResult(winner, summary, matches, maxResults) {
     }
     if (winner.result) {
         const res = winner.result;
-        if (res.matched)
-            summary.filesMatched++;
-        if (res.skippedBinary)
-            summary.skippedBinary++;
-        if (res.skippedTooLarge)
-            summary.skippedTooLarge++;
+        applyScanOutcome(summary, res);
         const remaining = maxResults - matches.length;
         if (remaining > 0 && res.matches.length > 0) {
             const take = Math.min(remaining, res.matches.length);
@@ -559,13 +493,6 @@ function processScanResult(winner, summary, matches, maxResults) {
         }
     }
 }
-function reportSearchProgress(onProgress, current, total, force = false) {
-    if (!onProgress || current === 0)
-        return;
-    if (!force && current % 25 !== 0)
-        return;
-    onProgress({ current, total });
-}
 async function waitForWinner(pending) {
     const raceCandidates = [];
     for (const task of pending) {
@@ -582,11 +509,7 @@ async function waitForWinner(pending) {
 async function executeParallel(files, pattern, opts, signal, summary) {
     const pool = getPool();
     const matches = [];
-    const scanOpts = {
-        maxFileSize: opts.maxFileSize,
-        skipBinary: opts.skipBinary,
-        contextLines: opts.contextLines,
-    };
+    const scanOpts = buildScanFileOptions(opts);
     const matcherOpts = {
         caseSensitive: opts.caseSensitive,
         wholeWord: opts.wholeWord,
@@ -596,8 +519,7 @@ async function executeParallel(files, pattern, opts, signal, summary) {
     const iterator = files[Symbol.asyncIterator]();
     let exhausted = false;
     const onAbort = () => {
-        summary.truncated = true;
-        summary.stoppedReason = 'timeout';
+        markTruncated(summary, 'timeout');
         for (const t of pending)
             t.cancel();
     };
@@ -629,12 +551,10 @@ async function executeParallel(files, pattern, opts, signal, summary) {
     }
     // Update summary truncation
     if (signal.aborted) {
-        summary.truncated = true;
-        summary.stoppedReason = 'timeout';
+        markTruncated(summary, 'timeout');
     }
     else if (matches.length >= opts.maxResults) {
-        summary.truncated = true;
-        summary.stoppedReason = 'maxResults';
+        markTruncated(summary, 'maxResults');
     }
     return matches;
 }
@@ -649,108 +569,110 @@ export async function scanFileInWorker(resolvedPath, requestedPath, matcher, opt
         skippedTooLarge: res.skippedTooLarge,
     };
 }
+async function searchSingleFile(details, opts, pattern, signal) {
+    const summary = createScanSummary();
+    summary.filesScanned = 1;
+    const matcher = buildMatcher(pattern, opts);
+    const result = await scanFileResolved(details.resolvedPath, details.requestedPath, matcher, {
+        ...buildScanFileOptions(opts),
+    }, signal, opts.maxResults);
+    if (result.matched)
+        summary.filesMatched = 1;
+    return buildSearchResult(path.dirname(details.resolvedPath), pattern, opts.filePattern, result.matches, summary);
+}
+async function searchDirectory(details, opts, pattern, signal, onProgress) {
+    const root = await validateExistingDirectory(details.resolvedPath, signal);
+    const rootDirectories = [root];
+    const stream = globEntries(buildGlobOptions({
+        cwd: root,
+        pattern: opts.filePattern,
+        excludePatterns: opts.excludePatterns,
+        includeHidden: opts.includeHidden,
+        baseNameMatch: opts.baseNameMatch,
+        caseSensitiveMatch: opts.caseSensitiveFileMatch,
+        followSymbolicLinks: false,
+        onlyFiles: true,
+        stats: false,
+        suppressErrors: true,
+    }));
+    async function* fileGenerator() {
+        let scanned = 0;
+        for await (const entry of stream) {
+            if (signal.aborted)
+                break;
+            if (scanned >= opts.maxFilesScanned)
+                break;
+            if (!entry.dirent.isFile())
+                continue;
+            const normalized = normalizePath(entry.path);
+            if (!isPathWithinDirectories(normalized, rootDirectories))
+                continue;
+            if (isSensitivePath(entry.path, normalized))
+                continue;
+            scanned++;
+            reportPeriodicProgress(onProgress, scanned, {
+                total: opts.maxFilesScanned,
+                throttleModulo: 25,
+            });
+            yield { resolvedPath: normalized, requestedPath: entry.path };
+        }
+        reportPeriodicProgress(onProgress, scanned, {
+            total: opts.maxFilesScanned,
+            throttleModulo: 25,
+            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';
+        }
+    }
+    const matcherOpts = {
+        caseSensitive: opts.caseSensitive,
+        wholeWord: opts.wholeWord,
+        isLiteral: opts.isLiteral,
+    };
+    validatePattern(pattern, matcherOpts);
+    const matches = shouldUseWorkers()
+        ? await executeParallel(countingStream(), pattern, opts, signal, summary)
+        : await executeSequential(countingStream(), pattern, opts, signal, summary);
+    return buildSearchResult(root, pattern, opts.filePattern, matches, summary);
+}
+function buildTimeoutSearchResult(basePath, pattern, filePattern) {
+    const timeoutSummary = createScanSummary();
+    markTruncated(timeoutSummary, 'timeout');
+    return buildSearchResult(basePath, pattern, filePattern, [], timeoutSummary);
+}
 export async function searchContent(basePath, pattern, options = {}) {
     if (!basePath.trim())
         throw new McpError(ErrorCode.E_INVALID_INPUT, 'basePath required');
     if (typeof pattern !== 'string')
         throw new McpError(ErrorCode.E_INVALID_INPUT, 'pattern required');
     const opts = resolveOptions(options);
-    const { signal, cleanup } = createTimedAbortSignal(options.signal, opts.timeoutMs);
     try {
-        const details = await validateExistingPathDetailed(basePath, signal);
-        const stats = await withAbort(fsp.stat(details.resolvedPath), signal);
-        // Check if simple file scan
-        if (stats.isFile()) {
-            const summary = createScanSummary();
-            summary.filesScanned = 1;
-            // Single file execution
-            const matcher = buildMatcher(pattern, opts);
-            const result = await scanFileResolved(details.resolvedPath, details.requestedPath, matcher, {
-                maxFileSize: opts.maxFileSize,
-                skipBinary: opts.skipBinary,
-                contextLines: opts.contextLines,
-            }, signal, opts.maxResults);
-            if (result.matched)
-                summary.filesMatched = 1;
-            return buildSearchResult(path.dirname(details.resolvedPath), pattern, opts.filePattern, result.matches, summary);
-        }
-        if (!stats.isDirectory()) {
-            throw new McpError(ErrorCode.E_INVALID_INPUT, `Path must be file or directory`, basePath);
-        }
-        const root = await validateExistingDirectory(details.resolvedPath, signal);
-        const rootDirectories = [root];
-        // Glob
-        const stream = globEntries({
-            cwd: root,
-            pattern: opts.filePattern,
-            excludePatterns: opts.excludePatterns,
-            includeHidden: opts.includeHidden,
-            baseNameMatch: opts.baseNameMatch,
-            caseSensitiveMatch: opts.caseSensitiveFileMatch,
-            followSymbolicLinks: false,
-            onlyFiles: true,
-            stats: false,
-            suppressErrors: true,
-        });
-        // Generator adapter to resolve paths
-        async function* fileGenerator() {
-            let scanned = 0;
-            for await (const entry of stream) {
-                if (signal.aborted)
-                    break;
-                if (scanned >= opts.maxFilesScanned)
-                    break;
-                if (!entry.dirent.isFile())
-                    continue;
-                // Helper to resolve
-                // We duplicate simple resolution logic to keep it fast
-                const normalized = normalizePath(entry.path);
-                if (!isPathWithinDirectories(normalized, rootDirectories))
-                    continue;
-                if (isSensitivePath(entry.path, normalized))
-                    continue;
-                scanned++;
-                reportSearchProgress(options.onProgress, scanned, opts.maxFilesScanned);
-                yield { resolvedPath: normalized, requestedPath: entry.path };
+        return await withTimedAbortSignal(options.signal, opts.timeoutMs, async (signal) => {
+            const details = await validateExistingPathDetailed(basePath, signal);
+            const stats = await withAbort(fsp.stat(details.resolvedPath), signal);
+            if (stats.isFile()) {
+                return searchSingleFile(details, opts, pattern, signal);
             }
-            reportSearchProgress(options.onProgress, scanned, opts.maxFilesScanned, true);
-        }
-        // Choose Strategy
-        // We recreate summary to track actual scans
-        const summary = createScanSummary();
-        const resolvedStream = fileGenerator();
-        // Wrap generator to count scanned files in summary
-        async function* countingStream() {
-            for await (const f of resolvedStream) {
-                summary.filesScanned++;
-                yield f;
+            if (!stats.isDirectory()) {
+                throw new McpError(ErrorCode.E_INVALID_INPUT, 'Path must be file or directory', basePath);
             }
-            if (summary.filesScanned >= opts.maxFilesScanned) {
-                summary.truncated = true;
-                summary.stoppedReason = 'maxFiles';
-            }
-        }
-        const matcherOpts = {
-            caseSensitive: opts.caseSensitive,
-            wholeWord: opts.wholeWord,
-            isLiteral: opts.isLiteral,
-        };
-        validatePattern(pattern, matcherOpts);
-        const matches = shouldUseWorkers()
-            ? await executeParallel(countingStream(), pattern, opts, signal, summary)
-            : await executeSequential(countingStream(), pattern, opts, signal, summary);
-        return buildSearchResult(root, pattern, opts.filePattern, matches, summary);
+            return searchDirectory(details, opts, pattern, signal, options.onProgress);
+        });
     }
     catch (error) {
         if (isTimeoutLikeError(error)) {
-            const timeoutSummary = createScanSummary();
-            timeoutSummary.truncated = true;
-            timeoutSummary.stoppedReason = 'timeout';
-            return buildSearchResult(basePath, pattern, opts.filePattern, [], timeoutSummary);
+            return buildTimeoutSearchResult(basePath, pattern, opts.filePattern);
         }
         throw error;
     }
-    finally {
-        cleanup();
-    }
 }

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

@@ -1,11 +1,13 @@
 import * as path from 'node:path';
 import { DEFAULT_SEARCH_MAX_FILES, DEFAULT_SEARCH_TIMEOUT_MS, } from '../constants.js';
-import { createTimedAbortSignal } from '../fs-helpers.js';
+import { withTimedAbortSignal } from '../fs-helpers.js';
 import { isSensitivePath } from '../path-policy.js';
 import { isPathWithinDirectories, normalizePath, validateExistingDirectory, validateExistingPathDetailed, } from '../path-validation.js';
-import { needsStatsForSort, withOptionalStoppedReason } from './common.js';
+import { reportPeriodicProgress } from '../progress-reporting.js';
+import { compareOptionalNumberDesc, compareStringValues, isEntryAccessibleByType, needsStatsForSort, resolveEntryType, resolveStopReason, stableSortByDerivedString, withOptionalStoppedReason, } from './common.js';
 import { isIgnoredByGitignore, loadRootGitignore } from './gitignore.js';
-import { globEntries, resolveEntryType } from './glob-engine.js';
+import { globEntries } from './glob-engine.js';
+import { buildGlobOptions } from './glob-helpers.js';
 // Internal default for find tool - not exposed to MCP users
 const INTERNAL_MAX_RESULTS = 1000;
 function normalizeOptions(options) {
@@ -41,17 +43,17 @@ function buildSearchResult(entry, entryType, needsStats) {
         ...(modified !== undefined ? { modified } : {}),
     };
 }
-function markStopped(state, reason) {
-    state.truncated = true;
-    state.stoppedReason = reason;
-}
 function shouldStopCollecting(state, normalized, signal) {
-    if (signal.aborted) {
-        markStopped(state, 'timeout');
-        return true;
-    }
-    if (state.filesScanned >= normalized.maxFilesScanned) {
-        markStopped(state, 'maxFiles');
+    const stopReason = resolveStopReason({
+        signal,
+        current: state.filesScanned,
+        max: normalized.maxFilesScanned,
+        abortedReason: 'timeout',
+        maxReason: 'maxFiles',
+    });
+    if (stopReason !== undefined) {
+        state.truncated = true;
+        state.stoppedReason = stopReason;
         return true;
     }
     return false;
@@ -68,7 +70,7 @@ function createCollectState() {
     };
 }
 function buildSearchStream(root, pattern, excludePatterns, normalized, needsStats) {
-    const options = {
+    const options = buildGlobOptions({
         cwd: root,
         pattern,
         excludePatterns,
@@ -78,10 +80,10 @@ function buildSearchStream(root, pattern, excludePatterns, normalized, needsStat
         followSymbolicLinks: false,
         onlyFiles: true,
         stats: needsStats,
-    };
-    if (normalized.maxDepth !== undefined) {
-        options.maxDepth = normalized.maxDepth;
-    }
+        ...(normalized.maxDepth !== undefined
+            ? { maxDepth: normalized.maxDepth }
+            : {}),
+    });
     return globEntries(options);
 }
 function buildCollectResult(state) {
@@ -99,22 +101,19 @@ function buildCollectResult(state) {
 function handleEntry(entry, entryType, needsStats, normalized, state) {
     state.results.push(buildSearchResult(entry, entryType, needsStats));
     if (state.results.length >= normalized.maxResults) {
-        markStopped(state, 'maxResults');
+        state.truncated = true;
+        state.stoppedReason = 'maxResults';
     }
 }
-function reportSearchFilesProgress(onProgress, current, total, force = false) {
-    if (!onProgress || current === 0)
-        return;
-    if (!force && current % 25 !== 0)
-        return;
-    onProgress({ current, total });
-}
-async function collectFromStream(stream, root, rootDirectories, gitignoreMatcher, normalized, needsStats, state, signal, onProgress) {
+async function collectFromStream(stream, root, rootDirectories, gitignoreMatcher, normalized, needsStats, state, signal, accessDeps, onProgress) {
     for await (const entry of stream) {
         if (shouldStopCollecting(state, normalized, signal))
             break;
         state.filesScanned++;
-        reportSearchFilesProgress(onProgress, state.filesScanned, normalized.maxFilesScanned);
+        reportPeriodicProgress(onProgress, state.filesScanned, {
+            total: normalized.maxFilesScanned,
+            throttleModulo: 25,
+        });
         if (isEntryIgnoredByGitignore(gitignoreMatcher, root, entry.path, entry.relativePath)) {
             continue;
         }
@@ -122,7 +121,7 @@ async function collectFromStream(stream, root, rootDirectories, gitignoreMatcher
         if (!shouldIncludeEntry(entryType, normalized)) {
             continue;
         }
-        const isAccessible = await isEntryAccessible(entry, entryType, rootDirectories, signal);
+        const isAccessible = await isEntryAccessibleByType(entry.path, entryType, rootDirectories, signal, accessDeps);
         if (!isAccessible) {
             state.skippedInaccessible++;
             continue;
@@ -131,38 +130,32 @@ async function collectFromStream(stream, root, rootDirectories, gitignoreMatcher
         if (state.truncated)
             break;
     }
-    reportSearchFilesProgress(onProgress, state.filesScanned, normalized.maxFilesScanned, true);
+    reportPeriodicProgress(onProgress, state.filesScanned, {
+        total: normalized.maxFilesScanned,
+        throttleModulo: 25,
+        force: true,
+    });
 }
 function isEntryIgnoredByGitignore(matcher, root, entryPath, relativePath) {
     if (!matcher)
         return false;
     return isIgnoredByGitignore(matcher, root, entryPath, relativePath ? { relativePath } : {});
 }
-async function isEntryAccessible(entry, entryType, rootDirectories, signal) {
-    if (entryType === 'symlink') {
-        try {
-            const validated = await validateExistingPathDetailed(entry.path, signal);
-            return !isSensitivePath(validated.requestedPath, validated.resolvedPath);
-        }
-        catch {
-            return false;
-        }
-    }
-    const resolvedPath = normalizePath(entry.path);
-    if (!isPathWithinDirectories(resolvedPath, rootDirectories)) {
-        return false;
-    }
-    return !isSensitivePath(entry.path, resolvedPath);
-}
 async function collectSearchResults(root, pattern, excludePatterns, normalized, signal, onProgress) {
     const needsStats = needsStatsForSort(normalized.sortBy);
     const stream = buildSearchStream(root, pattern, excludePatterns, normalized, needsStats);
     const state = createCollectState();
     const rootDirectories = [root];
+    const accessDeps = {
+        normalizePath,
+        isPathWithinDirectories,
+        isSensitivePath,
+        validateSymlinkPath: validateExistingPathDetailed,
+    };
     const gitignoreMatcher = normalized.respectGitignore
         ? await loadRootGitignore(root, signal)
         : null;
-    await collectFromStream(stream, root, rootDirectories, gitignoreMatcher, normalized, needsStats, state, signal, onProgress);
+    await collectFromStream(stream, root, rootDirectories, gitignoreMatcher, normalized, needsStats, state, signal, accessDeps, onProgress);
     return buildCollectResult(state);
 }
 function buildSearchSummary(results, filesScanned, truncated, stoppedReason, skippedInaccessible) {
@@ -174,27 +167,17 @@ function buildSearchSummary(results, filesScanned, truncated, stoppedReason, ski
     };
     return withOptionalStoppedReason(summary, stoppedReason);
 }
-const collator = new Intl.Collator(undefined, { numeric: true });
-function compareString(a, b) {
-    return collator.compare(a ?? '', b ?? '');
-}
 function compareNameThenPath(a, b) {
-    const nameCompare = compareString(a.name, b.name);
+    const nameCompare = compareStringValues(a.name, b.name);
     if (nameCompare !== 0)
         return nameCompare;
-    return compareString(a.path, b.path);
+    return compareStringValues(a.path, b.path);
 }
 function comparePathThenName(a, b) {
-    const pathCompare = compareString(a.path, b.path);
+    const pathCompare = compareStringValues(a.path, b.path);
     if (pathCompare !== 0)
         return pathCompare;
-    return compareString(a.name, b.name);
-}
-function compareOptionalNumberDesc(left, right, tieBreak) {
-    const diff = (right ?? 0) - (left ?? 0);
-    if (diff !== 0)
-        return diff;
-    return tieBreak();
+    return compareStringValues(a.name, b.name);
 }
 const SORT_COMPARATORS = {
     size: (a, b) => compareOptionalNumberDesc(a.size, b.size, () => compareNameThenPath(a, b)),
@@ -204,32 +187,7 @@ const SORT_COMPARATORS = {
 };
 export function sortSearchResults(results, sortBy) {
     if (sortBy === 'name') {
-        const decorated = [];
-        for (let index = 0; index < results.length; index += 1) {
-            const item = results[index];
-            if (!item)
-                continue;
-            decorated.push({
-                item,
-                baseName: path.basename(item.path ?? ''),
-                index,
-            });
-        }
-        decorated.sort((a, b) => {
-            const baseCompare = compareString(a.baseName, b.baseName);
-            if (baseCompare !== 0)
-                return baseCompare;
-            const pathCompare = compareString(a.item.path, b.item.path);
-            if (pathCompare !== 0)
-                return pathCompare;
-            return a.index - b.index;
-        });
-        for (let index = 0; index < decorated.length; index += 1) {
-            const entry = decorated[index];
-            if (entry) {
-                results[index] = entry.item;
-            }
-        }
+        stableSortByDerivedString(results, (item) => path.basename(item.path ?? ''), (left, right) => comparePathThenName(left, right));
         return;
     }
     const comparator = SORT_COMPARATORS[sortBy];
@@ -245,9 +203,8 @@ async function runSearchFiles(root, pattern, excludePatterns, normalized, signal
 }
 export async function searchFiles(basePath, pattern, excludePatterns = [], options = {}) {
     const normalized = normalizeOptions(options);
-    const { signal, cleanup } = createTimedAbortSignal(options.signal, normalized.timeoutMs);
-    const root = await validateExistingDirectory(basePath, signal);
-    try {
+    return withTimedAbortSignal(options.signal, normalized.timeoutMs, async (signal) => {
+        const root = await validateExistingDirectory(basePath, signal);
         const { results, summary } = await runSearchFiles(root, pattern, excludePatterns, normalized, signal, options.onProgress);
         return {
             basePath: root,
@@ -255,8 +212,5 @@ export async function searchFiles(basePath, pattern, excludePatterns = [], optio
             results,
             summary,
         };
-    }
-    finally {
-        cleanup();
-    }
+    });
 }