@j0hanz/filesystem-mcp 1.19.0 → 2.0.0

package/dist/tools/calculate-hash.js

@@ -1,187 +0,0 @@
-import { createHash } from 'node:crypto';
-import { createReadStream } from 'node:fs';
-import { stat } from 'node:fs/promises';
-import { basename, relative, win32 } from 'node:path';
-import { pipeline } from 'node:stream/promises';
-import { assertNotAborted, withAbort } from '../lib/abort.js';
-import { PARALLEL_CONCURRENCY } from '../lib/constants.js';
-import { classifyError, ErrorCode } from '../lib/errors.js';
-import { isIgnoredByGitignore, loadRootGitignore, } from '../lib/file-operations/core.js';
-import { globEntries } from '../lib/file-operations/traversal.js';
-import { validateExistingPath } from '../lib/paths.js';
-import { CalculateHashInputSchema, CalculateHashOutputSchema, } from '../schemas.js';
-import { FILE_READ_ICONS } from './icons.js';
-import { buildToolErrorResponse, buildToolResponse, createToolProgressSession, executeToolWithDiagnostics, READ_ONLY_TOOL_ANNOTATIONS, resolveFinalProgressCurrent, } from './shared.js';
-import { registerStandardTool } from './task-support.js';
-const WINDOWS_PATH_SEPARATOR = /\\/gu;
-export const CALCULATE_HASH_TOOL = {
-    name: 'calculate_hash',
-    title: 'Calculate Hash',
-    description: 'Calculate SHA-256 hash of a file or directory.',
-    inputSchema: CalculateHashInputSchema,
-    outputSchema: CalculateHashOutputSchema,
-    annotations: READ_ONLY_TOOL_ANNOTATIONS,
-    icons: FILE_READ_ICONS,
-    nuances: [
-        'Directory hashing respects root `.gitignore` and sorts paths for stable output.',
-    ],
-    taskSupport: 'optional',
-};
-async function hashFile(filePath, encoding, signal) {
-    const hasher = createHash('sha256');
-    await pipeline(createReadStream(filePath, { signal, highWaterMark: 64 * 1024 }), hasher, { signal });
-    return encoding ? hasher.digest(encoding) : hasher.digest();
-}
-function toStableRelativePath(root, entryPath) {
-    const relativePath = relative(root, entryPath);
-    return relativePath.includes(win32.sep)
-        ? relativePath.replace(WINDOWS_PATH_SEPARATOR, '/')
-        : relativePath;
-}
-function comparePaths(left, right) {
-    if (left.path < right.path)
-        return -1;
-    if (left.path > right.path)
-        return 1;
-    return 0;
-}
-function updateCompositeHash(hasher, pathLengthBytes, relativePath, fileHash) {
-    const relativePathBytes = Buffer.from(relativePath, 'utf8');
-    pathLengthBytes.writeUInt32BE(relativePathBytes.length, 0);
-    hasher.update(pathLengthBytes);
-    hasher.update(relativePathBytes);
-    hasher.update(fileHash);
-}
-async function hashDirectory(dirPath, options = {}) {
-    const { signal, onProgress } = options;
-    const gitignoreMatcher = await loadRootGitignore(dirPath, signal);
-    // Phase 1: collect all file paths that pass gitignore filtering.
-    const filteredPaths = [];
-    for await (const entry of globEntries({
-        cwd: dirPath,
-        pattern: '**/*',
-        excludePatterns: [],
-        includeHidden: false,
-        baseNameMatch: false,
-        caseSensitiveMatch: true,
-        followSymbolicLinks: false,
-        onlyFiles: true,
-        stats: false,
-        suppressErrors: true,
-    })) {
-        assertNotAborted(signal);
-        if (gitignoreMatcher &&
-            isIgnoredByGitignore(gitignoreMatcher, dirPath, entry.path)) {
-            continue;
-        }
-        filteredPaths.push({
-            filePath: entry.path,
-            relativePath: toStableRelativePath(dirPath, entry.path),
-        });
-    }
-    assertNotAborted(signal);
-    const concurrency = Math.min(PARALLEL_CONCURRENCY, 8);
-    const entries = [];
-    let filesHashed = 0;
-    const totalFiles = filteredPaths.length;
-    const taskQueue = filteredPaths;
-    const worker = async () => {
-        while (taskQueue.length > 0) {
-            const task = taskQueue.pop();
-            if (!task)
-                break;
-            assertNotAborted(signal);
-            const fileHash = await hashFile(task.filePath, undefined, signal);
-            entries.push({ path: task.relativePath, hash: fileHash });
-            filesHashed++;
-            onProgress?.({ current: filesHashed, total: totalFiles });
-        }
-    };
-    await Promise.all(Array.from({ length: concurrency }, () => worker()));
-    onProgress?.({ current: filesHashed, total: totalFiles });
-    assertNotAborted(signal);
-    // Sort by path with byte-wise semantics for deterministic ordering.
-    entries.sort(comparePaths);
-    // Create composite hash using length-delimited paths and binary digests.
-    const compositeHasher = createHash('sha256');
-    const pathLengthBytes = Buffer.allocUnsafe(4);
-    for (const { path: filePath, hash: fileHash } of entries) {
-        updateCompositeHash(compositeHasher, pathLengthBytes, filePath, fileHash);
-        assertNotAborted(signal);
-    }
-    return {
-        hash: compositeHasher.digest('hex'),
-        fileCount: entries.length,
-    };
-}
-async function handleCalculateHash(args, signal, onProgress) {
-    const validPath = await validateExistingPath(args.path, signal);
-    // Check if path is a directory or file
-    const stats = await withAbort(stat(validPath), signal);
-    if (stats.isDirectory()) {
-        // Hash directory: composite hash of all files
-        const { hash, fileCount } = await hashDirectory(validPath, {
-            ...(signal ? { signal } : {}),
-            ...(onProgress ? { onProgress } : {}),
-        });
-        return buildToolResponse(`${hash} (${fileCount} files)`, {
-            ok: true,
-            path: validPath,
-            hash,
-            isDirectory: true,
-            fileCount,
-        });
-    }
-    else {
-        // Hash single file
-        const hash = await hashFile(validPath, 'hex', signal);
-        onProgress?.({ current: 1 });
-        return buildToolResponse(hash, {
-            ok: true,
-            path: validPath,
-            hash,
-            isDirectory: false,
-        });
-    }
-}
-export function registerCalculateHashTool(server, options = {}) {
-    const handler = (args, ctx) => executeToolWithDiagnostics({
-        toolName: 'calculate_hash',
-        ctx,
-        outputSchema: CalculateHashOutputSchema,
-        timedSignal: {},
-        context: { path: args.path },
-        run: async (signal) => {
-            const baseName = basename(args.path);
-            const progress = createToolProgressSession(ctx, `${CALCULATE_HASH_TOOL.title}: ${baseName}`);
-            const progressWithMessage = ({ current, total, }) => {
-                progress.update({
-                    current,
-                    ...(total !== undefined ? { total } : {}),
-                    message: `${CALCULATE_HASH_TOOL.title}: ${baseName} [${current} files]`,
-                });
-            };
-            try {
-                const result = await handleCalculateHash(args, signal, progressWithMessage);
-                const sc = result.structuredContent;
-                const totalFiles = sc.fileCount ?? 1;
-                const finalCurrent = resolveFinalProgressCurrent(progress, totalFiles + 1);
-                let suffix;
-                if (sc.fileCount !== undefined && sc.fileCount > 1) {
-                    suffix = `${sc.fileCount} files • ${(sc.hash ?? '').slice(0, 8)}…`;
-                }
-                else {
-                    suffix = `${(sc.hash ?? '').slice(0, 8)}…`;
-                }
-                progress.complete(`${CALCULATE_HASH_TOOL.title}: ${baseName} • ${suffix}`, finalCurrent);
-                return result;
-            }
-            catch (error) {
-                progress.fail(`${CALCULATE_HASH_TOOL.title}: ${baseName} • ${classifyError(error)}`);
-                throw error;
-            }
-        },
-        onError: (error) => buildToolErrorResponse(error, ErrorCode.UNKNOWN, args.path),
-    });
-    registerStandardTool(server, CALCULATE_HASH_TOOL, handler, options);
-}

package/dist/tools/contract.d.ts

@@ -1,50 +0,0 @@
-import type { Icon } from '@modelcontextprotocol/server';
-import type { ZodType } from 'zod';
-export interface ToolContract {
-    /**
-     * The unique name of the tool (e.g., "read", "grep").
-     * This name is used in registration and client calls.
-     */
-    name: string;
-    /**
-     * A short human-readable title for documentation (e.g., "Read File").
-     */
-    title: string;
-    /**
-     * A detailed description of what the tool does.
-     */
-    description: string;
-    /**
-     * Zod schema for the tool's input arguments.
-     */
-    inputSchema: ZodType;
-    /**
-     * Zod schema for the tool's output result (optional).
-     */
-    outputSchema?: ZodType;
-    /**
-     * Optional annotations for tool behavior hints.
-     */
-    annotations?: {
-        readOnlyHint?: boolean;
-        idempotentHint?: boolean;
-        destructiveHint?: boolean;
-        openWorldHint?: boolean;
-    };
-    /**
-     * Specific usage nuances or edge cases for documentation.
-     */
-    nuances?: string[];
-    /**
-     * Common pitfalls or warnings for documentation.
-     */
-    gotchas?: string[];
-    /**
-     * Optional icons for display in user interfaces.
-     */
-    icons?: Icon[];
-    /**
-     * Task support level for the tool. Defaults to 'forbidden'.
-     */
-    taskSupport?: 'optional' | 'required' | 'forbidden';
-}

package/dist/tools/contract.js

@@ -1 +0,0 @@
-export {};

package/dist/tools/create-directory.d.ts

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

package/dist/tools/create-directory.js

@@ -1,68 +0,0 @@
-import { mkdir } from 'node:fs/promises';
-import { basename } from 'node:path';
-import { withAbort } from '../lib/abort.js';
-import { ErrorCode, McpError } from '../lib/errors.js';
-import { validatePathForWrite } from '../lib/paths.js';
-import { CreateDirectoryInputSchema, CreateDirectoryOutputSchema, } from '../schemas.js';
-import { DIR_CREATE_ICONS } from './icons.js';
-import { buildToolErrorResponse, buildToolResponse, executeToolWithDiagnostics, IDEMPOTENT_WRITE_TOOL_ANNOTATIONS, } from './shared.js';
-import { registerStandardTool } from './task-support.js';
-export const CREATE_DIRECTORY_TOOL = {
-    name: 'mkdir',
-    title: 'Create Directory',
-    description: 'Create a new directory at the specified path (recursive).',
-    inputSchema: CreateDirectoryInputSchema,
-    outputSchema: CreateDirectoryOutputSchema,
-    annotations: IDEMPOTENT_WRITE_TOOL_ANNOTATIONS,
-    icons: DIR_CREATE_ICONS,
-    taskSupport: 'forbidden',
-};
-async function handleCreateDirectory(args, signal) {
-    const allPaths = [];
-    if (args.path)
-        allPaths.push(args.path);
-    if (args.paths)
-        allPaths.push(...args.paths);
-    if (allPaths.length === 0) {
-        throw new McpError(ErrorCode.INVALID_INPUT, 'No paths provided to create.');
-    }
-    const validPaths = await Promise.all(allPaths.map((p) => validatePathForWrite(p, signal)));
-    await Promise.all(validPaths.map((p) => withAbort(mkdir(p, { recursive: true }), signal)));
-    const createdPath = validPaths.length === 1 ? validPaths[0] : undefined;
-    return buildToolResponse(`Successfully created ${validPaths.length} director${validPaths.length === 1 ? 'y' : 'ies'}`, {
-        ok: true,
-        ...(createdPath ? { path: createdPath } : {}),
-        paths: validPaths,
-    });
-}
-export function registerCreateDirectoryTool(server, options = {}) {
-    const handler = (args, ctx) => executeToolWithDiagnostics({
-        toolName: 'mkdir',
-        ctx,
-        outputSchema: CreateDirectoryOutputSchema,
-        timedSignal: {},
-        context: { path: args.path ?? args.paths?.[0] },
-        run: (signal) => handleCreateDirectory(args, signal),
-        onError: (error) => buildToolErrorResponse(error, ErrorCode.UNKNOWN, args.path ?? args.paths?.[0]),
-    });
-    registerStandardTool(server, CREATE_DIRECTORY_TOOL, handler, options, {
-        progressMessage: (args) => {
-            if (args.path && !args.paths?.length) {
-                return `${CREATE_DIRECTORY_TOOL.title}: ${basename(args.path)}`;
-            }
-            const count = (args.path ? 1 : 0) + (args.paths?.length ?? 0);
-            return `${CREATE_DIRECTORY_TOOL.title}: ${count} directories`;
-        },
-        completionMessage: (args, result) => {
-            if (args.path && !args.paths?.length) {
-                const name = basename(args.path);
-                if (result.isError)
-                    return `${CREATE_DIRECTORY_TOOL.title}: ${name} • ${result.errorCode}`;
-            }
-            const count = (args.path ? 1 : 0) + (args.paths?.length ?? 0);
-            if (result.isError)
-                return `${CREATE_DIRECTORY_TOOL.title}: ${count} directories • ${result.errorCode}`;
-            return `${CREATE_DIRECTORY_TOOL.title}: ${count} directories`;
-        },
-    });
-}

package/dist/tools/diff-files.d.ts

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

package/dist/tools/diff-files.js

@@ -1,136 +0,0 @@
-import { readFile, stat } from 'node:fs/promises';
-import { basename } from 'node:path';
-import { formatPatch, structuredPatch } from 'diff';
-import { withAbort } from '../lib/abort.js';
-import { MAX_TEXT_FILE_SIZE } from '../lib/constants.js';
-import { ErrorCode, McpError } from '../lib/errors.js';
-import { validateExistingPath } from '../lib/paths.js';
-import { DiffFilesInputSchema, DiffFilesOutputSchema } from '../schemas.js';
-import { FILE_READ_ICONS } from './icons.js';
-import { buildResourceLink, buildToolErrorResponse, buildToolResponse, executeToolWithDiagnostics, maybeExternalizeTextContent, READ_ONLY_TOOL_ANNOTATIONS, } from './shared.js';
-import { registerStandardTool } from './task-support.js';
-export const DIFF_FILES_TOOL = {
-    name: 'diff_files',
-    title: 'Diff Files',
-    description: 'Generate a unified diff between two files. ' +
-        'Output feeds directly into `apply_patch`. ' +
-        '`isIdentical=true` means files match \u2014 no patch needed.',
-    inputSchema: DiffFilesInputSchema,
-    outputSchema: DiffFilesOutputSchema,
-    annotations: READ_ONLY_TOOL_ANNOTATIONS,
-    icons: FILE_READ_ICONS,
-    taskSupport: 'optional',
-};
-function computeDiffStats(hunks) {
-    let linesAdded = 0;
-    let linesRemoved = 0;
-    for (const hunk of hunks) {
-        for (const line of hunk.lines) {
-            if (line.startsWith('+') && !line.startsWith('+++'))
-                linesAdded++;
-            else if (line.startsWith('-') && !line.startsWith('---'))
-                linesRemoved++;
-        }
-    }
-    return { linesAdded, linesRemoved, hunksCount: hunks.length };
-}
-function assertDiffFileSizeWithinLimit(filePath, size, maxFileSize) {
-    if (size <= maxFileSize)
-        return;
-    throw new McpError(ErrorCode.TOO_LARGE, `File too large for diff (${size} bytes > ${maxFileSize} bytes).`, filePath, { size, maxFileSize });
-}
-async function handleDiffFiles(args, signal, resourceStore) {
-    const maxFileSize = MAX_TEXT_FILE_SIZE;
-    const [originalPath, modifiedPath] = await Promise.all([
-        validateExistingPath(args.original, signal),
-        validateExistingPath(args.modified, signal),
-    ]);
-    const [originalStats, modifiedStats] = await Promise.all([
-        withAbort(stat(originalPath), signal),
-        withAbort(stat(modifiedPath), signal),
-    ]);
-    assertDiffFileSizeWithinLimit(originalPath, originalStats.size, maxFileSize);
-    assertDiffFileSizeWithinLimit(modifiedPath, modifiedStats.size, maxFileSize);
-    const [originalContent, modifiedContent] = await Promise.all([
-        readFile(originalPath, { encoding: 'utf-8', signal }),
-        readFile(modifiedPath, { encoding: 'utf-8', signal }),
-    ]);
-    const patchObj = await new Promise((resolve) => {
-        structuredPatch(basename(originalPath), basename(modifiedPath), originalContent, modifiedContent, undefined, undefined, {
-            ...(args.context !== undefined ? { context: args.context } : {}),
-            ignoreWhitespace: args.ignoreWhitespace,
-            stripTrailingCr: args.stripTrailingCr,
-            timeout: 10000,
-            callback: (res) => {
-                resolve(res);
-            },
-        });
-    });
-    if (!patchObj) {
-        throw new McpError(ErrorCode.TIMEOUT, `Diff timed out or too complex.`, originalPath);
-    }
-    const isIdentical = patchObj.hunks.length === 0;
-    const diffText = isIdentical ? '' : formatPatch(patchObj);
-    const stats = isIdentical ? undefined : computeDiffStats(patchObj.hunks);
-    const externalized = maybeExternalizeTextContent(resourceStore, diffText, {
-        name: 'diff:patch',
-        mimeType: 'text/x-diff',
-    });
-    if (!externalized) {
-        return buildToolResponse(isIdentical ? 'No differences' : diffText, {
-            ok: true,
-            diff: diffText,
-            isIdentical,
-            ...(stats ?? {}),
-        });
-    }
-    const { preview, entry } = externalized;
-    return buildToolResponse(preview, {
-        ok: true,
-        diff: preview,
-        isIdentical,
-        ...(stats ?? {}),
-        truncated: true,
-        resourceUri: entry.uri,
-    }, [
-        buildResourceLink({
-            uri: entry.uri,
-            name: entry.name,
-            mimeType: entry.mimeType,
-            description: 'Full diff content',
-            expiresAt: entry.expiresAt,
-        }),
-    ]);
-}
-export function registerDiffFilesTool(server, options = {}) {
-    const handler = (args, ctx) => executeToolWithDiagnostics({
-        toolName: 'diff_files',
-        ctx,
-        outputSchema: DiffFilesOutputSchema,
-        timedSignal: {},
-        context: { path: args.original },
-        run: (signal) => handleDiffFiles(args, signal, options.resourceStore),
-        onError: (error) => buildToolErrorResponse(error, ErrorCode.UNKNOWN, args.original),
-    });
-    registerStandardTool(server, DIFF_FILES_TOOL, handler, options, {
-        progressMessage: (args) => {
-            const n1 = basename(args.original);
-            const n2 = basename(args.modified);
-            return `${DIFF_FILES_TOOL.title}: ${n1} ⟷ ${n2}`;
-        },
-        completionMessage: (args, result) => {
-            const n1 = basename(args.original);
-            const n2 = basename(args.modified);
-            if (result.isError)
-                return `${DIFF_FILES_TOOL.title}: ${n1} ⟷ ${n2} • ${result.errorCode}`;
-            const sc = result.structuredContent;
-            if (sc.isIdentical)
-                return `${DIFF_FILES_TOOL.title}: ${n1} ⟷ ${n2} • identical`;
-            const added = sc.linesAdded ?? 0;
-            const removed = sc.linesRemoved ?? 0;
-            if (added > 0 || removed > 0)
-                return `${DIFF_FILES_TOOL.title}: ${n1} ⟷ ${n2} • +${added} -${removed}`;
-            return `${DIFF_FILES_TOOL.title}: ${n1} ⟷ ${n2}`;
-        },
-    });
-}

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

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