@j0hanz/filesystem-mcp 1.1.2 → 1.2.0

package/dist/schemas.js

@@ -23,30 +23,18 @@ const PathSchemaBase = z
 const OptionalPathSchema = PathSchemaBase.optional();
 const RequiredPathSchema = PathSchemaBase.min(1, 'Path required');
 const FileTypeSchema = z.enum(['file', 'directory', 'symlink', 'other']);
-const TreeEntryTypeSchema = z.enum(['file', 'directory', 'symlink', 'other']);
 const ListDirectorySortSchema = z.enum(['name', 'size', 'modified', 'type']);
 const SearchFilesSortSchema = z.enum(['name', 'size', 'modified', 'path']);
-const SearchFilesStopReasonSchema = z.enum([
-    'maxResults',
-    'maxFiles',
-    'timeout',
-]);
+const SearchStopReasonSchema = z.enum(['maxResults', 'maxFiles', 'timeout']);
 const ListDirectoryStopReasonSchema = z.enum(['maxEntries', 'aborted']);
-const SearchContentStopReasonSchema = z.enum([
-    'maxResults',
-    'maxFiles',
-    'timeout',
-]);
 const TreeEntrySchema = z.lazy(() => z.strictObject({
     name: z.string().describe('Name'),
-    type: TreeEntryTypeSchema.describe('Type'),
+    type: FileTypeSchema.describe('Type'),
     relativePath: z.string().describe('Relative path'),
     children: z.array(TreeEntrySchema).optional().describe('Children'),
 }));
 const ErrorSchema = z.strictObject({
-    code: z
-        .enum(Object.values(ErrorCode))
-        .describe('Error code (e.g. E_NOT_FOUND)'),
+    code: z.enum(ErrorCode).describe('Error code (e.g. E_NOT_FOUND)'),
     message: z.string().describe('Human-readable message'),
     path: z.string().optional().describe('Relevant path'),
     suggestion: z.string().optional().describe('Fix suggestion'),
@@ -65,35 +53,30 @@ const LineNumberSchema = z
     .number()
     .int({ error: 'Must be integer' })
     .min(1, 'Min: 1');
+function addReadRangeIssue(ctx, path, message) {
+    ctx.addIssue({
+        code: 'custom',
+        path: [path],
+        message,
+    });
+}
 const validateReadRange = (value, ctx) => {
     const hasHead = value.head !== undefined;
     const hasStart = value.startLine !== undefined;
     const hasEnd = value.endLine !== undefined;
     if (hasHead && (hasStart || hasEnd)) {
-        ctx.addIssue({
-            code: 'custom',
-            path: ['head'],
-            message: "Cannot use 'head' with 'startLine'/'endLine'",
-        });
+        addReadRangeIssue(ctx, 'head', "Cannot use 'head' with 'startLine'/'endLine'");
     }
     if (hasEnd && !hasStart) {
-        ctx.addIssue({
-            code: 'custom',
-            path: ['endLine'],
-            message: "'endLine' requires 'startLine'",
-        });
+        addReadRangeIssue(ctx, 'endLine', "'endLine' requires 'startLine'");
     }
     if (value.startLine !== undefined &&
         value.endLine !== undefined &&
         value.endLine < value.startLine) {
-        ctx.addIssue({
-            code: 'custom',
-            path: ['endLine'],
-            message: "'endLine' must be >= 'startLine'",
-        });
+        addReadRangeIssue(ctx, 'endLine', "'endLine' must be >= 'startLine'");
     }
 };
-const FileInfoSchema = z.object({
+const FileInfoSchema = z.strictObject({
     name: z.string().describe('Name'),
     path: z.string().describe('Absolute path'),
     type: FileTypeSchema.describe('Type'),
@@ -112,11 +95,6 @@ const OperationSummarySchema = z.object({
     succeeded: z.number().describe('Succeeded'),
     failed: z.number().describe('Failed'),
 });
-const ReadRangeInputSchema = z.strictObject({
-    head: HeadLinesSchema,
-    startLine: LineNumberSchema.optional(),
-    endLine: LineNumberSchema.optional(),
-});
 export const ListDirectoryInputSchema = z.strictObject({
     path: OptionalPathSchema.describe(DESC_PATH_ROOT),
     includeHidden: z
@@ -199,13 +177,6 @@ export const SearchFilesInputSchema = z.strictObject({
         .max(100, 'Max: 100')
         .optional()
         .describe('Maximum directory depth to scan'),
-    maxFilesScanned: z
-        .number()
-        .int({ error: 'Must be integer' })
-        .min(1, 'Min: 1')
-        .max(200000, 'Max: 200,000')
-        .optional()
-        .describe('Hard cap on files scanned'),
 });
 export const TreeInputSchema = z.strictObject({
     path: OptionalPathSchema.describe(DESC_PATH_ROOT),
@@ -242,17 +213,17 @@ export const SearchContentInputSchema = z.strictObject({
         .string()
         .min(1, 'Pattern required')
         .max(1000, 'Max 1000 chars')
-        .describe('Search text or regex (if isRegex=true)'),
+        .describe('Literal text to search for by default; treated as RE2 regex when isRegex is true.'),
     isRegex: z
         .boolean()
         .optional()
         .default(false)
-        .describe('Treat pattern as regex'),
+        .describe('Treat pattern as a RE2 regular expression. RE2 does not support lookahead, lookbehind, or backreferences.'),
     caseSensitive: z
         .boolean()
         .optional()
         .default(false)
-        .describe('Case-sensitive matching'),
+        .describe('Case-sensitive matching (default: false — searches are case-insensitive).'),
     wholeWord: z
         .boolean()
         .optional()
@@ -274,14 +245,6 @@ export const SearchContentInputSchema = z.strictObject({
         .optional()
         .default(500)
         .describe('Maximum match rows to return'),
-    maxFilesScanned: z
-        .number()
-        .int({ error: 'Must be integer' })
-        .min(1, 'Min: 1')
-        .max(200000, 'Max: 200,000')
-        .optional()
-        .default(20000)
-        .describe('Hard cap on files scanned'),
     filePattern: z
         .string()
         .min(1, 'Pattern required')
@@ -300,15 +263,16 @@ export const SearchContentInputSchema = z.strictObject({
         .default(false)
         .describe('Include ignored items (node_modules, etc).'),
 });
-export const ReadFileInputSchema = ReadRangeInputSchema.extend({
+export const ReadFileInputSchema = z
+    .strictObject({
     path: RequiredPathSchema.describe(DESC_PATH_REQUIRED),
     head: HeadLinesSchema.describe('Read first N lines (preview)'),
     startLine: LineNumberSchema.optional().describe('Start line (1-based, inclusive)'),
     endLine: LineNumberSchema.optional().describe('End line (1-based, inclusive). Requires startLine.'),
 })
-    .strict()
     .superRefine(validateReadRange);
-export const ReadMultipleFilesInputSchema = ReadRangeInputSchema.extend({
+export const ReadMultipleFilesInputSchema = z
+    .strictObject({
     paths: z
         .array(RequiredPathSchema)
         .min(1, 'Min 1 path required')
@@ -318,7 +282,6 @@ export const ReadMultipleFilesInputSchema = ReadRangeInputSchema.extend({
     startLine: LineNumberSchema.optional().describe('Start line (1-based, inclusive) per file'),
     endLine: LineNumberSchema.optional().describe('End line (1-based, inclusive) per file. Requires startLine.'),
 })
-    .strict()
     .superRefine(validateReadRange);
 export const GetFileInfoInputSchema = z.strictObject({
     path: RequiredPathSchema.describe(DESC_PATH_REQUIRED),
@@ -383,7 +346,7 @@ export const SearchFilesOutputSchema = SearchSummarySchema.extend({
         .optional(),
     filesScanned: z.number().optional().describe('Files scanned'),
     skippedInaccessible: z.number().optional().describe('Inaccessible files'),
-    stoppedReason: SearchFilesStopReasonSchema.optional().describe('Why search stopped'),
+    stoppedReason: SearchStopReasonSchema.optional().describe('Why search stopped'),
 });
 export const SearchContentOutputSchema = SearchSummarySchema.extend({
     ok: z.boolean(),
@@ -414,7 +377,7 @@ export const SearchContentOutputSchema = SearchSummarySchema.extend({
         .number()
         .optional()
         .describe('Lines skipped due to regex timeout'),
-    stoppedReason: SearchContentStopReasonSchema.optional().describe('Why search stopped'),
+    stoppedReason: SearchStopReasonSchema.optional().describe('Why search stopped'),
 });
 export const TreeOutputSchema = z.object({
     ok: z.boolean(),
@@ -496,15 +459,20 @@ export const EditFileInputSchema = z.strictObject({
     path: RequiredPathSchema.describe(DESC_PATH_REQUIRED),
     edits: z
         .array(z.object({
-        oldText: z.string().describe('Exact string to replace'),
-        newText: z.string().describe('Replacement string'),
+        oldText: z
+            .string()
+            .describe('Exact literal string to replace — must match character-for-character including whitespace and indentation. Include 3–5 lines of surrounding context to uniquely identify the location.'),
+        newText: z
+            .string()
+            .describe('Replacement string — preserve the indentation style of surrounding code.'),
     }))
-        .min(1, 'Min 1 edit required'),
+        .min(1, 'Min 1 edit required')
+        .describe('List of replacements to apply sequentially. Each edit replaces the first occurrence of oldText.'),
     dryRun: z
         .boolean()
         .optional()
         .default(false)
-        .describe('Check only, no writes'),
+        .describe('Preview edits without writing. Check unmatchedEdits in the response to verify all oldText values were found.'),
 });
 export const EditFileOutputSchema = z.object({
     ok: z.boolean(),
@@ -582,13 +550,6 @@ export const DiffFilesInputSchema = z.strictObject({
         .optional()
         .default(false)
         .describe('Strip trailing carriage returns before diffing'),
-    maxFileSize: z
-        .number()
-        .int({ error: 'Must be integer' })
-        .min(1, 'Min: 1')
-        .max(100 * 1024 * 1024, 'Max: 104,857,600 (100 MiB)')
-        .optional()
-        .describe('Maximum bytes per input file to diff'),
 });
 export const DiffFilesOutputSchema = z.object({
     ok: z.boolean(),
@@ -600,8 +561,9 @@ export const DiffFilesOutputSchema = z.object({
 });
 export const ApplyPatchInputSchema = z.strictObject({
     path: RequiredPathSchema.describe('Path to file to patch'),
-    patch: z.string().describe('Unified diff content to apply'),
-    fuzzy: z.boolean().optional().default(false).describe('Allow fuzzy patching'),
+    patch: z
+        .string()
+        .describe('Unified diff content to apply — must include @@ hunk headers. Generate with `diff_files`.'),
     fuzzFactor: z
         .number()
         .int({ error: 'Must be integer' })
@@ -614,14 +576,11 @@ export const ApplyPatchInputSchema = z.strictObject({
         .optional()
         .default(true)
         .describe('Auto-convert line endings to match target file'),
-    maxFileSize: z
-        .number()
-        .int({ error: 'Must be integer' })
-        .min(1, 'Min: 1')
-        .max(100 * 1024 * 1024, 'Max: 104,857,600 (100 MiB)')
+    dryRun: z
+        .boolean()
         .optional()
-        .describe('Maximum bytes for the target file before patching'),
-    dryRun: z.boolean().optional().default(false).describe('Check only'),
+        .default(false)
+        .describe('Validate the patch can be applied without writing. Check `applied` in the response before committing.'),
 });
 export const ApplyPatchOutputSchema = z.object({
     ok: z.boolean(),
@@ -639,18 +598,21 @@ export const SearchAndReplaceInputSchema = z.strictObject({
         error: 'Invalid glob or unsafe path (absolute/.. forbidden)',
     })
         .describe('Glob pattern (e.g. "**/*.ts")'),
-    excludePatterns: z.array(z.string()).optional().default([]),
-    searchPattern: z.string().min(1, 'Search pattern required'),
+    searchPattern: z
+        .string()
+        .min(1, 'Search pattern required')
+        .describe('Text to search for. Matched literally by default; treated as RE2 regex when isRegex is true.'),
     replacement: z.string().describe('Replacement text'),
-    isRegex: z.boolean().optional().default(false),
-    maxFileSize: z
-        .number()
-        .int({ error: 'Must be integer' })
-        .min(1, 'Min: 1')
-        .max(100 * 1024 * 1024, 'Max: 104,857,600 (100 MiB)')
+    isRegex: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe('Treat searchPattern as a RE2 regular expression. Supports capture group references ($1, $2) in replacement.'),
+    dryRun: z
+        .boolean()
         .optional()
-        .describe('Maximum bytes to read/replace per matched file'),
-    dryRun: z.boolean().optional().default(false),
+        .default(false)
+        .describe('Preview matches without writing. Check changedFiles and matches in the response before committing.'),
 });
 export const SearchAndReplaceOutputSchema = z.object({
     ok: z.boolean(),

package/dist/server.js

@@ -4,7 +4,7 @@ import { fileURLToPath } from 'node:url';
 import { InMemoryTaskMessageQueue, InMemoryTaskStore, } from '@modelcontextprotocol/sdk/experimental/tasks/stores/in-memory.js';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { InitializedNotificationSchema, RootsListChangedNotificationSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { InitializedNotificationSchema, RootsListChangedNotificationSchema, SetLevelRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
 import { z } from 'zod';
 import packageJsonRaw from '../package.json' with { type: 'json' };
 import { registerCompletions } from './completions.js';
@@ -12,33 +12,52 @@ import { formatUnknownErrorMessage } from './lib/errors.js';
 import { assertNotAborted, createTimedAbortSignal, withAbort, } from './lib/fs-helpers.js';
 import { getAllowedDirectories, getValidRootDirectories, isPathWithinDirectories, normalizePath, setAllowedDirectoriesResolved, } from './lib/path-validation.js';
 import { createInMemoryResourceStore } from './lib/resource-store.js';
+import { isRecord } from './lib/type-guards.js';
 import { registerGetHelpPrompt } from './prompts.js';
 import { registerInstructionResource, registerResultResources, } from './resources.js';
 import { registerAllTools } from './tools.js';
+import { withDefaultIcons } from './tools/shared.js';
 const PackageJsonSchema = z.object({
     version: z.string(),
     description: z.string().optional(),
     homepage: z.string().optional(),
 });
 const { version: SERVER_VERSION, description: SERVER_DESCRIPTION, homepage: SERVER_HOMEPAGE, } = PackageJsonSchema.parse(packageJsonRaw);
-function normalizeAllowedDirectories(dirs) {
-    return dirs
-        .map((dir) => dir.trim())
-        .filter((dir) => dir.length > 0)
-        .map(normalizePath);
+function normalizeCLIDirectories(dirs) {
+    const normalized = [];
+    for (const dir of dirs) {
+        const trimmed = dir.trim();
+        if (trimmed.length === 0)
+            continue;
+        normalized.push(normalizePath(trimmed));
+    }
+    return normalized;
 }
 const ROOTS_TIMEOUT_MS = 5000;
 const ROOTS_DEBOUNCE_MS = 100;
 const MCP_LOGGER_NAME = 'filesystem-mcp';
+const LOG_LEVEL_ORDER = {
+    debug: 0,
+    info: 1,
+    notice: 2,
+    warning: 3,
+    error: 4,
+    critical: 5,
+    alert: 6,
+    emergency: 7,
+};
 function canSendMcpLogs(server) {
     const capabilities = server.server.getClientCapabilities();
-    if (!capabilities || typeof capabilities !== 'object')
+    if (!isRecord(capabilities))
         return false;
     if (!('logging' in capabilities))
         return false;
     return Boolean(capabilities.logging);
 }
-function logToMcp(server, level, data) {
+function logToMcp(server, level, data, minLevel = 'debug') {
+    if (LOG_LEVEL_ORDER[level] < LOG_LEVEL_ORDER[minLevel]) {
+        return;
+    }
     if (!server || !canSendMcpLogs(server)) {
         console.error(data);
         return;
@@ -49,7 +68,7 @@ function logToMcp(server, level, data) {
         data,
     };
     void server.sendLoggingMessage(params).catch((error) => {
-        console.error(`Failed to send MCP log: ${level} │ ${data}`, data, formatUnknownErrorMessage(error));
+        console.error(`Failed to send MCP log: ${level} │ ${data}`, formatUnknownErrorMessage(error));
     });
 }
 class RootsManager {
@@ -57,8 +76,10 @@ class RootsManager {
     rootDirectories = [];
     clientInitialized = false;
     options;
-    constructor(options) {
+    loggingState;
+    constructor(options, loggingState) {
         this.options = options;
+        this.loggingState = loggingState ?? { minimumLevel: 'debug' };
     }
     isInitialized() {
         return this.clientInitialized;
@@ -91,7 +112,7 @@ class RootsManager {
         this.rootsUpdateTimeout.unref();
     }
     async recomputeAllowedDirectories() {
-        const cliAllowedDirs = normalizeAllowedDirectories(this.options.cliAllowedDirs ?? []);
+        const cliAllowedDirs = normalizeCLIDirectories(this.options.cliAllowedDirs ?? []);
         const allowCwd = this.options.allowCwd === true;
         const allowCwdDirs = allowCwd ? [normalizePath(process.cwd())] : [];
         const baseline = [...cliAllowedDirs, ...allowCwdDirs];
@@ -109,10 +130,10 @@ class RootsManager {
     }
     logMissingDirectories(server) {
         if (this.options.allowCwd) {
-            logToMcp(server, 'notice', 'No allowed directories specified. Using the current working directory as an allowed directory.');
+            logToMcp(server, 'notice', 'No allowed directories specified. Using the current working directory as an allowed directory.', this.loggingState.minimumLevel);
             return;
         }
-        logToMcp(server, 'warning', 'No allowed directories specified. Please provide directories as command-line arguments or enable --allow-cwd to use the current working directory.');
+        logToMcp(server, 'warning', 'No allowed directories specified. Please provide directories as command-line arguments or enable --allow-cwd to use the current working directory.', this.loggingState.minimumLevel);
     }
     async updateRootsFromClient(server) {
         try {
@@ -128,7 +149,7 @@ class RootsManager {
             this.rootDirectories = await resolveRootDirectories(roots);
         }
         catch (error) {
-            logToMcp(server, 'debug', `[DEBUG] MCP Roots protocol unavailable or failed: ${formatUnknownErrorMessage(error)}`);
+            logToMcp(server, 'debug', `[DEBUG] MCP Roots protocol unavailable or failed: ${formatUnknownErrorMessage(error)}`, this.loggingState.minimumLevel);
         }
         finally {
             await this.recomputeAllowedDirectories();
@@ -143,12 +164,10 @@ function getRootsManager(server) {
     }
     return manager;
 }
-const RootSchema = z
-    .object({
+const RootSchema = z.strictObject({
     uri: z.string(),
     name: z.string().optional(),
-})
-    .strict();
+});
 const RootsResponseSchema = z.object({
     roots: z.array(RootSchema).optional(),
 });
@@ -157,7 +176,13 @@ function extractRoots(value) {
     if (!parsed.success || !parsed.data.roots) {
         return [];
     }
-    return parsed.data.roots.filter(isRoot).map(normalizeRoot);
+    const roots = [];
+    for (const root of parsed.data.roots) {
+        if (isRoot(root)) {
+            roots.push(normalizeRoot(root));
+        }
+    }
+    return roots;
 }
 async function resolveRootDirectories(roots) {
     if (roots.length === 0)
@@ -171,16 +196,13 @@ async function resolveRootDirectories(roots) {
     }
 }
 function isRoot(value) {
-    return (value !== null &&
-        typeof value === 'object' &&
-        'uri' in value &&
-        typeof value.uri === 'string');
+    return isRecord(value) && typeof value['uri'] === 'string';
 }
 function normalizeRoot(root) {
     return root.name ? { uri: root.uri, name: root.name } : { uri: root.uri };
 }
 async function filterRootsWithinBaseline(roots, baseline, signal) {
-    const normalizedBaseline = normalizeAllowedDirectories(baseline);
+    const normalizedBaseline = normalizeCLIDirectories(baseline);
     const filtered = [];
     for (const root of roots) {
         const normalizedRoot = normalizePath(root);
@@ -204,16 +226,19 @@ async function isRootWithinBaseline(normalizedRoot, baseline, signal) {
         return false;
     }
 }
-const currentDir = path.dirname(fileURLToPath(import.meta.url));
-let serverInstructions = `
+async function loadServerInstructions() {
+    const defaultInstructions = `
 Filesystem MCP Instructions
 (Detailed instructions failed to load - check logs)
 `;
-try {
-    serverInstructions = await fs.readFile(path.join(currentDir, 'instructions.md'), 'utf-8');
-}
-catch (error) {
-    console.error('[WARNING] Failed to load instructions.md:', formatUnknownErrorMessage(error));
+    try {
+        const currentDir = path.dirname(fileURLToPath(import.meta.url));
+        return await fs.readFile(path.join(currentDir, 'instructions.md'), 'utf-8');
+    }
+    catch (error) {
+        console.error('[WARNING] Failed to load instructions.md:', formatUnknownErrorMessage(error));
+        return defaultInstructions;
+    }
 }
 async function getLocalIconInfo() {
     const name = 'logo.svg';
@@ -232,6 +257,7 @@ async function getLocalIconInfo() {
 }
 export async function createServer(options = {}) {
     const resourceStore = createInMemoryResourceStore();
+    const serverInstructions = await loadServerInstructions();
     const localIcon = await getLocalIconInfo();
     const taskStore = new InMemoryTaskStore();
     const taskMessageQueue = new InMemoryTaskMessageQueue();
@@ -254,29 +280,44 @@ export async function createServer(options = {}) {
     if (serverInstructions) {
         serverConfig.instructions = serverInstructions;
     }
-    const server = new McpServer({
+    const server = new McpServer(withDefaultIcons({
         name: 'filesystem-mcp',
         title: 'Filesystem MCP',
         version: SERVER_VERSION,
         ...(SERVER_DESCRIPTION ? { description: SERVER_DESCRIPTION } : {}),
         ...(SERVER_HOMEPAGE ? { websiteUrl: SERVER_HOMEPAGE } : {}),
-        ...(localIcon
-            ? {
-                icons: [
-                    {
-                        src: localIcon.src,
-                        mimeType: localIcon.mimeType,
-                    },
-                ],
-            }
-            : {}),
-    }, serverConfig);
-    const rootsManager = new RootsManager(options);
+    }, localIcon), serverConfig);
+    const loggingState = {
+        minimumLevel: 'debug',
+    };
+    const rootsManager = new RootsManager(options, loggingState);
     rootsManagers.set(server, rootsManager);
+    server.server.setRequestHandler(SetLevelRequestSchema, (req) => {
+        loggingState.minimumLevel = req.params.level;
+        return {};
+    });
     registerInstructionResource(server, serverInstructions, localIcon);
     registerGetHelpPrompt(server, serverInstructions, localIcon);
     registerResultResources(server, resourceStore, localIcon);
     registerCompletions(server);
+    {
+        const typedServer = server;
+        const origReg = typedServer.registerTool.bind(server);
+        typedServer.registerTool = (...regArgs) => {
+            const handlerIdx = regArgs.length - 1;
+            const origHandler = regArgs[handlerIdx];
+            if (typeof origHandler !== 'function')
+                return origReg(...regArgs);
+            regArgs[handlerIdx] = async (...hArgs) => {
+                const r = await origHandler(...hArgs);
+                if (!r || typeof r !== 'object')
+                    return r;
+                const record = r;
+                return Object.fromEntries(Object.entries(record).filter(([key]) => key !== 'structuredContent'));
+            };
+            return origReg(...regArgs);
+        };
+    }
     registerAllTools(server, {
         resourceStore,
         isInitialized: () => rootsManager.isInitialized(),

package/dist/tools/apply-patch.js

@@ -3,20 +3,18 @@ import * as path from 'node:path';
 import { applyPatch } from 'diff';
 import { MAX_TEXT_FILE_SIZE } from '../lib/constants.js';
 import { ErrorCode, McpError } from '../lib/errors.js';
-import { atomicWriteFile, createTimedAbortSignal, withAbort, } from '../lib/fs-helpers.js';
-import { withToolDiagnostics } from '../lib/observability.js';
+import { atomicWriteFile, withAbort } from '../lib/fs-helpers.js';
 import { validateExistingPath } from '../lib/path-validation.js';
-import { ApplyPatchInputSchema, ApplyPatchOutputSchema } from '../schemas.js';
-import { buildToolErrorResponse, buildToolResponse, withDefaultIcons, withToolErrorHandling, wrapToolHandler, } from './shared.js';
+import { ApplyPatchInputSchema, } from '../schemas.js';
+import { buildToolErrorResponse, buildToolResponse, DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS, executeToolWithDiagnostics, withDefaultIcons, wrapToolHandler, } from './shared.js';
+import { registerToolTaskIfAvailable } from './task-support.js';
 const APPLY_PATCH_TOOL = {
     title: 'Apply Patch',
-    description: 'Apply a unified patch to a file.',
+    description: 'Apply a unified diff patch to a file. ' +
+        'Generate the patch with `diff_files`, then validate with `dryRun: true` before writing. ' +
+        'On failure, regenerate a fresh patch via `diff_files` against the current file content and retry.',
     inputSchema: ApplyPatchInputSchema,
-    outputSchema: ApplyPatchOutputSchema,
-    annotations: {
-        readOnlyHint: false,
-        openWorldHint: false,
-    },
+    annotations: DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS,
 };
 function assertPatchTargetSizeWithinLimit(filePath, size, maxFileSize) {
     if (size <= maxFileSize)
@@ -33,19 +31,19 @@ function assertPatchHasHunks(patch) {
     }
 }
 async function handleApplyPatch(args, signal) {
-    const maxFileSize = args.maxFileSize ?? MAX_TEXT_FILE_SIZE;
+    const maxFileSize = MAX_TEXT_FILE_SIZE;
     const validPath = await validateExistingPath(args.path, signal);
     const stats = await withAbort(fs.stat(validPath), signal);
     assertPatchTargetSizeWithinLimit(validPath, stats.size, maxFileSize);
     const content = await fs.readFile(validPath, { encoding: 'utf-8', signal });
-    const fuzzFactor = args.fuzzFactor ?? (args.fuzzy ? 2 : 0);
+    const fuzzFactor = args.fuzzFactor ?? 0;
     assertPatchHasHunks(args.patch);
     const patched = applyPatch(content, args.patch, {
         fuzzFactor,
         autoConvertLineEndings: args.autoConvertLineEndings,
     });
     if (patched === false) {
-        throw new McpError(ErrorCode.E_INVALID_INPUT, 'Patch application failed. The file content may have changed or patch context is insufficient. Generate a fresh patch via diff_files against the current file, then retry. If differences are minor, enable fuzzy matching (fuzzy=true or fuzzFactor).');
+        throw new McpError(ErrorCode.E_INVALID_INPUT, 'Patch application failed. The file content may have changed or patch context is insufficient. Generate a fresh patch via diff_files against the current file, then retry. If differences are minor, enable fuzzy matching with the fuzzFactor parameter.');
     }
     if (args.dryRun) {
         return buildToolResponse('Dry run successful. Patch can be applied.', {
@@ -62,20 +60,22 @@ async function handleApplyPatch(args, signal) {
     });
 }
 export function registerApplyPatchTool(server, options = {}) {
-    const handler = (args, extra) => withToolDiagnostics('apply_patch', () => withToolErrorHandling(async () => {
-        const { signal, cleanup } = createTimedAbortSignal(extra.signal);
-        try {
-            return await handleApplyPatch(args, signal);
-        }
-        finally {
-            cleanup();
-        }
-    }, (error) => buildToolErrorResponse(error, ErrorCode.E_UNKNOWN, args.path)), { path: args.path });
-    server.registerTool('apply_patch', withDefaultIcons({ ...APPLY_PATCH_TOOL }, options.iconInfo), wrapToolHandler(handler, {
+    const handler = (args, extra) => executeToolWithDiagnostics({
+        toolName: 'apply_patch',
+        extra,
+        timedSignal: {},
+        context: { path: args.path },
+        run: (signal) => handleApplyPatch(args, signal),
+        onError: (error) => buildToolErrorResponse(error, ErrorCode.E_UNKNOWN, args.path),
+    });
+    const wrappedHandler = wrapToolHandler(handler, {
         guard: options.isInitialized,
         progressMessage: (args) => {
             const name = path.basename(args.path);
             return `🛠 apply_patch: ${name}`;
         },
-    }));
+    });
+    if (registerToolTaskIfAvailable(server, 'apply_patch', APPLY_PATCH_TOOL, wrappedHandler, options.iconInfo, options.isInitialized))
+        return;
+    server.registerTool('apply_patch', withDefaultIcons({ ...APPLY_PATCH_TOOL }, options.iconInfo), wrappedHandler);
 }