@j0hanz/filesystem-mcp 1.19.0 → 2.0.0

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

@@ -1,1194 +0,0 @@
-var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
-    if (value !== null && value !== void 0) {
-        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
-        var dispose, inner;
-        if (async) {
-            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
-            dispose = value[Symbol.asyncDispose];
-        }
-        if (dispose === void 0) {
-            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
-            dispose = value[Symbol.dispose];
-            if (async) inner = dispose;
-        }
-        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
-        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
-        env.stack.push({ value: value, dispose: dispose, async: async });
-    }
-    else if (async) {
-        env.stack.push({ async: true });
-    }
-    return value;
-};
-var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
-    return function (env) {
-        function fail(e) {
-            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
-            env.hasError = true;
-        }
-        var r, s = 0;
-        function next() {
-            while (r = env.stack.pop()) {
-                try {
-                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
-                    if (r.dispose) {
-                        var result = r.dispose.call(r.value);
-                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
-                    }
-                    else s |= 1;
-                }
-                catch (e) {
-                    fail(e);
-                }
-            }
-            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
-            if (env.hasError) throw env.error;
-        }
-        return next();
-    };
-})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-});
-import { AsyncResource } from 'node:async_hooks';
-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 { 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 { 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 } 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) {
-    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 buildLiteralMatcher(pattern, options) {
-    if (!options.caseSensitive) {
-        const final = escapeLiteral(pattern);
-        const regex = new RE2(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 flags = caseSensitive ? 'g' : 'gi';
-    const regex = new RE2(final, flags);
-    return (line) => countRegexLineMatches(regex, line);
-}
-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);
-    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: SafeFilePatternSchema,
-    excludePatterns: z.array(z.string()),
-    caseSensitive: z.boolean(),
-    maxResults: z.int().min(0),
-    maxFileSize: z.int().min(0),
-    maxFilesScanned: z.int().min(0),
-    timeoutMs: z.int().min(0),
-    skipBinary: z.boolean(),
-    contextLines: z.int().min(0),
-    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';
-const SEARCH_WORKER_NAME_PREFIX = 'filesystem-search';
-const SEARCH_WORKER_RESOURCE_TYPE = 'SearchWorkerTask';
-// --- 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.INVALID_INPUT, `Invalid search options:\n${z.prettifyError(result.error)}`, undefined, { errors: z.treeifyError(result.error) });
-    }
-    return result.data;
-}
-function getRemainingMatchCapacity(maxMatches, currentMatches, minimum = 0) {
-    return Math.max(minimum, maxMatches - currentMatches);
-}
-/**
- * Manages a sliding window of lines and pending context-after buffers.
- */
-class ContextBuffer {
-    capacity;
-    buffer; // Ring buffer fixed size
-    head = 0; // Next write index
-    size = 0; // Current count of items
-    pending = [];
-    constructor(contextLines) {
-        this.capacity = Math.max(0, contextLines);
-        this.buffer = new Array(this.capacity);
-    }
-    add(line) {
-        // 1. Fill Pending 'After' Contexts
-        if (this.pending.length > 0) {
-            let writeIndex = 0;
-            for (const p of this.pending) {
-                if (p.remaining > 0) {
-                    p.buffer.push(line);
-                    p.remaining--;
-                }
-                if (p.remaining > 0) {
-                    this.pending[writeIndex] = p;
-                    writeIndex++;
-                }
-            }
-            this.pending.length = writeIndex;
-        }
-        // 2. Maintain 'Before' Buffer
-        if (this.capacity > 0) {
-            this.buffer[this.head] = line;
-            this.head = (this.head + 1) % this.capacity;
-            if (this.size < this.capacity) {
-                this.size++;
-            }
-        }
-    }
-    snapshotBefore() {
-        if (this.size === 0)
-            return [];
-        const result = new Array(this.size);
-        if (this.size < this.capacity) {
-            for (let i = 0; i < this.size; i++) {
-                result[i] = this.buffer[i] ?? '';
-            }
-            return result;
-        }
-        let outIndex = 0;
-        for (let i = this.head; i < this.capacity; i++) {
-            result[outIndex] = this.buffer[i] ?? '';
-            outIndex++;
-        }
-        for (let i = 0; i < this.head; i++) {
-            result[outIndex] = this.buffer[i] ?? '';
-            outIndex++;
-        }
-        return result;
-    }
-    scheduleAfter() {
-        if (this.capacity === 0)
-            return [];
-        const buffer = [];
-        this.pending.push({ buffer, remaining: this.capacity });
-        return buffer;
-    }
-}
-function trimContent(line) {
-    return line.length > 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 [];
-    }
-    const matches = [];
-    const hasContext = options.contextLines > 0;
-    const ctx = hasContext ? new ContextBuffer(options.contextLines) : undefined;
-    let lineNumber = 1;
-    // Use for-await with readLines for memory efficiency
-    const lines = handle.readLines({ encoding: 'utf-8', signal });
-    try {
-        for await (const rawLine of lines) {
-            if (matches.length >= maxMatches)
-                break;
-            if (isCancelled())
-                break;
-            const matchCount = matcher(rawLine);
-            let trimmedLine = '';
-            if (matchCount > 0) {
-                trimmedLine = processLineMatch(matches, rawLine, lineNumber, matchCount, requestedPath, ctx);
-            }
-            else if (hasContext) {
-                trimmedLine = trimContent(rawLine);
-            }
-            if (ctx) {
-                ctx.add(trimmedLine);
-            }
-            lineNumber++;
-        }
-    }
-    finally {
-        try {
-            lines.close();
-        }
-        catch {
-            // Ignore close errors; handle cleanup is still managed by the caller.
-        }
-    }
-    return matches;
-}
-async function scanFileResolved(resolvedPath, requestedPath, matcher, options, signal, maxMatches = Number.POSITIVE_INFINITY, injectedBinaryDetector) {
-    const env_1 = { stack: [], error: void 0, hasError: false };
-    try {
-        assertNotAborted(signal);
-        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 {
-                matches: [],
-                matched: false,
-                skippedTooLarge: true,
-                skippedBinary: false,
-            };
-        }
-        if (options.skipBinary) {
-            const detect = injectedBinaryDetector ?? isProbablyBinary;
-            if (await detect(resolvedPath, handle, signal)) {
-                return {
-                    matches: [],
-                    matched: false,
-                    skippedTooLarge: false,
-                    skippedBinary: true,
-                };
-            }
-        }
-        const matches = await readMatches(handle, requestedPath, matcher, options, maxMatches, () => Boolean(signal?.aborted), signal);
-        return {
-            matches,
-            matched: matches.length > 0,
-            skippedTooLarge: false,
-            skippedBinary: false,
-        };
-    }
-    catch (e_1) {
-        env_1.error = e_1;
-        env_1.hasError = true;
-    }
-    finally {
-        const result_1 = __disposeResources(env_1);
-        if (result_1)
-            await result_1;
-    }
-}
-function buildScanFileOptions(opts) {
-    return {
-        maxFileSize: opts.maxFileSize,
-        skipBinary: opts.skipBinary,
-        contextLines: opts.contextLines,
-    };
-}
-function buildMatcherOptions(opts) {
-    return {
-        caseSensitive: opts.caseSensitive,
-        wholeWord: opts.wholeWord,
-        isLiteral: opts.isLiteral,
-    };
-}
-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,
-        filesMatched: 0,
-        skippedTooLarge: 0,
-        skippedBinary: 0,
-        skippedInaccessible: 0,
-        truncated: false,
-        stoppedReason: undefined,
-    };
-}
-function buildSearchContentResult(root, pattern, filePattern, matches, summary) {
-    const baseSummary = {
-        filesScanned: summary.filesScanned,
-        filesMatched: summary.filesMatched,
-        matches: matches.length,
-        truncated: summary.truncated,
-        skippedTooLarge: summary.skippedTooLarge,
-        skippedBinary: summary.skippedBinary,
-        skippedInaccessible: summary.skippedInaccessible,
-    };
-    return {
-        basePath: root,
-        pattern,
-        filePattern,
-        matches,
-        summary: withOptionalStoppedReason(baseSummary, summary.stoppedReason),
-    };
-}
-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() {
-        super(SEARCH_WORKER_RESOURCE_TYPE);
-    }
-    resolve(resolver, result) {
-        this.finish(resolver, result);
-    }
-    reject(rejector, error) {
-        this.finish(rejector, error);
-    }
-    finish(callback, value) {
-        if (this.#settled) {
-            return;
-        }
-        this.#settled = true;
-        this.runInAsyncScope(callback, undefined, value);
-        this.emitDestroy();
-    }
-}
-class SearchWorkerPool {
-    size;
-    debug;
-    workers;
-    pending = new Map();
-    nextRequestId = 0;
-    closed = false;
-    workerRoundRobin = 0;
-    constructor(size, debug) {
-        this.size = size;
-        this.debug = debug;
-        if (size <= 0)
-            throw new Error('Pool size must be positive');
-        this.workers = Array.from({ length: size }, () => undefined);
-    }
-    normalizeWorkerError(error, fallbackMessage) {
-        if (error instanceof Error) {
-            return error;
-        }
-        return new Error(`${fallbackMessage}: ${formatUnknownErrorMessage(error)}`);
-    }
-    rejectPendingForWorker(workerIndex, error) {
-        for (const [id, pendingRequest] of this.pending) {
-            if (pendingRequest.workerIndex !== workerIndex) {
-                continue;
-            }
-            this.pending.delete(id);
-            pendingRequest.reject(error);
-        }
-    }
-    markWorkerAsUnavailable(workerIndex, expectedWorker) {
-        if (this.closed)
-            return;
-        if (this.workers[workerIndex] !== expectedWorker)
-            return;
-        this.workers[workerIndex] = undefined;
-    }
-    getWorker(workerIndex) {
-        const existing = this.workers[workerIndex];
-        if (existing)
-            return existing;
-        const worker = this.initWorker(workerIndex);
-        this.workers[workerIndex] = worker;
-        return worker;
-    }
-    initWorker(index) {
-        const worker = new Worker(WORKER_SCRIPT_URL, {
-            name: `${SEARCH_WORKER_NAME_PREFIX}-${String(index)}`,
-            workerData: { debug: this.debug },
-            execArgv: isSourceContext ? ['--import', 'tsx/esm'] : undefined,
-        });
-        worker.on('message', (msg) => {
-            const p = this.pending.get(msg.id);
-            if (!p)
-                return;
-            this.pending.delete(msg.id);
-            if (msg.type === 'result')
-                p.resolve(msg.result);
-            else
-                p.reject(new Error(msg.error));
-        });
-        worker.on('messageerror', (error) => {
-            const normalized = this.normalizeWorkerError(error, `Worker ${String(index)} failed to deserialize a message`);
-            this.rejectPendingForWorker(index, normalized);
-            this.markWorkerAsUnavailable(index, worker);
-        });
-        worker.on('error', (error) => {
-            this.rejectPendingForWorker(index, error);
-            this.markWorkerAsUnavailable(index, worker);
-        });
-        worker.on('exit', (exitCode) => {
-            if (this.closed)
-                return;
-            this.rejectPendingForWorker(index, new Error(`Worker ${String(index)} exited with code ${String(exitCode)}`));
-            this.markWorkerAsUnavailable(index, worker);
-        });
-        worker.unref();
-        return worker;
-    }
-    scan(req) {
-        if (this.closed)
-            throw new Error(ERROR_WORKER_POOL_CLOSED);
-        const id = this.nextRequestId++;
-        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);
-        const promise = new Promise((resolve, reject) => {
-            const resource = new SearchWorkerTaskResource();
-            const pendingRequest = {
-                resolve: (result) => {
-                    resource.resolve(resolve, result);
-                },
-                reject: (error) => {
-                    resource.reject(reject, error);
-                },
-                workerIndex,
-            };
-            this.pending.set(id, pendingRequest);
-            try {
-                worker.postMessage({ type: 'scan', id, ...req });
-            }
-            catch (error) {
-                this.pending.delete(id);
-                pendingRequest.reject(this.normalizeWorkerError(error, `Failed to post scan request ${String(id)} to worker ${String(workerIndex)}`));
-                this.markWorkerAsUnavailable(workerIndex, worker);
-            }
-        });
-        return {
-            id,
-            promise,
-            cancel: () => {
-                const entry = this.pending.get(id);
-                if (entry) {
-                    this.pending.delete(id);
-                    try {
-                        worker.postMessage({ type: 'cancel', id });
-                    }
-                    catch {
-                        // Worker may already be terminating
-                    }
-                    entry.reject(new Error(ERROR_SCAN_CANCELLED));
-                }
-            },
-        };
-    }
-    async close() {
-        this.closed = true;
-        for (const p of this.pending.values())
-            p.reject(new Error(ERROR_WORKER_POOL_CLOSED));
-        this.pending.clear();
-        const terminations = [];
-        for (let index = 0; index < this.workers.length; index += 1) {
-            const worker = this.workers[index];
-            if (!worker)
-                continue;
-            terminations.push(worker.terminate());
-            this.workers[index] = undefined;
-        }
-        await Promise.all(terminations);
-    }
-}
-function isWorkerPoolAvailable() {
-    return !isSourceContext && hasWorkerScript;
-}
-function shouldUseWorkers() {
-    return isWorkerPoolAvailable() && SEARCH_WORKERS >= 2;
-}
-let poolInstance = null;
-function getPool() {
-    if (!poolInstance) {
-        const debug = process.env['FS_CONTEXT_SEARCH_WORKERS_DEBUG'] === '1';
-        poolInstance = new SearchWorkerPool(SEARCH_WORKERS, debug);
-    }
-    return poolInstance;
-}
-// --- Execution Strategies ---
-async function executeSequential(files, pattern, opts, signal, summary) {
-    const matches = [];
-    const matcher = buildMatcher(pattern, buildMatcherOptions(opts));
-    const scanOpts = buildScanFileOptions(opts);
-    for await (const file of files) {
-        if (signal.aborted) {
-            markTruncated(summary, 'timeout');
-            break;
-        }
-        if (matches.length >= opts.maxResults) {
-            markTruncated(summary, 'maxResults');
-            break;
-        }
-        try {
-            assertAllowedFileAccess(file.requestedPath, file.resolvedPath);
-            const remaining = getRemainingMatchCapacity(opts.maxResults, matches.length);
-            const result = await scanFileResolved(file.resolvedPath, file.requestedPath, matcher, scanOpts, signal, remaining);
-            applyScanOutcome(summary, result);
-            matches.push(...result.matches);
-        }
-        catch {
-            // Ignore access errors during mass scan
-            summary.skippedInaccessible++;
-        }
-    }
-    return matches;
-}
-async function fillWorkerPool(context) {
-    const { pool, pending, iterator, pattern, matcherOpts, scanOpts, maxResults, currentMatches, summary, } = context;
-    while (pending.size < SEARCH_WORKERS) {
-        const result = await iterator.next();
-        if (result.done)
-            return true;
-        try {
-            const remaining = getRemainingMatchCapacity(maxResults, currentMatches, 1);
-            const task = pool.scan({
-                resolvedPath: result.value.resolvedPath,
-                requestedPath: result.value.requestedPath,
-                pattern,
-                matcherOptions: matcherOpts,
-                scanOptions: scanOpts,
-                maxMatches: remaining,
-            });
-            pending.add(task);
-        }
-        catch {
-            summary.skippedInaccessible++;
-        }
-    }
-    return false;
-}
-function processScanResult(winner, summary, matches, maxResults) {
-    if (winner.error) {
-        if (winner.error.message !== ERROR_SCAN_CANCELLED) {
-            summary.skippedInaccessible++;
-        }
-        return;
-    }
-    if (winner.result) {
-        const res = winner.result;
-        applyScanOutcome(summary, res);
-        const remaining = getRemainingMatchCapacity(maxResults, matches.length);
-        if (remaining > 0 && res.matches.length > 0) {
-            const take = Math.min(remaining, res.matches.length);
-            for (let index = 0; index < take; index += 1) {
-                const match = res.matches[index];
-                if (match)
-                    matches.push(match);
-            }
-        }
-    }
-}
-async function waitForWinner(pending) {
-    const raceCandidates = [];
-    for (const task of pending) {
-        task.racePromise ??= task.promise.then((result) => ({ task, result, error: undefined }), (err) => ({
-            task,
-            result: undefined,
-            error: err instanceof Error
-                ? err
-                : new Error(formatUnknownErrorMessage(err)),
-        }));
-        raceCandidates.push(task.racePromise);
-    }
-    return Promise.race(raceCandidates);
-}
-function updateParallelTruncation(summary, signal, matchesLength, maxResults) {
-    if (signal.aborted) {
-        markTruncated(summary, 'timeout');
-        return;
-    }
-    if (matchesLength >= maxResults) {
-        markTruncated(summary, 'maxResults');
-    }
-}
-async function executeParallel(files, pattern, opts, signal, summary) {
-    const pool = getPool();
-    const matches = [];
-    const scanOpts = buildScanFileOptions(opts);
-    const matcherOpts = buildMatcherOptions(opts);
-    const pending = new Set();
-    const iterator = files[Symbol.asyncIterator]();
-    let exhausted = false;
-    const onAbort = () => {
-        markTruncated(summary, 'timeout');
-        for (const t of pending)
-            t.cancel();
-    };
-    signal.addEventListener('abort', onAbort, { once: true });
-    try {
-        for (;;) {
-            if (signal.aborted || matches.length >= opts.maxResults) {
-                break;
-            }
-            if (!exhausted) {
-                exhausted = await fillWorkerPool({
-                    pool,
-                    pending,
-                    iterator,
-                    pattern,
-                    matcherOpts,
-                    scanOpts,
-                    maxResults: opts.maxResults,
-                    currentMatches: matches.length,
-                    summary,
-                });
-            }
-            if (pending.size === 0 && exhausted) {
-                break;
-            }
-            // Wait for at least one
-            const winner = await waitForWinner(pending);
-            pending.delete(winner.task);
-            processScanResult(winner, summary, matches, opts.maxResults);
-        }
-    }
-    finally {
-        signal.removeEventListener('abort', onAbort);
-        // Cancel remaining
-        for (const t of pending)
-            t.cancel();
-        if (iterator.return)
-            await iterator.return();
-    }
-    updateParallelTruncation(summary, signal, matches.length, opts.maxResults);
-    return matches;
-}
-// --- Entry Points ---
-async function scanFileInWorker(resolvedPath, requestedPath, matcher, options, maxMatches, isCancelled, isBinaryDetector) {
-    // Direct scan used by worker script
-    const res = await scanFileResolved(resolvedPath, requestedPath, matcher, options, undefined, maxMatches, isBinaryDetector);
-    return {
-        matches: res.matches,
-        matched: res.matched,
-        skippedBinary: res.skippedBinary,
-        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 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);
-    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,
-    }));
-    const summary = createScanSummary();
-    async function* fileGenerator() {
-        for await (const entry of stream) {
-            if (signal.aborted)
-                break;
-            if (summary.filesScanned >= opts.maxFilesScanned)
-                break;
-            if (!entry.dirent.isFile())
-                continue;
-            const normalized = normalizePath(entry.path);
-            if (!isPathWithinDirectories(normalized, rootDirectories))
-                continue;
-            if (isSensitivePath(entry.path, normalized))
-                continue;
-            summary.filesScanned++;
-            onProgress?.({
-                current: summary.filesScanned,
-                total: opts.maxFilesScanned,
-            });
-            yield { resolvedPath: normalized, requestedPath: entry.path };
-        }
-        if (summary.filesScanned >= opts.maxFilesScanned) {
-            summary.truncated = true;
-            summary.stoppedReason = 'maxFiles';
-        }
-        onProgress?.({
-            current: summary.filesScanned,
-            total: opts.maxFilesScanned,
-        });
-    }
-    const matches = shouldUseWorkers()
-        ? 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) {
-    const timeoutSummary = createScanSummary();
-    markTruncated(timeoutSummary, 'timeout');
-    return buildSearchContentResult(basePath, pattern, filePattern, [], timeoutSummary);
-}
-export async function searchContent(basePath, pattern, options = {}) {
-    if (!basePath.trim())
-        throw new McpError(ErrorCode.INVALID_INPUT, 'basePath required');
-    if (typeof pattern !== 'string')
-        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(stat(details.resolvedPath), signal);
-            if (stats.isFile()) {
-                return searchSingleFile(details, opts, pattern, signal);
-            }
-            if (!stats.isDirectory()) {
-                throw new McpError(ErrorCode.INVALID_INPUT, 'Path must be file or directory', basePath);
-            }
-            return searchDirectory(details, opts, pattern, signal, options.onProgress);
-        });
-    }
-    catch (error) {
-        if (isTimeoutLikeError(error)) {
-            return buildTimeoutSearchResult(basePath, pattern, opts.filePattern);
-        }
-        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, signal, context) {
-    const { root, rootDirectories, gitignoreMatcher, normalized, needsStats, state, accessDeps, onProgress, } = context;
-    for await (const entry of stream) {
-        if (shouldStopCollecting(state, normalized, signal))
-            break;
-        state.filesScanned++;
-        onProgress?.({
-            current: state.filesScanned,
-            total: normalized.maxFilesScanned,
-        });
-        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;
-    }
-    onProgress?.({
-        current: state.filesScanned,
-        total: normalized.maxFilesScanned,
-    });
-}
-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, signal, {
-        root,
-        rootDirectories,
-        gitignoreMatcher,
-        normalized,
-        needsStats,
-        state,
-        accessDeps,
-        ...(onProgress ? { 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),
-};
-function sortSearchResults(results, sortBy) {
-    if (sortBy === 'name') {
-        stableSortByDerivedString(results, (item) => 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 {
-        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;
-    }
-}
-const log = debuglog('search-worker');
-if (parentPort) {
-    parentPort.on('message', handleMessage);
-    const data = workerData;
-    if (data?.debug) {
-        log(`Started with threadId=${String(threadId)}`);
-    }
-}