@j0hanz/filesystem-mcp 1.11.0 → 1.12.0

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

@@ -1,7 +1,61 @@
+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 * as fsp from 'node:fs/promises';
 import * as path from 'node:path';
+import { AsyncResource } from 'node:async_hooks';
 import { existsSync } from 'node:fs';
 import { fileURLToPath, pathToFileURL } from 'node:url';
+import { debuglog } from 'node:util';
 import { parentPort, threadId, Worker, workerData } from 'node:worker_threads';
 import RE2 from 're2';
 import safeRegex from 'safe-regex2';
@@ -125,6 +179,9 @@ const DEFAULTS = {
 };
 const ERROR_SCAN_CANCELLED = 'Scan cancelled';
 const ERROR_WORKER_POOL_CLOSED = 'Worker pool closed';
+const SEARCH_PROGRESS_THROTTLE_MODULO = 25;
+const SEARCH_WORKER_NAME_PREFIX = 'filesystem-search';
+const SEARCH_WORKER_RESOURCE_TYPE = 'SearchWorkerTask';
 // --- Helpers ---
 function resolveOptions(options) {
     const normalizedOptions = omitOptionKeys(options, ['signal', 'onProgress']);
@@ -135,6 +192,9 @@ function resolveOptions(options) {
     }
     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.
  */
@@ -208,6 +268,9 @@ function trimContent(line) {
         : line;
 }
 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;
@@ -259,11 +322,11 @@ async function readMatches(handle, requestedPath, matcher, options, maxMatches,
     return matches;
 }
 async function scanFileResolved(resolvedPath, requestedPath, matcher, options, signal, maxMatches = Number.POSITIVE_INFINITY, injectedBinaryDetector) {
-    assertNotAborted(signal);
-    const handle = await withAbort(fsp.open(resolvedPath, 'r'), signal);
+    const env_1 = { stack: [], error: void 0, hasError: false };
     try {
+        assertNotAborted(signal);
+        const handle = __addDisposableResource(env_1, await withAbort(fsp.open(resolvedPath, 'r'), signal), true);
         const stats = await withAbort(handle.stat(), signal);
-        // 1. Size Check
         if (stats.size > options.maxFileSize) {
             return {
                 matches: [],
@@ -272,7 +335,6 @@ async function scanFileResolved(resolvedPath, requestedPath, matcher, options, s
                 skippedBinary: false,
             };
         }
-        // 2. Binary Check
         if (options.skipBinary) {
             const detect = injectedBinaryDetector ?? isProbablyBinary;
             if (await detect(resolvedPath, handle, signal)) {
@@ -284,7 +346,6 @@ async function scanFileResolved(resolvedPath, requestedPath, matcher, options, s
                 };
             }
         }
-        // 3. Scan Content
         const matches = await readMatches(handle, requestedPath, matcher, options, maxMatches, () => Boolean(signal?.aborted), signal);
         return {
             matches,
@@ -293,8 +354,14 @@ async function scanFileResolved(resolvedPath, requestedPath, matcher, options, s
             skippedBinary: false,
         };
     }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
     finally {
-        await handle.close();
+        const result_1 = __disposeResources(env_1);
+        if (result_1)
+            await result_1;
     }
 }
 function buildScanFileOptions(opts) {
@@ -360,6 +427,26 @@ const isSourceContext = currentDir.endsWith('src\\lib\\file-operations') ||
 const WORKER_SCRIPT_PATH = path.join(currentDir, isSourceContext ? 'search-worker.ts' : 'search-worker.js');
 const WORKER_SCRIPT_URL = pathToFileURL(WORKER_SCRIPT_PATH);
 const hasWorkerScript = existsSync(WORKER_SCRIPT_PATH);
+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;
@@ -407,6 +494,7 @@ class SearchWorkerPool {
     }
     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,
         });
@@ -446,13 +534,23 @@ class SearchWorkerPool {
         const worker = this.getWorker(workerIndex);
         this.workerRoundRobin++;
         const promise = new Promise((resolve, reject) => {
-            this.pending.set(id, { resolve, reject, workerIndex });
+            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);
-                reject(this.normalizeWorkerError(error, `Failed to post scan request ${String(id)} to worker ${String(workerIndex)}`));
+                pendingRequest.reject(this.normalizeWorkerError(error, `Failed to post scan request ${String(id)} to worker ${String(workerIndex)}`));
                 this.markWorkerAsUnavailable(workerIndex, worker);
             }
         });
@@ -507,7 +605,7 @@ function getPool() {
 // --- Execution Strategies ---
 async function executeSequential(files, pattern, opts, signal, summary) {
     const matches = [];
-    const matcher = buildMatcher(pattern, opts);
+    const matcher = buildMatcher(pattern, buildMatcherOptions(opts));
     const scanOpts = buildScanFileOptions(opts);
     for await (const file of files) {
         if (signal.aborted) {
@@ -520,7 +618,7 @@ async function executeSequential(files, pattern, opts, signal, summary) {
         }
         try {
             assertAllowedFileAccess(file.requestedPath, file.resolvedPath);
-            const remaining = opts.maxResults - matches.length;
+            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);
@@ -539,7 +637,7 @@ async function fillWorkerPool(context) {
         if (result.done)
             return true;
         try {
-            const remaining = Math.max(1, maxResults - currentMatches);
+            const remaining = getRemainingMatchCapacity(maxResults, currentMatches, 1);
             const task = pool.scan({
                 resolvedPath: result.value.resolvedPath,
                 requestedPath: result.value.requestedPath,
@@ -566,7 +664,7 @@ function processScanResult(winner, summary, matches, maxResults) {
     if (winner.result) {
         const res = winner.result;
         applyScanOutcome(summary, res);
-        const remaining = maxResults - matches.length;
+        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) {
@@ -580,13 +678,14 @@ function processScanResult(winner, summary, matches, maxResults) {
 async function waitForWinner(pending) {
     const raceCandidates = [];
     for (const task of pending) {
-        raceCandidates.push(task.promise.then((result) => ({ task, result, error: undefined }), (err) => ({
+        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);
 }
@@ -705,13 +804,13 @@ async function searchDirectory(details, opts, pattern, signal, onProgress) {
             scanned++;
             reportPeriodicProgress(onProgress, scanned, {
                 total: opts.maxFilesScanned,
-                throttleModulo: 25,
+                throttleModulo: SEARCH_PROGRESS_THROTTLE_MODULO,
             });
             yield { resolvedPath: normalized, requestedPath: entry.path };
         }
         reportPeriodicProgress(onProgress, scanned, {
             total: opts.maxFilesScanned,
-            throttleModulo: 25,
+            throttleModulo: SEARCH_PROGRESS_THROTTLE_MODULO,
             force: true,
         });
     }
@@ -870,7 +969,7 @@ async function collectFromStream(stream, signal, context) {
         state.filesScanned++;
         reportPeriodicProgress(onProgress, state.filesScanned, {
             total: normalized.maxFilesScanned,
-            throttleModulo: 25,
+            throttleModulo: SEARCH_PROGRESS_THROTTLE_MODULO,
         });
         if (isEntryIgnoredByGitignore(gitignoreMatcher, root, entry.path, entry.relativePath)) {
             continue;
@@ -890,7 +989,7 @@ async function collectFromStream(stream, signal, context) {
     }
     reportPeriodicProgress(onProgress, state.filesScanned, {
         total: normalized.maxFilesScanned,
-        throttleModulo: 25,
+        throttleModulo: SEARCH_PROGRESS_THROTTLE_MODULO,
         force: true,
     });
 }
@@ -1099,10 +1198,11 @@ function handleMessage(message) {
             break;
     }
 }
+const log = debuglog('search-worker');
 if (parentPort) {
     parentPort.on('message', handleMessage);
     const data = workerData;
     if (data?.debug) {
-        console.error(`[SearchWorker] Started with threadId=${String(threadId)}`);
+        log(`Started with threadId=${String(threadId)}`);
     }
 }

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

@@ -25,141 +25,87 @@ function normalizePattern(pattern, baseNameMatch) {
         return normalized;
     return `**/${normalized}`;
 }
-function normalizeIgnorePatterns(patterns) {
-    return patterns.map(toPosixPath);
-}
 function splitPatternPrefix(normalizedPattern) {
     if (!GLOB_MAGIC_RE.test(normalizedPattern)) {
         return { prefix: '', remainder: normalizedPattern };
     }
     const segments = normalizedPattern.split(SEP);
-    const len = segments.length;
-    let splitIndex = len;
-    for (let i = 0; i < len; i++) {
-        const seg = segments[i];
-        if (seg && GLOB_MAGIC_RE.test(seg)) {
-            splitIndex = i;
-            break;
-        }
-    }
-    if (splitIndex === 0) {
+    const splitIndex = segments.findIndex((seg) => GLOB_MAGIC_RE.test(seg));
+    if (splitIndex <= 0) {
         return { prefix: '', remainder: normalizedPattern };
     }
-    if (splitIndex >= len) {
-        const prefix = segments.slice(0, len - 1).join(SEP);
-        const last = segments[len - 1];
-        return {
-            prefix: prefix ? prefix + SEP : '',
-            remainder: last ?? '',
-        };
-    }
     return {
         prefix: segments.slice(0, splitIndex).join(SEP) + SEP,
         remainder: segments.slice(splitIndex).join(SEP),
     };
 }
-function addDotfileCandidates(patterns, prefix, remainderSegments) {
-    const firstCandidateIndex = remainderSegments.findIndex((segment) => segment !== '**' && segment.length > 0);
-    if (firstCandidateIndex !== -1) {
-        const original = remainderSegments[firstCandidateIndex];
-        if (original && original.charCodeAt(0) !== DOT_CHAR_CODE) {
-            const newSegments = remainderSegments.slice();
-            newSegments[firstCandidateIndex] = `.${original}`;
-            patterns.add(`${prefix}${newSegments.join(SEP)}`);
-        }
-    }
-}
-function addGlobstarCandidates(patterns, prefix, remainder, maxDepth) {
-    const afterGlobstar = remainder.slice(3);
-    const addDotFile = afterGlobstar.length > 0 && afterGlobstar.charCodeAt(0) !== DOT_CHAR_CODE;
-    let depthPrefix = '';
-    for (let depth = 0; depth <= maxDepth; depth++) {
-        patterns.add(`${prefix}${depthPrefix}.*/**/${afterGlobstar}`);
-        if (addDotFile) {
-            patterns.add(`${prefix}${depthPrefix}.${afterGlobstar}`);
-        }
-        depthPrefix += '*/';
-    }
-}
 function buildHiddenPatterns(normalizedPattern, maxDepth) {
-    const patterns = new Set();
-    patterns.add(normalizedPattern);
+    const patterns = new Set([normalizedPattern]);
     const { prefix, remainder } = splitPatternPrefix(normalizedPattern);
     if (remainder.length > 0) {
-        const remainderSegments = remainder.split(SEP);
-        addDotfileCandidates(patterns, prefix, remainderSegments);
+        const segments = remainder.split(SEP);
+        const idx = segments.findIndex((seg) => seg !== '**' && seg.length > 0);
+        if (idx !== -1) {
+            const original = segments[idx];
+            if (original && original.charCodeAt(0) !== DOT_CHAR_CODE) {
+                const newSegments = [...segments];
+                newSegments[idx] = `.${original}`;
+                patterns.add(`${prefix}${newSegments.join(SEP)}`);
+            }
+        }
     }
     if (remainder.startsWith('**/')) {
-        addGlobstarCandidates(patterns, prefix, remainder, maxDepth);
+        const afterGlobstar = remainder.slice(3);
+        const addDotFile = afterGlobstar.length > 0 && afterGlobstar.charCodeAt(0) !== DOT_CHAR_CODE;
+        let depthPrefix = '';
+        for (let depth = 0; depth <= maxDepth; depth++) {
+            patterns.add(`${prefix}${depthPrefix}.*/**/${afterGlobstar}`);
+            if (addDotFile)
+                patterns.add(`${prefix}${depthPrefix}.${afterGlobstar}`);
+            depthPrefix += '*/';
+        }
     }
     return Array.from(patterns);
 }
-function shouldUseGlobDirents(options) {
-    return !options.stats && !options.followSymbolicLinks;
-}
-function assertOptionString(options, key) {
-    if (typeof options[key] !== 'string') {
-        throw new TypeError(`globEntries: options.${key} must be a string`);
-    }
-}
-function assertExcludePatternsOption(options) {
-    if (!Array.isArray(options.excludePatterns)) {
-        throw new TypeError('globEntries: options.excludePatterns must be an array');
+function assertOptionsShape(options) {
+    const optsUnknown = options;
+    if (typeof optsUnknown !== 'object' || optsUnknown === null) {
+        throw new TypeError('globEntries: options must be an object');
     }
-    for (const pattern of options.excludePatterns) {
-        if (typeof pattern !== 'string') {
-            throw new TypeError('globEntries: options.excludePatterns must contain only strings');
-        }
+    const opts = optsUnknown;
+    if (typeof opts.cwd !== 'string')
+        throw new TypeError('globEntries: options.cwd must be a string');
+    if (typeof opts.pattern !== 'string')
+        throw new TypeError('globEntries: options.pattern must be a string');
+    if (!Array.isArray(opts.excludePatterns) ||
+        opts.excludePatterns.some((p) => typeof p !== 'string')) {
+        throw new TypeError('globEntries: options.excludePatterns must be an array of strings');
     }
-}
-function assertBooleanOptions(options) {
     for (const key of GLOB_BOOLEAN_OPTION_KEYS) {
-        if (typeof options[key] !== 'boolean') {
+        if (typeof opts[key] !== 'boolean') {
             throw new TypeError(`globEntries: options.${key} must be a boolean`);
         }
     }
-}
-function assertOptionalMaxDepth(options) {
-    const { maxDepth } = options;
-    if (maxDepth === undefined)
-        return;
-    if (typeof maxDepth !== 'number' || !Number.isFinite(maxDepth)) {
+    if (opts.maxDepth !== undefined &&
+        (!Number.isFinite(opts.maxDepth) || typeof opts.maxDepth !== 'number')) {
         throw new TypeError('globEntries: options.maxDepth must be a finite number');
     }
-}
-function assertOptionalSuppressErrors(options) {
-    const { suppressErrors } = options;
-    if (suppressErrors === undefined)
-        return;
-    if (typeof suppressErrors !== 'boolean') {
+    if (opts.suppressErrors !== undefined &&
+        typeof opts.suppressErrors !== 'boolean') {
         throw new TypeError('globEntries: options.suppressErrors must be a boolean');
     }
 }
-function assertOptionsShape(options) {
-    const unknownOptions = options;
-    if (unknownOptions === null || typeof unknownOptions !== 'object') {
-        throw new TypeError('globEntries: options must be an object');
-    }
-    const o = unknownOptions;
-    assertOptionString(o, 'cwd');
-    assertOptionString(o, 'pattern');
-    assertExcludePatternsOption(o);
-    assertBooleanOptions(o);
-    assertOptionalMaxDepth(o);
-    assertOptionalSuppressErrors(o);
-}
 function normalizeOptions(options) {
     const cwd = path.resolve(options.cwd);
     const normalizedPattern = normalizePattern(options.pattern, options.baseNameMatch);
-    const maxHiddenDepth = options.maxDepth ?? DEFAULT_MAX_HIDDEN_DEPTH;
     const patterns = options.includeHidden
-        ? buildHiddenPatterns(normalizedPattern, maxHiddenDepth)
+        ? buildHiddenPatterns(normalizedPattern, options.maxDepth ?? DEFAULT_MAX_HIDDEN_DEPTH)
         : [normalizedPattern];
     const normalized = {
         cwd,
         patterns,
-        exclude: normalizeIgnorePatterns(options.excludePatterns),
-        useDirents: shouldUseGlobDirents(options),
+        exclude: options.excludePatterns.map(toPosixPath),
+        useDirents: !options.stats && !options.followSymbolicLinks,
         suppressErrors: options.suppressErrors ?? false,
     };
     if (options.maxDepth !== undefined) {
@@ -248,12 +194,9 @@ async function* processIterable(iterable, context) {
     const flush = async function* () {
         if (buffer.length === 0)
             return;
-        const requests = [];
-        for (const match of buffer) {
-            requests.push(resolveStringMatch(match, cwd, maxDepth, seen, onlyFiles, followSymlinks, returnStats, suppressErrors));
-        }
-        buffer.length = 0;
-        const results = await Promise.all(requests);
+        // Process buffer concurrently
+        const currentBuffer = buffer.splice(0, buffer.length);
+        const results = await Promise.all(currentBuffer.map((match) => resolveStringMatch(match, cwd, maxDepth, seen, onlyFiles, followSymlinks, returnStats, suppressErrors)));
         for (const entry of results) {
             if (entry !== null)
                 yield entry;