@j0hanz/filesystem-mcp 1.7.3 → 1.9.0

package/dist/tools/search-content.js

@@ -1,30 +1,28 @@
 import * as path from 'node:path';
 import RE2 from 're2';
-import { formatOperationSummary, joinLines } from '../config.js';
 import { DEFAULT_EXCLUDE_PATTERNS } from '../lib/constants.js';
 import { ErrorCode, formatUnknownErrorMessage, McpError, } from '../lib/errors.js';
-import { searchContent } from '../lib/file-operations/search-content.js';
+import { searchContent } from '../lib/file-operations/search.js';
+import { formatOperationSummary, joinLines } from '../config.js';
 import { SearchContentInputSchema, SearchContentOutputSchema, } from '../schemas.js';
-import { buildResourceLink, buildToolErrorResponse, buildToolResponse, createToolProgressSession, executeToolWithDiagnostics, READ_ONLY_TOOL_ANNOTATIONS, resolvePathOrRoot, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
+import { buildResourceLink, buildToolErrorResponse, buildToolResponse, createToolProgressSession, executeToolWithDiagnostics, READ_ONLY_TOOL_ANNOTATIONS, resolveFinalProgressCurrent, resolvePathOrRoot, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
 import { registerToolTaskIfAvailable } from './task-support.js';
 const MAX_INLINE_MATCHES = parseInt(process.env['FS_CONTEXT_MAX_INLINE_MATCHES'] ?? '', 10) || 50;
 export const SEARCH_CONTENT_TOOL = {
     name: 'grep',
     title: 'Search Content',
-    description: 'Search for text within file contents (grep-like). ' +
-        'Returns matching lines. ' +
-        'Path may be a directory or a single file. ' +
-        'Use `filePattern` to scope by file type (e.g. `**/*.ts`) and avoid noisy results. ' +
-        'Use includeHidden=true to include hidden files and directories.',
+    description: 'Search file contents for text (grep-like). Returns matching lines. ' +
+        'Scope with `filePattern` (e.g. `**/*.ts`) to reduce noise. ' +
+        '`includeHidden=true` for dotfiles.',
     inputSchema: SearchContentInputSchema,
     outputSchema: SearchContentOutputSchema,
     annotations: READ_ONLY_TOOL_ANNOTATIONS,
     nuances: [
-        'Inline match rows are capped (first 50); full structured results are externalized via `resourceUri`.',
+        'Inline results capped at 50 matches; full results via `resourceUri`.',
         'Skips binary and oversized files.',
     ],
     gotchas: [
-        'Skips binary and oversized files silently — check file type with `stat` if no matches appear.',
+        'Skips binary/oversized files silently — verify with `stat` if no matches.',
     ],
     taskSupport: 'optional',
 };
@@ -242,7 +240,7 @@ export function registerSearchContentTool(server, options = {}) {
                         suffix += ' [truncated — max files]';
                     }
                 }
-                const finalCurrent = Math.max((sc.filesScanned ?? 0) + 1, progress.getCurrent() + 1);
+                const finalCurrent = resolveFinalProgressCurrent(progress, (sc.filesScanned ?? 0) + 1);
                 progress.complete(`🔎︎ grep: ${pattern} • ${suffix}`, finalCurrent);
                 return result;
             }

package/dist/tools/search-files.js

@@ -1,18 +1,16 @@
 import * as path from 'node:path';
-import { formatOperationSummary, joinLines } from '../config.js';
 import { DEFAULT_EXCLUDE_PATTERNS, DEFAULT_SEARCH_TIMEOUT_MS, } from '../lib/constants.js';
 import { ErrorCode } from '../lib/errors.js';
-import { searchFiles } from '../lib/file-operations/search-files.js';
+import { searchFiles } from '../lib/file-operations/search.js';
+import { formatOperationSummary, joinLines } from '../config.js';
 import { SearchFilesInputSchema, SearchFilesOutputSchema } from '../schemas.js';
 import { buildToolErrorResponse, buildToolResponse, createProgressReporter, decodeOffsetCursor, encodeOffsetCursor, executeToolWithDiagnostics, notifyProgress, READ_ONLY_TOOL_ANNOTATIONS, resolvePathOrRoot, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
 import { registerToolTaskIfAvailable } from './task-support.js';
 export const SEARCH_FILES_TOOL = {
     name: 'find',
     title: 'Find Files',
-    description: 'Find files by glob pattern (e.g., **/*.ts). ' +
-        'Returns a list of matching files with metadata. ' +
-        'For text search inside files, use grep. ' +
-        'To bulk-edit the matched files, pass the same glob pattern to search_and_replace.',
+    description: 'Find files by glob pattern (e.g. `**/*.ts`). Returns matching files with metadata. ' +
+        'For content search, use `grep`. For bulk edits, pass the same glob to `search_and_replace`.',
     inputSchema: SearchFilesInputSchema,
     outputSchema: SearchFilesOutputSchema,
     annotations: READ_ONLY_TOOL_ANNOTATIONS,

package/dist/tools/shared.d.ts

@@ -1,8 +1,8 @@
 import type { ContentBlock, Icon, ProgressNotificationParams } from '@modelcontextprotocol/sdk/types.js';
 import { z } from 'zod';
-import type { FileInfo } from '../config.js';
 import { ErrorCode } from '../lib/errors.js';
 import type { ResourceStore } from '../lib/resource-store.js';
+import type { FileInfo } from '../config.js';
 export { type ToolContract } from './contract.js';
 export declare const READ_ONLY_TOOL_ANNOTATIONS: {
     readonly readOnlyHint: true;
@@ -12,6 +12,7 @@ export declare const READ_ONLY_TOOL_ANNOTATIONS: {
 };
 export declare const DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS: {
     readonly readOnlyHint: false;
+    readonly idempotentHint: false;
     readonly destructiveHint: true;
     readonly openWorldHint: false;
 };
@@ -123,7 +124,18 @@ export interface ToolProgressSession {
     fail: (message: string, minimumCurrent?: number) => void;
     getCurrent: () => number;
 }
+export interface BatchProgressCallbacks {
+    progress: ToolProgressSession;
+    onItemComplete: () => void;
+}
 export declare function createToolProgressSession(extra: ToolExtra, startMessage: string): ToolProgressSession;
+export declare function createBatchProgressCallbacks(extra: ToolExtra, params: {
+    toolLabel: string;
+    context: string;
+    totalItems: number;
+    itemVerb: string;
+}): BatchProgressCallbacks;
+export declare function resolveFinalProgressCurrent(progress: ToolProgressSession, ...candidates: number[]): number;
 export declare function wrapToolHandler<Args, Result>(handler: (args: Args, extra: ToolExtra) => Promise<ToolResult<Result>>, options: {
     guard?: (() => boolean) | undefined;
     progressMessage?: (args: Args) => string;
@@ -142,3 +154,8 @@ export declare function resolvePathOrRoot(pathValue: string | undefined): string
 export declare function encodeOffsetCursor(offset: number): string;
 export declare function decodeOffsetCursor(cursor: string): number;
 export declare function buildBatchPathContext(paths: readonly string[], unitLabel?: string): string;
+export declare function buildBatchCompletionSuffix(summary: {
+    total?: number;
+    failed?: number;
+    succeeded?: number;
+} | undefined, successWord: string, singularWord?: string): string;

package/dist/tools/shared.js

@@ -5,7 +5,7 @@ import { parseTrueEnvFlag } from '../lib/constants.js';
 import { createDetailedError, ErrorCode, formatDetailedError, getSuggestion, McpError, } from '../lib/errors.js';
 import { createTimedAbortSignal } from '../lib/fs-helpers.js';
 import { withToolDiagnostics } from '../lib/observability.js';
-import { getAllowedDirectories } from '../lib/path-validation.js';
+import { getAllowedDirectories } from '../lib/paths.js';
 export {} from './contract.js';
 const MAX_INLINE_CONTENT_CHARS = parseInt(process.env['FS_CONTEXT_MAX_INLINE_CHARS'] ?? '', 10) || 20_000;
 const MAX_INLINE_PREVIEW_CHARS = 4_000;
@@ -24,6 +24,7 @@ export const READ_ONLY_TOOL_ANNOTATIONS = {
 };
 export const DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS = {
     readOnlyHint: false,
+    idempotentHint: false,
     destructiveHint: true,
     openWorldHint: false,
 };
@@ -293,6 +294,15 @@ export function createToolProgressSession(extra, startMessage) {
             cursor = value;
         return cursor;
     };
+    const finishProgress = (message, minimumCurrent) => {
+        const finalCurrent = Math.max(cursor + 1, minimumCurrent ?? 1, 1);
+        notifyProgress(extra, {
+            current: finalCurrent,
+            total: finalCurrent,
+            ...(message !== undefined ? { message } : {}),
+        });
+        cursor = finalCurrent;
+    };
     return {
         update: ({ current, total, message }) => {
             const normalized = setCursor(current);
@@ -309,27 +319,27 @@ export function createToolProgressSession(extra, startMessage) {
                 message: messageForCurrent(next),
             });
         },
-        complete: (message, minimumCurrent) => {
-            const finalCurrent = Math.max(cursor + 1, minimumCurrent ?? 1, 1);
-            notifyProgress(extra, {
-                current: finalCurrent,
-                total: finalCurrent,
-                message,
-            });
-            cursor = finalCurrent;
-        },
-        fail: (message, minimumCurrent) => {
-            const finalCurrent = Math.max(cursor + 1, minimumCurrent ?? 1, 1);
-            notifyProgress(extra, {
-                current: finalCurrent,
-                total: finalCurrent,
-                message,
-            });
-            cursor = finalCurrent;
-        },
+        complete: finishProgress,
+        fail: finishProgress,
         getCurrent: () => cursor,
     };
 }
+export function createBatchProgressCallbacks(extra, params) {
+    const progress = createToolProgressSession(extra, `${params.toolLabel}: ${params.context}`);
+    const onItemComplete = () => {
+        progress.increment((current) => `${params.toolLabel}: ${params.context} [${current}/${params.totalItems} ${params.itemVerb}]`);
+    };
+    return { progress, onItemComplete };
+}
+export function resolveFinalProgressCurrent(progress, ...candidates) {
+    let finalCurrent = progress.getCurrent() + 1;
+    for (const candidate of candidates) {
+        if (candidate > finalCurrent) {
+            finalCurrent = candidate;
+        }
+    }
+    return finalCurrent;
+}
 async function withProgress(message, extra, run, getCompletionMessage) {
     if (!canReportProgress(extra)) {
         return run();
@@ -430,3 +440,13 @@ export function buildBatchPathContext(paths, unitLabel = 'paths') {
         : '';
     return `${paths.length} ${normalizedLabel} [${first}${extraPaths}]`;
 }
+export function buildBatchCompletionSuffix(summary, successWord, singularWord) {
+    const total = summary?.total ?? 0;
+    const failed = summary?.failed ?? 0;
+    const succeeded = summary?.succeeded ?? 0;
+    if (failed) {
+        return `${succeeded}/${total} ${successWord}, ${failed} failed`;
+    }
+    const word = total === 1 && singularWord ? singularWord : successWord;
+    return `${total} ${word}`;
+}

package/dist/tools/stat-many.js

@@ -1,36 +1,21 @@
-import { formatBytes, joinLines } from '../config.js';
 import { DEFAULT_SEARCH_TIMEOUT_MS } from '../lib/constants.js';
 import { ErrorCode } from '../lib/errors.js';
-import { getMultipleFileInfo } from '../lib/file-operations/file-info.js';
+import { getMultipleFileInfo } from '../lib/file-operations/metadata.js';
+import { formatBytes, joinLines } from '../config.js';
 import { GetMultipleFileInfoInputSchema, GetMultipleFileInfoOutputSchema, } from '../schemas.js';
-import { buildBatchPathContext, buildFileInfoPayload, buildToolErrorResponse, buildToolResponse, createToolProgressSession, executeToolWithDiagnostics, READ_ONLY_TOOL_ANNOTATIONS, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
+import { buildBatchCompletionSuffix, buildBatchPathContext, buildFileInfoPayload, buildToolErrorResponse, buildToolResponse, createBatchProgressCallbacks, executeToolWithDiagnostics, READ_ONLY_TOOL_ANNOTATIONS, resolveFinalProgressCurrent, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
 import { registerToolTaskIfAvailable } from './task-support.js';
 export const GET_MULTIPLE_FILE_INFO_TOOL = {
     name: 'stat_many',
     title: 'Get Multiple File Info',
-    description: 'Get metadata (including tokenEstimate) for multiple files or directories in one request. Use tokenEstimate (size÷4) to pre-screen token cost before reading.',
+    description: 'Get metadata for multiple files/directories in one request. ' +
+        'Use `tokenEstimate` (size\u00f74) to pre-screen token cost before reading.',
     inputSchema: GetMultipleFileInfoInputSchema,
     outputSchema: GetMultipleFileInfoOutputSchema,
     annotations: READ_ONLY_TOOL_ANNOTATIONS,
     taskSupport: 'optional',
     nuances: ['Use before read/search when file size/type uncertainty exists.'],
 };
-function buildStatManyCompletionSuffix(summary) {
-    const total = summary?.total ?? 0;
-    const failed = summary?.failed ?? 0;
-    const succeeded = summary?.succeeded ?? 0;
-    if (failed) {
-        return `${succeeded}/${total} OK, ${failed} failed`;
-    }
-    return `${total} OK`;
-}
-function createStatManyProgressCallbacks(extra, context, totalPaths) {
-    const progress = createToolProgressSession(extra, `🕮 stat_many: ${context}`);
-    const onProgress = () => {
-        progress.increment((current) => `🕮 stat_many: ${context} [${current}/${totalPaths} scanned]`);
-    };
-    return { progress, onProgress };
-}
 function formatFileInfoDetail(info) {
     const lines = [
         `${info.name} (${info.type})`,
@@ -90,13 +75,18 @@ export function registerGetMultipleFileInfoTool(server, options = {}) {
             context: { path: primaryPath },
             run: async (signal) => {
                 const context = buildBatchPathContext(args.paths);
-                const { progress, onProgress } = createStatManyProgressCallbacks(extra, context, args.paths.length);
+                const { progress, onItemComplete } = createBatchProgressCallbacks(extra, {
+                    toolLabel: '🕮 stat_many',
+                    context,
+                    totalItems: args.paths.length,
+                    itemVerb: 'scanned',
+                });
                 try {
-                    const result = await handleGetMultipleFileInfo(args, signal, onProgress);
+                    const result = await handleGetMultipleFileInfo(args, signal, onItemComplete);
                     const sc = result.structuredContent;
-                    const suffix = buildStatManyCompletionSuffix(sc.summary);
+                    const suffix = buildBatchCompletionSuffix(sc.summary, 'OK');
                     const total = sc.summary?.total ?? 0;
-                    const finalCurrent = Math.max(total, progress.getCurrent() + 1);
+                    const finalCurrent = resolveFinalProgressCurrent(progress, total);
                     progress.complete(`🕮 stat_many: ${context} • ${suffix}`, finalCurrent);
                     return result;
                 }

package/dist/tools/stat.js

@@ -1,14 +1,15 @@
 import * as path from 'node:path';
-import { formatBytes, joinLines } from '../config.js';
 import { DEFAULT_SEARCH_TIMEOUT_MS } from '../lib/constants.js';
 import { ErrorCode } from '../lib/errors.js';
-import { getFileInfo } from '../lib/file-operations/file-info.js';
+import { getFileInfo } from '../lib/file-operations/metadata.js';
+import { formatBytes, joinLines } from '../config.js';
 import { GetFileInfoInputSchema, GetFileInfoOutputSchema } from '../schemas.js';
 import { buildFileInfoPayload, buildToolErrorResponse, buildToolResponse, executeToolWithDiagnostics, READ_ONLY_TOOL_ANNOTATIONS, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
 export const GET_FILE_INFO_TOOL = {
     name: 'stat',
     title: 'Get File Info',
-    description: 'Get metadata (size, modified time, permissions, mime type, tokenEstimate) for a file or directory. Use tokenEstimate (size÷4) to pre-screen token cost before reading.',
+    description: 'Get file/directory metadata: size, modified, permissions, mime, tokenEstimate. ' +
+        'Use `tokenEstimate` (size\u00f74) to pre-screen token cost before reading.',
     inputSchema: GetFileInfoInputSchema,
     outputSchema: GetFileInfoOutputSchema,
     annotations: READ_ONLY_TOOL_ANNOTATIONS,

package/dist/tools/task-support.js

@@ -1,7 +1,7 @@
 import { channel } from 'node:diagnostics_channel';
 import { CallToolResultSchema } from '@modelcontextprotocol/sdk/types.js';
 import { ErrorCode, McpError } from '../lib/errors.js';
-import { isRecord } from '../lib/type-guards.js';
+import { isRecord } from '../lib/utils.js';
 import { buildToolErrorResponse, maybeStripStructuredContentFromResult, withDefaultIcons, } from './shared.js';
 function isExperimentalTaskRegistration(value) {
     if (!value || typeof value !== 'object')

package/dist/tools/tree.js

@@ -1,16 +1,15 @@
 import * as path from 'node:path';
 import { DEFAULT_SEARCH_TIMEOUT_MS } from '../lib/constants.js';
 import { ErrorCode } from '../lib/errors.js';
-import { formatTreeAscii, treeDirectory } from '../lib/file-operations/tree.js';
+import { formatTreeAscii, treeDirectory, } from '../lib/file-operations/metadata.js';
 import { TreeInputSchema, TreeOutputSchema } from '../schemas.js';
 import { buildToolErrorResponse, buildToolResponse, createProgressReporter, executeToolWithDiagnostics, notifyProgress, READ_ONLY_TOOL_ANNOTATIONS, resolvePathOrRoot, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
 import { registerToolTaskIfAvailable } from './task-support.js';
 export const TREE_TOOL = {
     name: 'tree',
     title: 'Tree',
-    description: 'Render a directory tree (bounded recursion). ' +
-        'Returns an ASCII tree for quick scanning and a structured JSON tree for programmatic use. ' +
-        'Note: maxDepth=0 returns only the root node with empty children array.',
+    description: 'Render a directory tree (bounded recursion). Returns ASCII tree + structured JSON. ' +
+        '`maxDepth=0` returns only the root node.',
     inputSchema: TreeInputSchema,
     outputSchema: TreeOutputSchema,
     annotations: READ_ONLY_TOOL_ANNOTATIONS,

package/dist/tools/write-file.js

@@ -2,7 +2,7 @@ import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import { ErrorCode } from '../lib/errors.js';
 import { atomicWriteFile, withAbort } from '../lib/fs-helpers.js';
-import { validatePathForWrite } from '../lib/path-validation.js';
+import { validatePathForWrite } from '../lib/paths.js';
 import { WriteFileInputSchema, WriteFileOutputSchema } from '../schemas.js';
 import { buildToolErrorResponse, buildToolResponse, DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS, executeToolWithDiagnostics, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
 import { registerToolTaskIfAvailable } from './task-support.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@j0hanz/filesystem-mcp",
-  "version": "1.7.3",
+  "version": "1.9.0",
   "mcpName": "io.github.j0hanz/filesystem-mcp",
   "description": "MCP Server that enables LLMs to interact with the local filesystem.",
   "type": "module",
@@ -35,8 +35,11 @@
     "type-check:diagnostics": "tsc --noEmit --extendedDiagnostics",
     "type-check:trace": "node -e \"require('fs').rmSync('.ts-trace',{recursive:true,force:true})\" && tsc --noEmit --generateTrace .ts-trace",
     "lint": "eslint .",
+    "lint:tests": "eslint src/__tests__",
     "lint:fix": "eslint . --fix",
     "test": "node scripts/tasks.mjs test",
+    "test:fast": "node --test --import tsx/esm src/__tests__/**/*.test.ts node-tests/**/*.test.ts",
+    "test:coverage": "node scripts/tasks.mjs test --coverage",
     "knip": "knip",
     "knip:fix": "knip --fix",
     "inspector": "npm run build && npx -y @modelcontextprotocol/inspector node dist/index.js ${workspaceFolder}",
@@ -65,18 +68,19 @@
     "commander": "^14.0.3",
     "diff": "^8.0.3",
     "ignore": "^7.0.5",
-    "re2": "^1.23.2",
+    "re2": "^1.23.3",
     "safe-regex2": "^5.0.0",
     "zod": "^4.3.6"
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
-    "eslint": "^10.0.2",
     "@trivago/prettier-plugin-sort-imports": "^6.0.2",
     "@types/node": "^24",
+    "eslint": "^10.0.2",
     "eslint-config-prettier": "^10.1.8",
-    "eslint-plugin-de-morgan": "^2.0.0",
-    "eslint-plugin-depend": "^1.4.0",
+    "eslint-plugin-de-morgan": "^2.1.1",
+    "eslint-plugin-depend": "^1.5.0",
+    "eslint-plugin-sonarjs": "^4.0.0",
     "eslint-plugin-unused-imports": "^4.4.1",
     "jscpd": "^4.0.8",
     "knip": "^5.85.0",

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

@@ -1,10 +0,0 @@
-import type { FileInfo, GetMultipleFileInfoResult } from '../../config.js';
-interface FileInfoOptions {
-    includeMimeType?: boolean | undefined;
-    signal?: AbortSignal | undefined;
-    onProgress?: () => void;
-}
-export declare function getFileInfo(filePath: string, options?: FileInfoOptions): Promise<FileInfo>;
-type GetMultipleFileInfoOptions = FileInfoOptions;
-export declare function getMultipleFileInfo(paths: readonly string[], options?: GetMultipleFileInfoOptions): Promise<GetMultipleFileInfoResult>;
-export {};

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

@@ -1,143 +0,0 @@
-import * as fsp from 'node:fs/promises';
-import * as path from 'node:path';
-import { getMimeType, PARALLEL_CONCURRENCY } from '../constants.js';
-import { isAbortError } from '../errors.js';
-import { assertNotAborted, getFileType, isHidden, processInParallel, withAbort, } from '../fs-helpers.js';
-import { assertAllowedFileAccess } from '../path-policy.js';
-import { validateExistingPathDetailed } from '../path-validation.js';
-import { applyIndexedErrors, applyIndexedValues } from './common.js';
-const PERM_STRINGS = [
-    '---',
-    '--x',
-    '-w-',
-    '-wx',
-    'r--',
-    'r-x',
-    'rw-',
-    'rwx',
-];
-const UNKNOWN_PATH = '(unknown)';
-function getPermissions(mode) {
-    const ownerIndex = (mode >> 6) & 0b111;
-    const groupIndex = (mode >> 3) & 0b111;
-    const otherIndex = mode & 0b111;
-    const owner = PERM_STRINGS[ownerIndex] ?? '---';
-    const group = PERM_STRINGS[groupIndex] ?? '---';
-    const other = PERM_STRINGS[otherIndex] ?? '---';
-    return `${owner}${group}${other}`;
-}
-function buildFileInfoResult(name, requestedPath, isSymlink, stats, mimeType, symlinkTarget) {
-    const tokenEstimate = stats.isFile() ? Math.ceil(stats.size / 4) : undefined;
-    return {
-        name,
-        path: requestedPath,
-        type: isSymlink ? 'symlink' : getFileType(stats),
-        size: stats.size,
-        ...(tokenEstimate !== undefined ? { tokenEstimate } : {}),
-        created: stats.birthtime,
-        modified: stats.mtime,
-        accessed: stats.atime,
-        permissions: getPermissions(stats.mode),
-        isHidden: isHidden(name),
-        ...(mimeType !== undefined ? { mimeType } : {}),
-        ...(symlinkTarget !== undefined ? { symlinkTarget } : {}),
-    };
-}
-async function getSymlinkTarget(pathToRead, signal) {
-    assertNotAborted(signal);
-    try {
-        return await withAbort(fsp.readlink(pathToRead), signal);
-    }
-    catch (error) {
-        if (isAbortError(error))
-            throw error;
-        return undefined;
-    }
-}
-export async function getFileInfo(filePath, options = {}) {
-    const { signal } = options;
-    assertNotAborted(signal);
-    const { requestedPath, resolvedPath, isSymlink } = await validateExistingPathDetailed(filePath, signal);
-    assertAllowedFileAccess(requestedPath, resolvedPath);
-    const name = path.basename(requestedPath);
-    const ext = path.extname(name).toLowerCase();
-    const includeMimeType = options.includeMimeType !== false;
-    const mimeType = includeMimeType && ext.length > 0 ? getMimeType(ext) : undefined;
-    const symlinkTarget = isSymlink
-        ? await getSymlinkTarget(requestedPath, signal)
-        : undefined;
-    const stats = await withAbort(fsp.stat(resolvedPath), signal);
-    return buildFileInfoResult(name, requestedPath, isSymlink, stats, mimeType, symlinkTarget);
-}
-function buildEmptyResult() {
-    return {
-        results: [],
-        summary: { total: 0, succeeded: 0, failed: 0, totalSize: 0 },
-    };
-}
-async function processFileInfo(filePath, options) {
-    const info = await getFileInfo(filePath, options);
-    return { path: filePath, info };
-}
-function buildIndexedPathTasks(paths) {
-    const tasks = [];
-    for (let index = 0; index < paths.length; index += 1) {
-        const filePath = paths[index];
-        if (filePath === undefined)
-            continue;
-        tasks.push({ filePath, index });
-    }
-    return tasks;
-}
-async function readFileInfoInParallel(paths, options) {
-    return processInParallel(buildIndexedPathTasks(paths), async ({ filePath, index }) => {
-        const value = await processFileInfo(filePath, options);
-        options.onProgress?.();
-        return { index, value };
-    }, PARALLEL_CONCURRENCY, options.signal);
-}
-function calculateSummary(results) {
-    let succeeded = 0;
-    let failed = 0;
-    let totalSize = 0;
-    for (const result of results) {
-        if (result.info !== undefined) {
-            succeeded++;
-            totalSize += result.info.size;
-        }
-        else {
-            failed++;
-        }
-    }
-    return {
-        total: results.length,
-        succeeded,
-        failed,
-        totalSize,
-    };
-}
-export async function getMultipleFileInfo(paths, options = {}) {
-    if (paths.length === 0)
-        return buildEmptyResult();
-    const output = new Array(paths.length);
-    for (let index = 0; index < paths.length; index += 1) {
-        output[index] = { path: paths[index] ?? UNKNOWN_PATH };
-    }
-    const { results, errors } = await readFileInfoInParallel(paths, options);
-    applyIndexedValues(output, results);
-    applyIndexedErrors({
-        output,
-        errors,
-        resolveIndex: (failureIndex) => failureIndex >= 0 && failureIndex < output.length
-            ? failureIndex
-            : undefined,
-        buildValue: (resolvedIndex, error) => ({
-            path: paths[resolvedIndex] ?? UNKNOWN_PATH,
-            error: error.message,
-        }),
-    });
-    return {
-        results: output,
-        summary: calculateSummary(output),
-    };
-}

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

@@ -1,6 +0,0 @@
-import { type Ignore } from 'ignore';
-export declare function loadRootGitignore(root: string, signal?: AbortSignal): Promise<Ignore | null>;
-export declare function isIgnoredByGitignore(matcher: Ignore, root: string, absolutePath: string, options?: {
-    isDirectory?: boolean;
-    relativePath?: string;
-}): boolean;

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

@@ -1,45 +0,0 @@
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-import ignore, {} from 'ignore';
-import { isNodeError } from '../errors.js';
-import { toPosixPath } from '../path-format.js';
-function parseGitignoreLines(contents) {
-    const lines = [];
-    for (const line of contents.split(/\r?\n/u)) {
-        const trimmed = line.trim();
-        if (trimmed.length > 0) {
-            lines.push(trimmed);
-        }
-    }
-    return lines;
-}
-export async function loadRootGitignore(root, signal) {
-    const gitignorePath = path.join(root, '.gitignore');
-    let contents;
-    try {
-        contents = await fs.readFile(gitignorePath, {
-            encoding: 'utf-8',
-            signal,
-        });
-    }
-    catch (error) {
-        if (isNodeError(error) && error.code === 'ENOENT') {
-            return null;
-        }
-        throw error;
-    }
-    const matcher = ignore();
-    matcher.add(parseGitignoreLines(contents));
-    return matcher;
-}
-export function isIgnoredByGitignore(matcher, root, absolutePath, options = {}) {
-    let relative = options.relativePath;
-    relative ??= path.relative(root, absolutePath);
-    if (relative.length === 0)
-        return false;
-    const normalized = toPosixPath(relative);
-    if (options.isDirectory) {
-        return matcher.ignores(normalized.endsWith('/') ? normalized : `${normalized}/`);
-    }
-    return matcher.ignores(normalized);
-}

package/dist/lib/file-operations/list-directory.d.ts

@@ -1,14 +0,0 @@
-import type { ListDirectoryResult } from '../../config.js';
-interface ListDirectoryOptions {
-    includeHidden?: boolean;
-    excludePatterns?: readonly string[];
-    maxDepth?: number;
-    maxEntries?: number;
-    sortBy?: 'name' | 'size' | 'modified' | 'type';
-    includeSymlinkTargets?: boolean;
-    pattern?: string;
-    timeoutMs?: number;
-    signal?: AbortSignal;
-}
-export declare function listDirectory(dirPath: string, options?: ListDirectoryOptions): Promise<ListDirectoryResult>;
-export {};