@j0hanz/filesystem-mcp 1.9.0 → 1.10.0

package/dist/lib/resource-store.d.ts

@@ -6,6 +6,7 @@ export interface TextResourceEntry {
     hash: string;
     size: number;
     storedAt: string;
+    expiresAt: string;
 }
 export interface ResourceStore {
     putText(params: {
@@ -21,6 +22,7 @@ interface ResourceStoreOptions {
     maxEntries: number;
     maxTotalBytes: number;
     maxEntryBytes: number;
+    entryTtlMs: number;
 }
 export declare function createInMemoryResourceStore(options?: Partial<ResourceStoreOptions>): ResourceStore;
 export {};

package/dist/lib/resource-store.js

@@ -5,6 +5,7 @@ const DEFAULT_RESOURCE_STORE_OPTIONS = {
     maxEntries: 64,
     maxTotalBytes: 25 * 1024 * 1024,
     maxEntryBytes: 10 * 1024 * 1024,
+    entryTtlMs: 30 * 60 * 1000, // 30 minutes
 };
 const RESOURCE_STORE_DIAGNOSTICS_CHANNEL = channel('filesystem-mcp:resource-store');
 function publishResourceStoreDiagnostics(event) {
@@ -18,7 +19,15 @@ function estimateBytes(text) {
 function computeSha256(text) {
     return hash('sha256', text, 'hex');
 }
+function buildIndexKey(mimeType, contentHash) {
+    return `${mimeType}:${contentHash}`;
+}
+function isExpired(entry, now = Date.now()) {
+    const expiresAt = Date.parse(entry.expiresAt);
+    return Number.isFinite(expiresAt) && expiresAt <= now;
+}
 function createTextEntry(params) {
+    const storedAt = new Date();
     return {
         uri: params.uri,
         name: params.name,
@@ -26,7 +35,8 @@ function createTextEntry(params) {
         text: params.text,
         hash: computeSha256(params.text),
         size: estimateBytes(params.text),
-        storedAt: new Date().toISOString(),
+        storedAt: storedAt.toISOString(),
+        expiresAt: new Date(storedAt.getTime() + params.ttlMs).toISOString(),
     };
 }
 export function createInMemoryResourceStore(options = {}) {
@@ -35,26 +45,36 @@ export function createInMemoryResourceStore(options = {}) {
         ...options,
     };
     const byUri = new Map();
-    const byHashIndex = new Map(); // sha256hex → uri
+    const byHashIndex = new Map(); // mimeType:sha256hex -> uri
     let totalBytes = 0;
-    function evictOldest() {
-        const first = byUri.keys().next();
-        if (first.done)
-            return;
-        const uri = first.value;
+    function removeEntry(uri, reason) {
         const existing = byUri.get(uri);
         if (!existing)
             return;
         totalBytes -= existing.size;
         byUri.delete(uri);
-        byHashIndex.delete(existing.hash);
+        byHashIndex.delete(buildIndexKey(existing.mimeType, existing.hash));
         publishResourceStoreDiagnostics({
             phase: 'cache_evict',
             uri,
             name: existing.name,
             bytes: existing.size,
+            ...(reason !== undefined ? { reason } : {}),
         });
     }
+    function evictOldest() {
+        const first = byUri.keys().next();
+        if (first.done)
+            return;
+        removeEntry(first.value);
+    }
+    function pruneExpiredEntries(now = Date.now()) {
+        for (const [uri, entry] of byUri) {
+            if (isExpired(entry, now)) {
+                removeEntry(uri, 'expired');
+            }
+        }
+    }
     function enforceLimits() {
         while (byUri.size > resolved.maxEntries)
             evictOldest();
@@ -65,6 +85,7 @@ export function createInMemoryResourceStore(options = {}) {
         }
     }
     function putText(params) {
+        pruneExpiredEntries();
         const mimeType = params.mimeType ?? 'text/plain';
         const entryBytes = estimateBytes(params.text);
         if (entryBytes > resolved.maxEntryBytes) {
@@ -76,17 +97,26 @@ export function createInMemoryResourceStore(options = {}) {
             throw new McpError(ErrorCode.E_TOO_LARGE, `Resource too large to cache (${entryBytes} bytes)`);
         }
         const contentHash = computeSha256(params.text);
-        const existingUri = byHashIndex.get(contentHash);
+        const indexKey = buildIndexKey(mimeType, contentHash);
+        const existingUri = byHashIndex.get(indexKey);
         if (existingUri !== undefined) {
             const cached = byUri.get(existingUri);
             if (cached !== undefined) {
-                publishResourceStoreDiagnostics({
-                    phase: 'cache_hit',
-                    uri: cached.uri,
-                    name: cached.name,
-                    bytes: cached.size,
-                });
-                return cached;
+                if (isExpired(cached)) {
+                    removeEntry(existingUri, 'expired');
+                }
+                else {
+                    publishResourceStoreDiagnostics({
+                        phase: 'cache_hit',
+                        uri: cached.uri,
+                        name: cached.name,
+                        bytes: cached.size,
+                    });
+                    return cached;
+                }
+            }
+            else {
+                byHashIndex.delete(indexKey);
             }
         }
         const id = randomUUID();
@@ -96,9 +126,10 @@ export function createInMemoryResourceStore(options = {}) {
             name: params.name,
             mimeType,
             text: params.text,
+            ttlMs: resolved.entryTtlMs,
         });
         byUri.set(uri, entry);
-        byHashIndex.set(contentHash, uri);
+        byHashIndex.set(indexKey, uri);
         totalBytes += entryBytes;
         publishResourceStoreDiagnostics({
             phase: 'cache_store',
@@ -129,6 +160,15 @@ export function createInMemoryResourceStore(options = {}) {
             });
             throw new McpError(ErrorCode.E_NOT_FOUND, `Resource not found: ${uri}. The cached result may have been evicted. Re-run the originating tool to regenerate.`);
         }
+        if (isExpired(existing)) {
+            removeEntry(uri, 'expired');
+            publishResourceStoreDiagnostics({
+                phase: 'cache_miss',
+                uri,
+                reason: 'expired',
+            });
+            throw new McpError(ErrorCode.E_NOT_FOUND, `Resource expired: ${uri}. Re-run the originating tool to regenerate.`);
+        }
         publishResourceStoreDiagnostics({
             phase: 'cache_hit',
             uri: existing.uri,
@@ -148,6 +188,7 @@ export function createInMemoryResourceStore(options = {}) {
         });
     }
     function keys() {
+        pruneExpiredEntries();
         return Array.from(byUri.keys());
     }
     return { putText, getText, clear, keys };

package/dist/prompts.d.ts

@@ -1,3 +1,5 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { type IconInfo } from './tools/shared.js';
 export declare function registerGetHelpPrompt(server: McpServer, instructions: string, iconInfo?: IconInfo): void;
+export declare function registerCompareFilesPrompt(server: McpServer, iconInfo?: IconInfo): void;
+export declare function registerAnalyzePathPrompt(server: McpServer, iconInfo?: IconInfo): void;

package/dist/prompts.js

@@ -3,6 +3,12 @@ import { withDefaultIcons } from './tools/shared.js';
 const HELP_PROMPT_NAME = 'get-help';
 const HELP_PROMPT_TITLE = 'Get Help';
 const HELP_PROMPT_DESCRIPTION = 'Return filesystem-mcp usage instructions.';
+const COMPARE_FILES_PROMPT_NAME = 'compare-files';
+const COMPARE_FILES_PROMPT_TITLE = 'Compare Files';
+const COMPARE_FILES_PROMPT_DESCRIPTION = 'Generate a workflow for comparing two files using diff_files.';
+const ANALYZE_PATH_PROMPT_NAME = 'analyze-path';
+const ANALYZE_PATH_PROMPT_TITLE = 'Analyze Path';
+const ANALYZE_PATH_PROMPT_DESCRIPTION = 'Generate a workflow for analyzing a file or directory using stat, read, and tree.';
 function filterInstructionsByTopic(instructions, topic) {
     const normalized = topic.trim().toLowerCase();
     if (!normalized)
@@ -46,3 +52,48 @@ export function registerGetHelpPrompt(server, instructions, iconInfo) {
         };
     });
 }
+export function registerCompareFilesPrompt(server, iconInfo) {
+    server.registerPrompt(COMPARE_FILES_PROMPT_NAME, {
+        ...withDefaultIcons({
+            title: COMPARE_FILES_PROMPT_TITLE,
+            description: COMPARE_FILES_PROMPT_DESCRIPTION,
+        }, iconInfo),
+        argsSchema: {
+            original: z.string().describe('Path to the original file.'),
+            modified: z.string().describe('Path to the modified file.'),
+        },
+    }, ({ original, modified }) => ({
+        description: COMPARE_FILES_PROMPT_DESCRIPTION,
+        messages: [
+            {
+                role: 'user',
+                content: {
+                    type: 'text',
+                    text: `Compare files and explain differences.\n\n1. Call \`diff_files\` with:\n   - original: ${original}\n   - modified: ${modified}\n2. Summarize: additions, deletions, and semantic changes.\n3. Flag any potential issues (conflicts, regressions, breaking changes).`,
+                },
+            },
+        ],
+    }));
+}
+export function registerAnalyzePathPrompt(server, iconInfo) {
+    server.registerPrompt(ANALYZE_PATH_PROMPT_NAME, {
+        ...withDefaultIcons({
+            title: ANALYZE_PATH_PROMPT_TITLE,
+            description: ANALYZE_PATH_PROMPT_DESCRIPTION,
+        }, iconInfo),
+        argsSchema: {
+            path: z.string().describe('Absolute path to analyze.'),
+        },
+    }, ({ path: targetPath }) => ({
+        description: ANALYZE_PATH_PROMPT_DESCRIPTION,
+        messages: [
+            {
+                role: 'user',
+                content: {
+                    type: 'text',
+                    text: `Analyze the path: ${targetPath}\n\n1. Call \`stat\` to determine if it is a file or directory.\n2. If file: call \`read\` with \`includeHash: true\` and summarize contents.\n3. If directory: call \`tree\` (maxDepth: 3) and \`ls\` to summarize structure.\n4. Report: type, size, permissions, key observations.`,
+                },
+            },
+        ],
+    }));
+}

package/dist/resources/generated-instructions.js

@@ -1,17 +1,42 @@
 import { buildToolCatalogDetailsOnly } from './tool-catalog.js';
-import { buildCoreContextPack, getSharedConstraints, getToolContracts, } from './tool-info.js';
+import { buildCoreContextPack, formatToolNameList, getSharedConstraints, getTaskCapableToolNames, getToolContracts, pickAvailableToolNames, } from './tool-info.js';
 import { buildWorkflowGuide } from './workflows.js';
-const INSTRUCTIONS_HEADER = `<role>
+function buildToolsOverview() {
+    const rows = [
+        ['Navigate', pickAvailableToolNames(['roots', 'ls', 'tree', 'find'])],
+        [
+            'Inspect',
+            pickAvailableToolNames(['stat', 'stat_many', 'grep', 'calculate_hash']),
+        ],
+        ['Read', pickAvailableToolNames(['read', 'read_many', 'diff_files'])],
+        [
+            'Write',
+            pickAvailableToolNames([
+                'mkdir',
+                'write',
+                'edit',
+                'mv',
+                'rm',
+                'apply_patch',
+                'search_and_replace',
+            ]),
+        ],
+    ];
+    return rows
+        .filter(([, names]) => names.length > 0)
+        .map(([category, names]) => `| ${category} | ${formatToolNameList(names)} |`)
+        .join('\n');
+}
+function buildInstructionsHeader() {
+    const taskCapable = formatToolNameList(getTaskCapableToolNames());
+    return `<role>
 Filesystem agent. Scope: allowed roots only. Discover paths before acting — never guess.
 </role>
 
 <tools_overview>
 | Category | Tools |
 |----------|-------|
-| Navigate | \`roots\`, \`ls\`, \`tree\`, \`find\` |
-| Inspect  | \`stat\`, \`stat_many\`, \`grep\`, \`calculate_hash\` |
-| Read     | \`read\`, \`read_many\`, \`diff_files\` |
-| Write    | \`mkdir\`, \`write\`, \`edit\`, \`mv\`, \`rm\`, \`apply_patch\`, \`search_and_replace\` |
+${buildToolsOverview()}
 </tools_overview>
 
 <resources>
@@ -24,10 +49,12 @@ Filesystem agent. Scope: allowed roots only. Discover paths before acting — ne
 </resources>
 
 <task_protocol>
-Async execution: pass \`_meta.progressToken\` in \`tools/call\`, poll \`tasks/get\`, then call \`tasks/result\`.
-Task-capable: \`find\`, \`tree\`, \`read\`, \`read_many\`, \`stat_many\`, \`grep\`, \`mkdir\`, \`write\`, \`mv\`, \`rm\`, \`calculate_hash\`, \`apply_patch\`, \`search_and_replace\`.
+Task execution: Tools returning a task ID must be polled via \`tasks/get\`, then retrieved via \`tasks/result\`.
+Progress: Pass \`_meta.progressToken\` in \`tools/call\` to receive \`notifications/progress\`.
+Task-capable: ${taskCapable}.
 </task_protocol>
 `;
+}
 const INSTRUCTIONS_FOOTER = `<constraints>
 ${getSharedConstraints()
     .map((c) => `- ${c}`)
@@ -54,7 +81,7 @@ function formatToolSection(tool) {
 export function buildServerInstructions() {
     const toolSections = getToolContracts().map(formatToolSection).join('\n\n');
     return [
-        INSTRUCTIONS_HEADER,
+        buildInstructionsHeader(),
         buildCoreContextPack(),
         '',
         buildToolCatalogDetailsOnly(),

package/dist/resources/tool-catalog.js

@@ -1,10 +1,24 @@
-import { buildCoreContextPack } from './tool-info.js';
-const CATALOG_GUIDE = `<tool_selection_guide>
+import { buildCoreContextPack, pickAvailableToolNames } from './tool-info.js';
+function buildCrossToolDataFlow() {
+    const flows = [];
+    if (pickAvailableToolNames(['find', 'read']).length === 2) {
+        flows.push('find.results[].path -> read.path');
+    }
+    if (pickAvailableToolNames(['grep', 'read']).length === 2) {
+        flows.push('grep.matches[].file -> read.path');
+    }
+    if (pickAvailableToolNames(['diff_files', 'apply_patch']).length === 2) {
+        flows.push('diff_files.diff -> apply_patch.patch');
+    }
+    flows.push('toolResult.resourceUri -> resources/read.uri');
+    return flows.join('\n');
+}
+function buildCatalogGuide() {
+    return `<tool_selection_guide>
 ## Cross-Tool Data Flow
 
 \`\`\`
-find(results[].path) -> grep.paths
-diff_files(patch) -> apply_patch.patch
+${buildCrossToolDataFlow()}
 \`\`\`
 
 ## Search Strategy
@@ -19,16 +33,25 @@ diff_files(patch) -> apply_patch.patch
 - \`write\`: create files or overwrite full contents.
 - \`search_and_replace\`: bulk multi-file replacements.
 
+### edit vs write vs search_and_replace Decision
+
+1. **Single file, targeted change?** -> \`edit\` (match exact text, replace first occurrence)
+2. **Single file, full rewrite?** -> \`write\` (overwrite entire content)
+3. **Multiple files, same change?** -> \`search_and_replace\` (glob + pattern across files)
+4. **Not sure what to change?** -> \`grep\` first, then decide
+
 ## Patch Management
 
 - Generate patches with \`diff_files\` first.
 - Validate with \`apply_patch(dryRun:true)\` before writing.
-- \`apply_patch\` accepts unified diffs only.
+- \`apply_patch\` accepts unified diffs - single-file or multi-file.
+- Multi-file: \`path\` is base directory; each file is best-effort with per-file \`results[]\`.
 </tool_selection_guide>
 `;
+}
 export function buildToolCatalog() {
-    return `${buildCoreContextPack()}\n\n${CATALOG_GUIDE}`;
+    return `${buildCoreContextPack()}\n\n${buildCatalogGuide()}`;
 }
 export function buildToolCatalogDetailsOnly() {
-    return CATALOG_GUIDE;
+    return buildCatalogGuide();
 }

package/dist/resources/tool-info.d.ts

@@ -1,5 +1,9 @@
 import type { ToolContract } from '../tools/contract.js';
 export declare function getToolContracts(): ToolContract[];
+export declare function getSortedToolContracts(): ToolContract[];
+export declare function pickAvailableToolNames(names: readonly string[]): string[];
+export declare function formatToolNameList(names: readonly string[]): string;
+export declare function getTaskCapableToolNames(): string[];
 export declare function buildCoreContextPack(): string;
 export declare function getSharedConstraints(): string[];
 export declare function buildToolInfo(name: string): string | undefined;

package/dist/resources/tool-info.js

@@ -8,6 +8,9 @@ function toEntry(contract) {
         annotations.push('[Idempotent]');
     if (contract.annotations?.readOnlyHint)
         annotations.push('[Read-Only]');
+    if (contract.taskSupport === 'optional' ||
+        contract.taskSupport === 'required')
+        annotations.push('[Task]');
     return {
         name: contract.name,
         description: contract.description,
@@ -21,13 +24,28 @@ function toEntry(contract) {
     };
 }
 const ENTRIES = Object.fromEntries(ALL_TOOLS.map((contract) => [contract.name, toEntry(contract)]));
+const CONTRACTS_BY_NAME = new Map(ALL_TOOLS.map((contract) => [contract.name, contract]));
 export function getToolContracts() {
     return ALL_TOOLS;
 }
+export function getSortedToolContracts() {
+    return [...ALL_TOOLS].sort((left, right) => left.name.localeCompare(right.name));
+}
+export function pickAvailableToolNames(names) {
+    return names.filter((name) => CONTRACTS_BY_NAME.has(name));
+}
+export function formatToolNameList(names) {
+    return names.map((name) => `\`${name}\``).join(', ');
+}
+export function getTaskCapableToolNames() {
+    return getSortedToolContracts()
+        .filter((contract) => contract.taskSupport === 'optional' ||
+        contract.taskSupport === 'required')
+        .map((contract) => contract.name);
+}
 export function buildCoreContextPack() {
-    const names = Object.keys(ENTRIES).sort((a, b) => a.localeCompare(b));
-    const rows = names.map((name) => {
-        const e = ENTRIES[name];
+    const rows = getSortedToolContracts().map((contract) => {
+        const e = ENTRIES[contract.name];
         if (!e)
             return '';
         const annotations = e.annotations ? ` ${e.annotations.join(' ')}` : '';

package/dist/resources/workflows.js

@@ -1,20 +1,32 @@
+import { formatToolNameList, pickAvailableToolNames } from './tool-info.js';
 export function buildWorkflowGuide() {
+    const exploreTools = formatToolNameList(pickAvailableToolNames([
+        'roots',
+        'ls',
+        'tree',
+        'stat',
+        'stat_many',
+        'read',
+        'read_many',
+    ]));
+    const searchTools = formatToolNameList(pickAvailableToolNames(['find', 'grep', 'read']));
+    const editTools = formatToolNameList(pickAvailableToolNames(['edit', 'search_and_replace', 'mv', 'rm', 'mkdir']));
     return `<workflows>
 ### A: EXPLORE — directory layout or file content
-1. \`roots\` → \`ls\` or \`tree\` → \`stat\`/\`stat_many\` → \`read\`/\`read_many\`.
+1. ${exploreTools}.
    > **Strict:** Resolve paths first. Never guess.
 
 ### B: SEARCH — files by pattern or content
-1. \`find\` (glob) → \`grep\` (content) → \`read\` (verify).
+1. ${searchTools}.
    > **Strict:** Content search with \`grep\`, not \`find\`.
 
 ### C: EDIT — modify files or layout
-1. \`edit\` (targeted replacement) or \`search_and_replace\` (bulk).
-2. \`mv\`/\`rm\` (layout) or \`mkdir\` (create dirs).
+1. ${editTools}.
+2. Use \`edit\` for targeted changes, \`search_and_replace\` for bulk changes, and \`mv\`/\`rm\`/\`mkdir\` for layout updates.
    > **Strict:** Confirm destructive ops (\`write\`, \`mv\`, \`rm\`, bulk replace).
 
 ### D: PATCH — apply unified diffs
 1. \`diff_files\` → \`apply_patch(dryRun:true)\` → \`apply_patch\`.
-   > **Tip:** Feed \`diff_files\` output directly to \`apply_patch\`.
+   > **Tip:** Feed \`diff_files\` output directly. Multi-file patches: \`path\` = base dir, results per file.
 </workflows>`;
 }

package/dist/schemas.d.ts

@@ -9,6 +9,7 @@ interface TreeEntry {
     name: string;
     type: z.infer<typeof FileTypeSchema>;
     relativePath: string;
+    size?: number | undefined;
     children?: TreeEntry[] | undefined;
 }
 export declare const ToolErrorResponseSchema: z.ZodObject<{
@@ -34,13 +35,14 @@ export declare const ToolErrorResponseSchema: z.ZodObject<{
     }, z.core.$strict>;
 }, z.core.$strict>;
 declare const HeadLinesSchema: z.ZodOptional<z.ZodInt>;
-declare const LineNumberSchema: z.ZodNumber;
+declare const TailLinesSchema: z.ZodOptional<z.ZodInt>;
+declare const LineNumberSchema: z.ZodInt;
 export declare const ListDirectoryInputSchema: z.ZodObject<{
     path: z.ZodOptional<z.ZodString>;
     includeHidden: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     includeIgnored: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    maxDepth: z.ZodOptional<z.ZodNumber>;
-    maxEntries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    maxDepth: z.ZodOptional<z.ZodInt>;
+    maxEntries: z.ZodDefault<z.ZodOptional<z.ZodInt>>;
     sortBy: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
         name: "name";
         size: "size";
@@ -55,7 +57,7 @@ export declare const ListAllowedDirectoriesInputSchema: z.ZodObject<{}, z.core.$
 export declare const SearchFilesInputSchema: z.ZodObject<{
     path: z.ZodOptional<z.ZodString>;
     pattern: z.ZodString;
-    maxResults: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    maxResults: z.ZodDefault<z.ZodOptional<z.ZodInt>>;
     includeIgnored: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     includeHidden: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     sortBy: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
@@ -64,15 +66,16 @@ export declare const SearchFilesInputSchema: z.ZodObject<{
         path: "path";
         modified: "modified";
     }>>>;
-    maxDepth: z.ZodOptional<z.ZodNumber>;
+    maxDepth: z.ZodOptional<z.ZodInt>;
     cursor: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 export declare const TreeInputSchema: z.ZodObject<{
     path: z.ZodOptional<z.ZodString>;
-    maxDepth: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-    maxEntries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    maxDepth: z.ZodDefault<z.ZodOptional<z.ZodInt>>;
+    maxEntries: z.ZodDefault<z.ZodOptional<z.ZodInt>>;
     includeHidden: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     includeIgnored: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    includeSizes: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
 }, z.core.$strict>;
 export declare const SearchContentInputSchema: z.ZodObject<{
     path: z.ZodOptional<z.ZodString>;
@@ -80,20 +83,24 @@ export declare const SearchContentInputSchema: z.ZodObject<{
     isRegex: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     caseSensitive: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     wholeWord: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    contextLines: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-    maxResults: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    contextLines: z.ZodDefault<z.ZodOptional<z.ZodInt>>;
+    maxResults: z.ZodDefault<z.ZodOptional<z.ZodInt>>;
     filePattern: z.ZodDefault<z.ZodOptional<z.ZodString>>;
     includeHidden: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     includeIgnored: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    multiline: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
 }, z.core.$strict>;
 export declare const ReadFileInputSchema: z.ZodObject<{
+    includeHash: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     head: typeof HeadLinesSchema;
+    tail: typeof TailLinesSchema;
     startLine: z.ZodOptional<typeof LineNumberSchema>;
     endLine: z.ZodOptional<typeof LineNumberSchema>;
     path: z.ZodString;
 }, z.core.$strict>;
 export declare const ReadMultipleFilesInputSchema: z.ZodObject<{
     head: typeof HeadLinesSchema;
+    tail: typeof TailLinesSchema;
     startLine: z.ZodOptional<typeof LineNumberSchema>;
     endLine: z.ZodOptional<typeof LineNumberSchema>;
     paths: z.ZodArray<z.ZodString>;
@@ -250,6 +257,7 @@ export declare const SearchContentOutputSchema: z.ZodObject<{
     matches: z.ZodOptional<z.ZodArray<z.ZodObject<{
         file: z.ZodString;
         line: z.ZodNumber;
+        column: z.ZodOptional<z.ZodNumber>;
         content: z.ZodString;
         matchCount: z.ZodNumber;
         contextBefore: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -303,14 +311,17 @@ export declare const ReadFileOutputSchema: z.ZodObject<{
         head: "head";
         full: "full";
         range: "range";
+        tail: "tail";
     }>>;
     head: z.ZodOptional<z.ZodNumber>;
+    tail: z.ZodOptional<z.ZodNumber>;
     startLine: z.ZodOptional<z.ZodNumber>;
     endLine: z.ZodOptional<z.ZodNumber>;
     linesRead: z.ZodOptional<z.ZodNumber>;
     hasMoreLines: z.ZodOptional<z.ZodBoolean>;
     ok: z.ZodBoolean;
     path: z.ZodOptional<z.ZodString>;
+    contentHash: z.ZodOptional<z.ZodString>;
     error: z.ZodOptional<z.ZodObject<{
         code: z.ZodEnum<{
             readonly E_ACCESS_DENIED: "E_ACCESS_DENIED";
@@ -342,8 +353,10 @@ export declare const ReadMultipleFilesOutputSchema: z.ZodObject<{
             head: "head";
             full: "full";
             range: "range";
+            tail: "tail";
         }>>;
         head: z.ZodOptional<z.ZodNumber>;
+        tail: z.ZodOptional<z.ZodNumber>;
         startLine: z.ZodOptional<z.ZodNumber>;
         endLine: z.ZodOptional<z.ZodNumber>;
         linesRead: z.ZodOptional<z.ZodNumber>;
@@ -352,6 +365,7 @@ export declare const ReadMultipleFilesOutputSchema: z.ZodObject<{
         truncationReason: z.ZodOptional<z.ZodEnum<{
             head: "head";
             range: "range";
+            tail: "tail";
             externalized: "externalized";
         }>>;
         maxTotalSize: z.ZodOptional<z.ZodNumber>;
@@ -544,6 +558,7 @@ export declare const EditFileOutputSchema: z.ZodObject<{
     appliedEdits: z.ZodOptional<z.ZodNumber>;
     lineRange: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
     unmatchedEdits: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    diff: z.ZodOptional<z.ZodString>;
     error: z.ZodOptional<z.ZodObject<{
         code: z.ZodEnum<{
             readonly E_ACCESS_DENIED: "E_ACCESS_DENIED";
@@ -658,7 +673,7 @@ export declare const CalculateHashOutputSchema: z.ZodObject<{
 export declare const DiffFilesInputSchema: z.ZodObject<{
     original: z.ZodString;
     modified: z.ZodString;
-    context: z.ZodOptional<z.ZodNumber>;
+    context: z.ZodOptional<z.ZodInt>;
     ignoreWhitespace: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     stripTrailingCr: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
 }, z.core.$strict>;
@@ -666,6 +681,9 @@ export declare const DiffFilesOutputSchema: z.ZodObject<{
     ok: z.ZodBoolean;
     diff: z.ZodOptional<z.ZodString>;
     isIdentical: z.ZodOptional<z.ZodBoolean>;
+    linesAdded: z.ZodOptional<z.ZodNumber>;
+    linesRemoved: z.ZodOptional<z.ZodNumber>;
+    hunksCount: z.ZodOptional<z.ZodNumber>;
     truncated: z.ZodOptional<z.ZodBoolean>;
     resourceUri: z.ZodOptional<z.ZodString>;
     error: z.ZodOptional<z.ZodObject<{
@@ -691,7 +709,7 @@ export declare const DiffFilesOutputSchema: z.ZodObject<{
 export declare const ApplyPatchInputSchema: z.ZodObject<{
     path: z.ZodString;
     patch: z.ZodString;
-    fuzzFactor: z.ZodOptional<z.ZodNumber>;
+    fuzzFactor: z.ZodOptional<z.ZodInt>;
     autoConvertLineEndings: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     dryRun: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
 }, z.core.$strict>;
@@ -699,6 +717,17 @@ export declare const ApplyPatchOutputSchema: z.ZodObject<{
     ok: z.ZodBoolean;
     path: z.ZodOptional<z.ZodString>;
     applied: z.ZodOptional<z.ZodBoolean>;
+    hunksApplied: z.ZodOptional<z.ZodNumber>;
+    linesAdded: z.ZodOptional<z.ZodNumber>;
+    linesRemoved: z.ZodOptional<z.ZodNumber>;
+    results: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        applied: z.ZodBoolean;
+        hunksApplied: z.ZodOptional<z.ZodNumber>;
+        linesAdded: z.ZodOptional<z.ZodNumber>;
+        linesRemoved: z.ZodOptional<z.ZodNumber>;
+        error: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
     error: z.ZodOptional<z.ZodObject<{
         code: z.ZodEnum<{
             readonly E_ACCESS_DENIED: "E_ACCESS_DENIED";
@@ -721,14 +750,16 @@ export declare const ApplyPatchOutputSchema: z.ZodObject<{
 }, z.core.$strict>;
 export declare const SearchAndReplaceInputSchema: z.ZodObject<{
     path: z.ZodOptional<z.ZodString>;
-    filePattern: z.ZodString;
+    filePattern: z.ZodDefault<z.ZodOptional<z.ZodString>>;
     searchPattern: z.ZodString;
     replacement: z.ZodString;
     isRegex: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    caseSensitive: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     dryRun: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     includeHidden: z.ZodOptional<z.ZodBoolean>;
     includeIgnored: z.ZodOptional<z.ZodBoolean>;
     returnDiff: z.ZodOptional<z.ZodBoolean>;
+    maxFiles: z.ZodOptional<z.ZodInt>;
 }, z.core.$strict>;
 export declare const SearchAndReplaceOutputSchema: z.ZodObject<{
     ok: z.ZodBoolean;
@@ -746,6 +777,10 @@ export declare const SearchAndReplaceOutputSchema: z.ZodObject<{
     }, z.core.$strict>>>;
     changedFilesTruncated: z.ZodOptional<z.ZodBoolean>;
     diff: z.ZodOptional<z.ZodString>;
+    diffTruncated: z.ZodOptional<z.ZodBoolean>;
+    stoppedReason: z.ZodOptional<z.ZodEnum<{
+        maxFiles: "maxFiles";
+    }>>;
     dryRun: z.ZodOptional<z.ZodBoolean>;
     error: z.ZodOptional<z.ZodObject<{
         code: z.ZodEnum<{