@j0hanz/filesystem-mcp 1.1.0 → 1.1.2

package/README.md

@@ -137,6 +137,15 @@ The server communicates via `stdio`. Ensure your MCP client is configured to run
 | `apply_patch`        | Apply unified patch                 | `path`, `patch`                               |
 | `search_and_replace` | Search & replace across files       | `filePattern`, `searchPattern`, `replacement` |
 
+### Behavioral Notes
+
+- `rm` with `recursive: false`:
+  - Deletes files and empty directories.
+  - Returns `E_INVALID_INPUT` for non-empty directories with guidance to use `recursive: true`.
+- `includeIgnored: false` (default) for navigation/search tools:
+  - Excludes common generated/vendor directories such as `node_modules`, `dist`, `.git`, and similar patterns.
+  - Set `includeIgnored: true` to include those entries.
+
 ### Resources
 
 | URI Pattern                    | Description                                      |
@@ -252,6 +261,12 @@ args = ["-y", "@j0hanz/filesystem-mcp@latest", "${workspaceFolder}"]
 - **Path Restrictions**: All file operations are strictly validated against the allowed root directories provided at startup.
 - **Path Validation**: Uses `isPathWithinDirectories` to prevent path traversal attacks.
 - **Hidden Files**: Hidden files (starting with `.`) are excluded by default in listings and searches unless explicitly requested.
+- **Ignored Directories**: Ignored directories (for example `node_modules`, `.git`, `dist`) are excluded by default unless `includeIgnored=true`.
+
+## Testing Notes
+
+- For protocol-level validation, prefer an MCP SDK client (`listTools`, `listResources`, `listPrompts`, `callTool`, `readResource`) as source-of-truth.
+- Some third-party MCP CLIs may have URI parsing limitations when reading resources; if this happens, verify resource behavior through SDK client calls.
 
 ## Development Workflow
 

package/dist/lib/constants.js

@@ -146,24 +146,42 @@ export const KNOWN_BINARY_EXTENSIONS = new Set([
     '.dat',
 ]);
 export const DEFAULT_EXCLUDE_PATTERNS = [
+    '**/node_modules',
     '**/node_modules/**',
+    '**/dist',
     '**/dist/**',
+    '**/build',
     '**/build/**',
+    '**/coverage',
     '**/coverage/**',
+    '**/.git',
     '**/.git/**',
+    '**/.vscode',
     '**/.vscode/**',
+    '**/.idea',
     '**/.idea/**',
     '**/.DS_Store',
+    '**/.next',
     '**/.next/**',
+    '**/.nuxt',
     '**/.nuxt/**',
+    '**/.output',
     '**/.output/**',
+    '**/.svelte-kit',
     '**/.svelte-kit/**',
+    '**/.cache',
     '**/.cache/**',
+    '**/.yarn',
     '**/.yarn/**',
+    '**/jspm_packages',
     '**/jspm_packages/**',
+    '**/bower_components',
     '**/bower_components/**',
+    '**/out',
     '**/out/**',
+    '**/tmp',
     '**/tmp/**',
+    '**/.temp',
     '**/.temp/**',
     '**/npm-debug.log',
     '**/yarn-debug.log',

package/dist/schemas.d.ts

@@ -403,6 +403,7 @@ export declare const EditFileOutputSchema: z.ZodObject<{
     ok: z.ZodBoolean;
     path: z.ZodOptional<z.ZodString>;
     appliedEdits: z.ZodOptional<z.ZodNumber>;
+    lineRange: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
     unmatchedEdits: z.ZodOptional<z.ZodArray<z.ZodString>>;
     error: z.ZodOptional<z.ZodObject<{
         code: z.ZodEnum<{

package/dist/schemas.js

@@ -510,6 +510,10 @@ export const EditFileOutputSchema = z.object({
     ok: z.boolean(),
     path: z.string().optional(),
     appliedEdits: z.number().optional(),
+    lineRange: z
+        .tuple([z.number(), z.number()])
+        .optional()
+        .describe('Line range modified [start, end] (1-based)'),
     unmatchedEdits: z
         .array(z.string())
         .optional()

package/dist/tools/apply-patch.js

@@ -45,7 +45,7 @@ async function handleApplyPatch(args, signal) {
         autoConvertLineEndings: args.autoConvertLineEndings,
     });
     if (patched === false) {
-        throw new McpError(ErrorCode.E_INVALID_INPUT, `Patch application failed. The file content may have changed or the patch context is insufficient. Try enable fuzzy matching.`);
+        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).');
     }
     if (args.dryRun) {
         return buildToolResponse('Dry run successful. Patch can be applied.', {

package/dist/tools/delete-file.js

@@ -19,10 +19,32 @@ const DELETE_FILE_TOOL = {
 };
 async function handleDeleteFile(args, signal) {
     const validPath = await validatePathForWrite(args.path, signal);
-    await withAbort(fs.rm(validPath, {
-        recursive: args.recursive,
-        force: args.ignoreIfNotExists,
-    }), signal);
+    let stats;
+    try {
+        stats = await withAbort(fs.lstat(validPath), signal);
+    }
+    catch (error) {
+        if (isNodeError(error) &&
+            error.code === 'ENOENT' &&
+            args.ignoreIfNotExists) {
+            return buildToolResponse(`Successfully deleted: ${args.path}`, {
+                ok: true,
+                path: validPath,
+            });
+        }
+        throw error;
+    }
+    if (stats.isDirectory() && !args.recursive) {
+        // Use rmdir for non-recursive directory deletes so non-empty directories
+        // consistently return ENOTEMPTY-style errors with actionable guidance.
+        await withAbort(fs.rmdir(validPath), signal);
+    }
+    else {
+        await withAbort(fs.rm(validPath, {
+            recursive: args.recursive,
+            force: args.ignoreIfNotExists,
+        }), signal);
+    }
     return buildToolResponse(`Successfully deleted: ${args.path}`, {
         ok: true,
         path: validPath,
@@ -45,6 +67,12 @@ export function registerDeleteFileTool(server, options = {}) {
             if (error.code === 'ENOTEMPTY') {
                 return buildToolErrorResponse(new Error(`Directory is not empty: ${args.path}. Use recursive: true to delete non-empty directories.`), ErrorCode.E_INVALID_INPUT, args.path);
             }
+            if (error.code === 'EISDIR') {
+                return buildToolErrorResponse(new Error(`Path is a directory: ${args.path}. Use recursive: true to delete directories.`), ErrorCode.E_INVALID_INPUT, args.path);
+            }
+            if (error.code === 'EEXIST') {
+                return buildToolErrorResponse(new Error(`Directory is not empty: ${args.path}. Use recursive: true to delete non-empty directories.`), ErrorCode.E_INVALID_INPUT, args.path);
+            }
             if (error.code === 'EPERM' || error.code === 'EACCES') {
                 return buildToolErrorResponse(error, ErrorCode.E_PERMISSION_DENIED, args.path);
             }

package/dist/tools/edit-file.js

@@ -21,25 +21,45 @@ function applyEdits(content, edits) {
     let newContent = content;
     let appliedEdits = 0;
     const unmatchedEdits = [];
+    let minLine;
+    let maxLine;
     for (const edit of edits) {
         if (!newContent.includes(edit.oldText)) {
             unmatchedEdits.push(edit.oldText);
             continue;
         }
+        const index = newContent.indexOf(edit.oldText);
+        const linesBefore = newContent.slice(0, index).split('\n').length;
+        const newTextLines = edit.newText.split('\n').length;
+        const startLine = linesBefore;
+        const endLine = linesBefore + newTextLines - 1;
+        if (minLine === undefined || startLine < minLine)
+            minLine = startLine;
+        if (maxLine === undefined || endLine > maxLine)
+            maxLine = endLine;
         newContent = newContent.replace(edit.oldText, edit.newText);
         appliedEdits += 1;
     }
-    return { content: newContent, appliedEdits, unmatchedEdits };
+    const result = {
+        content: newContent,
+        appliedEdits,
+        unmatchedEdits,
+    };
+    if (minLine !== undefined && maxLine !== undefined) {
+        result.lineRange = [minLine, maxLine];
+    }
+    return result;
 }
 async function handleEditFile(args, signal) {
     const validPath = await validateExistingPath(args.path, signal);
     const content = await fs.readFile(validPath, { encoding: 'utf-8', signal });
-    const { content: newContent, appliedEdits, unmatchedEdits, } = applyEdits(content, args.edits);
+    const { content: newContent, appliedEdits, unmatchedEdits, lineRange, } = applyEdits(content, args.edits);
     const structured = {
         ok: true,
         path: validPath,
         appliedEdits,
         ...(unmatchedEdits.length > 0 ? { unmatchedEdits } : {}),
+        ...(lineRange ? { lineRange } : {}),
     };
     if (args.dryRun) {
         return buildToolResponse(`Dry run complete. ${appliedEdits} edits would be applied.`, structured);
@@ -68,5 +88,17 @@ export function registerEditFileTool(server, options = {}) {
             const name = path.basename(args.path);
             return `🛠 edit: ${name} (${args.edits.length} edits)`;
         },
+        completionMessage: (args, result) => {
+            const name = path.basename(args.path);
+            if (result.isError)
+                return `🛠 edit: ${name} ➟ Failed`;
+            const sc = result.structuredContent;
+            if (!sc.ok)
+                return `🛠 edit: ${name} ➟ Failed`;
+            if (sc.lineRange) {
+                return `🛠 edit: ${name} ➟ [${sc.lineRange[0]}-${sc.lineRange[1]}]`;
+            }
+            return `🛠 edit: ${name} ➟ (${sc.appliedEdits ?? 0} edits)`;
+        },
     }));
 }

package/dist/tools/search-content.js

@@ -202,7 +202,17 @@ export function registerSearchContentTool(server, options = {}) {
         });
         const result = await handleSearchContent(normalizedArgs, extra.signal, options.resourceStore, createProgressReporter(extra));
         const sc = result.structuredContent;
-        const suffix = sc.ok && sc.totalMatches ? String(sc.totalMatches) : 'No matches';
+        const count = sc.ok && sc.totalMatches ? sc.totalMatches : 0;
+        let suffix;
+        if (count === 0) {
+            suffix = 'No matches';
+        }
+        else if (count === 1) {
+            suffix = '1 match';
+        }
+        else {
+            suffix = `${count} matches`;
+        }
         const finalCurrent = (sc.filesScanned ?? 0) + 1;
         notifyProgress(extra, {
             current: finalCurrent,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@j0hanz/filesystem-mcp",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "mcpName": "io.github.j0hanz/filesystem-mcp",
   "description": "MCP Server that enables LLMs to interact with the local filesystem.",
   "type": "module",