@j0hanz/filesystem-mcp 1.7.3 → 1.9.0

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

@@ -1,218 +0,0 @@
-import * as path from 'node:path';
-import { DEFAULT_SEARCH_MAX_FILES, DEFAULT_SEARCH_TIMEOUT_MS, } from '../constants.js';
-import { createTimedAbortSignal } from '../fs-helpers.js';
-import { isSensitivePath } from '../path-policy.js';
-import { isPathWithinDirectories, normalizePath, validateExistingDirectory, validateExistingPathDetailed, } from '../path-validation.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';
-// 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 = {
-        cwd: root,
-        pattern,
-        excludePatterns,
-        includeHidden: normalized.includeHidden,
-        baseNameMatch: normalized.baseNameMatch,
-        caseSensitiveMatch: true,
-        followSymbolicLinks: false,
-        onlyFiles: true,
-        stats: needsStats,
-    };
-    if (normalized.maxDepth !== undefined) {
-        options.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';
-    }
-}
-function reportSearchFilesProgress(onProgress, current, total, force = false) {
-    if (!onProgress || current === 0)
-        return;
-    if (!force && current % 25 !== 0)
-        return;
-    onProgress({ current, total });
-}
-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++;
-        reportSearchFilesProgress(onProgress, state.filesScanned, 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;
-    }
-    reportSearchFilesProgress(onProgress, state.filesScanned, normalized.maxFilesScanned, 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);
-    const { signal, cleanup } = createTimedAbortSignal(options.signal, normalized.timeoutMs);
-    const root = await validateExistingDirectory(basePath, signal);
-    try {
-        const { results, summary } = await runSearchFiles(root, pattern, excludePatterns, normalized, signal, options.onProgress);
-        return {
-            basePath: root,
-            pattern,
-            results,
-            summary,
-        };
-    }
-    finally {
-        cleanup();
-    }
-}

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,129 +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 { buildMatcher, scanFileInWorker } from './search-content.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 {};

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

@@ -1,269 +0,0 @@
-import * as path from 'node:path';
-import { DEFAULT_EXCLUDE_PATTERNS, DEFAULT_SEARCH_TIMEOUT_MS, } from '../constants.js';
-import { createTimedAbortSignal } from '../fs-helpers.js';
-import { toPosixPath } from '../path-format.js';
-import { isSensitivePath } from '../path-policy.js';
-import { isPathWithinDirectories, normalizePath, validateExistingDirectory, validateExistingPathDetailed, } from '../path-validation.js';
-import { isEntryAccessibleByType, resolveEntryType, resolveStopReason, } from './common.js';
-import { isIgnoredByGitignore, loadRootGitignore } from './gitignore.js';
-import { globEntries } from './glob-engine.js';
-function toSafeNonNegativeInt(value, fallback) {
-    if (typeof value !== 'number' || !Number.isFinite(value))
-        return fallback;
-    const asInt = Math.floor(value);
-    return asInt >= 0 ? asInt : fallback;
-}
-function toSafePositiveInt(value, fallback) {
-    if (typeof value !== 'number' || !Number.isFinite(value))
-        return fallback;
-    const asInt = Math.floor(value);
-    return asInt > 0 ? asInt : fallback;
-}
-function toSafeBoolean(value, fallback) {
-    if (typeof value !== 'boolean')
-        return fallback;
-    return value;
-}
-function normalizeOptions(options) {
-    return {
-        maxDepth: toSafeNonNegativeInt(options.maxDepth, 5),
-        maxEntries: toSafeNonNegativeInt(options.maxEntries, 1000),
-        includeHidden: toSafeBoolean(options.includeHidden, false),
-        includeIgnored: toSafeBoolean(options.includeIgnored, false),
-        timeoutMs: toSafePositiveInt(options.timeoutMs, DEFAULT_SEARCH_TIMEOUT_MS),
-    };
-}
-function ensureParentNodes(rootNode, nodeByPath, relativePath) {
-    const normalized = toPosixPath(relativePath);
-    if (normalized.length === 0 || normalized === '.')
-        return rootNode;
-    const segments = [];
-    for (const segment of normalized.split('/')) {
-        if (segment.length > 0) {
-            segments.push(segment);
-        }
-    }
-    const parentSegmentCount = Math.max(0, segments.length - 1);
-    let current = rootNode;
-    let currentPath = '';
-    for (let index = 0; index < parentSegmentCount; index += 1) {
-        const segment = segments[index];
-        if (!segment)
-            continue;
-        currentPath =
-            currentPath.length === 0
-                ? segment
-                : path.posix.join(currentPath, segment);
-        let child = nodeByPath.get(currentPath);
-        if (!child) {
-            child = {
-                name: segment,
-                type: 'directory',
-                relativePath: currentPath,
-                children: [],
-            };
-            nodeByPath.set(currentPath, child);
-            current.children ??= [];
-            current.children.push(child);
-        }
-        current = child;
-    }
-    return current;
-}
-function sortTree(node) {
-    if (!node.children)
-        return;
-    node.children.sort(compareTreeEntries);
-    for (const child of node.children) {
-        sortTree(child);
-    }
-}
-function compareTreeEntries(a, b) {
-    const diff = getTreeTypeRank(a.type) - getTreeTypeRank(b.type);
-    if (diff !== 0)
-        return diff;
-    return a.name.localeCompare(b.name);
-}
-function getTreeTypeRank(type) {
-    if (type === 'directory')
-        return 0;
-    if (type === 'file')
-        return 1;
-    return 2;
-}
-async function resolveTreeEntry(entry, root, rootDirectories, gitignoreMatcher, signal, accessDeps) {
-    const type = resolveEntryType(entry.dirent);
-    const isAccessible = await isEntryAccessibleByType(entry.path, type, rootDirectories, signal, accessDeps);
-    if (!isAccessible) {
-        return null;
-    }
-    if (gitignoreMatcher &&
-        isIgnoredByGitignore(gitignoreMatcher, root, entry.path, {
-            isDirectory: type === 'directory',
-        })) {
-        return null;
-    }
-    const relative = path.relative(root, entry.path) || path.basename(entry.path);
-    const relativePosix = toPosixPath(relative);
-    const name = path.basename(entry.path);
-    return { type, relativePosix, name };
-}
-function upsertChildNode(parent, nodeByPath, resolved, childPathIndexByParent) {
-    const ensureDirectoryShape = (node) => {
-        if (node.type === 'directory') {
-            node.children ??= [];
-        }
-        else {
-            delete node.children;
-        }
-    };
-    const maybeUpdateType = (existing, nextType) => {
-        if (existing.type === nextType)
-            return;
-        const preservePopulatedDirectory = existing.type === 'directory' &&
-            Array.isArray(existing.children) &&
-            existing.children.length > 0;
-        if (preservePopulatedDirectory)
-            return;
-        existing.type = nextType;
-        ensureDirectoryShape(existing);
-    };
-    const attachChild = (child) => {
-        parent.children ??= [];
-        let seen = childPathIndexByParent.get(parent);
-        if (!seen) {
-            seen = new Set();
-            for (const entry of parent.children) {
-                seen.add(entry.relativePath);
-            }
-            childPathIndexByParent.set(parent, seen);
-        }
-        const key = child.relativePath;
-        if (seen.has(key))
-            return;
-        seen.add(key);
-        parent.children.push(child);
-    };
-    const existing = nodeByPath.get(resolved.relativePosix);
-    if (existing) {
-        // Avoid duplicate directory nodes when a child file is encountered before the directory entry.
-        // Prefer preserving an existing populated directory node over overwriting it.
-        maybeUpdateType(existing, resolved.type);
-        existing.name = resolved.name;
-        existing.relativePath = resolved.relativePosix;
-        ensureDirectoryShape(existing);
-        attachChild(existing);
-        return;
-    }
-    const node = {
-        name: resolved.name,
-        type: resolved.type,
-        relativePath: resolved.relativePosix,
-        ...(resolved.type === 'directory' ? { children: [] } : {}),
-    };
-    nodeByPath.set(resolved.relativePosix, node);
-    attachChild(node);
-}
-export function formatTreeAscii(tree) {
-    const lines = [];
-    const walk = (node, prefix, isLast, isRoot) => {
-        let connector = '';
-        let linePrefix = '';
-        if (!isRoot) {
-            connector = isLast ? '└── ' : '├── ';
-            linePrefix = prefix;
-        }
-        lines.push(`${linePrefix}${connector}${node.name}`);
-        if (!node.children || node.children.length === 0)
-            return;
-        let nextPrefix = '';
-        if (!isRoot) {
-            const continuation = isLast ? '    ' : '│   ';
-            nextPrefix = `${prefix}${continuation}`;
-        }
-        const count = node.children.length;
-        for (let index = 0; index < count; index += 1) {
-            const child = node.children[index];
-            if (child) {
-                walk(child, nextPrefix, index === count - 1, false);
-            }
-        }
-    };
-    walk(tree, '', true, true);
-    return lines.join('\n');
-}
-export async function treeDirectory(dirPath, options = {}) {
-    const normalized = normalizeOptions(options);
-    const { signal, cleanup } = createTimedAbortSignal(options.signal, normalized.timeoutMs);
-    const root = await validateExistingDirectory(dirPath, signal);
-    const rootNormalized = normalizePath(root);
-    const rootDirectories = [rootNormalized];
-    const accessDeps = {
-        normalizePath,
-        isPathWithinDirectories,
-        isSensitivePath,
-        validateSymlinkPath: validateExistingPathDetailed,
-    };
-    try {
-        const excludePatterns = normalized.includeIgnored
-            ? []
-            : DEFAULT_EXCLUDE_PATTERNS;
-        const gitignoreMatcher = normalized.includeIgnored
-            ? null
-            : await loadRootGitignore(root, signal);
-        const rootNode = {
-            name: path.basename(root) || root,
-            type: 'directory',
-            relativePath: '.',
-            children: [],
-        };
-        const nodeByPath = new Map();
-        const childPathIndexByParent = new WeakMap();
-        let totalEntries = 0;
-        let truncated = false;
-        const stream = globEntries({
-            cwd: root,
-            pattern: '**/*',
-            excludePatterns,
-            includeHidden: normalized.includeHidden,
-            baseNameMatch: false,
-            caseSensitiveMatch: true,
-            maxDepth: normalized.maxDepth,
-            followSymbolicLinks: false,
-            onlyFiles: false,
-            stats: false,
-            suppressErrors: true,
-        });
-        for await (const entry of stream) {
-            const stopReason = resolveStopReason({
-                signal,
-                current: totalEntries,
-                max: normalized.maxEntries,
-                abortedReason: 'aborted',
-                maxReason: 'maxEntries',
-            });
-            if (stopReason) {
-                truncated = true;
-                break;
-            }
-            const resolved = await resolveTreeEntry(entry, root, rootDirectories, gitignoreMatcher, signal, accessDeps);
-            if (!resolved) {
-                continue;
-            }
-            const parent = ensureParentNodes(rootNode, nodeByPath, resolved.relativePosix);
-            upsertChildNode(parent, nodeByPath, resolved, childPathIndexByParent);
-            totalEntries += 1;
-            options.onProgress?.({ current: totalEntries });
-        }
-        sortTree(rootNode);
-        return {
-            root,
-            tree: rootNode,
-            truncated,
-            totalEntries,
-        };
-    }
-    finally {
-        cleanup();
-    }
-}

package/dist/lib/path-format.d.ts

@@ -1 +0,0 @@
-export declare function toPosixPath(value: string): string;

package/dist/lib/path-format.js

@@ -1,7 +0,0 @@
-const WINDOWS_PATH_SEPARATOR = '\\';
-const POSIX_PATH_SEPARATOR = '/';
-export function toPosixPath(value) {
-    return value.includes(WINDOWS_PATH_SEPARATOR)
-        ? value.replace(/\\/gu, POSIX_PATH_SEPARATOR)
-        : value;
-}

package/dist/lib/path-policy.d.ts

@@ -1,2 +0,0 @@
-export declare function isSensitivePath(requestedPath: string, resolvedPath?: string): boolean;
-export declare function assertAllowedFileAccess(requestedPath: string, resolvedPath?: string): void;