@j0hanz/filesystem-mcp 1.7.2 → 1.7.3

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

@@ -2,3 +2,45 @@ export declare function needsStatsForSort(sortBy: string): boolean;
 export declare function withOptionalStoppedReason<T extends object, R extends string>(summary: T, stoppedReason: R | undefined): T | (T & {
     stoppedReason: R;
 });
+export interface DirentLike {
+    isDirectory(): boolean;
+    isFile(): boolean;
+    isSymbolicLink(): boolean;
+}
+export type EntryType = 'file' | 'directory' | 'symlink' | 'other';
+export interface IndexedValue<T> {
+    index: number;
+    value: T;
+}
+export interface IndexedError {
+    index: number;
+    error: Error;
+}
+export declare function resolveEntryType(dirent: DirentLike): EntryType;
+export declare function resolveStopReason<R extends string>(options: {
+    signal: AbortSignal;
+    current: number;
+    max: number;
+    abortedReason: R;
+    maxReason: R;
+}): R | undefined;
+export declare function compareStringValues(left?: string, right?: string): number;
+export declare function compareOptionalNumberDesc(left: number | undefined, right: number | undefined, tieBreak: () => number): number;
+export declare function stableSortByDerivedString<T>(items: T[], derive: (item: T) => string, tieBreak: (left: T, right: T) => number): void;
+export declare function applyIndexedValues<T>(output: T[], results: readonly IndexedValue<T>[]): void;
+export declare function applyIndexedErrors<T>(options: {
+    output: T[];
+    errors: readonly IndexedError[];
+    resolveIndex: (failureIndex: number) => number | undefined;
+    buildValue: (resolvedIndex: number, error: Error) => T;
+}): void;
+export interface EntryAccessDependencies {
+    normalizePath: (inputPath: string) => string;
+    isPathWithinDirectories: (normalizedPath: string, rootDirectories: readonly string[]) => boolean;
+    isSensitivePath: (requestedPath: string, resolvedPath: string) => boolean;
+    validateSymlinkPath: (inputPath: string, signal: AbortSignal) => Promise<{
+        requestedPath: string;
+        resolvedPath: string;
+    }>;
+}
+export declare function isEntryAccessibleByType(entryPath: string, entryType: EntryType, rootDirectories: readonly string[], signal: AbortSignal, deps: EntryAccessDependencies): Promise<boolean>;

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

@@ -1,9 +1,96 @@
 export function needsStatsForSort(sortBy) {
     return sortBy === 'size' || sortBy === 'modified';
 }
+const collator = new Intl.Collator(undefined, { numeric: true });
 export function withOptionalStoppedReason(summary, stoppedReason) {
     if (stoppedReason === undefined) {
         return summary;
     }
     return { ...summary, stoppedReason };
 }
+export function resolveEntryType(dirent) {
+    if (dirent.isSymbolicLink())
+        return 'symlink';
+    if (dirent.isDirectory())
+        return 'directory';
+    if (dirent.isFile())
+        return 'file';
+    return 'other';
+}
+export function resolveStopReason(options) {
+    if (options.signal.aborted)
+        return options.abortedReason;
+    if (options.current >= options.max)
+        return options.maxReason;
+    return undefined;
+}
+export function compareStringValues(left, right) {
+    return collator.compare(left ?? '', right ?? '');
+}
+export function compareOptionalNumberDesc(left, right, tieBreak) {
+    const diff = (right ?? 0) - (left ?? 0);
+    if (diff !== 0)
+        return diff;
+    return tieBreak();
+}
+export function stableSortByDerivedString(items, derive, tieBreak) {
+    const decorated = [];
+    for (let index = 0; index < items.length; index += 1) {
+        const item = items[index];
+        if (item === undefined)
+            continue;
+        decorated.push({
+            item,
+            derived: derive(item),
+            index,
+        });
+    }
+    decorated.sort((left, right) => {
+        const derivedCompare = compareStringValues(left.derived, right.derived);
+        if (derivedCompare !== 0)
+            return derivedCompare;
+        const tiedCompare = tieBreak(left.item, right.item);
+        if (tiedCompare !== 0)
+            return tiedCompare;
+        return left.index - right.index;
+    });
+    for (let index = 0; index < decorated.length; index += 1) {
+        const entry = decorated[index];
+        if (!entry)
+            continue;
+        items[index] = entry.item;
+    }
+}
+export function applyIndexedValues(output, results) {
+    for (const result of results) {
+        if (result.index < 0 || result.index >= output.length)
+            continue;
+        output[result.index] = result.value;
+    }
+}
+export function applyIndexedErrors(options) {
+    for (const failure of options.errors) {
+        const resolvedIndex = options.resolveIndex(failure.index);
+        if (resolvedIndex === undefined)
+            continue;
+        if (resolvedIndex < 0 || resolvedIndex >= options.output.length)
+            continue;
+        options.output[resolvedIndex] = options.buildValue(resolvedIndex, failure.error);
+    }
+}
+export async function isEntryAccessibleByType(entryPath, entryType, rootDirectories, signal, deps) {
+    if (entryType !== 'symlink') {
+        const normalizedPath = deps.normalizePath(entryPath);
+        if (!deps.isPathWithinDirectories(normalizedPath, rootDirectories)) {
+            return false;
+        }
+        return !deps.isSensitivePath(entryPath, normalizedPath);
+    }
+    try {
+        const validated = await deps.validateSymlinkPath(entryPath, signal);
+        return !deps.isSensitivePath(validated.requestedPath, validated.resolvedPath);
+    }
+    catch {
+        return false;
+    }
+}

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

@@ -5,6 +5,7 @@ import { isAbortError } from '../errors.js';
 import { assertNotAborted, getFileType, isHidden, processInParallel, withAbort, } from '../fs-helpers.js';
 import { assertAllowedFileAccess } from '../path-policy.js';
 import { validateExistingPathDetailed } from '../path-validation.js';
+import { applyIndexedErrors, applyIndexedValues } from './common.js';
 const PERM_STRINGS = [
     '---',
     '--x',
@@ -95,23 +96,6 @@ async function readFileInfoInParallel(paths, options) {
         return { index, value };
     }, PARALLEL_CONCURRENCY, options.signal);
 }
-function applyResults(output, results) {
-    for (const result of results) {
-        output[result.index] = result.value;
-    }
-}
-function applyErrors(output, errors, paths) {
-    for (const failure of errors) {
-        const { index } = failure;
-        if (!isValidOutputIndex(index, output.length))
-            continue;
-        const filePath = paths[index] ?? UNKNOWN_PATH;
-        output[index] = { path: filePath, error: failure.error.message };
-    }
-}
-function isValidOutputIndex(index, length) {
-    return index >= 0 && index < length;
-}
 function calculateSummary(results) {
     let succeeded = 0;
     let failed = 0;
@@ -140,8 +124,18 @@ export async function getMultipleFileInfo(paths, options = {}) {
         output[index] = { path: paths[index] ?? UNKNOWN_PATH };
     }
     const { results, errors } = await readFileInfoInParallel(paths, options);
-    applyResults(output, results);
-    applyErrors(output, errors, paths);
+    applyIndexedValues(output, results);
+    applyIndexedErrors({
+        output,
+        errors,
+        resolveIndex: (failureIndex) => failureIndex >= 0 && failureIndex < output.length
+            ? failureIndex
+            : undefined,
+        buildValue: (resolvedIndex, error) => ({
+            path: paths[resolvedIndex] ?? UNKNOWN_PATH,
+            error: error.message,
+        }),
+    });
     return {
         results: output,
         summary: calculateSummary(output),

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

@@ -1,10 +1,5 @@
 import type { Stats } from 'node:fs';
-interface DirentLike {
-    isDirectory(): boolean;
-    isFile(): boolean;
-    isSymbolicLink(): boolean;
-}
-export declare function resolveEntryType(dirent: DirentLike): 'file' | 'directory' | 'symlink' | 'other';
+import type { DirentLike } from './common.js';
 interface GlobEntry {
     path: string;
     relativePath?: string;

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

@@ -4,15 +4,6 @@ import { glob as fsGlob } from 'node:fs/promises';
 import { getToolContextSnapshot, publishOpsTraceEnd, publishOpsTraceError, publishOpsTraceStart, shouldPublishOpsTrace, startPerfMeasure, } from '../observability.js';
 import { toPosixPath } from '../path-format.js';
 import { isRecord } from '../type-guards.js';
-export function resolveEntryType(dirent) {
-    if (dirent.isDirectory())
-        return 'directory';
-    if (dirent.isSymbolicLink())
-        return 'symlink';
-    if (dirent.isFile())
-        return 'file';
-    return 'other';
-}
 const GLOB_MAGIC_RE = /[*?[\]{}!]/u;
 const DEFAULT_MAX_HIDDEN_DEPTH = 10;
 const GLOB_BATCH_CONCURRENCY = 64;

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

@@ -1,11 +1,11 @@
 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, processInParallel, withAbort, } from '../fs-helpers.js';
+import { createTimedAbortSignal, isHidden, processInParallel, withAbort, } 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 { globEntries, resolveEntryType } from './glob-engine.js';
+import { isEntryAccessibleByType, needsStatsForSort, resolveEntryType, resolveStopReason, withOptionalStoppedReason, } from './common.js';
+import { globEntries } from './glob-engine.js';
 function normalizePattern(pattern) {
     if (!pattern || pattern.length === 0)
         return undefined;
@@ -40,18 +40,11 @@ function resolveMaxDepth(normalized) {
     }
     return normalized.maxDepth;
 }
-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('.')) {
+        if (!normalized.includeHidden && isHidden(dirent.name)) {
             continue;
         }
         entries.push({ dirent, entryPath: path.join(basePath, dirent.name) });
@@ -149,32 +142,6 @@ function trackSymlink(entryType, includeSymlinkTargets, counters) {
         counters.symlinksNotFollowed += 1;
     }
 }
-async function isEntryAccessible(entryPath, entryType, basePathDirectories, signal, counters) {
-    if (entryType !== 'symlink') {
-        const normalized = normalizePath(entryPath);
-        if (!isPathWithinDirectories(normalized, basePathDirectories)) {
-            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)) {
-            counters.skippedInaccessible += 1;
-            return false;
-        }
-        return true;
-    }
-    catch {
-        counters.skippedInaccessible += 1;
-        return false;
-    }
-}
 function appendEntry(entry, entryType, symlinkTarget, ctx) {
     updateTotals(entryType, ctx.totals);
     ctx.entries.push(buildDirectoryEntry(ctx.basePath, entry, entryType, ctx.needsStats, symlinkTarget));
@@ -214,6 +181,12 @@ async function collectEntries(basePath, normalized, signal, needsStats, maxDepth
     const totals = { files: 0, directories: 0 };
     const counters = { skippedInaccessible: 0, symlinksNotFollowed: 0 };
     const basePathDirectories = [basePath];
+    const accessDeps = {
+        normalizePath,
+        isPathWithinDirectories,
+        isSensitivePath,
+        validateSymlinkPath: validateExistingPathDetailed,
+    };
     let truncated = false;
     let stoppedReason;
     const pending = [];
@@ -232,7 +205,13 @@ async function collectEntries(basePath, normalized, signal, needsStats, maxDepth
         entries,
     };
     for await (const entry of stream) {
-        const stopReason = getStopReason(signal, acceptedCount, normalized.maxEntries);
+        const stopReason = resolveStopReason({
+            signal,
+            current: acceptedCount,
+            max: normalized.maxEntries,
+            abortedReason: 'aborted',
+            maxReason: 'maxEntries',
+        });
         if (stopReason) {
             truncated = true;
             stoppedReason = stopReason;
@@ -240,8 +219,9 @@ async function collectEntries(basePath, normalized, signal, needsStats, maxDepth
         }
         const entryType = resolveEntryType(entry.dirent);
         trackSymlink(entryType, normalized.includeSymlinkTargets, counters);
-        const accessible = await isEntryAccessible(entry.path, entryType, basePathDirectories, signal, counters);
+        const accessible = await isEntryAccessibleByType(entry.path, entryType, basePathDirectories, signal, accessDeps);
         if (!accessible) {
+            counters.skippedInaccessible += 1;
             continue;
         }
         acceptedCount += 1;

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

@@ -2,6 +2,7 @@ import * as fsp from 'node:fs/promises';
 import { DEFAULT_READ_MANY_MAX_TOTAL_SIZE, MAX_TEXT_FILE_SIZE, PARALLEL_CONCURRENCY, } from '../constants.js';
 import { processInParallel, readFile, readFileWithStats, withAbort, } from '../fs-helpers.js';
 import { validateExistingPath } from '../path-validation.js';
+import { applyIndexedErrors, applyIndexedValues } from './common.js';
 const UNKNOWN_PATH = '(unknown)';
 function estimateReadSize(stats, maxSize) {
     // `readFile`/`readFileWithStats` are always invoked with a `maxSize` cap, so the
@@ -173,11 +174,6 @@ function buildOutput(filePaths) {
     }
     return output;
 }
-function applyResults(output, results) {
-    for (const result of results) {
-        output[result.index] = result.value;
-    }
-}
 function resolveErrorOriginalIndex(failureIndex, filesToProcess, totalInputFiles) {
     // processInParallel implementations vary: some return error indices relative to
     // the submitted batch (filesToProcess), others may forward the task/index.
@@ -192,18 +188,6 @@ function resolveErrorOriginalIndex(failureIndex, filesToProcess, totalInputFiles
     }
     return undefined;
 }
-function applyErrors(output, errors, filesToProcess, filePaths) {
-    for (const failure of errors) {
-        const originalIndex = resolveErrorOriginalIndex(failure.index, filesToProcess, filePaths.length);
-        if (originalIndex === undefined)
-            continue;
-        const filePath = filePaths[originalIndex] ?? UNKNOWN_PATH;
-        output[originalIndex] = {
-            path: filePath,
-            error: failure.error.message,
-        };
-    }
-}
 function buildFilesToProcess(filePaths, validated, skippedBudget) {
     const filesToProcess = [];
     for (let index = 0; index < filePaths.length; index += 1) {
@@ -253,8 +237,16 @@ export async function readMultipleFiles(filePaths, options = {}) {
     const { skippedBudget, validated } = await collectFileBudget(filePaths, normalized.maxTotalSize, normalized.maxSize, signal);
     const filesToProcess = buildFilesToProcess(filePaths, validated, skippedBudget);
     const { results, errors } = await readFilesInParallel(filesToProcess, normalized, signal, options.onReadComplete);
-    applyResults(output, results);
-    applyErrors(output, errors, filesToProcess, filePaths);
+    applyIndexedValues(output, results);
+    applyIndexedErrors({
+        output,
+        errors,
+        resolveIndex: (failureIndex) => resolveErrorOriginalIndex(failureIndex, filesToProcess, filePaths.length),
+        buildValue: (resolvedIndex, error) => ({
+            path: filePaths[resolvedIndex] ?? UNKNOWN_PATH,
+            error: error.message,
+        }),
+    });
     applySkippedBudget(output, skippedBudget, filePaths, normalized.maxTotalSize);
     return output;
 }

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

@@ -291,6 +291,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 +493,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 +550,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);
@@ -582,11 +585,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 +595,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 +627,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,6 +645,80 @@ 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({
+        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++;
+            reportSearchProgress(onProgress, scanned, opts.maxFilesScanned);
+            yield { resolvedPath: normalized, requestedPath: entry.path };
+        }
+        reportSearchProgress(onProgress, scanned, opts.maxFilesScanned, 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');
@@ -659,94 +729,17 @@ export async function searchContent(basePath, pattern, options = {}) {
     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);
+            return await 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.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 };
-            }
-            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 (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 await 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;
     }