@j0hanz/filesystem-mcp 1.7.3 → 1.9.0

package/dist/lib/file-operations/list-directory.js

@@ -1,256 +0,0 @@
-import * as fsp from 'node:fs/promises';
-import * as path from 'node:path';
-import { DEFAULT_LIST_MAX_ENTRIES, DEFAULT_MAX_DEPTH, DEFAULT_SEARCH_TIMEOUT_MS, PARALLEL_CONCURRENCY, } from '../constants.js';
-import { createTimedAbortSignal, isHidden, processInParallel, withAbort, } from '../fs-helpers.js';
-import { isSensitivePath } from '../path-policy.js';
-import { isPathWithinDirectories, normalizePath, validateExistingDirectory, validateExistingPathDetailed, } from '../path-validation.js';
-import { isEntryAccessibleByType, needsStatsForSort, resolveEntryType, resolveStopReason, withOptionalStoppedReason, } from './common.js';
-import { globEntries } from './glob-engine.js';
-function normalizePattern(pattern) {
-    if (!pattern || pattern.length === 0)
-        return undefined;
-    return pattern;
-}
-function normalizeOptions(options) {
-    const pattern = normalizePattern(options.pattern);
-    const normalized = {
-        includeHidden: options.includeHidden ?? false,
-        excludePatterns: options.excludePatterns ?? [],
-        maxDepth: options.maxDepth ?? DEFAULT_MAX_DEPTH,
-        maxEntries: options.maxEntries ?? DEFAULT_LIST_MAX_ENTRIES,
-        sortBy: options.sortBy ?? 'name',
-        includeSymlinkTargets: options.includeSymlinkTargets ?? false,
-        timeoutMs: options.timeoutMs ?? DEFAULT_SEARCH_TIMEOUT_MS,
-        ...(pattern !== undefined ? { pattern } : {}),
-    };
-    return normalized;
-}
-function sortEntries(entries, sortBy) {
-    const compare = {
-        name: (a, b) => a.name.localeCompare(b.name),
-        type: (a, b) => a.type.localeCompare(b.type),
-        size: (a, b) => (a.size ?? 0) - (b.size ?? 0),
-        modified: (a, b) => (a.modified?.getTime() ?? 0) - (b.modified?.getTime() ?? 0),
-    }[sortBy];
-    entries.sort(compare);
-}
-function resolveMaxDepth(normalized) {
-    if (!normalized.pattern) {
-        return 1;
-    }
-    return normalized.maxDepth;
-}
-async function* readDirectoryEntries(basePath, normalized, needsStats, signal) {
-    const dirents = await withAbort(fsp.readdir(basePath, { withFileTypes: true }), signal);
-    const entries = [];
-    for (const dirent of dirents) {
-        if (!normalized.includeHidden && isHidden(dirent.name)) {
-            continue;
-        }
-        entries.push({ dirent, entryPath: path.join(basePath, dirent.name) });
-    }
-    if (!needsStats) {
-        for (const entry of entries) {
-            yield {
-                path: entry.entryPath,
-                dirent: entry.dirent,
-            };
-        }
-        return;
-    }
-    const { results, errors } = await processInParallel(entries.map((_, index) => index), async (index) => {
-        const candidate = entries[index];
-        if (!candidate) {
-            throw new Error(`Entry index out of range: ${String(index)}`);
-        }
-        return {
-            index,
-            stats: await withAbort(fsp.lstat(candidate.entryPath), signal),
-        };
-    }, PARALLEL_CONCURRENCY, signal);
-    if (errors.length > 0) {
-        throw errors[0]?.error ?? new Error('Failed to read entry stats');
-    }
-    const statsByIndex = [];
-    for (const result of results) {
-        statsByIndex[result.index] = result.stats;
-    }
-    for (let index = 0; index < entries.length; index += 1) {
-        const entry = entries[index];
-        if (!entry)
-            continue;
-        const stats = statsByIndex[index];
-        yield {
-            path: entry.entryPath,
-            dirent: entry.dirent,
-            ...(stats ? { stats } : {}),
-        };
-    }
-}
-function createEntryStream(basePath, normalized, maxDepth, needsStats, signal) {
-    if (shouldUseFastPath(normalized, maxDepth)) {
-        return readDirectoryEntries(basePath, normalized, needsStats, signal);
-    }
-    return globEntries({
-        cwd: basePath,
-        pattern: normalized.pattern ?? '*',
-        excludePatterns: normalized.excludePatterns,
-        includeHidden: normalized.includeHidden,
-        baseNameMatch: false,
-        caseSensitiveMatch: true,
-        maxDepth,
-        followSymbolicLinks: false,
-        onlyFiles: false,
-        stats: needsStats,
-    });
-}
-function shouldUseFastPath(normalized, maxDepth) {
-    return (!normalized.pattern &&
-        normalized.excludePatterns.length === 0 &&
-        maxDepth === 1);
-}
-function resolveRelativePath(basePath, entryPath) {
-    return path.relative(basePath, entryPath) || path.basename(entryPath);
-}
-async function resolveSymlinkTarget(entryType, includeSymlinkTargets, entryPath) {
-    if (entryType !== 'symlink' || !includeSymlinkTargets) {
-        return undefined;
-    }
-    return fsp.readlink(entryPath).catch(() => undefined);
-}
-function updateTotals(entryType, totals) {
-    if (entryType === 'file')
-        totals.files += 1;
-    if (entryType === 'directory')
-        totals.directories += 1;
-}
-function buildDirectoryEntry(basePath, entry, entryType, needsStats, symlinkTarget) {
-    const size = needsStats && entry.stats?.isFile() ? entry.stats.size : undefined;
-    const modified = needsStats ? entry.stats?.mtime : undefined;
-    return {
-        name: path.basename(entry.path),
-        path: entry.path,
-        relativePath: resolveRelativePath(basePath, entry.path),
-        type: entryType,
-        ...(size !== undefined ? { size } : {}),
-        ...(modified !== undefined ? { modified } : {}),
-        ...(symlinkTarget !== undefined ? { symlinkTarget } : {}),
-    };
-}
-function trackSymlink(entryType, includeSymlinkTargets, counters) {
-    if (entryType === 'symlink' && !includeSymlinkTargets) {
-        counters.symlinksNotFollowed += 1;
-    }
-}
-function appendEntry(entry, entryType, symlinkTarget, ctx) {
-    updateTotals(entryType, ctx.totals);
-    ctx.entries.push(buildDirectoryEntry(ctx.basePath, entry, entryType, ctx.needsStats, symlinkTarget));
-}
-async function enqueueAppendEntry(entry, entryType, ctx, pending, flushPending) {
-    if (!ctx.includeSymlinkTargets) {
-        appendEntry(entry, entryType, undefined, ctx);
-        return;
-    }
-    // Preserve the original behavior: resolve symlink targets in parallel
-    // when includeSymlinkTargets is enabled (bounded by PARALLEL_CONCURRENCY).
-    const task = (async () => {
-        const symlinkTarget = await resolveSymlinkTarget(entryType, ctx.includeSymlinkTargets, entry.path);
-        appendEntry(entry, entryType, symlinkTarget, ctx);
-    })();
-    pending.push(task);
-    if (pending.length >= PARALLEL_CONCURRENCY) {
-        await flushPending();
-    }
-}
-function buildSummary(entries, totals, maxDepth, truncated, stoppedReason, counters) {
-    const summary = {
-        totalEntries: entries.length,
-        entriesScanned: entries.length,
-        entriesVisible: entries.length,
-        totalFiles: totals.files,
-        totalDirectories: totals.directories,
-        maxDepthReached: maxDepth,
-        truncated,
-        skippedInaccessible: counters.skippedInaccessible,
-        symlinksNotFollowed: counters.symlinksNotFollowed,
-    };
-    return withOptionalStoppedReason(summary, stoppedReason);
-}
-async function collectEntries(basePath, normalized, signal, needsStats, maxDepth) {
-    const entries = [];
-    const totals = { files: 0, directories: 0 };
-    const counters = { skippedInaccessible: 0, symlinksNotFollowed: 0 };
-    const basePathDirectories = [basePath];
-    const accessDeps = {
-        normalizePath,
-        isPathWithinDirectories,
-        isSensitivePath,
-        validateSymlinkPath: validateExistingPathDetailed,
-    };
-    let truncated = false;
-    let stoppedReason;
-    const pending = [];
-    let acceptedCount = 0;
-    const stream = createEntryStream(basePath, normalized, maxDepth, needsStats, signal);
-    const flushPending = async () => {
-        if (pending.length === 0)
-            return;
-        await Promise.allSettled(pending.splice(0));
-    };
-    const appendCtx = {
-        basePath,
-        needsStats,
-        includeSymlinkTargets: normalized.includeSymlinkTargets,
-        totals,
-        entries,
-    };
-    for await (const entry of stream) {
-        const stopReason = resolveStopReason({
-            signal,
-            current: acceptedCount,
-            max: normalized.maxEntries,
-            abortedReason: 'aborted',
-            maxReason: 'maxEntries',
-        });
-        if (stopReason) {
-            truncated = true;
-            stoppedReason = stopReason;
-            break;
-        }
-        const entryType = resolveEntryType(entry.dirent);
-        trackSymlink(entryType, normalized.includeSymlinkTargets, counters);
-        const accessible = await isEntryAccessibleByType(entry.path, entryType, basePathDirectories, signal, accessDeps);
-        if (!accessible) {
-            counters.skippedInaccessible += 1;
-            continue;
-        }
-        acceptedCount += 1;
-        await enqueueAppendEntry(entry, entryType, appendCtx, pending, flushPending);
-    }
-    if (normalized.includeSymlinkTargets) {
-        await flushPending();
-    }
-    return { entries, totals, truncated, stoppedReason, counters };
-}
-async function executeListDirectory(basePath, normalized, signal) {
-    const needsStats = needsStatsForSort(normalized.sortBy);
-    const maxDepth = resolveMaxDepth(normalized);
-    const { entries, totals, truncated, stoppedReason, counters } = await collectEntries(basePath, normalized, signal, needsStats, maxDepth);
-    sortEntries(entries, normalized.sortBy);
-    return {
-        entries,
-        summary: buildSummary(entries, totals, maxDepth, truncated, stoppedReason, counters),
-    };
-}
-export async function listDirectory(dirPath, options = {}) {
-    const normalized = normalizeOptions(options);
-    const { signal, cleanup } = createTimedAbortSignal(options.signal, normalized.timeoutMs);
-    const basePath = await validateExistingDirectory(dirPath, signal);
-    try {
-        const { entries, summary } = await executeListDirectory(basePath, normalized, signal);
-        return { path: basePath, entries, summary };
-    }
-    finally {
-        cleanup();
-    }
-}

package/dist/lib/file-operations/read-multiple-files.d.ts

@@ -1,25 +0,0 @@
-interface ReadMultipleResult {
-    path: string;
-    content?: string;
-    truncated?: boolean;
-    totalLines?: number;
-    readMode?: 'full' | 'head' | 'range';
-    head?: number;
-    startLine?: number;
-    endLine?: number;
-    linesRead?: number;
-    hasMoreLines?: boolean;
-    error?: string;
-}
-interface ReadMultipleOptions {
-    encoding?: BufferEncoding;
-    maxSize?: number;
-    maxTotalSize?: number;
-    head?: number;
-    startLine?: number;
-    endLine?: number;
-    signal?: AbortSignal;
-    onReadComplete?: () => void;
-}
-export declare function readMultipleFiles(filePaths: readonly string[], options?: ReadMultipleOptions): Promise<ReadMultipleResult[]>;
-export {};

package/dist/lib/file-operations/read-multiple-files.js

@@ -1,252 +0,0 @@
-import * as fsp from 'node:fs/promises';
-import { DEFAULT_READ_MANY_MAX_TOTAL_SIZE, MAX_TEXT_FILE_SIZE, PARALLEL_CONCURRENCY, } from '../constants.js';
-import { processInParallel, readFile, readFileWithStats, withAbort, } from '../fs-helpers.js';
-import { validateExistingPath } from '../path-validation.js';
-import { applyIndexedErrors, applyIndexedValues } from './common.js';
-const UNKNOWN_PATH = '(unknown)';
-function estimateReadSize(stats, maxSize) {
-    // `readFile`/`readFileWithStats` are always invoked with a `maxSize` cap, so the
-    // combined budget should reflect the maximum number of bytes we might actually read.
-    return Math.min(stats.size, maxSize);
-}
-function buildReadOptions(options) {
-    const readOptions = {
-        encoding: options.encoding,
-        maxSize: options.maxSize,
-    };
-    applyLineSelection(readOptions, options);
-    return readOptions;
-}
-function buildReadMultipleResult(filePath, result) {
-    const output = {
-        path: filePath,
-        content: result.content,
-        truncated: result.truncated,
-        readMode: result.readMode,
-    };
-    if (result.totalLines !== undefined)
-        output.totalLines = result.totalLines;
-    if (result.head !== undefined)
-        output.head = result.head;
-    if (result.startLine !== undefined)
-        output.startLine = result.startLine;
-    if (result.endLine !== undefined)
-        output.endLine = result.endLine;
-    if (result.linesRead !== undefined)
-        output.linesRead = result.linesRead;
-    if (result.hasMoreLines !== undefined) {
-        output.hasMoreLines = result.hasMoreLines;
-    }
-    return output;
-}
-async function readSingleFile(task, readOptions) {
-    const { filePath, index, validPath, stats } = task;
-    const result = validPath && stats
-        ? await readFileWithStats(filePath, validPath, stats, readOptions)
-        : await readFile(filePath, readOptions);
-    return {
-        index,
-        value: buildReadMultipleResult(filePath, result),
-    };
-}
-async function readFilesInParallel(filesToProcess, options, signal, onReadComplete) {
-    const readOptions = buildReadOptions(options);
-    if (signal) {
-        readOptions.signal = signal;
-    }
-    return processInParallel(filesToProcess, async (task) => {
-        const result = await readSingleFile(task, readOptions);
-        onReadComplete?.();
-        return result;
-    }, PARALLEL_CONCURRENCY, signal);
-}
-function normalizeReadMultipleOptions(options) {
-    const normalized = {
-        encoding: options.encoding ?? 'utf-8',
-        maxSize: Math.min(options.maxSize ?? MAX_TEXT_FILE_SIZE, MAX_TEXT_FILE_SIZE),
-        maxTotalSize: options.maxTotalSize ?? DEFAULT_READ_MANY_MAX_TOTAL_SIZE,
-    };
-    applyLineSelection(normalized, options);
-    return normalized;
-}
-function applyLineSelection(target, source) {
-    if (source.head !== undefined)
-        target.head = source.head;
-    if (source.startLine !== undefined)
-        target.startLine = source.startLine;
-    if (source.endLine !== undefined)
-        target.endLine = source.endLine;
-}
-function resolveNormalizedOptions(options) {
-    const { signal, ...rest } = options;
-    return {
-        normalized: normalizeReadMultipleOptions(rest),
-        ...(signal ? { signal } : {}),
-    };
-}
-async function validateFile(filePath, index, signal) {
-    const validPath = await validateExistingPath(filePath, signal);
-    const stats = await withAbort(fsp.stat(validPath), signal);
-    return { filePath, index, validPath, stats };
-}
-function markRemainingSkipped(startIndex, total, skippedBudget) {
-    for (let index = startIndex; index < total; index += 1) {
-        skippedBudget.add(index);
-    }
-}
-async function tryValidateFile(filePath, index, signal) {
-    try {
-        return await validateFile(filePath, index, signal);
-    }
-    catch {
-        return undefined;
-    }
-}
-async function validateBatch(tasks, signal) {
-    if (tasks.length === 0)
-        return new Map();
-    const { results } = await processInParallel(tasks, async (task) => tryValidateFile(task.filePath, task.index, signal), PARALLEL_CONCURRENCY, signal);
-    const infos = new Map();
-    for (const info of results) {
-        if (!info)
-            continue;
-        infos.set(info.index, info);
-    }
-    return infos;
-}
-function applyBudgetForRange(options) {
-    const { batchStart, batchEnd, totalFiles, maxTotalSize, maxSize, validated, skippedBudget, totalSize: startingTotalSize, } = options;
-    let totalSize = startingTotalSize;
-    for (let index = batchStart; index < batchEnd; index += 1) {
-        const info = validated.get(index);
-        if (!info)
-            continue;
-        const { exceeded, totalSize: nextTotalSize } = applyBudget(totalSize, estimateReadSize(info.stats, maxSize), maxTotalSize, index, totalFiles, skippedBudget);
-        if (exceeded) {
-            return { totalSize, exceeded: true };
-        }
-        totalSize = nextTotalSize;
-    }
-    return { totalSize, exceeded: false };
-}
-async function collectFileBudget(filePaths, maxTotalSize, maxSize, signal) {
-    const skippedBudget = new Set();
-    const validated = new Map();
-    let totalSize = 0;
-    const totalFiles = filePaths.length;
-    for (let batchStart = 0; batchStart < totalFiles; batchStart += PARALLEL_CONCURRENCY) {
-        const batchTasks = [];
-        const batchEnd = Math.min(batchStart + PARALLEL_CONCURRENCY, totalFiles);
-        for (let index = batchStart; index < batchEnd; index += 1) {
-            const filePath = filePaths[index];
-            if (!filePath)
-                continue;
-            if (validated.has(index))
-                continue;
-            batchTasks.push({ filePath, index });
-        }
-        const batchInfos = await validateBatch(batchTasks, signal);
-        for (const [index, info] of batchInfos) {
-            validated.set(index, info);
-        }
-        const budgetResult = applyBudgetForRange({
-            batchStart,
-            batchEnd,
-            totalFiles,
-            maxTotalSize,
-            maxSize,
-            validated,
-            skippedBudget,
-            totalSize,
-        });
-        const { exceeded, totalSize: nextTotalSize } = budgetResult;
-        if (exceeded) {
-            return { skippedBudget, validated };
-        }
-        totalSize = nextTotalSize;
-    }
-    return { skippedBudget, validated };
-}
-function buildOutput(filePaths) {
-    const output = new Array(filePaths.length);
-    for (let index = 0; index < filePaths.length; index += 1) {
-        output[index] = { path: filePaths[index] ?? UNKNOWN_PATH };
-    }
-    return output;
-}
-function resolveErrorOriginalIndex(failureIndex, filesToProcess, totalInputFiles) {
-    // processInParallel implementations vary: some return error indices relative to
-    // the submitted batch (filesToProcess), others may forward the task/index.
-    const batchIndex = filesToProcess[failureIndex]?.index;
-    if (typeof batchIndex === 'number' &&
-        batchIndex >= 0 &&
-        batchIndex < totalInputFiles) {
-        return batchIndex;
-    }
-    if (failureIndex >= 0 && failureIndex < totalInputFiles) {
-        return failureIndex;
-    }
-    return undefined;
-}
-function buildFilesToProcess(filePaths, validated, skippedBudget) {
-    const filesToProcess = [];
-    for (let index = 0; index < filePaths.length; index += 1) {
-        if (skippedBudget.has(index))
-            continue;
-        const filePath = filePaths[index];
-        if (!filePath)
-            continue;
-        const cached = validated.get(index);
-        if (cached) {
-            filesToProcess.push({
-                filePath,
-                index,
-                validPath: cached.validPath,
-                stats: cached.stats,
-            });
-            continue;
-        }
-        filesToProcess.push({ filePath, index });
-    }
-    return filesToProcess;
-}
-function applyBudget(totalSize, estimatedSize, maxTotalSize, index, totalFiles, skippedBudget) {
-    if (totalSize + estimatedSize > maxTotalSize) {
-        skippedBudget.add(index);
-        markRemainingSkipped(index + 1, totalFiles, skippedBudget);
-        return { totalSize, exceeded: true };
-    }
-    return { totalSize: totalSize + estimatedSize, exceeded: false };
-}
-function applySkippedBudget(output, skippedBudget, filePaths, maxTotalSize) {
-    for (const index of skippedBudget) {
-        const filePath = filePaths[index];
-        if (!filePath)
-            continue;
-        output[index] = {
-            path: filePath,
-            error: `Skipped: combined estimated read would exceed maxTotalSize (${maxTotalSize} bytes)`,
-        };
-    }
-}
-export async function readMultipleFiles(filePaths, options = {}) {
-    if (filePaths.length === 0)
-        return [];
-    const { normalized, signal } = resolveNormalizedOptions(options);
-    const output = buildOutput(filePaths);
-    const { skippedBudget, validated } = await collectFileBudget(filePaths, normalized.maxTotalSize, normalized.maxSize, signal);
-    const filesToProcess = buildFilesToProcess(filePaths, validated, skippedBudget);
-    const { results, errors } = await readFilesInParallel(filesToProcess, normalized, signal, options.onReadComplete);
-    applyIndexedValues(output, results);
-    applyIndexedErrors({
-        output,
-        errors,
-        resolveIndex: (failureIndex) => resolveErrorOriginalIndex(failureIndex, filesToProcess, filePaths.length),
-        buildValue: (resolvedIndex, error) => ({
-            path: filePaths[resolvedIndex] ?? UNKNOWN_PATH,
-            error: error.message,
-        }),
-    });
-    applySkippedBudget(output, skippedBudget, filePaths, normalized.maxTotalSize);
-    return output;
-}

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

@@ -1,27 +0,0 @@
-import type { SearchFilesResult } from '../../config.js';
-type SortBy = 'name' | 'size' | 'modified' | 'path';
-interface SearchFilesOptions {
-    maxResults?: number;
-    sortBy?: SortBy;
-    maxDepth?: number;
-    maxFilesScanned?: number;
-    timeoutMs?: number;
-    baseNameMatch?: boolean;
-    skipSymlinks?: boolean;
-    includeHidden?: boolean;
-    respectGitignore?: boolean;
-    signal?: AbortSignal;
-    onProgress?: (progress: {
-        total?: number;
-        current: number;
-    }) => void;
-}
-interface Sortable {
-    name?: string;
-    size?: number;
-    modified?: Date;
-    path?: string;
-}
-export declare function sortSearchResults(results: Sortable[], sortBy: SortBy): void;
-export declare function searchFiles(basePath: string, pattern: string, excludePatterns?: readonly string[], options?: SearchFilesOptions): Promise<SearchFilesResult>;
-export {};