@j0hanz/filesystem-mcp 1.7.3 → 1.9.0

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

@@ -1,12 +1,15 @@
 import * as fsp from 'node:fs/promises';
 import { z } from 'zod';
-import type { ContentMatch, SearchContentResult } from '../../config.js';
+import type { ContentMatch, SearchContentResult, SearchFilesResult } from '../../config.js';
 export declare const MatcherOptionsSchema: z.ZodObject<{
     caseSensitive: z.ZodBoolean;
     wholeWord: z.ZodBoolean;
     isLiteral: z.ZodBoolean;
 }, z.core.$strict>;
 export type MatcherOptions = z.infer<typeof MatcherOptionsSchema>;
+export type Matcher = (line: string) => number;
+export declare function validatePattern(pattern: string, options: MatcherOptions): void;
+export declare function buildMatcher(pattern: string, options: MatcherOptions): Matcher;
 export interface ScanFileOptions {
     maxFileSize: number;
     skipBinary: boolean;
@@ -36,8 +39,6 @@ export interface SearchContentOptions extends Partial<ResolvedOptions> {
         current: number;
     }) => void;
 }
-export type Matcher = (line: string) => number;
-export declare function buildMatcher(pattern: string, options: MatcherOptions): Matcher;
 type BinaryDetector = (resolvedPath: string, handle: fsp.FileHandle, signal?: AbortSignal) => Promise<boolean>;
 export interface ScanRequest {
     type: 'scan';
@@ -73,4 +74,29 @@ interface WorkerScanResult {
 }
 export declare function scanFileInWorker(resolvedPath: string, requestedPath: string, matcher: Matcher, options: ScanFileOptions, maxMatches: number, isCancelled: () => boolean, isBinaryDetector: BinaryDetector): Promise<WorkerScanResult>;
 export declare function searchContent(basePath: string, pattern: string, options?: SearchContentOptions): Promise<SearchContentResult>;
+type SortBy = 'name' | 'size' | 'modified' | 'path';
+interface SearchFilesOptions {
+    maxResults?: number;
+    sortBy?: SortBy;
+    maxDepth?: number;
+    maxFilesScanned?: number;
+    timeoutMs?: number;
+    baseNameMatch?: boolean;
+    skipSymlinks?: boolean;
+    includeHidden?: boolean;
+    respectGitignore?: boolean;
+    signal?: AbortSignal;
+    onProgress?: (progress: {
+        total?: number;
+        current: number;
+    }) => void;
+}
+interface Sortable {
+    name?: string;
+    size?: number;
+    modified?: Date;
+    path?: string;
+}
+export declare function sortSearchResults(results: Sortable[], sortBy: SortBy): void;
+export declare function searchFiles(basePath: string, pattern: string, excludePatterns?: readonly string[], options?: SearchFilesOptions): Promise<SearchFilesResult>;
 export {};

package/dist/lib/file-operations/{search-content.js → search.js}

@@ -1,70 +1,23 @@
 import * as fsp from 'node:fs/promises';
 import * as path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
-import { Worker } from 'node:worker_threads';
-import { z } from 'zod';
+import { parentPort, threadId, Worker, workerData } from 'node:worker_threads';
 import RE2 from 're2';
 import safeRegex from 'safe-regex2';
+import { z } from 'zod';
 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 { assertAllowedFileAccess, isSensitivePath } from '../path-policy.js';
-import { isPathWithinDirectories, normalizePath, validateExistingDirectory, validateExistingPathDetailed, } from '../path-validation.js';
-import { withOptionalStoppedReason } from './common.js';
-import { globEntries } from './glob-engine.js';
-// --- Configuration & Schemas ---
-const INTERNAL_MAX_RESULTS = 500;
+import { assertNotAborted, isProbablyBinary, withAbort, withTimedAbortSignal, } from '../fs-helpers.js';
+import { startPerfMeasure } from '../observability.js';
+import { assertAllowedFileAccess, isPathWithinDirectories, isSensitivePath, normalizePath, validateExistingDirectory, validateExistingPathDetailed, } from '../paths.js';
+import { mergeOptions, omitOptionKeys, reportPeriodicProgress, } from '../utils.js';
+import { compareOptionalNumberDesc, compareStringValues, isEntryAccessibleByType, isIgnoredByGitignore, loadRootGitignore, needsStatsForSort, resolveEntryType, resolveStopReason, stableSortByDerivedString, withOptionalStoppedReason, } from './core.js';
+import { buildGlobOptions, globEntries } from './traversal.js';
 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()),
-    caseSensitive: z.boolean(),
-    maxResults: z.number().int().nonnegative(),
-    maxFileSize: z.number().int().nonnegative(),
-    maxFilesScanned: z.number().int().nonnegative(),
-    timeoutMs: z.number().int().nonnegative(),
-    skipBinary: z.boolean(),
-    contextLines: z.number().int().nonnegative(),
-    wholeWord: z.boolean(),
-    isLiteral: z.boolean(),
-    includeHidden: z.boolean(),
-    baseNameMatch: z.boolean(),
-    caseSensitiveFileMatch: z.boolean(),
-});
-const DEFAULTS = {
-    filePattern: '**/*',
-    excludePatterns: DEFAULT_EXCLUDE_PATTERNS,
-    caseSensitive: false,
-    maxResults: INTERNAL_MAX_RESULTS,
-    maxFileSize: MAX_SEARCHABLE_FILE_SIZE,
-    maxFilesScanned: DEFAULT_SEARCH_MAX_FILES,
-    timeoutMs: DEFAULT_SEARCH_TIMEOUT_MS,
-    skipBinary: true,
-    contextLines: 0,
-    wholeWord: false,
-    isLiteral: true,
-    includeHidden: false,
-    baseNameMatch: false,
-    caseSensitiveFileMatch: true,
-};
-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 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;
@@ -82,7 +35,7 @@ function buildRegexPattern(pattern, options) {
     const escaped = options.isLiteral ? escapeLiteral(pattern) : pattern;
     return options.wholeWord ? `\\b${escaped}\\b` : escaped;
 }
-function validatePattern(pattern, options) {
+export function validatePattern(pattern, options) {
     if (options.isLiteral && pattern.length === 0)
         return;
     if (options.isLiteral && !options.wholeWord)
@@ -129,6 +82,52 @@ export function buildMatcher(pattern, options) {
     validatePattern(pattern, options); // Re-validate to be safe
     return buildRegexMatcher(final, options.caseSensitive);
 }
+// --- Configuration & Schemas ---
+const SEARCH_CONTENT_MAX_RESULTS = 500;
+const SearchOptionsSchema = z.strictObject({
+    filePattern: z.string().min(1),
+    excludePatterns: z.array(z.string()),
+    caseSensitive: z.boolean(),
+    maxResults: z.number().int().nonnegative(),
+    maxFileSize: z.number().int().nonnegative(),
+    maxFilesScanned: z.number().int().nonnegative(),
+    timeoutMs: z.number().int().nonnegative(),
+    skipBinary: z.boolean(),
+    contextLines: z.number().int().nonnegative(),
+    wholeWord: z.boolean(),
+    isLiteral: z.boolean(),
+    includeHidden: z.boolean(),
+    baseNameMatch: z.boolean(),
+    caseSensitiveFileMatch: z.boolean(),
+});
+const DEFAULTS = {
+    filePattern: '**/*',
+    excludePatterns: DEFAULT_EXCLUDE_PATTERNS,
+    caseSensitive: false,
+    maxResults: SEARCH_CONTENT_MAX_RESULTS,
+    maxFileSize: MAX_SEARCHABLE_FILE_SIZE,
+    maxFilesScanned: DEFAULT_SEARCH_MAX_FILES,
+    timeoutMs: DEFAULT_SEARCH_TIMEOUT_MS,
+    skipBinary: true,
+    contextLines: 0,
+    wholeWord: false,
+    isLiteral: true,
+    includeHidden: false,
+    baseNameMatch: false,
+    caseSensitiveFileMatch: true,
+};
+const ERROR_SCAN_CANCELLED = 'Scan cancelled';
+const ERROR_WORKER_POOL_CLOSED = 'Worker pool closed';
+// --- Helpers ---
+function resolveOptions(options) {
+    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;
+}
 /**
  * Manages a sliding window of lines and pending context-after buffers.
  */
@@ -321,7 +320,7 @@ function createScanSummary() {
         stoppedReason: undefined,
     };
 }
-function buildSearchResult(root, pattern, filePattern, matches, summary) {
+function buildSearchContentResult(root, pattern, filePattern, matches, summary) {
     const baseSummary = {
         filesScanned: summary.filesScanned,
         filesMatched: summary.filesMatched,
@@ -562,13 +561,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) {
@@ -654,12 +646,12 @@ async function searchSingleFile(details, opts, pattern, signal) {
     }, signal, opts.maxResults);
     if (result.matched)
         summary.filesMatched = 1;
-    return buildSearchResult(path.dirname(details.resolvedPath), pattern, opts.filePattern, result.matches, summary);
+    return buildSearchContentResult(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({
+    const stream = globEntries(buildGlobOptions({
         cwd: root,
         pattern: opts.filePattern,
         excludePatterns: opts.excludePatterns,
@@ -670,7 +662,7 @@ async function searchDirectory(details, opts, pattern, signal, onProgress) {
         onlyFiles: true,
         stats: false,
         suppressErrors: true,
-    });
+    }));
     async function* fileGenerator() {
         let scanned = 0;
         for await (const entry of stream) {
@@ -686,10 +678,17 @@ async function searchDirectory(details, opts, pattern, signal, onProgress) {
             if (isSensitivePath(entry.path, normalized))
                 continue;
             scanned++;
-            reportSearchProgress(onProgress, scanned, opts.maxFilesScanned);
+            reportPeriodicProgress(onProgress, scanned, {
+                total: opts.maxFilesScanned,
+                throttleModulo: 25,
+            });
             yield { resolvedPath: normalized, requestedPath: entry.path };
         }
-        reportSearchProgress(onProgress, scanned, opts.maxFilesScanned, true);
+        reportPeriodicProgress(onProgress, scanned, {
+            total: opts.maxFilesScanned,
+            throttleModulo: 25,
+            force: true,
+        });
     }
     const summary = createScanSummary();
     const resolvedStream = fileGenerator();
@@ -712,12 +711,12 @@ async function searchDirectory(details, opts, pattern, signal, onProgress) {
     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 buildSearchContentResult(root, pattern, opts.filePattern, matches, summary);
 }
 function buildTimeoutSearchResult(basePath, pattern, filePattern) {
     const timeoutSummary = createScanSummary();
     markTruncated(timeoutSummary, 'timeout');
-    return buildSearchResult(basePath, pattern, filePattern, [], timeoutSummary);
+    return buildSearchContentResult(basePath, pattern, filePattern, [], timeoutSummary);
 }
 export async function searchContent(basePath, pattern, options = {}) {
     if (!basePath.trim())
@@ -725,17 +724,18 @@ export async function searchContent(basePath, pattern, options = {}) {
     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);
-        if (stats.isFile()) {
-            return await searchSingleFile(details, opts, pattern, signal);
-        }
-        if (!stats.isDirectory()) {
-            throw new McpError(ErrorCode.E_INVALID_INPUT, 'Path must be file or directory', basePath);
-        }
-        return await searchDirectory(details, opts, pattern, signal, options.onProgress);
+        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);
+            }
+            if (!stats.isDirectory()) {
+                throw new McpError(ErrorCode.E_INVALID_INPUT, 'Path must be file or directory', basePath);
+            }
+            return searchDirectory(details, opts, pattern, signal, options.onProgress);
+        });
     }
     catch (error) {
         if (isTimeoutLikeError(error)) {
@@ -743,7 +743,334 @@ export async function searchContent(basePath, pattern, options = {}) {
         }
         throw error;
     }
+}
+// Internal default for find tool - not exposed to MCP users
+const SEARCH_FILES_MAX_RESULTS = 1000;
+function normalizeSearchFilesOptions(options) {
+    const normalized = {
+        maxResults: options.maxResults ?? SEARCH_FILES_MAX_RESULTS,
+        sortBy: options.sortBy ?? 'path',
+        maxFilesScanned: options.maxFilesScanned ?? DEFAULT_SEARCH_MAX_FILES,
+        timeoutMs: options.timeoutMs ?? DEFAULT_SEARCH_TIMEOUT_MS,
+        baseNameMatch: options.baseNameMatch ?? false,
+        skipSymlinks: options.skipSymlinks ?? true,
+        includeHidden: options.includeHidden ?? false,
+        respectGitignore: options.respectGitignore ?? false,
+    };
+    if (options.maxDepth !== undefined) {
+        normalized.maxDepth = options.maxDepth;
+    }
+    return normalized;
+}
+function buildSearchFilesResult(entry, entryType, needsStats) {
+    let resolvedType = 'other';
+    if (entryType === 'directory') {
+        resolvedType = 'directory';
+    }
+    else if (entryType === 'file') {
+        resolvedType = 'file';
+    }
+    const size = needsStats && entry.stats?.isFile() ? entry.stats.size : undefined;
+    const modified = needsStats ? entry.stats?.mtime : undefined;
+    return {
+        path: entry.path,
+        type: resolvedType,
+        ...(size !== undefined ? { size } : {}),
+        ...(modified !== undefined ? { modified } : {}),
+    };
+}
+function shouldStopCollecting(state, normalized, signal) {
+    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;
+}
+function shouldIncludeEntry(entryType, normalized) {
+    return !normalized.skipSymlinks || entryType !== 'symlink';
+}
+function createCollectState() {
+    return {
+        results: [],
+        filesScanned: 0,
+        truncated: false,
+        skippedInaccessible: 0,
+    };
+}
+function buildSearchStream(root, pattern, excludePatterns, normalized, needsStats) {
+    const options = buildGlobOptions({
+        cwd: root,
+        pattern,
+        excludePatterns,
+        includeHidden: normalized.includeHidden,
+        baseNameMatch: normalized.baseNameMatch,
+        caseSensitiveMatch: true,
+        followSymbolicLinks: false,
+        onlyFiles: true,
+        stats: needsStats,
+        ...(normalized.maxDepth !== undefined
+            ? { maxDepth: normalized.maxDepth }
+            : {}),
+    });
+    return globEntries(options);
+}
+function buildCollectResult(state) {
+    const outcome = {
+        results: state.results,
+        filesScanned: state.filesScanned,
+        truncated: state.truncated,
+        skippedInaccessible: state.skippedInaccessible,
+    };
+    if (state.stoppedReason !== undefined) {
+        outcome.stoppedReason = state.stoppedReason;
+    }
+    return outcome;
+}
+function handleEntry(entry, entryType, needsStats, normalized, state) {
+    state.results.push(buildSearchFilesResult(entry, entryType, needsStats));
+    if (state.results.length >= normalized.maxResults) {
+        state.truncated = true;
+        state.stoppedReason = 'maxResults';
+    }
+}
+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++;
+        reportPeriodicProgress(onProgress, state.filesScanned, {
+            total: normalized.maxFilesScanned,
+            throttleModulo: 25,
+        });
+        if (isEntryIgnoredByGitignore(gitignoreMatcher, root, entry.path, entry.relativePath)) {
+            continue;
+        }
+        const entryType = resolveEntryType(entry.dirent);
+        if (!shouldIncludeEntry(entryType, normalized)) {
+            continue;
+        }
+        const isAccessible = await isEntryAccessibleByType(entry.path, entryType, rootDirectories, signal, accessDeps);
+        if (!isAccessible) {
+            state.skippedInaccessible++;
+            continue;
+        }
+        handleEntry(entry, entryType, needsStats, normalized, state);
+        if (state.truncated)
+            break;
+    }
+    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 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, accessDeps, onProgress);
+    return buildCollectResult(state);
+}
+function buildSearchSummary(results, filesScanned, truncated, stoppedReason, skippedInaccessible) {
+    const summary = {
+        matched: results.length,
+        truncated,
+        skippedInaccessible,
+        filesScanned,
+    };
+    return withOptionalStoppedReason(summary, stoppedReason);
+}
+function compareNameThenPath(a, b) {
+    const nameCompare = compareStringValues(a.name, b.name);
+    if (nameCompare !== 0)
+        return nameCompare;
+    return compareStringValues(a.path, b.path);
+}
+function comparePathThenName(a, b) {
+    const pathCompare = compareStringValues(a.path, b.path);
+    if (pathCompare !== 0)
+        return pathCompare;
+    return compareStringValues(a.name, b.name);
+}
+const SORT_COMPARATORS = {
+    size: (a, b) => compareOptionalNumberDesc(a.size, b.size, () => compareNameThenPath(a, b)),
+    modified: (a, b) => compareOptionalNumberDesc(a.modified?.getTime(), b.modified?.getTime(), () => compareNameThenPath(a, b)),
+    path: (a, b) => comparePathThenName(a, b),
+    name: (a, b) => compareNameThenPath(a, b),
+};
+export function sortSearchResults(results, sortBy) {
+    if (sortBy === 'name') {
+        stableSortByDerivedString(results, (item) => path.basename(item.path ?? ''), (left, right) => comparePathThenName(left, right));
+        return;
+    }
+    const comparator = SORT_COMPARATORS[sortBy];
+    results.sort(comparator);
+}
+async function runSearchFiles(root, pattern, excludePatterns, normalized, signal, onProgress) {
+    const { results, filesScanned, truncated, stoppedReason, skippedInaccessible, } = await collectSearchResults(root, pattern, excludePatterns, normalized, signal, onProgress);
+    sortSearchResults(results, normalized.sortBy);
+    return {
+        results,
+        summary: buildSearchSummary(results, filesScanned, truncated, stoppedReason, skippedInaccessible),
+    };
+}
+export async function searchFiles(basePath, pattern, excludePatterns = [], options = {}) {
+    const normalized = normalizeSearchFilesOptions(options);
+    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,
+            pattern,
+            results,
+            summary,
+        };
+    });
+}
+const matcherCache = new Map();
+const MAX_MATCHER_CACHE_SIZE = 100;
+function getMatcherCacheKey(pattern, options) {
+    const cs = options.caseSensitive ? '1' : '0';
+    const ww = options.wholeWord ? '1' : '0';
+    const lit = options.isLiteral ? '1' : '0';
+    return `${pattern}|${cs}|${ww}|${lit}`;
+}
+function getCachedMatcher(pattern, options) {
+    const key = getMatcherCacheKey(pattern, options);
+    const cached = matcherCache.get(key);
+    if (cached) {
+        refreshMatcherCacheEntry(key, cached);
+        return cached;
+    }
+    const matcher = buildMatcher(pattern, options);
+    refreshMatcherCacheEntry(key, matcher);
+    evictOldestMatcherIfNeeded();
+    return matcher;
+}
+function refreshMatcherCacheEntry(key, matcher) {
+    matcherCache.delete(key);
+    matcherCache.set(key, matcher);
+}
+function evictOldestMatcherIfNeeded() {
+    if (matcherCache.size <= MAX_MATCHER_CACHE_SIZE)
+        return;
+    const firstKey = matcherCache.keys().next().value;
+    if (firstKey !== undefined) {
+        matcherCache.delete(firstKey);
+    }
+}
+const cancelledRequests = new Set();
+const activeRequests = new Set();
+let shuttingDown = false;
+function maybeFinishShutdown() {
+    if (!shuttingDown)
+        return;
+    if (activeRequests.size > 0)
+        return;
+    parentPort?.close();
+}
+function consumeCancelled(id) {
+    if (!cancelledRequests.has(id)) {
+        return false;
+    }
+    cancelledRequests.delete(id);
+    return true;
+}
+function markCancelledIfActive(id) {
+    if (activeRequests.has(id)) {
+        cancelledRequests.add(id);
+    }
+}
+function buildScanResponse(id, result) {
+    return {
+        type: 'result',
+        id,
+        result,
+    };
+}
+function buildErrorResponse(id, error) {
+    return {
+        type: 'error',
+        id,
+        error: formatUnknownErrorMessage(error),
+    };
+}
+async function handleScanRequest(request) {
+    const { id, resolvedPath, requestedPath, pattern, matcherOptions, scanOptions, maxMatches, } = request;
+    if (consumeCancelled(id))
+        return;
+    activeRequests.add(id);
+    const endMeasure = startPerfMeasure('searchWorker.scan', {
+        maxMatches,
+    });
+    let ok = false;
+    try {
+        const matcher = getCachedMatcher(pattern, matcherOptions);
+        const isCancelled = () => cancelledRequests.has(id);
+        const result = await scanFileInWorker(resolvedPath, requestedPath, matcher, scanOptions, maxMatches, isCancelled, isProbablyBinary);
+        if (consumeCancelled(id))
+            return;
+        parentPort?.postMessage(buildScanResponse(id, result));
+        ok = true;
+    }
+    catch (err) {
+        if (consumeCancelled(id))
+            return;
+        parentPort?.postMessage(buildErrorResponse(id, err));
+    }
     finally {
-        cleanup();
+        activeRequests.delete(id);
+        cancelledRequests.delete(id);
+        endMeasure?.(ok);
+        maybeFinishShutdown();
+    }
+}
+function handleMessage(message) {
+    switch (message.type) {
+        case 'scan':
+            if (shuttingDown)
+                return;
+            void handleScanRequest(message);
+            break;
+        case 'cancel':
+            markCancelledIfActive(message.id);
+            break;
+        case 'shutdown':
+            shuttingDown = true;
+            for (const id of activeRequests) {
+                markCancelledIfActive(id);
+            }
+            maybeFinishShutdown();
+            break;
+    }
+}
+if (parentPort) {
+    parentPort.on('message', handleMessage);
+    const data = workerData;
+    if (data?.debug) {
+        console.error(`[SearchWorker] Started with threadId=${String(threadId)}`);
     }
 }

package/dist/lib/file-operations/{glob-engine.d.ts → traversal.d.ts}

@@ -1,5 +1,5 @@
 import type { Stats } from 'node:fs';
-import type { DirentLike } from './common.js';
+import type { DirentLike } from './core.js';
 interface GlobEntry {
     path: string;
     relativePath?: string;
@@ -20,4 +20,21 @@ export interface GlobEntriesOptions {
     suppressErrors?: boolean;
 }
 export declare function globEntries(options: GlobEntriesOptions): AsyncGenerator<GlobEntry>;
+export interface GlobConfig {
+    cwd: string;
+    pattern: string;
+    excludePatterns?: readonly string[];
+    includeHidden?: boolean;
+    baseNameMatch?: boolean;
+    caseSensitiveMatch?: boolean;
+    followSymbolicLinks?: boolean;
+    onlyFiles?: boolean;
+    stats?: boolean;
+    maxDepth?: number;
+    suppressErrors?: boolean;
+}
+/**
+ * Builds standard options for globEntries to ensure consistency across search tools.
+ */
+export declare function buildGlobOptions(config: GlobConfig): Parameters<typeof globEntries>[0];
 export {};