@j0hanz/fs-context-mcp 2.0.0 → 2.0.2

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

@@ -1,5 +1,857 @@
-import { executeSearch } from './search/engine.js';
-export async function searchContent(basePath, searchPattern, options = {}) {
-    return executeSearch(basePath, searchPattern, options, options.signal);
+import * as fsp from 'node:fs/promises';
+import * as path from 'node:path';
+import readline from 'node:readline';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { Worker } from 'node:worker_threads';
+import RE2 from 're2';
+import safeRegex from 'safe-regex2';
+import { DEFAULT_SEARCH_MAX_FILES, DEFAULT_SEARCH_TIMEOUT_MS, MAX_LINE_CONTENT_LENGTH, MAX_SEARCHABLE_FILE_SIZE, SEARCH_WORKERS, } from '../constants.js';
+import { assertNotAborted, createTimedAbortSignal, isProbablyBinary, withAbort, } from '../fs-helpers.js';
+import { publishOpsTraceEnd, publishOpsTraceError, publishOpsTraceStart, shouldPublishOpsTrace, } from '../observability.js';
+import { getAllowedDirectories, isPathWithinDirectories, normalizePath, toAccessDeniedWithHint, validateExistingDirectory, validateExistingPathDetailed, } from '../path-validation.js';
+import { globEntries } from './glob-engine.js';
+const INTERNAL_MAX_RESULTS = 500;
+const DEFAULTS = {
+    filePattern: '**/*',
+    excludePatterns: [],
+    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,
+};
+function mergeOptions(partial) {
+    const rest = { ...partial };
+    delete rest.signal;
+    return { ...DEFAULTS, ...rest };
+}
+function validatePattern(pattern, options) {
+    if (options.isLiteral && !options.wholeWord) {
+        return;
+    }
+    const final = buildRegexPattern(pattern, options);
+    assertSafePattern(final, pattern);
+}
+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 assertSafePattern(final, original) {
+    if (!safeRegex(final)) {
+        throw new Error(`Potentially unsafe regular expression (ReDoS risk): ${original}`);
+    }
+}
+function buildLiteralMatcher(pattern, options) {
+    const needle = options.caseSensitive ? pattern : pattern.toLowerCase();
+    return (line) => {
+        const hay = options.caseSensitive ? line : line.toLowerCase();
+        if (needle.length === 0 || hay.length === 0)
+            return 0;
+        let count = 0;
+        let pos = hay.indexOf(needle);
+        while (pos !== -1) {
+            count++;
+            pos = hay.indexOf(needle, pos + needle.length);
+        }
+        return count;
+    };
+}
+function buildRegexMatcher(final, caseSensitive) {
+    const regex = new RE2(final, caseSensitive ? 'g' : 'gi');
+    return (line) => {
+        regex.lastIndex = 0;
+        let count = 0;
+        let match;
+        while ((match = regex.exec(line)) !== null) {
+            count++;
+            if (match[0].length === 0) {
+                regex.lastIndex++;
+            }
+        }
+        return count;
+    };
+}
+export function buildMatcher(pattern, options) {
+    if (options.isLiteral && !options.wholeWord && !options.caseSensitive) {
+        if (pattern.length === 0) {
+            return () => 0;
+        }
+        return buildRegexMatcher(escapeLiteral(pattern), false);
+    }
+    if (options.isLiteral && !options.wholeWord) {
+        return buildLiteralMatcher(pattern, options);
+    }
+    const final = buildRegexPattern(pattern, options);
+    assertSafePattern(final, pattern);
+    return buildRegexMatcher(final, options.caseSensitive);
+}
+function makeContext() {
+    return { before: [], pendingAfter: [] };
+}
+function pushContext(ctx, line, max) {
+    if (max <= 0)
+        return;
+    ctx.before.push(line);
+    if (ctx.before.length > max)
+        ctx.before.shift();
+    for (const pending of ctx.pendingAfter) {
+        if (pending.left <= 0)
+            continue;
+        pending.buffer.push(line);
+        pending.left -= 1;
+    }
+    while (ctx.pendingAfter.length > 0 && ctx.pendingAfter[0]?.left === 0) {
+        ctx.pendingAfter.shift();
+    }
+}
+function trimContent(line) {
+    return line.trimEnd().slice(0, MAX_LINE_CONTENT_LENGTH);
+}
+function buildReadline(handle, signal) {
+    const input = handle.createReadStream({
+        encoding: 'utf-8',
+        autoClose: false,
+    });
+    const baseOptions = {
+        input,
+        crlfDelay: Infinity,
+    };
+    const options = signal ? { ...baseOptions, signal } : baseOptions;
+    const rl = readline.createInterface(options);
+    return { rl, input };
+}
+function updateContext(line, contextLines, ctx) {
+    if (contextLines <= 0)
+        return undefined;
+    const trimmedLine = trimContent(line);
+    pushContext(ctx, trimmedLine, contextLines);
+    return trimmedLine;
+}
+function appendMatch(matches, requestedPath, line, trimmedLine, lineNo, count, contextLines, ctx) {
+    const contextBefore = contextLines > 0 ? [...ctx.before] : undefined;
+    const contextAfterBuffer = contextLines > 0 ? [] : undefined;
+    const match = {
+        file: requestedPath,
+        line: lineNo,
+        content: trimmedLine ?? trimContent(line),
+        matchCount: count,
+        ...(contextBefore ? { contextBefore } : {}),
+        ...(contextAfterBuffer ? { contextAfter: contextAfterBuffer } : {}),
+    };
+    matches.push(match);
+    if (contextAfterBuffer) {
+        ctx.pendingAfter.push({
+            buffer: contextAfterBuffer,
+            left: contextLines,
+        });
+    }
+}
+function recordLineMatch(line, matcher, options, requestedPath, lineNo, matches, ctx) {
+    const trimmedLine = updateContext(line, options.contextLines, ctx);
+    const count = matcher(line);
+    if (count > 0) {
+        appendMatch(matches, requestedPath, line, trimmedLine, lineNo, count, options.contextLines, ctx);
+    }
+}
+async function readLoop(rl, matcher, options, requestedPath, maxMatches, isCancelled, matches, ctx) {
+    let lineNo = 0;
+    for await (const line of rl) {
+        if (isCancelled())
+            break;
+        lineNo++;
+        recordLineMatch(line, matcher, options, requestedPath, lineNo, matches, ctx);
+        if (matches.length >= maxMatches)
+            break;
+    }
+}
+function buildSkipResult(skippedTooLarge, skippedBinary) {
+    return {
+        matches: [],
+        matched: false,
+        skippedTooLarge,
+        skippedBinary,
+    };
+}
+function buildMatchResult(matches) {
+    return {
+        matches,
+        matched: matches.length > 0,
+        skippedTooLarge: false,
+        skippedBinary: false,
+    };
+}
+async function shouldSkipBinary(scanOptions, resolvedPath, handle, options) {
+    return (scanOptions.skipBinary &&
+        (await options.isProbablyBinary(resolvedPath, handle, options.signal)));
+}
+async function readMatches(handle, requestedPath, matcher, options, maxMatches, isCancelled, signal) {
+    const { rl, input } = buildReadline(handle, signal);
+    const ctx = makeContext();
+    const matches = [];
+    try {
+        await readLoop(rl, matcher, options, requestedPath, maxMatches, isCancelled, matches, ctx);
+        return matches;
+    }
+    finally {
+        rl.close();
+        input.destroy();
+    }
+}
+async function scanWithHandle(handle, resolvedPath, requestedPath, options) {
+    const scanOptions = options.options;
+    const stats = await withAbort(handle.stat(), options.signal);
+    if (stats.size > scanOptions.maxFileSize) {
+        return buildSkipResult(true, false);
+    }
+    if (await shouldSkipBinary(scanOptions, resolvedPath, handle, options)) {
+        return buildSkipResult(false, true);
+    }
+    const matches = await readMatches(handle, requestedPath, options.matcher, scanOptions, options.maxMatches, options.isCancelled, options.signal);
+    return buildMatchResult(matches);
+}
+async function scanFileWithMatcher(resolvedPath, requestedPath, options) {
+    assertNotAborted(options.signal);
+    const handle = await withAbort(fsp.open(resolvedPath, 'r'), options.signal);
+    try {
+        return await scanWithHandle(handle, resolvedPath, requestedPath, options);
+    }
+    finally {
+        await handle.close();
+    }
+}
+async function scanFileResolved(resolvedPath, requestedPath, matcher, options, signal, maxMatches = Number.POSITIVE_INFINITY) {
+    const scanOptions = {
+        matcher,
+        options,
+        maxMatches,
+        isCancelled: () => Boolean(signal?.aborted),
+        isProbablyBinary,
+    };
+    if (signal) {
+        scanOptions.signal = signal;
+    }
+    return scanFileWithMatcher(resolvedPath, requestedPath, scanOptions);
+}
+export async function scanFileInWorker(resolvedPath, requestedPath, matcher, options, maxMatches, isCancelled, isBinaryDetector) {
+    const result = await scanFileWithMatcher(resolvedPath, requestedPath, {
+        matcher,
+        options,
+        maxMatches,
+        isCancelled,
+        isProbablyBinary: isBinaryDetector,
+    });
+    return {
+        matches: result.matches,
+        matched: result.matched,
+        skippedTooLarge: result.skippedTooLarge,
+        skippedBinary: result.skippedBinary,
+    };
+}
+function resolveNonSymlinkPath(entryPath, allowedDirs) {
+    const normalized = normalizePath(entryPath);
+    if (!isPathWithinDirectories(normalized, allowedDirs)) {
+        throw toAccessDeniedWithHint(entryPath, normalized, normalized);
+    }
+    return { resolvedPath: normalized, requestedPath: normalized };
+}
+function createScanSummary() {
+    return {
+        filesScanned: 0,
+        filesMatched: 0,
+        skippedTooLarge: 0,
+        skippedBinary: 0,
+        skippedInaccessible: 0,
+        truncated: false,
+        stoppedReason: undefined,
+    };
+}
+function shouldStopCollecting(summary, maxFilesScanned, signal) {
+    if (signal.aborted) {
+        summary.truncated = true;
+        summary.stoppedReason = 'timeout';
+        return true;
+    }
+    if (summary.filesScanned >= maxFilesScanned) {
+        summary.truncated = true;
+        summary.stoppedReason = 'maxFiles';
+        return true;
+    }
+    return false;
+}
+async function resolveEntryPath(entry, allowedDirs, signal) {
+    try {
+        return entry.dirent.isSymbolicLink()
+            ? await validateExistingPathDetailed(entry.path, signal)
+            : resolveNonSymlinkPath(entry.path, allowedDirs);
+    }
+    catch {
+        return null;
+    }
+}
+async function* collectFromStream(stream, opts, allowedDirs, signal, summary) {
+    for await (const entry of stream) {
+        if (!entry.dirent.isFile())
+            continue;
+        if (shouldStopCollecting(summary, opts.maxFilesScanned, signal)) {
+            break;
+        }
+        const resolved = await resolveEntryPath(entry, allowedDirs, signal);
+        if (!resolved) {
+            summary.skippedInaccessible++;
+            continue;
+        }
+        summary.filesScanned++;
+        yield resolved;
+    }
+}
+function collectFilesStream(root, opts, allowedDirs, signal) {
+    const summary = createScanSummary();
+    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,
+    });
+    return {
+        stream: collectFromStream(stream, opts, allowedDirs, signal, summary),
+        summary,
+    };
+}
+function shouldStopOnSignalOrLimit(signal, matchesCount, maxResults, summary) {
+    if (signal.aborted) {
+        summary.truncated = true;
+        summary.stoppedReason = 'timeout';
+        return true;
+    }
+    if (matchesCount >= maxResults) {
+        summary.truncated = true;
+        summary.stoppedReason = 'maxResults';
+        return true;
+    }
+    return false;
+}
+function applyScanResult(result, matches, summary, remaining) {
+    if (result.skippedTooLarge)
+        summary.skippedTooLarge++;
+    if (result.skippedBinary)
+        summary.skippedBinary++;
+    if (result.matched)
+        summary.filesMatched++;
+    if (result.matches.length > 0 && remaining > 0) {
+        matches.push(...result.matches.slice(0, remaining));
+    }
+}
+async function scanSequentialFile(file, matcher, scanOptions, signal, maxResults, matches, summary) {
+    try {
+        const remaining = maxResults - matches.length;
+        const result = await scanFileResolved(file.resolvedPath, file.requestedPath, matcher, scanOptions, signal, remaining);
+        applyScanResult(result, matches, summary, remaining);
+    }
+    catch {
+        summary.skippedInaccessible++;
+    }
+}
+async function collectSequentialMatches(files, matcher, scanOptions, maxResults, signal, summary) {
+    const matches = [];
+    for await (const file of files) {
+        if (shouldStopOnSignalOrLimit(signal, matches.length, maxResults, summary)) {
+            break;
+        }
+        await scanSequentialFile(file, matcher, scanOptions, signal, maxResults, matches, summary);
+    }
+    return matches;
+}
+async function scanFilesSequential(files, pattern, matcherOptions, scanOptions, maxResults, signal, summary) {
+    const matcher = buildMatcher(pattern, matcherOptions);
+    return await collectSequentialMatches(files, matcher, scanOptions, maxResults, signal, summary);
+}
+const currentDir = path.dirname(fileURLToPath(import.meta.url));
+const currentFile = fileURLToPath(import.meta.url);
+const isSourceContext = currentFile.endsWith('.ts');
+const WORKER_SCRIPT_PATH = path.join(currentDir, isSourceContext ? 'search-worker.ts' : 'search-worker.js');
+const WORKER_SCRIPT_URL = pathToFileURL(WORKER_SCRIPT_PATH);
+const MAX_RESPAWNS = 3;
+function handleWorkerMessage(slot, message, log) {
+    const pending = slot.pending.get(message.id);
+    if (!pending) {
+        log(`Received message for unknown request ${String(message.id)}`);
+        return;
+    }
+    slot.pending.delete(message.id);
+    if (message.type === 'result') {
+        pending.resolve(message.result);
+    }
+    else {
+        pending.reject(new Error(message.error));
+    }
+}
+function handleWorkerError(slot, error, log) {
+    log(`Worker ${String(slot.index)} error: ${error.message}`);
+    for (const [, pending] of slot.pending) {
+        pending.reject(new Error(`Worker error: ${error.message}`));
+    }
+    slot.pending.clear();
+    slot.worker?.terminate().catch(() => { });
+    slot.worker = null;
+}
+function handleWorkerExit(slot, code, isClosed, maxRespawns, log) {
+    log(`Worker ${String(slot.index)} exited with code ${String(code)}`);
+    if (isClosed) {
+        return;
+    }
+    if (slot.pending.size > 0) {
+        const error = new Error(`Worker exited unexpectedly with code ${String(code)}`);
+        for (const [, pending] of slot.pending) {
+            pending.reject(error);
+        }
+        slot.pending.clear();
+    }
+    slot.worker = null;
+    if (code !== 0 && slot.respawnCount < maxRespawns) {
+        slot.respawnCount++;
+        log(`Worker ${String(slot.index)} will be respawned on next request (attempt ${String(slot.respawnCount)}/${String(maxRespawns)})`);
+    }
+    else if (slot.respawnCount >= maxRespawns) {
+        log(`Worker ${String(slot.index)} exceeded max respawns, slot disabled`);
+    }
+}
+function selectSlot(slots, nextSlotIndex, maxRespawns) {
+    let bestSlot = null;
+    let bestNextSlotIndex = nextSlotIndex;
+    let bestPending = Number.POSITIVE_INFINITY;
+    for (let offset = 0; offset < slots.length; offset++) {
+        const index = (nextSlotIndex + offset) % slots.length;
+        const slot = slots[index];
+        if (!slot)
+            continue;
+        if (!slot.worker && slot.respawnCount >= maxRespawns)
+            continue;
+        const pendingSize = slot.pending.size;
+        if (pendingSize < bestPending) {
+            bestSlot = slot;
+            bestPending = pendingSize;
+            bestNextSlotIndex = (index + 1) % slots.length;
+            if (bestPending === 0)
+                break;
+        }
+    }
+    return { slot: bestSlot, nextSlotIndex: bestNextSlotIndex };
+}
+function attachWorkerHandlers(worker, slot, getClosed, maxRespawns, log) {
+    worker.on('message', (message) => {
+        handleWorkerMessage(slot, message, log);
+    });
+    worker.on('error', (error) => {
+        handleWorkerError(slot, error, log);
+    });
+    worker.on('exit', (code) => {
+        handleWorkerExit(slot, code, getClosed(), maxRespawns, log);
+    });
+}
+class SearchWorkerPool {
+    slots;
+    debug;
+    nextRequestId = 0;
+    nextSlotIndex = 0;
+    closed = false;
+    constructor(options) {
+        this.debug = options.debug ?? false;
+        this.slots = [];
+        for (let i = 0; i < options.size; i++) {
+            this.slots.push({
+                worker: null,
+                pending: new Map(),
+                respawnCount: 0,
+                index: i,
+            });
+        }
+    }
+    log(message) {
+        if (this.debug) {
+            console.error(`[SearchWorkerPool] ${message}`);
+        }
+    }
+    spawnWorker(slot) {
+        this.log(`Spawning worker for slot ${String(slot.index)}`);
+        const workerOptions = {
+            workerData: {
+                debug: this.debug,
+                threadId: slot.index,
+            },
+            type: 'module',
+            execArgv: isSourceContext ? ['--import', 'tsx/esm'] : undefined,
+        };
+        const worker = new Worker(WORKER_SCRIPT_URL, workerOptions);
+        worker.unref();
+        const logEntry = (entry) => {
+            this.log(entry);
+        };
+        attachWorkerHandlers(worker, slot, () => this.closed, MAX_RESPAWNS, logEntry);
+        return worker;
+    }
+    getWorker(slot) {
+        slot.worker ??= this.spawnWorker(slot);
+        return slot.worker;
+    }
+    ensureOpen() {
+        if (this.closed) {
+            throw new Error('Worker pool is closed');
+        }
+    }
+    selectAvailableSlot() {
+        const selection = selectSlot(this.slots, this.nextSlotIndex, MAX_RESPAWNS);
+        this.nextSlotIndex = selection.nextSlotIndex;
+        if (!selection.slot) {
+            throw new Error('All worker slots are disabled');
+        }
+        return selection.slot;
+    }
+    buildScanRequest(id, request) {
+        return {
+            type: 'scan',
+            id,
+            ...request,
+        };
+    }
+    createScanPromise(slot, worker, scanRequest) {
+        let settled = false;
+        return new Promise((resolve, reject) => {
+            const safeResolve = (result) => {
+                if (settled)
+                    return;
+                settled = true;
+                resolve(result);
+            };
+            const safeReject = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                reject(error);
+            };
+            slot.pending.set(scanRequest.id, {
+                resolve: safeResolve,
+                reject: safeReject,
+                request: scanRequest,
+            });
+            worker.postMessage(scanRequest);
+        });
+    }
+    createCancel(slot, worker, id) {
+        return () => {
+            const pending = slot.pending.get(id);
+            if (!pending)
+                return;
+            slot.pending.delete(id);
+            worker.postMessage({ type: 'cancel', id });
+            pending.reject(new Error('Scan cancelled'));
+        };
+    }
+    scan(request) {
+        this.ensureOpen();
+        const slot = this.selectAvailableSlot();
+        const worker = this.getWorker(slot);
+        const id = this.nextRequestId++;
+        const scanRequest = this.buildScanRequest(id, request);
+        const promise = this.createScanPromise(slot, worker, scanRequest);
+        const cancel = this.createCancel(slot, worker, id);
+        const outcome = promise.then((result) => ({ task, result }), (error) => ({
+            task,
+            error: error instanceof Error ? error : new Error(String(error)),
+        }));
+        const task = { id, promise, cancel, outcome };
+        return task;
+    }
+    async close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        this.log('Closing worker pool');
+        for (const slot of this.slots) {
+            for (const [, pending] of slot.pending) {
+                pending.reject(new Error('Worker pool closed'));
+            }
+            slot.pending.clear();
+        }
+        const terminatePromises = [];
+        for (const slot of this.slots) {
+            if (slot.worker) {
+                slot.worker.postMessage({ type: 'shutdown' });
+                terminatePromises.push(slot.worker.terminate());
+                slot.worker = null;
+            }
+        }
+        await Promise.allSettled(terminatePromises);
+        this.log('Worker pool closed');
+    }
+}
+function isWorkerPoolAvailable() {
+    return !isSourceContext;
+}
+let poolInstance = null;
+let poolSize = 0;
+let poolDebug = false;
+function getSearchWorkerPool(size, debug = false) {
+    if (size <= 0) {
+        throw new Error('Pool size must be positive');
+    }
+    if (poolInstance && poolSize === size && poolDebug === debug) {
+        return poolInstance;
+    }
+    if (poolInstance) {
+        void poolInstance.close();
+    }
+    poolInstance = new SearchWorkerPool({ size, debug });
+    poolSize = size;
+    poolDebug = debug;
+    return poolInstance;
+}
+function createParallelScanConfig(pattern, matcherOptions, scanOptions, maxResults, signal) {
+    const debug = process.env.FS_CONTEXT_SEARCH_WORKERS_DEBUG === '1';
+    return {
+        pool: getSearchWorkerPool(SEARCH_WORKERS, debug),
+        pattern,
+        matcherOptions,
+        scanOptions,
+        maxResults,
+        maxInFlight: Math.max(1, SEARCH_WORKERS),
+        signal,
+    };
+}
+function createParallelScanState(files, summary) {
+    return {
+        matches: [],
+        summary,
+        inFlight: new Set(),
+        iterator: files[Symbol.asyncIterator](),
+        done: false,
+        stoppedEarly: false,
+    };
+}
+function markTruncated(summary, reason) {
+    summary.truncated = true;
+    summary.stoppedReason = reason;
+}
+function cancelInFlight(inFlight) {
+    for (const task of inFlight) {
+        task.cancel();
+        void task.promise.catch(() => { });
+    }
+    inFlight.clear();
+}
+function stopIfSignaledOrLimited(config, state) {
+    if (!shouldStopOnSignalOrLimit(config.signal, state.matches.length, config.maxResults, state.summary)) {
+        return false;
+    }
+    state.stoppedEarly = true;
+    state.done = true;
+    cancelInFlight(state.inFlight);
+    return true;
+}
+async function awaitNextOutcome(inFlight) {
+    function* outcomes() {
+        for (const task of inFlight) {
+            yield task.outcome;
+        }
+    }
+    return await Promise.race(outcomes());
+}
+function handleWorkerOutcome(outcome, config, state) {
+    state.inFlight.delete(outcome.task);
+    if (outcome.error) {
+        if (outcome.error.message !== 'Scan cancelled') {
+            state.summary.skippedInaccessible++;
+        }
+        return;
+    }
+    const { result } = outcome;
+    if (!result)
+        return;
+    const remaining = config.maxResults - state.matches.length;
+    if (remaining <= 0) {
+        markTruncated(state.summary, 'maxResults');
+        return;
+    }
+    applyScanResult(result, state.matches, state.summary, remaining);
+    if (state.matches.length >= config.maxResults) {
+        markTruncated(state.summary, 'maxResults');
+    }
+}
+async function enqueueNextTask(config, state) {
+    if (stopIfSignaledOrLimited(config, state))
+        return;
+    const next = await state.iterator.next();
+    if (next.done) {
+        state.done = true;
+        return;
+    }
+    const remaining = Math.max(1, config.maxResults - state.matches.length);
+    const task = config.pool.scan({
+        resolvedPath: next.value.resolvedPath,
+        requestedPath: next.value.requestedPath,
+        pattern: config.pattern,
+        matcherOptions: config.matcherOptions,
+        scanOptions: config.scanOptions,
+        maxMatches: remaining,
+    });
+    state.inFlight.add(task);
+}
+async function fillInFlight(config, state) {
+    while (!state.done && state.inFlight.size < config.maxInFlight) {
+        await enqueueNextTask(config, state);
+    }
+}
+async function drainInFlight(config, state) {
+    await fillInFlight(config, state);
+    while (state.inFlight.size > 0) {
+        if (stopIfSignaledOrLimited(config, state))
+            break;
+        handleWorkerOutcome(await awaitNextOutcome(state.inFlight), config, state);
+        if (stopIfSignaledOrLimited(config, state))
+            break;
+        await fillInFlight(config, state);
+    }
+}
+async function finalizeParallelScan(state) {
+    if (!state.stoppedEarly)
+        return;
+    cancelInFlight(state.inFlight);
+    await state.iterator.return?.();
+}
+function attachAbortHandler(config, state) {
+    const onAbort = () => {
+        state.stoppedEarly = true;
+        markTruncated(state.summary, 'timeout');
+        cancelInFlight(state.inFlight);
+    };
+    config.signal.addEventListener('abort', onAbort, { once: true });
+    return onAbort;
+}
+async function scanFilesParallel(files, pattern, matcherOptions, scanOptions, maxResults, signal, summary) {
+    const config = createParallelScanConfig(pattern, matcherOptions, scanOptions, maxResults, signal);
+    const state = createParallelScanState(files, summary);
+    const onAbort = attachAbortHandler(config, state);
+    try {
+        await drainInFlight(config, state);
+        await finalizeParallelScan(state);
+    }
+    finally {
+        signal.removeEventListener('abort', onAbort);
+    }
+    return state.matches;
+}
+function buildMatcherOptions(opts) {
+    return {
+        caseSensitive: opts.caseSensitive,
+        wholeWord: opts.wholeWord,
+        isLiteral: opts.isLiteral,
+    };
+}
+function buildScanOptions(opts) {
+    return {
+        maxFileSize: opts.maxFileSize,
+        skipBinary: opts.skipBinary,
+        contextLines: opts.contextLines,
+    };
+}
+function shouldUseWorkers() {
+    // Multi-CPU only: require at least 2 workers to justify thread overhead.
+    return isWorkerPoolAvailable() && SEARCH_WORKERS >= 2;
+}
+function buildTraceContext(opts) {
+    if (!shouldPublishOpsTrace())
+        return undefined;
+    return {
+        op: 'searchContent',
+        engine: shouldUseWorkers() ? 'workers' : 'sequential',
+        maxResults: opts.maxResults,
+    };
+}
+async function withOpsTrace(context, run) {
+    if (!context) {
+        return await run();
+    }
+    publishOpsTraceStart(context);
+    try {
+        return await run();
+    }
+    catch (error) {
+        publishOpsTraceError(context, error);
+        throw error;
+    }
+    finally {
+        publishOpsTraceEnd(context);
+    }
+}
+async function scanMatches(files, pattern, matcherOptions, scanOptions, maxResults, signal, summary) {
+    if (shouldUseWorkers()) {
+        return await scanFilesParallel(files, pattern, matcherOptions, scanOptions, maxResults, signal, summary);
+    }
+    return await scanFilesSequential(files, pattern, matcherOptions, scanOptions, maxResults, signal, summary);
+}
+function buildSummary(summary, matches) {
+    const baseSummary = {
+        filesScanned: summary.filesScanned,
+        filesMatched: summary.filesMatched,
+        matches: matches.length,
+        truncated: summary.truncated,
+        skippedTooLarge: summary.skippedTooLarge,
+        skippedBinary: summary.skippedBinary,
+        skippedInaccessible: summary.skippedInaccessible,
+        linesSkippedDueToRegexTimeout: 0,
+    };
+    return {
+        ...baseSummary,
+        ...(summary.stoppedReason !== undefined
+            ? { stoppedReason: summary.stoppedReason }
+            : {}),
+    };
+}
+function buildSearchResult(root, pattern, filePattern, matches, summary) {
+    return {
+        basePath: root,
+        pattern,
+        filePattern,
+        matches,
+        summary: buildSummary(summary, matches),
+    };
+}
+async function executeSearch(root, pattern, opts, allowedDirs, signal) {
+    const matcherOptions = buildMatcherOptions(opts);
+    const scanOptions = buildScanOptions(opts);
+    const traceContext = buildTraceContext(opts);
+    return await withOpsTrace(traceContext, async () => {
+        validatePattern(pattern, matcherOptions);
+        const { stream, summary } = collectFilesStream(root, opts, allowedDirs, signal);
+        const matches = await scanMatches(stream, pattern, matcherOptions, scanOptions, opts.maxResults, signal, summary);
+        return buildSearchResult(root, pattern, opts.filePattern, matches, summary);
+    });
+}
+export async function searchContent(basePath, pattern, options = {}) {
+    const opts = mergeOptions(options);
+    const root = await validateExistingDirectory(basePath, options.signal);
+    const { signal, cleanup } = createTimedAbortSignal(options.signal, opts.timeoutMs);
+    const allowedDirs = getAllowedDirectories();
+    try {
+        return await executeSearch(root, pattern, opts, allowedDirs, signal);
+    }
+    finally {
+        cleanup();
+    }
 }
 //# sourceMappingURL=search-content.js.map