@j0hanz/filesystem-mcp 1.13.0 → 1.13.1

package/dist/completions.js

@@ -47,6 +47,9 @@ const PATH_ARGUMENTS = new Set([
 const DESTINATION_CONTEXT_KEYS = ['source', 'path', 'cwd', 'root'];
 const PRIMARY_PATH_CONTEXT_KEYS = ['path', 'cwd', 'root'];
 const DEFAULT_CONTEXT_KEYS = ['path', 'source', 'cwd', 'root'];
+const ENUM_ARGUMENT_VALUES = new Map([
+    ['sortby', ['modified', 'name', 'path', 'size', 'type']],
+]);
 function isPathLikeArgumentName(argName) {
     return (PATH_ARGUMENTS.has(argName) ||
         argName.endsWith('paths') ||
@@ -56,6 +59,16 @@ function isPathLikeArgumentName(argName) {
         argName.endsWith('dirs') ||
         argName.endsWith('dir'));
 }
+function getEnumCompletions(argName, currentValue) {
+    const values = ENUM_ARGUMENT_VALUES.get(argName);
+    if (!values)
+        return undefined;
+    const prefix = currentValue.toLowerCase();
+    const filtered = prefix
+        ? values.filter((v) => v.startsWith(prefix))
+        : [...values];
+    return buildCompletionResult(filtered);
+}
 function isTemplateVariableChar(char) {
     const code = char.charCodeAt(0);
     const isDigit = code >= 48 && code <= 57;
@@ -452,6 +465,10 @@ export function registerCompletions(server, instructions = '') {
                 : toolNameValues;
             return buildCompletionResponse(buildCompletionResult(filtered));
         }
+        const enumResult = getEnumCompletions(argName, argument.value);
+        if (enumResult) {
+            return buildCompletionResponse(enumResult);
+        }
         const isPathArg = isPathLikeArgumentName(argName) ||
             isPathArgumentFromReference(argName, ref);
         if (!isPathArg) {

package/dist/tools/edit-file.js

@@ -185,7 +185,7 @@ function buildEditCompletionMessage(args, result) {
     const added = structuredContent.linesAdded ?? 0;
     const removed = structuredContent.linesRemoved ?? 0;
     const dry = args.dryRun ? 'dry run ' : '';
-    return `🛠 edit: ${name} • ${dry}+${added} -${removed}`;
+    return `🛠 edit: ${name} • ${dry} +${added} -${removed}`;
 }
 async function applyEdits(content, edits, ignoreWhitespace) {
     let newContent = content;

package/dist/tools/replace-in-files.js

@@ -1,6 +1,8 @@
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
+import { AsyncLocalStorage } from 'node:async_hooks';
 import { Buffer } from 'node:buffer';
+import { performance } from 'node:perf_hooks';
 import { createTwoFilesPatch } from 'diff';
 import RE2 from 're2';
 import safeRegex from 'safe-regex2';
@@ -110,6 +112,13 @@ class LiteralReplacementMatcher {
         return content.replaceAll(this.searchPattern, () => replacement);
     }
 }
+const replaceContextStorage = new AsyncLocalStorage();
+function getReplaceContext() {
+    const ctx = replaceContextStorage.getStore();
+    if (!ctx)
+        throw new Error('Replace context not found in AsyncLocalStorage');
+    return ctx;
+}
 function buildReplacementPlan(content, replacement, matcher) {
     const matchCount = matcher.count(content);
     if (matchCount === 0) {
@@ -124,8 +133,8 @@ function buildReplacementPlan(content, replacement, matcher) {
 function formatFileTooLargeError(filePath, size, maxFileSize) {
     return `File too large: ${filePath} (${size} bytes > ${maxFileSize} bytes)`;
 }
-async function processEntry(entryPath, context) {
-    const { options, replacement, matcher, maxFileSize, signal, summary } = context;
+async function processEntry(entryPath) {
+    const { options, signal, summary } = getReplaceContext();
     let validPath;
     try {
         validPath = await validatePathForWrite(entryPath, signal);
@@ -139,12 +148,7 @@ async function processEntry(entryPath, context) {
         return;
     }
     try {
-        const plan = await readReplacementPlan(validPath, {
-            matcher,
-            replacement,
-            maxFileSize,
-            signal,
-        });
+        const plan = await readReplacementPlan(validPath);
         if (!plan) {
             return;
         }
@@ -172,19 +176,20 @@ async function processEntry(entryPath, context) {
         });
     }
 }
-async function readReplacementPlan(validPath, context) {
+async function readReplacementPlan(validPath) {
+    const { matcher, replacement, maxFileSize, signal } = getReplaceContext();
     let fileHandle;
     try {
         const fd = await fs.open(validPath, 'r');
         fileHandle = fd;
         const stats = await fileHandle.stat();
-        if (stats.size > context.maxFileSize) {
-            throw new Error(formatFileTooLargeError(validPath, stats.size, context.maxFileSize));
+        if (stats.size > maxFileSize) {
+            throw new Error(formatFileTooLargeError(validPath, stats.size, maxFileSize));
         }
         let content;
-        if (context.matcher.testBuffer) {
-            const buffer = await fileHandle.readFile({ signal: context.signal });
-            if (!context.matcher.testBuffer(buffer)) {
+        if (matcher.testBuffer) {
+            const buffer = await fileHandle.readFile({ signal });
+            if (!matcher.testBuffer(buffer)) {
                 return undefined;
             }
             content = buffer.toString('utf-8');
@@ -192,10 +197,10 @@ async function readReplacementPlan(validPath, context) {
         else {
             content = await fileHandle.readFile({
                 encoding: 'utf-8',
-                signal: context.signal,
+                signal,
             });
         }
-        return buildReplacementPlan(content, context.replacement, context.matcher);
+        return buildReplacementPlan(content, replacement, matcher);
     }
     finally {
         if (fileHandle) {
@@ -211,10 +216,13 @@ async function maybeAppendPatchDiff(summary, params) {
         return;
     }
     const patch = await new Promise((resolve) => {
-        createTwoFilesPatch(path.basename(params.filePath), path.basename(params.filePath), params.originalContent, params.updatedContent, 'Original', 'Modified', {
-            callback: (res) => {
-                resolve(res ?? '');
-            },
+        // Defer to event loop to avoid blocking on large diffs
+        setImmediate(() => {
+            createTwoFilesPatch(path.basename(params.filePath), path.basename(params.filePath), params.originalContent, params.updatedContent, 'Original', 'Modified', {
+                callback: (res) => {
+                    resolve(res ?? '');
+                },
+            });
         });
     });
     if (summary.diff.length + patch.length <=
@@ -315,7 +323,22 @@ export async function handleSearchAndReplace(args, signal, onProgress = () => {
         suppressErrors: true,
     });
     const summary = createReplaceSummary(root);
-    const { stoppedByLimit } = await processEntriesConcurrently(entries, {
+    const timerStartName = `searchAndReplaceStart_${Date.now()}`;
+    const timerEndName = `searchAndReplaceEnd_${Date.now()}`;
+    const metricName = `searchAndReplace_${Date.now()}`;
+    performance.mark(timerStartName);
+    const context = {
+        options: {
+            dryRun: args.dryRun,
+            returnDiff: args.returnDiff ?? false,
+        },
+        replacement: args.replacement,
+        matcher,
+        maxFileSize,
+        signal,
+        summary,
+    };
+    const { stoppedByLimit } = await replaceContextStorage.run(context, () => processEntriesConcurrently(entries, {
         signal,
         concurrency: REPLACE_CONCURRENCY,
         ...(args.maxFiles !== undefined ? { maxEntries: args.maxFiles } : {}),
@@ -325,18 +348,15 @@ export async function handleSearchAndReplace(args, signal, onProgress = () => {
                 throttleModulo: 25,
             });
         },
-        runEntry: async (entryPath) => processEntry(entryPath, {
-            options: {
-                dryRun: args.dryRun,
-                returnDiff: args.returnDiff ?? false,
-            },
-            replacement: args.replacement,
-            matcher,
-            maxFileSize,
-            signal,
-            summary,
-        }),
-    });
+        runEntry: processEntry,
+    }));
+    performance.mark(timerEndName);
+    performance.measure(metricName, timerStartName, timerEndName);
+    const durationMs = performance.getEntriesByName(metricName)[0]?.duration ?? 0;
+    performance.clearMarks(timerStartName);
+    performance.clearMarks(timerEndName);
+    performance.clearMeasures(metricName);
+    summary.perfTimeMs = durationMs;
     if (stoppedByLimit) {
         summary.stoppedReason = 'maxFiles';
     }
@@ -394,7 +414,10 @@ export function registerSearchAndReplaceTool(server, options = {}) {
 function buildSearchAndReplaceText(summary, dryRun) {
     const failureSuffix = summary.failedFiles > 0 ? ` (${summary.failedFiles} failed)` : '';
     const dryRunSuffix = dryRun ? ' (Dry run)' : '';
-    return `Found ${summary.totalMatches} matches in ${summary.filesChanged} files${failureSuffix}.${dryRunSuffix}`;
+    const timing = summary.perfTimeMs
+        ? ` [\u23F1\uFE0F ${summary.perfTimeMs.toFixed(0)}ms]`
+        : '';
+    return `Found ${summary.totalMatches} matches in ${summary.filesChanged} files${failureSuffix}.${dryRunSuffix}${timing}`;
 }
 function buildSearchAndReplaceStructuredResult(summary, args) {
     return {

package/dist/tools/search-content.js

@@ -1,4 +1,5 @@
 import * as path from 'node:path';
+import { performance } from 'node:perf_hooks';
 import RE2 from 're2';
 import { DEFAULT_EXCLUDE_PATTERNS } from '../lib/constants.js';
 import { ErrorCode, formatUnknownErrorMessage, McpError, } from '../lib/errors.js';
@@ -18,6 +19,7 @@ const CONFIG = {
         maxFiles: 'max files',
     },
 };
+let searchMetricSequence = 0;
 const TRUTHY_SUMMARY_FIELDS = [
     'filesMatched',
     'skippedTooLarge',
@@ -26,15 +28,20 @@ const TRUTHY_SUMMARY_FIELDS = [
     'linesSkippedDueToRegexTimeout',
 ];
 function buildStructuredSummaryFields(summary) {
-    const truthyFields = Object.fromEntries(TRUTHY_SUMMARY_FIELDS.flatMap((key) => {
+    const result = {};
+    for (const key of TRUTHY_SUMMARY_FIELDS) {
         const value = summary[key];
-        return value ? [[key, value]] : [];
-    }));
-    return {
-        ...truthyFields,
-        ...(summary.truncated ? { truncated: true } : {}),
-        ...(summary.stoppedReason ? { stoppedReason: summary.stoppedReason } : {}),
-    };
+        if (value) {
+            result[key] = value;
+        }
+    }
+    if (summary.truncated) {
+        result.truncated = true;
+    }
+    if (summary.stoppedReason) {
+        result.stoppedReason = summary.stoppedReason;
+    }
+    return result;
 }
 function buildCompletionSuffix(count, filesMatched, scope, stoppedReason) {
     if (count === 0)
@@ -46,6 +53,15 @@ function buildCompletionSuffix(count, filesMatched, scope, stoppedReason) {
         : '';
     return `${count} ${matchWord} in ${filesMatched} ${fileWord}${reasonSuffix}`;
 }
+function createSearchMetricNames() {
+    searchMetricSequence += 1;
+    const metricSuffix = `${Date.now()}_${searchMetricSequence}`;
+    return {
+        timerStartName: `searchContentStart_${metricSuffix}`,
+        timerEndName: `searchContentEnd_${metricSuffix}`,
+        metricName: `searchContent_${metricSuffix}`,
+    };
+}
 function compareNormalizedMatches(left, right) {
     const fileCompare = left.relativeFile.localeCompare(right.relativeFile);
     if (fileCompare !== 0)
@@ -159,30 +175,11 @@ const SearchResponseBuilder = {
     buildMatchList(heading, matches) {
         if (matches.length === 0)
             return heading;
-        // Fast path: calculate exact byte length to avoid arrays and string concatenation in V8
-        // +1 for newline after heading. Each match gets: "  " (2) + relativeFile + ":" + line + ": " (2) + content + "\n"
-        let totalBytes = Buffer.byteLength(heading, 'utf8');
+        const parts = [heading];
         for (const match of matches) {
-            totalBytes +=
-                1 + // \n
-                    2 + // "  "
-                    Buffer.byteLength(match.relativeFile, 'utf8') +
-                    1 + // ":"
-                    Math.max(4, String(match.line).length) +
-                    2 + // ": "
-                    Buffer.byteLength(match.content, 'utf8');
+            parts.push(`\n  ${match.relativeFile}:${String(match.line).padStart(4)}: ${match.content}`);
         }
-        const buf = Buffer.allocUnsafe(totalBytes);
-        let offset = buf.write(heading, 0, 'utf8');
-        for (const match of matches) {
-            offset += buf.write('\n  ', offset, 'utf8');
-            offset += buf.write(match.relativeFile, offset, 'utf8');
-            offset += buf.write(':', offset, 'utf8');
-            offset += buf.write(String(match.line).padStart(4), offset, 'utf8');
-            offset += buf.write(': ', offset, 'utf8');
-            offset += buf.write(match.content, offset, 'utf8');
-        }
-        return buf.toString('utf8', 0, offset);
+        return parts.join('');
     },
     resolveTruncatedReason(summary) {
         if (summary.stoppedReason === 'timeout')
@@ -215,6 +212,7 @@ const SearchResponseBuilder = {
 const SearchExecutor = {
     async run(args, basePath, signal, onProgress) {
         const excludePatterns = args.includeIgnored ? [] : DEFAULT_EXCLUDE_PATTERNS;
+        const { timerStartName, timerEndName, metricName } = createSearchMetricNames();
         const options = {
             includeHidden: args.includeHidden,
             excludePatterns,
@@ -228,6 +226,7 @@ const SearchExecutor = {
             ...(signal ? { signal } : {}),
             ...(onProgress ? { onProgress } : {}),
         };
+        performance.mark(timerStartName);
         try {
             return await searchContent(basePath, args.pattern, options);
         }
@@ -237,6 +236,13 @@ const SearchExecutor = {
             }
             throw error;
         }
+        finally {
+            performance.mark(timerEndName);
+            performance.measure(metricName, timerStartName, timerEndName);
+            performance.clearMarks(timerStartName);
+            performance.clearMarks(timerEndName);
+            performance.clearMeasures(metricName);
+        }
     },
     createMatcher(args) {
         if (!args.isRegex)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@j0hanz/filesystem-mcp",
-  "version": "1.13.0",
+  "version": "1.13.1",
   "mcpName": "io.github.j0hanz/filesystem-mcp",
   "description": "A local filesystem MCP server that lets LLMs and AI agents read, write, search, diff, patch, and manage files safely and efficiently. Built for reliable, structured, and controlled filesystem interaction.",
   "type": "module",