@j0hanz/filesystem-mcp 1.1.2 → 1.2.1

package/dist/tools/calculate-hash.js

@@ -2,26 +2,22 @@ import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import { createHash } from 'node:crypto';
 import { createReadStream } from 'node:fs';
+import { PARALLEL_CONCURRENCY } from '../lib/constants.js';
 import { ErrorCode } from '../lib/errors.js';
 import { isIgnoredByGitignore, loadRootGitignore, } from '../lib/file-operations/gitignore.js';
 import { globEntries } from '../lib/file-operations/glob-engine.js';
-import { assertNotAborted, createTimedAbortSignal, withAbort, } from '../lib/fs-helpers.js';
-import { withToolDiagnostics } from '../lib/observability.js';
+import { assertNotAborted, withAbort } from '../lib/fs-helpers.js';
 import { validateExistingPath } from '../lib/path-validation.js';
 import { CalculateHashInputSchema, CalculateHashOutputSchema, } from '../schemas.js';
-import { buildToolErrorResponse, buildToolResponse, createProgressReporter, getExperimentalTaskRegistration, notifyProgress, withDefaultIcons, withToolErrorHandling, wrapToolHandler, } from './shared.js';
-import { createToolTaskHandler } from './task-support.js';
+import { buildToolErrorResponse, buildToolResponse, createProgressReporter, executeToolWithDiagnostics, notifyProgress, READ_ONLY_TOOL_ANNOTATIONS, withDefaultIcons, wrapToolHandler, } from './shared.js';
+import { registerToolTaskIfAvailable } from './task-support.js';
 const WINDOWS_PATH_SEPARATOR = /\\/gu;
 const CALCULATE_HASH_TOOL = {
     title: 'Calculate Hash',
     description: 'Calculate SHA-256 hash of a file or directory.',
     inputSchema: CalculateHashInputSchema,
     outputSchema: CalculateHashOutputSchema,
-    annotations: {
-        readOnlyHint: true,
-        idempotentHint: true,
-        openWorldHint: false,
-    },
+    annotations: READ_ONLY_TOOL_ANNOTATIONS,
 };
 async function hashFile(filePath, encoding, signal) {
     assertNotAborted(signal);
@@ -64,9 +60,8 @@ function reportHashProgress(onProgress, current, force = false) {
 async function hashDirectory(dirPath, options = {}) {
     const { signal, onProgress } = options;
     const gitignoreMatcher = await loadRootGitignore(dirPath, signal);
-    // Enumerate all files in directory.
-    const entries = [];
-    let filesHashed = 0;
+    // Phase 1: collect all file paths that pass gitignore filtering.
+    const filteredPaths = [];
     for await (const entry of globEntries({
         cwd: dirPath,
         pattern: '**/*',
@@ -84,12 +79,25 @@ async function hashDirectory(dirPath, options = {}) {
             isIgnoredByGitignore(gitignoreMatcher, dirPath, entry.path)) {
             continue;
         }
-        // entry.path is already absolute, no need to join
-        const fileHash = await hashFile(entry.path, undefined, signal);
-        // Use posix separators so hashes are stable across OS path separators.
-        const relativePath = toStableRelativePath(dirPath, entry.path);
-        entries.push({ path: relativePath, hash: fileHash });
-        filesHashed++;
+        filteredPaths.push({
+            filePath: entry.path,
+            relativePath: toStableRelativePath(dirPath, entry.path),
+        });
+    }
+    assertNotAborted(signal);
+    // Phase 2: hash files concurrently with bounded pool.
+    const concurrency = Math.min(PARALLEL_CONCURRENCY, 8);
+    const entries = [];
+    let filesHashed = 0;
+    for (let i = 0; i < filteredPaths.length; i += concurrency) {
+        assertNotAborted(signal);
+        const batch = filteredPaths.slice(i, i + concurrency);
+        const batchResults = await Promise.all(batch.map(async ({ filePath, relativePath }) => {
+            const fileHash = await hashFile(filePath, undefined, signal);
+            return { path: relativePath, hash: fileHash };
+        }));
+        entries.push(...batchResults);
+        filesHashed += batchResults.length;
         reportHashProgress(onProgress, filesHashed);
     }
     reportHashProgress(onProgress, filesHashed, true);
@@ -139,43 +147,33 @@ async function handleCalculateHash(args, signal, onProgress) {
     }
 }
 export function registerCalculateHashTool(server, options = {}) {
-    const handler = (args, extra) => withToolDiagnostics('calculate_hash', () => withToolErrorHandling(async () => {
-        notifyProgress(extra, {
-            current: 0,
-            message: `🕮 calculate_hash: ${path.basename(args.path)}`,
-        });
-        const { signal, cleanup } = createTimedAbortSignal(extra.signal);
-        try {
+    const handler = (args, extra) => executeToolWithDiagnostics({
+        toolName: 'calculate_hash',
+        extra,
+        timedSignal: {},
+        context: { path: args.path },
+        run: async (signal) => {
+            notifyProgress(extra, {
+                current: 0,
+                message: `🕮 calculate_hash: ${path.basename(args.path)}`,
+            });
             const result = await handleCalculateHash(args, signal, createProgressReporter(extra));
             const sc = result.structuredContent;
             const totalFiles = sc.ok ? (sc.fileCount ?? 1) : 1;
             const finalCurrent = totalFiles + 1;
-            const suffix = sc.ok
-                ? `${(sc.hash ?? '').slice(0, 8)}...`
-                : 'failed';
+            const suffix = sc.ok ? `${(sc.hash ?? '').slice(0, 8)}...` : 'failed';
             notifyProgress(extra, {
                 current: finalCurrent,
                 message: `🕮 calculate_hash: ${path.basename(args.path)} ➟ ${suffix}`,
             });
             return result;
-        }
-        finally {
-            cleanup();
-        }
-    }, (error) => buildToolErrorResponse(error, ErrorCode.E_UNKNOWN, args.path)), { path: args.path });
+        },
+        onError: (error) => buildToolErrorResponse(error, ErrorCode.E_UNKNOWN, args.path),
+    });
     const wrappedHandler = wrapToolHandler(handler, {
         guard: options.isInitialized,
     });
-    const taskOptions = options.isInitialized
-        ? { guard: options.isInitialized }
-        : undefined;
-    const tasks = getExperimentalTaskRegistration(server);
-    if (tasks?.registerToolTask) {
-        tasks.registerToolTask('calculate_hash', withDefaultIcons({
-            ...CALCULATE_HASH_TOOL,
-            execution: { taskSupport: 'optional' },
-        }, options.iconInfo), createToolTaskHandler(wrappedHandler, taskOptions));
+    if (registerToolTaskIfAvailable(server, 'calculate_hash', CALCULATE_HASH_TOOL, wrappedHandler, options.iconInfo, options.isInitialized))
         return;
-    }
     server.registerTool('calculate_hash', withDefaultIcons({ ...CALCULATE_HASH_TOOL }, options.iconInfo), wrappedHandler);
 }

package/dist/tools/create-directory.js

@@ -1,21 +1,17 @@
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import { ErrorCode } from '../lib/errors.js';
-import { createTimedAbortSignal, withAbort } from '../lib/fs-helpers.js';
-import { withToolDiagnostics } from '../lib/observability.js';
+import { withAbort } from '../lib/fs-helpers.js';
 import { validatePathForWrite } from '../lib/path-validation.js';
 import { CreateDirectoryInputSchema, CreateDirectoryOutputSchema, } from '../schemas.js';
-import { buildToolErrorResponse, buildToolResponse, withDefaultIcons, withToolErrorHandling, wrapToolHandler, } from './shared.js';
+import { buildToolErrorResponse, buildToolResponse, executeToolWithDiagnostics, IDEMPOTENT_WRITE_TOOL_ANNOTATIONS, withDefaultIcons, wrapToolHandler, } from './shared.js';
+import { registerToolTaskIfAvailable } from './task-support.js';
 const CREATE_DIRECTORY_TOOL = {
     title: 'Create Directory',
     description: 'Create a new directory at the specified path (recursive)',
     inputSchema: CreateDirectoryInputSchema,
     outputSchema: CreateDirectoryOutputSchema,
-    annotations: {
-        readOnlyHint: false,
-        idempotentHint: true,
-        openWorldHint: false,
-    },
+    annotations: IDEMPOTENT_WRITE_TOOL_ANNOTATIONS,
 };
 async function handleCreateDirectory(args, signal) {
     const validPath = await validatePathForWrite(args.path, signal);
@@ -26,17 +22,19 @@ async function handleCreateDirectory(args, signal) {
     });
 }
 export function registerCreateDirectoryTool(server, options = {}) {
-    const handler = (args, extra) => withToolDiagnostics('mkdir', () => withToolErrorHandling(async () => {
-        const { signal, cleanup } = createTimedAbortSignal(extra.signal);
-        try {
-            return await handleCreateDirectory(args, signal);
-        }
-        finally {
-            cleanup();
-        }
-    }, (error) => buildToolErrorResponse(error, ErrorCode.E_UNKNOWN, args.path)), { path: args.path });
-    server.registerTool('mkdir', withDefaultIcons({ ...CREATE_DIRECTORY_TOOL }, options.iconInfo), wrapToolHandler(handler, {
+    const handler = (args, extra) => executeToolWithDiagnostics({
+        toolName: 'mkdir',
+        extra,
+        timedSignal: {},
+        context: { path: args.path },
+        run: (signal) => handleCreateDirectory(args, signal),
+        onError: (error) => buildToolErrorResponse(error, ErrorCode.E_UNKNOWN, args.path),
+    });
+    const wrappedHandler = wrapToolHandler(handler, {
         guard: options.isInitialized,
         progressMessage: (args) => `🛠 mkdir: ${path.basename(args.path)}`,
-    }));
+    });
+    if (registerToolTaskIfAvailable(server, 'mkdir', CREATE_DIRECTORY_TOOL, wrappedHandler, options.iconInfo, options.isInitialized))
+        return;
+    server.registerTool('mkdir', withDefaultIcons({ ...CREATE_DIRECTORY_TOOL }, options.iconInfo), wrappedHandler);
 }

package/dist/tools/delete-file.js

@@ -1,21 +1,17 @@
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import { ErrorCode, isNodeError } from '../lib/errors.js';
-import { createTimedAbortSignal, withAbort } from '../lib/fs-helpers.js';
-import { withToolDiagnostics } from '../lib/observability.js';
+import { withAbort } from '../lib/fs-helpers.js';
 import { validatePathForWrite } from '../lib/path-validation.js';
 import { DeleteFileInputSchema, DeleteFileOutputSchema } from '../schemas.js';
-import { buildToolErrorResponse, buildToolResponse, withDefaultIcons, withToolErrorHandling, wrapToolHandler, } from './shared.js';
+import { buildToolErrorResponse, buildToolResponse, DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS, executeToolWithDiagnostics, withDefaultIcons, wrapToolHandler, } from './shared.js';
+import { registerToolTaskIfAvailable } from './task-support.js';
 const DELETE_FILE_TOOL = {
     title: 'Delete File',
     description: 'Delete a file or directory.',
     inputSchema: DeleteFileInputSchema,
     outputSchema: DeleteFileOutputSchema,
-    annotations: {
-        readOnlyHint: false,
-        destructiveHint: true,
-        openWorldHint: false,
-    },
+    annotations: DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS,
 };
 async function handleDeleteFile(args, signal) {
     const validPath = await validatePathForWrite(args.path, signal);
@@ -51,36 +47,38 @@ async function handleDeleteFile(args, signal) {
     });
 }
 export function registerDeleteFileTool(server, options = {}) {
-    const handler = (args, extra) => withToolDiagnostics('rm', () => withToolErrorHandling(async () => {
-        const { signal, cleanup } = createTimedAbortSignal(extra.signal);
-        try {
-            return await handleDeleteFile(args, signal);
-        }
-        finally {
-            cleanup();
-        }
-    }, (error) => {
-        if (isNodeError(error)) {
-            if (error.code === 'ENOENT') {
-                return buildToolErrorResponse(error, ErrorCode.E_NOT_FOUND, args.path);
-            }
-            if (error.code === 'ENOTEMPTY') {
-                return buildToolErrorResponse(new Error(`Directory is not empty: ${args.path}. Use recursive: true to delete non-empty directories.`), ErrorCode.E_INVALID_INPUT, args.path);
-            }
-            if (error.code === 'EISDIR') {
-                return buildToolErrorResponse(new Error(`Path is a directory: ${args.path}. Use recursive: true to delete directories.`), ErrorCode.E_INVALID_INPUT, args.path);
-            }
-            if (error.code === 'EEXIST') {
-                return buildToolErrorResponse(new Error(`Directory is not empty: ${args.path}. Use recursive: true to delete non-empty directories.`), ErrorCode.E_INVALID_INPUT, args.path);
+    const handler = (args, extra) => executeToolWithDiagnostics({
+        toolName: 'rm',
+        extra,
+        timedSignal: {},
+        context: { path: args.path },
+        run: (signal) => handleDeleteFile(args, signal),
+        onError: (error) => {
+            if (isNodeError(error)) {
+                if (error.code === 'ENOENT') {
+                    return buildToolErrorResponse(error, ErrorCode.E_NOT_FOUND, args.path);
+                }
+                if (error.code === 'ENOTEMPTY') {
+                    return buildToolErrorResponse(new Error(`Directory is not empty: ${args.path}. Use recursive: true to delete non-empty directories.`), ErrorCode.E_INVALID_INPUT, args.path);
+                }
+                if (error.code === 'EISDIR') {
+                    return buildToolErrorResponse(new Error(`Path is a directory: ${args.path}. Use recursive: true to delete directories.`), ErrorCode.E_INVALID_INPUT, args.path);
+                }
+                if (error.code === 'EEXIST') {
+                    return buildToolErrorResponse(new Error(`Directory is not empty: ${args.path}. Use recursive: true to delete non-empty directories.`), ErrorCode.E_INVALID_INPUT, args.path);
+                }
+                if (error.code === 'EPERM' || error.code === 'EACCES') {
+                    return buildToolErrorResponse(error, ErrorCode.E_PERMISSION_DENIED, args.path);
+                }
             }
-            if (error.code === 'EPERM' || error.code === 'EACCES') {
-                return buildToolErrorResponse(error, ErrorCode.E_PERMISSION_DENIED, args.path);
-            }
-        }
-        return buildToolErrorResponse(error, ErrorCode.E_UNKNOWN, args.path);
-    }), { path: args.path });
-    server.registerTool('rm', withDefaultIcons({ ...DELETE_FILE_TOOL }, options.iconInfo), wrapToolHandler(handler, {
+            return buildToolErrorResponse(error, ErrorCode.E_UNKNOWN, args.path);
+        },
+    });
+    const wrappedHandler = wrapToolHandler(handler, {
         guard: options.isInitialized,
         progressMessage: (args) => `🛠 rm: ${path.basename(args.path)}`,
-    }));
+    });
+    if (registerToolTaskIfAvailable(server, 'rm', DELETE_FILE_TOOL, wrappedHandler, options.iconInfo, options.isInitialized))
+        return;
+    server.registerTool('rm', withDefaultIcons({ ...DELETE_FILE_TOOL }, options.iconInfo), wrappedHandler);
 }

package/dist/tools/diff-files.js

@@ -3,21 +3,18 @@ import * as path from 'node:path';
 import { createTwoFilesPatch } from 'diff';
 import { MAX_TEXT_FILE_SIZE } from '../lib/constants.js';
 import { ErrorCode, McpError } from '../lib/errors.js';
-import { createTimedAbortSignal, withAbort } from '../lib/fs-helpers.js';
-import { withToolDiagnostics } from '../lib/observability.js';
+import { withAbort } from '../lib/fs-helpers.js';
 import { validateExistingPath } from '../lib/path-validation.js';
 import { DiffFilesInputSchema, DiffFilesOutputSchema } from '../schemas.js';
-import { buildResourceLink, buildToolErrorResponse, buildToolResponse, maybeExternalizeTextContent, withDefaultIcons, withToolErrorHandling, wrapToolHandler, } from './shared.js';
+import { buildResourceLink, buildToolErrorResponse, buildToolResponse, executeToolWithDiagnostics, maybeExternalizeTextContent, READ_ONLY_TOOL_ANNOTATIONS, withDefaultIcons, wrapToolHandler, } from './shared.js';
 const DIFF_FILES_TOOL = {
     title: 'Diff Files',
-    description: 'Generate a unified diff between two files.',
+    description: 'Generate a unified diff between two files. ' +
+        'Output feeds directly into `apply_patch`. ' +
+        'Check `isIdentical` in the response — if true, the files are already in sync and no patch is needed.',
     inputSchema: DiffFilesInputSchema,
     outputSchema: DiffFilesOutputSchema,
-    annotations: {
-        readOnlyHint: true,
-        idempotentHint: true,
-        openWorldHint: false,
-    },
+    annotations: READ_ONLY_TOOL_ANNOTATIONS,
 };
 function assertDiffFileSizeWithinLimit(filePath, size, maxFileSize) {
     if (size <= maxFileSize)
@@ -25,7 +22,7 @@ function assertDiffFileSizeWithinLimit(filePath, size, maxFileSize) {
     throw new McpError(ErrorCode.E_TOO_LARGE, `File too large for diff: ${filePath} (${size} bytes > ${maxFileSize} bytes).`, filePath, { size, maxFileSize });
 }
 async function handleDiffFiles(args, signal, resourceStore) {
-    const maxFileSize = args.maxFileSize ?? MAX_TEXT_FILE_SIZE;
+    const maxFileSize = MAX_TEXT_FILE_SIZE;
     const [originalPath, modifiedPath] = await Promise.all([
         validateExistingPath(args.original, signal),
         validateExistingPath(args.modified, signal),
@@ -75,15 +72,14 @@ async function handleDiffFiles(args, signal, resourceStore) {
     ]);
 }
 export function registerDiffFilesTool(server, options = {}) {
-    const handler = (args, extra) => withToolDiagnostics('diff_files', () => withToolErrorHandling(async () => {
-        const { signal, cleanup } = createTimedAbortSignal(extra.signal);
-        try {
-            return await handleDiffFiles(args, signal, options.resourceStore);
-        }
-        finally {
-            cleanup();
-        }
-    }, (error) => buildToolErrorResponse(error, ErrorCode.E_UNKNOWN, args.original)), { path: args.original });
+    const handler = (args, extra) => executeToolWithDiagnostics({
+        toolName: 'diff_files',
+        extra,
+        timedSignal: {},
+        context: { path: args.original },
+        run: (signal) => handleDiffFiles(args, signal, options.resourceStore),
+        onError: (error) => buildToolErrorResponse(error, ErrorCode.E_UNKNOWN, args.original),
+    });
     server.registerTool('diff_files', withDefaultIcons({ ...DIFF_FILES_TOOL }, options.iconInfo), wrapToolHandler(handler, {
         guard: options.isInitialized,
         progressMessage: (args) => {

package/dist/tools/edit-file.js

@@ -1,21 +1,19 @@
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import { ErrorCode } from '../lib/errors.js';
-import { atomicWriteFile, createTimedAbortSignal } from '../lib/fs-helpers.js';
-import { withToolDiagnostics } from '../lib/observability.js';
+import { atomicWriteFile } from '../lib/fs-helpers.js';
 import { validateExistingPath } from '../lib/path-validation.js';
 import { EditFileInputSchema, EditFileOutputSchema } from '../schemas.js';
-import { buildToolErrorResponse, buildToolResponse, withDefaultIcons, withToolErrorHandling, wrapToolHandler, } from './shared.js';
+import { buildToolErrorResponse, buildToolResponse, DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS, executeToolWithDiagnostics, withDefaultIcons, wrapToolHandler, } from './shared.js';
 const EDIT_FILE_TOOL = {
     title: 'Edit File',
     description: 'Edit a file by replacing text. Sequentially applies a list of string replacements. ' +
-        'Replaces the first occurrence of each `oldText`.',
+        'Replaces the first occurrence of each `oldText`. ' +
+        '`oldText` must match exactly — include 3–5 lines of surrounding context to uniquely target the location. ' +
+        'Use `dryRun: true` to validate edits before writing.',
     inputSchema: EditFileInputSchema,
     outputSchema: EditFileOutputSchema,
-    annotations: {
-        readOnlyHint: false,
-        openWorldHint: false,
-    },
+    annotations: DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS,
 };
 function applyEdits(content, edits) {
     let newContent = content;
@@ -37,7 +35,7 @@ function applyEdits(content, edits) {
             minLine = startLine;
         if (maxLine === undefined || endLine > maxLine)
             maxLine = endLine;
-        newContent = newContent.replace(edit.oldText, edit.newText);
+        newContent = newContent.replace(edit.oldText, () => edit.newText);
         appliedEdits += 1;
     }
     const result = {
@@ -73,15 +71,14 @@ async function handleEditFile(args, signal) {
     return buildToolResponse(message, structured);
 }
 export function registerEditFileTool(server, options = {}) {
-    const handler = (args, extra) => withToolDiagnostics('edit', () => withToolErrorHandling(async () => {
-        const { signal, cleanup } = createTimedAbortSignal(extra.signal);
-        try {
-            return await handleEditFile(args, signal);
-        }
-        finally {
-            cleanup();
-        }
-    }, (error) => buildToolErrorResponse(error, ErrorCode.E_UNKNOWN, args.path)), { path: args.path });
+    const handler = (args, extra) => executeToolWithDiagnostics({
+        toolName: 'edit',
+        extra,
+        timedSignal: {},
+        context: { path: args.path },
+        run: (signal) => handleEditFile(args, signal),
+        onError: (error) => buildToolErrorResponse(error, ErrorCode.E_UNKNOWN, args.path),
+    });
     server.registerTool('edit', withDefaultIcons({ ...EDIT_FILE_TOOL }, options.iconInfo), wrapToolHandler(handler, {
         guard: options.isInitialized,
         progressMessage: (args) => {

package/dist/tools/list-directory.js

@@ -3,9 +3,8 @@ import { formatOperationSummary, joinLines } from '../config.js';
 import { DEFAULT_EXCLUDE_PATTERNS } from '../lib/constants.js';
 import { ErrorCode } from '../lib/errors.js';
 import { listDirectory } from '../lib/file-operations/list-directory.js';
-import { withToolDiagnostics } from '../lib/observability.js';
 import { ListDirectoryInputSchema, ListDirectoryOutputSchema, } from '../schemas.js';
-import { buildToolErrorResponse, buildToolResponse, resolvePathOrRoot, withDefaultIcons, withToolErrorHandling, wrapToolHandler, } from './shared.js';
+import { buildToolErrorResponse, buildToolResponse, executeToolWithDiagnostics, READ_ONLY_TOOL_ANNOTATIONS, resolvePathOrRoot, withDefaultIcons, wrapToolHandler, } from './shared.js';
 const LIST_DIRECTORY_TOOL = {
     title: 'List Directory',
     description: 'List the immediate contents of a directory (non-recursive). ' +
@@ -15,11 +14,7 @@ const LIST_DIRECTORY_TOOL = {
         'For recursive searches, use find instead.',
     inputSchema: ListDirectoryInputSchema,
     outputSchema: ListDirectoryOutputSchema,
-    annotations: {
-        readOnlyHint: true,
-        idempotentHint: true,
-        openWorldHint: false,
-    },
+    annotations: READ_ONLY_TOOL_ANNOTATIONS,
 };
 function buildListTextResult(result) {
     const { entries, summary, path } = result;
@@ -29,13 +24,11 @@ function buildListTextResult(result) {
         }
         return `${path} (no matches)`;
     }
-    const lines = [
-        path,
-        ...entries.map((entry) => {
-            const suffix = entry.type === 'directory' ? '/' : '';
-            return `  ${entry.relativePath}${suffix}`;
-        }),
-    ];
+    const lines = [path];
+    for (const entry of entries) {
+        const suffix = entry.type === 'directory' ? '/' : '';
+        lines.push(`  ${entry.relativePath}${suffix}`);
+    }
     let truncatedReason;
     if (summary.truncated) {
         if (summary.stoppedReason === 'maxEntries') {
@@ -62,20 +55,22 @@ function buildStructuredListEntry(entry) {
 }
 function buildStructuredListResult(result) {
     const { entries, summary, path: resultPath } = result;
+    const structuredEntries = [];
+    for (const entry of entries) {
+        structuredEntries.push(buildStructuredListEntry(entry));
+    }
     return {
         ok: true,
         path: resultPath,
-        entries: entries.map(buildStructuredListEntry),
+        entries: structuredEntries,
         totalEntries: summary.totalEntries,
-        truncated: summary.truncated,
-        entriesScanned: summary.entriesScanned,
-        entriesVisible: summary.entriesVisible,
+        ...(summary.truncated ? { truncated: summary.truncated } : {}),
         totalFiles: summary.totalFiles,
         totalDirectories: summary.totalDirectories,
-        maxDepthReached: summary.maxDepthReached,
-        stoppedReason: summary.stoppedReason,
-        skippedInaccessible: summary.skippedInaccessible,
-        symlinksNotFollowed: summary.symlinksNotFollowed,
+        ...(summary.stoppedReason ? { stoppedReason: summary.stoppedReason } : {}),
+        ...(summary.skippedInaccessible
+            ? { skippedInaccessible: summary.skippedInaccessible }
+            : {}),
     };
 }
 async function handleListDirectory(args, signal) {
@@ -94,7 +89,13 @@ async function handleListDirectory(args, signal) {
     return buildToolResponse(buildListTextResult(result), buildStructuredListResult(result));
 }
 export function registerListDirectoryTool(server, options = {}) {
-    const handler = (args, extra) => withToolDiagnostics('ls', () => withToolErrorHandling(() => handleListDirectory(args, extra.signal), (error) => buildToolErrorResponse(error, ErrorCode.E_NOT_DIRECTORY, args.path ?? '.')), { path: args.path ?? '.' });
+    const handler = (args, extra) => executeToolWithDiagnostics({
+        toolName: 'ls',
+        extra,
+        context: { path: args.path ?? '.' },
+        run: (signal) => handleListDirectory(args, signal),
+        onError: (error) => buildToolErrorResponse(error, ErrorCode.E_NOT_DIRECTORY, args.path ?? '.'),
+    });
     server.registerTool('ls', withDefaultIcons({ ...LIST_DIRECTORY_TOOL }, options.iconInfo), wrapToolHandler(handler, {
         guard: options.isInitialized,
         progressMessage: (args) => {

package/dist/tools/move-file.js

@@ -1,21 +1,17 @@
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import { ErrorCode, isNodeError } from '../lib/errors.js';
-import { createTimedAbortSignal, withAbort } from '../lib/fs-helpers.js';
-import { withToolDiagnostics } from '../lib/observability.js';
+import { withAbort } from '../lib/fs-helpers.js';
 import { validateExistingPath, validatePathForWrite, } from '../lib/path-validation.js';
 import { MoveFileInputSchema, MoveFileOutputSchema } from '../schemas.js';
-import { buildToolErrorResponse, buildToolResponse, withDefaultIcons, withToolErrorHandling, wrapToolHandler, } from './shared.js';
+import { buildToolErrorResponse, buildToolResponse, DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS, executeToolWithDiagnostics, withDefaultIcons, wrapToolHandler, } from './shared.js';
+import { registerToolTaskIfAvailable } from './task-support.js';
 const MOVE_FILE_TOOL = {
     title: 'Move File',
     description: 'Move or rename a file or directory.',
     inputSchema: MoveFileInputSchema,
     outputSchema: MoveFileOutputSchema,
-    annotations: {
-        readOnlyHint: false,
-        destructiveHint: true,
-        openWorldHint: false,
-    },
+    annotations: DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS,
 };
 async function handleMoveFile(args, signal) {
     const validSource = await validateExistingPath(args.source, signal);
@@ -42,17 +38,19 @@ async function handleMoveFile(args, signal) {
     });
 }
 export function registerMoveFileTool(server, options = {}) {
-    const handler = (args, extra) => withToolDiagnostics('mv', () => withToolErrorHandling(async () => {
-        const { signal, cleanup } = createTimedAbortSignal(extra.signal);
-        try {
-            return await handleMoveFile(args, signal);
-        }
-        finally {
-            cleanup();
-        }
-    }, (error) => buildToolErrorResponse(error, ErrorCode.E_UNKNOWN, args.source)), { path: args.source });
-    server.registerTool('mv', withDefaultIcons({ ...MOVE_FILE_TOOL }, options.iconInfo), wrapToolHandler(handler, {
+    const handler = (args, extra) => executeToolWithDiagnostics({
+        toolName: 'mv',
+        extra,
+        timedSignal: {},
+        context: { path: args.source },
+        run: (signal) => handleMoveFile(args, signal),
+        onError: (error) => buildToolErrorResponse(error, ErrorCode.E_UNKNOWN, args.source),
+    });
+    const wrappedHandler = wrapToolHandler(handler, {
         guard: options.isInitialized,
         progressMessage: (args) => `🛠 mv: ${path.basename(args.source)} ➟ ${path.basename(args.destination)}`,
-    }));
+    });
+    if (registerToolTaskIfAvailable(server, 'mv', MOVE_FILE_TOOL, wrappedHandler, options.iconInfo, options.isInitialized))
+        return;
+    server.registerTool('mv', withDefaultIcons({ ...MOVE_FILE_TOOL }, options.iconInfo), wrappedHandler);
 }