@j0hanz/filesystem-mcp 1.8.0 → 1.9.0

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

@@ -1,216 +0,0 @@
-import * as path from 'node:path';
-import { DEFAULT_SEARCH_MAX_FILES, DEFAULT_SEARCH_TIMEOUT_MS, } from '../constants.js';
-import { withTimedAbortSignal } from '../fs-helpers.js';
-import { isSensitivePath } from '../path-policy.js';
-import { isPathWithinDirectories, normalizePath, validateExistingDirectory, validateExistingPathDetailed, } from '../path-validation.js';
-import { reportPeriodicProgress } from '../progress-reporting.js';
-import { compareOptionalNumberDesc, compareStringValues, isEntryAccessibleByType, needsStatsForSort, resolveEntryType, resolveStopReason, stableSortByDerivedString, withOptionalStoppedReason, } from './common.js';
-import { isIgnoredByGitignore, loadRootGitignore } from './gitignore.js';
-import { globEntries } from './glob-engine.js';
-import { buildGlobOptions } from './glob-helpers.js';
-// Internal default for find tool - not exposed to MCP users
-const INTERNAL_MAX_RESULTS = 1000;
-function normalizeOptions(options) {
-    const normalized = {
-        maxResults: options.maxResults ?? INTERNAL_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 buildSearchResult(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(buildSearchResult(entry, entryType, needsStats));
-    if (state.results.length >= normalized.maxResults) {
-        state.truncated = true;
-        state.stoppedReason = 'maxResults';
-    }
-}
-async function collectFromStream(stream, root, rootDirectories, gitignoreMatcher, normalized, needsStats, state, signal, accessDeps, onProgress) {
-    for await (const entry of stream) {
-        if (shouldStopCollecting(state, normalized, signal))
-            break;
-        state.filesScanned++;
-        reportPeriodicProgress(onProgress, state.filesScanned, {
-            total: normalized.maxFilesScanned,
-            throttleModulo: 25,
-        });
-        if (isEntryIgnoredByGitignore(gitignoreMatcher, root, entry.path, entry.relativePath)) {
-            continue;
-        }
-        const entryType = resolveEntryType(entry.dirent);
-        if (!shouldIncludeEntry(entryType, normalized)) {
-            continue;
-        }
-        const isAccessible = await isEntryAccessibleByType(entry.path, entryType, rootDirectories, signal, accessDeps);
-        if (!isAccessible) {
-            state.skippedInaccessible++;
-            continue;
-        }
-        handleEntry(entry, entryType, needsStats, normalized, state);
-        if (state.truncated)
-            break;
-    }
-    reportPeriodicProgress(onProgress, state.filesScanned, {
-        total: normalized.maxFilesScanned,
-        throttleModulo: 25,
-        force: true,
-    });
-}
-function isEntryIgnoredByGitignore(matcher, root, entryPath, relativePath) {
-    if (!matcher)
-        return false;
-    return isIgnoredByGitignore(matcher, root, entryPath, relativePath ? { relativePath } : {});
-}
-async function collectSearchResults(root, pattern, excludePatterns, normalized, signal, onProgress) {
-    const needsStats = needsStatsForSort(normalized.sortBy);
-    const stream = buildSearchStream(root, pattern, excludePatterns, normalized, needsStats);
-    const state = createCollectState();
-    const rootDirectories = [root];
-    const accessDeps = {
-        normalizePath,
-        isPathWithinDirectories,
-        isSensitivePath,
-        validateSymlinkPath: validateExistingPathDetailed,
-    };
-    const gitignoreMatcher = normalized.respectGitignore
-        ? await loadRootGitignore(root, signal)
-        : null;
-    await collectFromStream(stream, root, rootDirectories, gitignoreMatcher, normalized, needsStats, state, signal, accessDeps, onProgress);
-    return buildCollectResult(state);
-}
-function buildSearchSummary(results, filesScanned, truncated, stoppedReason, skippedInaccessible) {
-    const summary = {
-        matched: results.length,
-        truncated,
-        skippedInaccessible,
-        filesScanned,
-    };
-    return withOptionalStoppedReason(summary, stoppedReason);
-}
-function compareNameThenPath(a, b) {
-    const nameCompare = compareStringValues(a.name, b.name);
-    if (nameCompare !== 0)
-        return nameCompare;
-    return compareStringValues(a.path, b.path);
-}
-function comparePathThenName(a, b) {
-    const pathCompare = compareStringValues(a.path, b.path);
-    if (pathCompare !== 0)
-        return pathCompare;
-    return compareStringValues(a.name, b.name);
-}
-const SORT_COMPARATORS = {
-    size: (a, b) => compareOptionalNumberDesc(a.size, b.size, () => compareNameThenPath(a, b)),
-    modified: (a, b) => compareOptionalNumberDesc(a.modified?.getTime(), b.modified?.getTime(), () => compareNameThenPath(a, b)),
-    path: (a, b) => comparePathThenName(a, b),
-    name: (a, b) => compareNameThenPath(a, b),
-};
-export function sortSearchResults(results, sortBy) {
-    if (sortBy === 'name') {
-        stableSortByDerivedString(results, (item) => path.basename(item.path ?? ''), (left, right) => comparePathThenName(left, right));
-        return;
-    }
-    const comparator = SORT_COMPARATORS[sortBy];
-    results.sort(comparator);
-}
-async function runSearchFiles(root, pattern, excludePatterns, normalized, signal, onProgress) {
-    const { results, filesScanned, truncated, stoppedReason, skippedInaccessible, } = await collectSearchResults(root, pattern, excludePatterns, normalized, signal, onProgress);
-    sortSearchResults(results, normalized.sortBy);
-    return {
-        results,
-        summary: buildSearchSummary(results, filesScanned, truncated, stoppedReason, skippedInaccessible),
-    };
-}
-export async function searchFiles(basePath, pattern, excludePatterns = [], options = {}) {
-    const normalized = normalizeOptions(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,
-        };
-    });
-}

package/dist/lib/file-operations/search-matcher.d.ts

@@ -1,10 +0,0 @@
-import { z } from 'zod';
-export declare const MatcherOptionsSchema: z.ZodObject<{
-    caseSensitive: z.ZodBoolean;
-    wholeWord: z.ZodBoolean;
-    isLiteral: z.ZodBoolean;
-}, z.core.$strict>;
-export type MatcherOptions = z.infer<typeof MatcherOptionsSchema>;
-export type Matcher = (line: string) => number;
-export declare function validatePattern(pattern: string, options: MatcherOptions): void;
-export declare function buildMatcher(pattern: string, options: MatcherOptions): Matcher;

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

@@ -1,72 +0,0 @@
-import { z } from 'zod';
-import RE2 from 're2';
-import safeRegex from 'safe-regex2';
-export const MatcherOptionsSchema = z.strictObject({
-    caseSensitive: z.boolean(),
-    wholeWord: z.boolean(),
-    isLiteral: z.boolean(),
-});
-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;
-}
-export function validatePattern(pattern, options) {
-    if (options.isLiteral && pattern.length === 0)
-        return;
-    if (options.isLiteral && !options.wholeWord)
-        return;
-    const final = buildRegexPattern(pattern, options);
-    if (!safeRegex(final)) {
-        throw new Error(`Potentially unsafe regular expression (ReDoS risk): ${pattern}`);
-    }
-}
-function buildLiteralMatcher(pattern, options) {
-    if (!options.caseSensitive) {
-        const final = escapeLiteral(pattern);
-        const regex = new RegExp(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 regex = new RE2(final, caseSensitive ? 'g' : 'gi');
-    return (line) => countRegexLineMatches(regex, line);
-}
-export 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);
-    validatePattern(pattern, options); // Re-validate to be safe
-    return buildRegexMatcher(final, options.caseSensitive);
-}

package/dist/lib/file-operations/search-worker.d.ts

@@ -1,2 +0,0 @@
-import type { ScanRequest, ScanResult, WorkerResponse } from './search-content.js';
-export type { WorkerResponse, ScanRequest, ScanResult };

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

@@ -1,131 +0,0 @@
-import { parentPort, threadId, workerData } from 'node:worker_threads';
-import { formatUnknownErrorMessage } from '../errors.js';
-import { isProbablyBinary } from '../fs-helpers.js';
-import { startPerfMeasure } from '../observability.js';
-import { scanFileInWorker } from './search-content.js';
-import { buildMatcher } from './search-matcher.js';
-import {} from './search-matcher.js';
-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;
-    }
-}
-if (parentPort) {
-    parentPort.on('message', handleMessage);
-    const data = workerData;
-    if (data?.debug) {
-        console.error(`[SearchWorker] Started with threadId=${String(threadId)}`);
-    }
-}

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

@@ -1,28 +0,0 @@
-import type { EntryType } from './common.js';
-interface TreeEntry {
-    name: string;
-    type: EntryType;
-    relativePath: string;
-    children?: TreeEntry[];
-}
-interface TreeOptions {
-    maxDepth?: number;
-    maxEntries?: number;
-    includeHidden?: boolean;
-    includeIgnored?: boolean;
-    timeoutMs?: number;
-    signal?: AbortSignal;
-    onProgress?: (progress: {
-        total?: number;
-        current: number;
-    }) => void;
-}
-interface TreeResult {
-    root: string;
-    tree: TreeEntry;
-    truncated: boolean;
-    totalEntries: number;
-}
-export declare function formatTreeAscii(tree: TreeEntry): string;
-export declare function treeDirectory(dirPath: string, options?: TreeOptions): Promise<TreeResult>;
-export {};