@j0hanz/filesystem-mcp 1.19.0 → 2.0.0

package/dist/tools/tree.js

@@ -1,102 +0,0 @@
-import { basename } from 'node:path';
-import { DEFAULT_SEARCH_TIMEOUT_MS } from '../lib/constants.js';
-import { classifyError, ErrorCode } from '../lib/errors.js';
-import { formatTreeAscii, treeDirectory, } from '../lib/file-operations/metadata.js';
-import { TreeInputSchema, TreeOutputSchema } from '../schemas.js';
-import { DIRECTORY_ICONS } from './icons.js';
-import { buildToolErrorResponse, buildToolResponse, createProgressReporter, executeToolWithDiagnostics, notifyProgress, READ_ONLY_TOOL_ANNOTATIONS, resolvePathOrRoot, } from './shared.js';
-import { registerStandardTool } from './task-support.js';
-export const TREE_TOOL = {
-    name: 'tree',
-    title: 'Tree',
-    description: 'Render a directory tree (bounded recursion). Returns ASCII tree + structured JSON. ' +
-        '`maxDepth=0` returns only the root node.',
-    inputSchema: TreeInputSchema,
-    outputSchema: TreeOutputSchema,
-    annotations: READ_ONLY_TOOL_ANNOTATIONS,
-    icons: DIRECTORY_ICONS,
-    taskSupport: 'optional',
-};
-async function handleTree(args, signal, onProgress) {
-    const basePath = resolvePathOrRoot(args.path);
-    const result = await treeDirectory(basePath, {
-        maxDepth: args.maxDepth,
-        maxEntries: args.maxEntries,
-        includeHidden: args.includeHidden,
-        includeIgnored: args.includeIgnored,
-        includeSizes: args.includeSizes,
-        ...(signal ? { signal } : {}),
-        ...(onProgress ? { onProgress } : {}),
-    });
-    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);
-}
-export function registerTreeTool(server, options = {}) {
-    const handler = (args, ctx) => {
-        const targetPath = args.path ?? '.';
-        return executeToolWithDiagnostics({
-            toolName: 'tree',
-            ctx,
-            outputSchema: TreeOutputSchema,
-            timedSignal: { timeoutMs: DEFAULT_SEARCH_TIMEOUT_MS },
-            context: { path: targetPath },
-            run: async (signal) => {
-                const context = args.path ? basename(args.path) : '.';
-                let progressCursor = 0;
-                const knownTotal = args.maxEntries;
-                notifyProgress(ctx, {
-                    current: 0,
-                    total: knownTotal,
-                    message: `${TREE_TOOL.title}: ${context}`,
-                });
-                const baseReporter = createProgressReporter(ctx);
-                const onProgress = (progress) => {
-                    const { current } = progress;
-                    if (current > progressCursor)
-                        progressCursor = current;
-                    baseReporter({
-                        current,
-                        total: knownTotal,
-                        message: `${TREE_TOOL.title}: ${context} [${current} entries]`,
-                    });
-                };
-                try {
-                    const result = await handleTree(args, signal, onProgress);
-                    const sc = result.structuredContent;
-                    const count = sc.totalEntries ?? 0;
-                    const { truncated } = sc;
-                    let suffix = `${count} ${count === 1 ? 'entry' : 'entries'}`;
-                    if (truncated)
-                        suffix += ' [truncated]';
-                    const finalCurrent = Math.max(count, progressCursor + 1);
-                    notifyProgress(ctx, {
-                        current: finalCurrent,
-                        total: finalCurrent,
-                        message: `${TREE_TOOL.title}: ${context} • ${suffix}`,
-                    });
-                    return result;
-                }
-                catch (error) {
-                    const finalCurrent = Math.max(progressCursor + 1, 1);
-                    notifyProgress(ctx, {
-                        current: finalCurrent,
-                        total: finalCurrent,
-                        message: `${TREE_TOOL.title}: ${context} • ${classifyError(error)}`,
-                    });
-                    throw error;
-                }
-            },
-            onError: (error) => buildToolErrorResponse(error, ErrorCode.NOT_DIRECTORY, targetPath),
-        });
-    };
-    registerStandardTool(server, TREE_TOOL, handler, options);
-}

package/dist/tools/write-file.d.ts

@@ -1,4 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/server';
-import { type ToolContract, type ToolRegistrationOptions } from './shared.js';
-export declare const WRITE_FILE_TOOL: ToolContract;
-export declare function registerWriteFileTool(server: McpServer, options?: ToolRegistrationOptions): void;

package/dist/tools/write-file.js

@@ -1,60 +0,0 @@
-import { mkdir } from 'node:fs/promises';
-import { basename, dirname } from 'node:path';
-import { withAbort } from '../lib/abort.js';
-import { ErrorCode } from '../lib/errors.js';
-import { atomicWriteFile } from '../lib/fs-helpers.js';
-import { Logger } from '../lib/logger.js';
-import { validatePathForWrite } from '../lib/paths.js';
-import { formatBytes } from '../config.js';
-import { WriteFileInputSchema, WriteFileOutputSchema } from '../schemas.js';
-import { FILE_EDIT_ICONS } from './icons.js';
-import { buildToolErrorResponse, buildToolResponse, DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS, executeToolWithDiagnostics, } from './shared.js';
-import { registerStandardTool } from './task-support.js';
-export const WRITE_FILE_TOOL = {
-    name: 'write',
-    title: 'Write File',
-    description: 'Write content to a file, OVERWRITING ALL existing content. Creates the file and parent directories if needed.',
-    inputSchema: WriteFileInputSchema,
-    outputSchema: WriteFileOutputSchema,
-    annotations: DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS,
-    icons: FILE_EDIT_ICONS,
-    taskSupport: 'forbidden',
-};
-async function handleWriteFile(args, signal) {
-    const validPath = await validatePathForWrite(args.path, signal);
-    // Ensure parent directory exists
-    await withAbort(mkdir(dirname(validPath), { recursive: true }), signal);
-    await atomicWriteFile(validPath, args.content, { encoding: 'utf-8', signal });
-    const bytesWritten = Buffer.byteLength(args.content, 'utf-8');
-    Logger.info(`write: ${args.path} (${bytesWritten} bytes)`);
-    return buildToolResponse(`Successfully wrote to file: ${args.path}`, {
-        ok: true,
-        path: validPath,
-        bytesWritten,
-    });
-}
-export function registerWriteFileTool(server, options = {}) {
-    const handler = (args, ctx) => executeToolWithDiagnostics({
-        toolName: 'write',
-        ctx,
-        outputSchema: WriteFileOutputSchema,
-        timedSignal: {},
-        context: { path: args.path },
-        run: async (signal) => {
-            const result = await handleWriteFile(args, signal);
-            void ctx.log?.('info', `write: ${args.path} (${String(result.structuredContent.bytesWritten ?? 0)} bytes)`);
-            return result;
-        },
-        onError: (error) => buildToolErrorResponse(error, ErrorCode.UNKNOWN, args.path),
-    });
-    registerStandardTool(server, WRITE_FILE_TOOL, handler, options, {
-        progressMessage: (args) => `${WRITE_FILE_TOOL.title}: ${basename(args.path)}`,
-        completionMessage: (args, result) => {
-            const name = basename(args.path);
-            if (result.isError)
-                return `${WRITE_FILE_TOOL.title}: ${name} • ${result.errorCode}`;
-            const sc = result.structuredContent;
-            return `${WRITE_FILE_TOOL.title}: ${name} • ${formatBytes(sc.bytesWritten ?? 0)}`;
-        },
-    });
-}

package/dist/tools.d.ts

@@ -1,5 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/server';
-import { type ToolContract } from './tools/contract.js';
-import type { ToolRegistrationOptions } from './tools/shared.js';
-export declare const ALL_TOOLS: ToolContract[];
-export declare function registerAllTools(server: McpServer, options?: ToolRegistrationOptions): void;

package/dist/tools.js

@@ -1,54 +0,0 @@
-import { APPLY_PATCH_TOOL, registerApplyPatchTool, } from './tools/apply-patch.js';
-import { CALCULATE_HASH_TOOL, registerCalculateHashTool, } from './tools/calculate-hash.js';
-import {} from './tools/contract.js';
-import { CREATE_DIRECTORY_TOOL, registerCreateDirectoryTool, } from './tools/create-directory.js';
-import { DELETE_FILE_TOOL, registerDeleteFileTool, } from './tools/delete-file.js';
-import { DIFF_FILES_TOOL, registerDiffFilesTool } from './tools/diff-files.js';
-import { EDIT_FILE_TOOL, registerEditFileTool } from './tools/edit-file.js';
-import { LIST_DIRECTORY_TOOL, registerListDirectoryTool, } from './tools/list-directory.js';
-import { MOVE_FILE_TOOL, registerMoveFileTool } from './tools/move-file.js';
-import { READ_MANY_TOOL, registerReadMultipleFilesTool, } from './tools/read-multiple.js';
-import { READ_FILE_TOOL, registerReadFileTool } from './tools/read.js';
-import { registerSearchAndReplaceTool, SEARCH_AND_REPLACE_TOOL, } from './tools/replace-in-files.js';
-import { LIST_ALLOWED_DIRECTORIES_TOOL, registerListAllowedDirectoriesTool, } from './tools/roots.js';
-import { registerSearchContentTool, SEARCH_CONTENT_TOOL, } from './tools/search-content.js';
-import { registerSearchFilesTool, SEARCH_FILES_TOOL, } from './tools/search-files.js';
-import { GET_MULTIPLE_FILE_INFO_TOOL, registerGetMultipleFileInfoTool, } from './tools/stat-many.js';
-import { GET_FILE_INFO_TOOL, registerGetFileInfoTool } from './tools/stat.js';
-import { registerTreeTool, TREE_TOOL } from './tools/tree.js';
-import { registerWriteFileTool, WRITE_FILE_TOOL } from './tools/write-file.js';
-const TOOL_ENTRIES = [
-    {
-        contract: LIST_ALLOWED_DIRECTORIES_TOOL,
-        register: registerListAllowedDirectoriesTool,
-    },
-    { contract: LIST_DIRECTORY_TOOL, register: registerListDirectoryTool },
-    { contract: SEARCH_FILES_TOOL, register: registerSearchFilesTool },
-    { contract: TREE_TOOL, register: registerTreeTool },
-    { contract: READ_FILE_TOOL, register: registerReadFileTool },
-    {
-        contract: READ_MANY_TOOL,
-        register: registerReadMultipleFilesTool,
-    },
-    { contract: GET_FILE_INFO_TOOL, register: registerGetFileInfoTool },
-    {
-        contract: GET_MULTIPLE_FILE_INFO_TOOL,
-        register: registerGetMultipleFileInfoTool,
-    },
-    { contract: SEARCH_CONTENT_TOOL, register: registerSearchContentTool },
-    { contract: CREATE_DIRECTORY_TOOL, register: registerCreateDirectoryTool },
-    { contract: WRITE_FILE_TOOL, register: registerWriteFileTool },
-    { contract: EDIT_FILE_TOOL, register: registerEditFileTool },
-    { contract: MOVE_FILE_TOOL, register: registerMoveFileTool },
-    { contract: DELETE_FILE_TOOL, register: registerDeleteFileTool },
-    { contract: CALCULATE_HASH_TOOL, register: registerCalculateHashTool },
-    { contract: DIFF_FILES_TOOL, register: registerDiffFilesTool },
-    { contract: APPLY_PATCH_TOOL, register: registerApplyPatchTool },
-    { contract: SEARCH_AND_REPLACE_TOOL, register: registerSearchAndReplaceTool },
-];
-export const ALL_TOOLS = TOOL_ENTRIES.map((e) => e.contract);
-export function registerAllTools(server, options = {}) {
-    for (const { register } of TOOL_ENTRIES) {
-        register(server, options);
-    }
-}