@j0hanz/fs-context-mcp 2.0.7 → 2.1.1

package/dist/tools.js

@@ -7,15 +7,34 @@ import { listDirectory } from './lib/file-operations/list-directory.js';
 import { readMultipleFiles } from './lib/file-operations/read-multiple-files.js';
 import { searchContent } from './lib/file-operations/search-content.js';
 import { searchFiles } from './lib/file-operations/search-files.js';
+import { formatTreeAscii, treeDirectory } from './lib/file-operations/tree.js';
 import { createTimedAbortSignal, readFile } from './lib/fs-helpers.js';
 import { withToolDiagnostics } from './lib/observability.js';
 import { getAllowedDirectories } from './lib/path-validation.js';
-import { GetFileInfoInputSchema, GetFileInfoOutputSchema, GetMultipleFileInfoInputSchema, GetMultipleFileInfoOutputSchema, ListAllowedDirectoriesInputSchema, ListAllowedDirectoriesOutputSchema, ListDirectoryInputSchema, ListDirectoryOutputSchema, ReadFileInputSchema, ReadFileOutputSchema, ReadMultipleFilesInputSchema, ReadMultipleFilesOutputSchema, SearchContentInputSchema, SearchContentOutputSchema, SearchFilesInputSchema, SearchFilesOutputSchema, } from './schemas.js';
-function buildContentBlock(text, structuredContent) {
+import { GetFileInfoInputSchema, GetFileInfoOutputSchema, GetMultipleFileInfoInputSchema, GetMultipleFileInfoOutputSchema, ListAllowedDirectoriesInputSchema, ListAllowedDirectoriesOutputSchema, ListDirectoryInputSchema, ListDirectoryOutputSchema, ReadFileInputSchema, ReadFileOutputSchema, ReadMultipleFilesInputSchema, ReadMultipleFilesOutputSchema, SearchContentInputSchema, SearchContentOutputSchema, SearchFilesInputSchema, SearchFilesOutputSchema, TreeInputSchema, TreeOutputSchema, } from './schemas.js';
+const MAX_INLINE_CONTENT_CHARS = 20_000;
+const MAX_INLINE_PREVIEW_CHARS = 4_000;
+const MAX_INLINE_MATCHES = 50;
+function buildTextPreview(text) {
+    if (text.length <= MAX_INLINE_PREVIEW_CHARS)
+        return text;
+    return `${text.slice(0, MAX_INLINE_PREVIEW_CHARS)}\n… [truncated preview]`;
+}
+function buildResourceLink(params) {
+    return {
+        type: 'resource_link',
+        uri: params.uri,
+        name: params.name,
+        ...(params.description ? { description: params.description } : {}),
+        ...(params.mimeType ? { mimeType: params.mimeType } : {}),
+    };
+}
+function buildContentBlock(text, structuredContent, extraContent = []) {
     const json = JSON.stringify(structuredContent);
     return {
         content: [
             { type: 'text', text },
+            ...extraContent,
             { type: 'text', text: json },
         ],
         structuredContent,
@@ -29,9 +48,10 @@ function resolveDetailedError(error, defaultCode, path) {
     }
     return detailed;
 }
-export function buildToolResponse(text, structuredContent) {
-    return buildContentBlock(text, structuredContent);
+export function buildToolResponse(text, structuredContent, extraContent = []) {
+    return buildContentBlock(text, structuredContent, extraContent);
 }
+const NOT_INITIALIZED_ERROR = new McpError(ErrorCode.E_INVALID_INPUT, 'Client not initialized; wait for notifications/initialized');
 async function withToolErrorHandling(run, onError) {
     try {
         return await run();
@@ -62,6 +82,82 @@ export function buildToolErrorResponse(error, defaultCode, path) {
         isError: true,
     };
 }
+function buildNotInitializedResult() {
+    return buildToolErrorResponse(NOT_INITIALIZED_ERROR, ErrorCode.E_INVALID_INPUT);
+}
+async function sendProgressNotification(extra, params) {
+    if (!extra.sendNotification)
+        return;
+    try {
+        await extra.sendNotification({
+            method: 'notifications/progress',
+            params,
+        });
+    }
+    catch {
+        // Ignore progress notification failures to avoid breaking tool execution.
+    }
+}
+function resolveToolOk(result) {
+    if (!result || typeof result !== 'object')
+        return true;
+    const typed = result;
+    if (typed.isError === true)
+        return false;
+    const structured = typed.structuredContent;
+    if (structured &&
+        typeof structured === 'object' &&
+        'ok' in structured &&
+        typeof structured.ok === 'boolean') {
+        return Boolean(structured.ok);
+    }
+    return true;
+}
+async function withProgress(tool, extra, run) {
+    const token = extra._meta?.progressToken;
+    if (!token) {
+        return await run();
+    }
+    const total = 1;
+    await sendProgressNotification(extra, {
+        progressToken: token,
+        progress: 0,
+        total,
+        message: `${tool} started`,
+    });
+    try {
+        const result = await run();
+        const ok = resolveToolOk(result);
+        await sendProgressNotification(extra, {
+            progressToken: token,
+            progress: total,
+            total,
+            message: ok ? `${tool} completed` : `${tool} failed`,
+        });
+        return result;
+    }
+    catch (error) {
+        await sendProgressNotification(extra, {
+            progressToken: token,
+            progress: total,
+            total,
+            message: `${tool} failed`,
+        });
+        throw error;
+    }
+}
+function wrapToolHandler(handler, options) {
+    return async (args, extra) => {
+        const resolvedExtra = extra ?? {};
+        if (options.guard && !options.guard()) {
+            return buildNotInitializedResult();
+        }
+        if (options.progressTool) {
+            return await withProgress(options.progressTool, resolvedExtra, () => handler(args, resolvedExtra));
+        }
+        return await handler(args, resolvedExtra);
+    };
+}
 function resolvePathOrRoot(pathValue) {
     if (pathValue && pathValue.trim().length > 0)
         return pathValue;
@@ -133,6 +229,7 @@ function buildStructuredSearchResult(result) {
             file: match.relativeFile,
             line: match.line,
             content: match.content,
+            matchCount: match.matchCount,
             ...(match.contextBefore
                 ? { contextBefore: [...match.contextBefore] }
                 : {}),
@@ -171,6 +268,9 @@ function buildFileInfoPayload(info) {
         path: info.path,
         type: info.type,
         size: info.size,
+        ...(info.tokenEstimate !== undefined
+            ? { tokenEstimate: info.tokenEstimate }
+            : {}),
         created: info.created.toISOString(),
         modified: info.modified.toISOString(),
         accessed: info.accessed.toISOString(),
@@ -238,6 +338,18 @@ const SEARCH_FILES_TOOL = {
         openWorldHint: true,
     },
 };
+const TREE_TOOL = {
+    title: 'Tree',
+    description: 'Render a directory tree (bounded recursion). ' +
+        'Returns an ASCII tree for quick scanning and a structured JSON tree for programmatic use.',
+    inputSchema: TreeInputSchema,
+    outputSchema: TreeOutputSchema,
+    annotations: {
+        readOnlyHint: true,
+        idempotentHint: true,
+        openWorldHint: true,
+    },
+};
 const READ_FILE_TOOL = {
     title: 'Read File',
     description: 'Read the text contents of a file. ' +
@@ -317,9 +429,9 @@ function handleListAllowedDirectories() {
     };
     return buildToolResponse(buildTextRoots(dirs), structured);
 }
-export function registerListAllowedDirectoriesTool(server) {
+export function registerListAllowedDirectoriesTool(server, options = {}) {
     const handler = () => withToolErrorHandling(() => withToolDiagnostics('roots', () => Promise.resolve(handleListAllowedDirectories())), (error) => buildToolErrorResponse(error, ErrorCode.E_UNKNOWN));
-    server.registerTool('roots', LIST_ALLOWED_DIRECTORIES_TOOL, handler);
+    server.registerTool('roots', LIST_ALLOWED_DIRECTORIES_TOOL, wrapToolHandler(handler, { guard: options.isInitialized }));
 }
 function buildStructuredListEntry(entry) {
     return {
@@ -348,14 +460,16 @@ async function handleListDirectory(args, signal) {
     const result = await listDirectory(dirPath, options);
     return buildToolResponse(buildListTextResult(result), buildStructuredListResult(result));
 }
-export function registerListDirectoryTool(server) {
-    server.registerTool('ls', LIST_DIRECTORY_TOOL, (args, extra) => withToolDiagnostics('ls', () => withToolErrorHandling(() => handleListDirectory(args, extra.signal), (error) => buildToolErrorResponse(error, ErrorCode.E_NOT_DIRECTORY, args.path ?? '.')), { path: args.path ?? '.' }));
+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 ?? '.' });
+    server.registerTool('ls', LIST_DIRECTORY_TOOL, wrapToolHandler(handler, { guard: options.isInitialized }));
 }
 async function handleSearchFiles(args, signal) {
     const basePath = resolvePathOrRoot(args.path);
     const excludePatterns = args.includeIgnored ? [] : DEFAULT_EXCLUDE_PATTERNS;
     const result = await searchFiles(basePath, args.pattern, excludePatterns, {
         maxResults: args.maxResults,
+        respectGitignore: !args.includeIgnored,
         ...(signal ? { signal } : {}),
     });
     const relativeResults = result.results.map((entry) => ({
@@ -369,14 +483,33 @@ async function handleSearchFiles(args, signal) {
         totalMatches: result.summary.matched,
         truncated: result.summary.truncated,
     };
-    const text = joinLines([
-        `Found ${relativeResults.length}:`,
-        ...relativeResults.map((entry) => `  ${entry.path}`),
-    ]);
+    let truncatedReason;
+    if (result.summary.truncated) {
+        if (result.summary.stoppedReason === 'timeout') {
+            truncatedReason = 'timeout';
+        }
+        else if (result.summary.stoppedReason === 'maxFiles') {
+            truncatedReason = `max files (${result.summary.filesScanned})`;
+        }
+        else {
+            truncatedReason = `max results (${result.summary.matched})`;
+        }
+    }
+    const summaryOptions = {
+        truncated: result.summary.truncated,
+        ...(truncatedReason ? { truncatedReason } : {}),
+    };
+    const textLines = relativeResults.length === 0
+        ? ['No matches']
+        : [
+            `Found ${relativeResults.length}:`,
+            ...relativeResults.map((entry) => `  ${entry.path}`),
+        ];
+    const text = joinLines(textLines) + formatOperationSummary(summaryOptions);
     return buildToolResponse(text, structured);
 }
-function registerSearchFilesTool(server) {
-    server.registerTool('find', SEARCH_FILES_TOOL, (args, extra) => withToolDiagnostics('find', () => withToolErrorHandling(async () => {
+function registerSearchFilesTool(server, options = {}) {
+    const handler = (args, extra) => withToolDiagnostics('find', () => withToolErrorHandling(async () => {
         const { signal, cleanup } = createTimedAbortSignal(extra.signal, DEFAULT_SEARCH_TIMEOUT_MS);
         try {
             return await handleSearchFiles(args, signal);
@@ -384,9 +517,52 @@ function registerSearchFilesTool(server) {
         finally {
             cleanup();
         }
-    }, (error) => buildToolErrorResponse(error, ErrorCode.E_INVALID_PATTERN, args.path)), { path: args.path ?? '.' }));
+    }, (error) => buildToolErrorResponse(error, ErrorCode.E_INVALID_PATTERN, args.path)), { path: args.path ?? '.' });
+    server.registerTool('find', SEARCH_FILES_TOOL, wrapToolHandler(handler, {
+        guard: options.isInitialized,
+        progressTool: 'find',
+    }));
+}
+async function handleTree(args, signal) {
+    const basePath = resolvePathOrRoot(args.path);
+    const result = await treeDirectory(basePath, {
+        maxDepth: args.maxDepth,
+        maxEntries: args.maxEntries,
+        includeHidden: args.includeHidden,
+        includeIgnored: args.includeIgnored,
+        ...(signal ? { signal } : {}),
+    });
+    const ascii = formatTreeAscii(result.tree);
+    const structured = {
+        ok: true,
+        root: result.root,
+        tree: result.tree,
+        ascii,
+        truncated: result.truncated,
+        totalEntries: result.totalEntries,
+    };
+    const text = result.truncated ? `${ascii}\n[truncated]` : ascii;
+    return buildToolResponse(text, structured);
 }
-async function handleReadFile(args, signal) {
+function registerTreeTool(server, options = {}) {
+    const handler = (args, extra) => {
+        const targetPath = args.path ?? '.';
+        return withToolDiagnostics('tree', () => withToolErrorHandling(async () => {
+            const { signal, cleanup } = createTimedAbortSignal(extra.signal, DEFAULT_SEARCH_TIMEOUT_MS);
+            try {
+                return await handleTree(args, signal);
+            }
+            finally {
+                cleanup();
+            }
+        }, (error) => buildToolErrorResponse(error, ErrorCode.E_NOT_DIRECTORY, targetPath)), { path: targetPath });
+    };
+    server.registerTool('tree', TREE_TOOL, wrapToolHandler(handler, {
+        guard: options.isInitialized,
+        progressTool: 'tree',
+    }));
+}
+async function handleReadFile(args, signal, resourceStore) {
     const options = {
         encoding: 'utf-8',
         maxSize: MAX_TEXT_FILE_SIZE,
@@ -395,6 +571,12 @@ async function handleReadFile(args, signal) {
     if (args.head !== undefined) {
         options.head = args.head;
     }
+    if (args.startLine !== undefined) {
+        options.startLine = args.startLine;
+    }
+    if (args.endLine !== undefined) {
+        options.endLine = args.endLine;
+    }
     if (signal) {
         options.signal = signal;
     }
@@ -404,45 +586,112 @@ async function handleReadFile(args, signal) {
         path: args.path,
         content: result.content,
         truncated: result.truncated,
+        resourceUri: undefined,
         totalLines: result.totalLines,
+        readMode: result.readMode,
+        head: result.head,
+        startLine: result.startLine,
+        endLine: result.endLine,
+        linesRead: result.linesRead,
+        hasMoreLines: result.hasMoreLines,
+    };
+    if (!resourceStore || result.content.length <= MAX_INLINE_CONTENT_CHARS) {
+        return buildToolResponse(result.content, structured);
+    }
+    const entry = resourceStore.putText({
+        name: `read:${path.basename(args.path)}`,
+        mimeType: 'text/plain',
+        text: result.content,
+    });
+    const preview = buildTextPreview(result.content);
+    const structuredWithResource = {
+        ...structured,
+        content: preview,
+        truncated: true,
+        resourceUri: entry.uri,
     };
-    return buildToolResponse(result.content, structured);
+    const text = joinLines([
+        `Output too large to inline (${result.content.length} chars).`,
+        'Preview:',
+        preview,
+    ]);
+    return buildToolResponse(text, structuredWithResource, [
+        buildResourceLink({
+            uri: entry.uri,
+            name: entry.name,
+            mimeType: entry.mimeType,
+            description: 'Full file contents',
+        }),
+    ]);
 }
-function registerReadFileTool(server) {
+function registerReadFileTool(server, options = {}) {
     const handler = (args, extra) => withToolDiagnostics('read', () => withToolErrorHandling(async () => {
         const { signal, cleanup } = createTimedAbortSignal(extra.signal, DEFAULT_SEARCH_TIMEOUT_MS);
         try {
-            return await handleReadFile(args, signal);
+            return await handleReadFile(args, signal, options.resourceStore);
         }
         finally {
             cleanup();
         }
     }, (error) => buildToolErrorResponse(error, ErrorCode.E_NOT_FILE, args.path)), { path: args.path });
-    server.registerTool('read', READ_FILE_TOOL, handler);
+    server.registerTool('read', READ_FILE_TOOL, wrapToolHandler(handler, { guard: options.isInitialized }));
 }
-async function handleReadMultipleFiles(args, signal) {
+async function handleReadMultipleFiles(args, signal, resourceStore) {
     const options = {
         ...(signal ? { signal } : {}),
     };
     if (args.head !== undefined) {
         options.head = args.head;
     }
+    if (args.startLine !== undefined) {
+        options.startLine = args.startLine;
+    }
+    if (args.endLine !== undefined) {
+        options.endLine = args.endLine;
+    }
     const results = await readMultipleFiles(args.paths, options);
+    const mappedResults = results.map((result) => {
+        if (!resourceStore || !result.content) {
+            return result;
+        }
+        if (result.content.length <= MAX_INLINE_CONTENT_CHARS) {
+            return result;
+        }
+        const entry = resourceStore.putText({
+            name: `read:${path.basename(result.path)}`,
+            mimeType: 'text/plain',
+            text: result.content,
+        });
+        return {
+            ...result,
+            content: buildTextPreview(result.content),
+            truncated: true,
+            resourceUri: entry.uri,
+        };
+    });
     const structured = {
         ok: true,
-        results: results.map((result) => ({
+        results: mappedResults.map((result) => ({
             path: result.path,
             content: result.content,
             truncated: result.truncated,
+            resourceUri: result.resourceUri,
+            readMode: result.readMode,
+            head: result.head,
+            startLine: result.startLine,
+            endLine: result.endLine,
+            linesRead: result.linesRead,
+            hasMoreLines: result.hasMoreLines,
+            totalLines: result.totalLines,
             error: result.error,
         })),
         summary: {
-            total: results.length,
-            succeeded: results.filter((r) => r.error === undefined).length,
-            failed: results.filter((r) => r.error !== undefined).length,
+            total: mappedResults.length,
+            succeeded: mappedResults.filter((r) => r.error === undefined).length,
+            failed: mappedResults.filter((r) => r.error !== undefined).length,
         },
     };
-    const text = joinLines(results.map((result) => {
+    const text = joinLines(mappedResults.map((result) => {
         if (result.error) {
             return `${result.path}: ${result.error}`;
         }
@@ -450,19 +699,20 @@ async function handleReadMultipleFiles(args, signal) {
     }));
     return buildToolResponse(text, structured);
 }
-function registerReadMultipleFilesTool(server) {
-    server.registerTool('read_many', READ_MULTIPLE_FILES_TOOL, (args, extra) => {
+function registerReadMultipleFilesTool(server, options = {}) {
+    const handler = (args, extra) => {
         const primaryPath = args.paths[0] ?? '';
         return withToolDiagnostics('read_many', () => withToolErrorHandling(async () => {
             const { signal, cleanup } = createTimedAbortSignal(extra.signal, DEFAULT_SEARCH_TIMEOUT_MS);
             try {
-                return await handleReadMultipleFiles(args, signal);
+                return await handleReadMultipleFiles(args, signal, options.resourceStore);
             }
             finally {
                 cleanup();
             }
         }, (error) => buildToolErrorResponse(error, ErrorCode.E_NOT_FILE, primaryPath)), { path: primaryPath });
-    });
+    };
+    server.registerTool('read_many', READ_MULTIPLE_FILES_TOOL, wrapToolHandler(handler, { guard: options.isInitialized }));
 }
 async function handleGetFileInfo(args, signal) {
     const info = await getFileInfo(args.path, {
@@ -475,8 +725,8 @@ async function handleGetFileInfo(args, signal) {
     };
     return buildToolResponse(formatFileInfoDetails(info), structured);
 }
-function registerGetFileInfoTool(server) {
-    server.registerTool('stat', GET_FILE_INFO_TOOL, (args, extra) => withToolDiagnostics('stat', () => withToolErrorHandling(async () => {
+function registerGetFileInfoTool(server, options = {}) {
+    const handler = (args, extra) => withToolDiagnostics('stat', () => withToolErrorHandling(async () => {
         const { signal, cleanup } = createTimedAbortSignal(extra.signal, DEFAULT_SEARCH_TIMEOUT_MS);
         try {
             return await handleGetFileInfo(args, signal);
@@ -484,7 +734,8 @@ function registerGetFileInfoTool(server) {
         finally {
             cleanup();
         }
-    }, (error) => buildToolErrorResponse(error, ErrorCode.E_NOT_FOUND, args.path)), { path: args.path }));
+    }, (error) => buildToolErrorResponse(error, ErrorCode.E_NOT_FOUND, args.path)), { path: args.path });
+    server.registerTool('stat', GET_FILE_INFO_TOOL, wrapToolHandler(handler, { guard: options.isInitialized }));
 }
 async function handleGetMultipleFileInfo(args, signal) {
     const result = await getMultipleFileInfo(args.paths, {
@@ -515,8 +766,8 @@ async function handleGetMultipleFileInfo(args, signal) {
     }));
     return buildToolResponse(text, structured);
 }
-function registerGetMultipleFileInfoTool(server) {
-    server.registerTool('stat_many', GET_MULTIPLE_FILE_INFO_TOOL, (args, extra) => {
+function registerGetMultipleFileInfoTool(server, options = {}) {
+    const handler = (args, extra) => {
         const primaryPath = args.paths[0] ?? '';
         return withToolDiagnostics('stat_many', () => withToolErrorHandling(async () => {
             const { signal, cleanup } = createTimedAbortSignal(extra.signal, DEFAULT_SEARCH_TIMEOUT_MS);
@@ -527,26 +778,75 @@ function registerGetMultipleFileInfoTool(server) {
                 cleanup();
             }
         }, (error) => buildToolErrorResponse(error, ErrorCode.E_NOT_FOUND, primaryPath)), { path: primaryPath });
-    });
+    };
+    server.registerTool('stat_many', GET_MULTIPLE_FILE_INFO_TOOL, wrapToolHandler(handler, { guard: options.isInitialized }));
 }
-async function handleSearchContent(args, signal) {
+async function handleSearchContent(args, signal, resourceStore) {
     const basePath = resolvePathOrRoot(args.path);
     const result = await searchContent(basePath, args.pattern, signal
         ? { includeHidden: args.includeHidden, signal }
         : { includeHidden: args.includeHidden });
-    return buildToolResponse(buildSearchTextResult(result), buildStructuredSearchResult(result));
-}
-function registerSearchContentTool(server) {
-    server.registerTool('grep', SEARCH_CONTENT_TOOL, (args, extra) => withToolDiagnostics('grep', () => withToolErrorHandling(async () => handleSearchContent(args, extra.signal), (error) => buildToolErrorResponse(error, ErrorCode.E_UNKNOWN, args.path ?? '.')), { path: args.path ?? '.' }));
-}
-export function registerAllTools(server) {
-    registerListAllowedDirectoriesTool(server);
-    registerListDirectoryTool(server);
-    registerSearchFilesTool(server);
-    registerReadFileTool(server);
-    registerReadMultipleFilesTool(server);
-    registerGetFileInfoTool(server);
-    registerGetMultipleFileInfoTool(server);
-    registerSearchContentTool(server);
+    const structuredFull = buildStructuredSearchResult(result);
+    const normalizedMatches = normalizeSearchMatches(result);
+    const needsExternalize = normalizedMatches.length > MAX_INLINE_MATCHES;
+    if (!resourceStore || !needsExternalize) {
+        return buildToolResponse(buildSearchTextResult(result), structuredFull);
+    }
+    const previewMatches = normalizedMatches.slice(0, MAX_INLINE_MATCHES);
+    const previewStructured = {
+        ok: true,
+        matches: previewMatches.map((match) => ({
+            file: match.relativeFile,
+            line: match.line,
+            content: match.content,
+            matchCount: match.matchCount,
+            ...(match.contextBefore
+                ? { contextBefore: [...match.contextBefore] }
+                : {}),
+            ...(match.contextAfter ? { contextAfter: [...match.contextAfter] } : {}),
+        })),
+        totalMatches: structuredFull.totalMatches,
+        truncated: true,
+        resourceUri: undefined,
+    };
+    const entry = resourceStore.putText({
+        name: 'grep:matches',
+        mimeType: 'application/json',
+        text: JSON.stringify(structuredFull),
+    });
+    previewStructured.resourceUri = entry.uri;
+    const text = joinLines([
+        `Found ${normalizedMatches.length} (showing first ${MAX_INLINE_MATCHES}):`,
+        ...previewMatches.map((match) => {
+            const lineNum = String(match.line).padStart(4);
+            return `  ${match.relativeFile}:${lineNum}: ${match.content}`;
+        }),
+    ]);
+    return buildToolResponse(text, previewStructured, [
+        buildResourceLink({
+            uri: entry.uri,
+            name: entry.name,
+            mimeType: entry.mimeType,
+            description: 'Full grep results as JSON (structuredContent)',
+        }),
+    ]);
+}
+function registerSearchContentTool(server, options = {}) {
+    const handler = (args, extra) => withToolDiagnostics('grep', () => withToolErrorHandling(async () => handleSearchContent(args, extra.signal, options.resourceStore), (error) => buildToolErrorResponse(error, ErrorCode.E_UNKNOWN, args.path ?? '.')), { path: args.path ?? '.' });
+    server.registerTool('grep', SEARCH_CONTENT_TOOL, wrapToolHandler(handler, {
+        guard: options.isInitialized,
+        progressTool: 'grep',
+    }));
+}
+export function registerAllTools(server, options = {}) {
+    registerListAllowedDirectoriesTool(server, options);
+    registerListDirectoryTool(server, options);
+    registerSearchFilesTool(server, options);
+    registerTreeTool(server, options);
+    registerReadFileTool(server, options);
+    registerReadMultipleFilesTool(server, options);
+    registerGetFileInfoTool(server, options);
+    registerGetMultipleFileInfoTool(server, options);
+    registerSearchContentTool(server, options);
 }
 //# sourceMappingURL=tools.js.map