@j0hanz/filesystem-mcp 1.3.2 → 1.4.0

package/dist/completions.js

@@ -7,6 +7,7 @@ import { isRecord } from './lib/type-guards.js';
 const MAX_COMPLETION_ITEMS = 100;
 const COMPLETION_RATE_LIMIT_MS = 100;
 const completionLastCallMs = new Map();
+const completionLastResult = new Map();
 function extractTopicCompletions(instructions) {
     const headers = [];
     for (const line of instructions.split('\n')) {
@@ -394,6 +395,16 @@ export function registerCompletions(server, instructions = '') {
         const now = Date.now();
         const lastCallMs = completionLastCallMs.get(argName) ?? 0;
         if (now - lastCallMs < COMPLETION_RATE_LIMIT_MS) {
+            const lastResult = completionLastResult.get(argName);
+            if (lastResult) {
+                return {
+                    completion: {
+                        values: lastResult.values,
+                        total: lastResult.total,
+                        hasMore: lastResult.hasMore,
+                    },
+                };
+            }
             return { completion: { values: [], total: 0, hasMore: false } };
         }
         completionLastCallMs.set(argName, now);
@@ -403,6 +414,7 @@ export function registerCompletions(server, instructions = '') {
             argumentName: argName,
             ...(contextArguments ? { contextArguments } : {}),
         });
+        completionLastResult.set(argName, completions);
         return {
             completion: {
                 values: completions.values,

package/dist/lib/resource-store.d.ts

@@ -15,6 +15,7 @@ export interface ResourceStore {
     }): TextResourceEntry;
     getText(uri: string): TextResourceEntry;
     clear(): void;
+    keys(): string[];
 }
 interface ResourceStoreOptions {
     maxEntries: number;

package/dist/lib/resource-store.js

@@ -147,5 +147,8 @@ export function createInMemoryResourceStore(options = {}) {
             bytes: bytesBeforeClear,
         });
     }
-    return { putText, getText, clear };
+    function keys() {
+        return Array.from(byUri.keys());
+    }
+    return { putText, getText, clear, keys };
 }

package/dist/tools/contract.d.ts

@@ -38,4 +38,8 @@ export interface ToolContract {
      * Common pitfalls or warnings for documentation.
      */
     gotchas?: string[];
+    /**
+     * Task support level for the tool. Defaults to 'optional'.
+     */
+    taskSupport?: 'optional' | 'required' | 'forbidden';
 }

package/dist/tools/read-multiple.js

@@ -14,6 +14,7 @@ export const READ_MULTIPLE_FILES_TOOL = {
     inputSchema: ReadMultipleFilesInputSchema,
     outputSchema: ReadMultipleFilesOutputSchema,
     annotations: READ_ONLY_TOOL_ANNOTATIONS,
+    taskSupport: 'required',
     nuances: ['Total read budget is capped by `MAX_READ_MANY_TOTAL_SIZE`.'],
     gotchas: [
         'Per-file `truncationReason` can be `head`, `range`, or `externalized`.',

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

@@ -23,6 +23,7 @@ export const SEARCH_AND_REPLACE_TOOL = {
     inputSchema: SearchAndReplaceInputSchema,
     outputSchema: SearchAndReplaceOutputSchema,
     annotations: DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS,
+    taskSupport: 'required',
     gotchas: [
         'Literal mode is default; `isRegex=true` enables RE2 + capture replacements (`$1`, `$2`).',
     ],

package/dist/tools/search-content.js

@@ -26,6 +26,7 @@ export const SEARCH_CONTENT_TOOL = {
     gotchas: [
         'Inline match rows are capped (first 50); full structured results are externalized via `resourceUri`.',
     ],
+    taskSupport: 'required',
 };
 function assertValidRegexPattern(pattern) {
     try {

package/dist/tools/search-files.js

@@ -38,6 +38,7 @@ export const SEARCH_FILES_TOOL = {
         'Respects `.gitignore` unless `includeIgnored=true`.',
         'Returns relative paths plus metadata; may truncate.',
     ],
+    taskSupport: 'required',
 };
 async function handleSearchFiles(args, signal, onProgress) {
     const basePath = resolvePathOrRoot(args.path);

package/dist/tools/shared.js

@@ -125,6 +125,11 @@ function canSendProgress(extra) {
     return (extra._meta?.progressToken !== undefined &&
         extra.sendNotification !== undefined);
 }
+function canReportProgress(extra) {
+    const taskExtra = extra;
+    const hasTask = taskExtra.taskId !== undefined && taskExtra.taskStore !== undefined;
+    return canSendProgress(extra) || hasTask;
+}
 export function withDefaultIcons(tool, iconInfo) {
     if (!iconInfo) {
         return maybeStripOutputSchema(tool);
@@ -216,25 +221,53 @@ export function buildToolErrorResponse(error, defaultCode, path) {
 function buildNotInitializedResult() {
     return buildToolErrorResponse(NOT_INITIALIZED_ERROR, ErrorCode.E_INVALID_INPUT);
 }
-async function sendProgressNotification(extra, params) {
-    if (!canSendProgress(extra))
-        return;
-    try {
-        await extra.sendNotification({
-            method: 'notifications/progress',
-            params,
-        });
+async function reportProgress(extra, progress) {
+    const taskExtra = extra;
+    if (typeof taskExtra.taskId === 'string' &&
+        taskExtra.taskStore !== undefined &&
+        taskExtra.taskStore !== null) {
+        const store = taskExtra.taskStore;
+        if (typeof store.updateTaskStatus === 'function') {
+            try {
+                let statusMessage = progress.message;
+                if (progress.total !== undefined) {
+                    statusMessage = statusMessage
+                        ? `${statusMessage} (${progress.current}/${progress.total})`
+                        : `${progress.current}/${progress.total}`;
+                }
+                else {
+                    statusMessage ??= `${progress.current}`;
+                }
+                await store.updateTaskStatus(taskExtra.taskId, 'working', statusMessage);
+            }
+            catch (error) {
+                console.error('Failed to update task status message:', error);
+            }
+        }
     }
-    catch (error) {
-        // Ignore progress notification failures to avoid breaking tool execution.
-        console.error('Failed to send progress notification:', error);
+    if (canSendProgress(extra)) {
+        try {
+            await extra.sendNotification({
+                method: 'notifications/progress',
+                params: {
+                    progressToken: extra._meta.progressToken,
+                    progress: progress.current,
+                    ...(progress.total !== undefined ? { total: progress.total } : {}),
+                    ...(progress.message !== undefined
+                        ? { message: progress.message }
+                        : {}),
+                },
+            });
+        }
+        catch (error) {
+            console.error('Failed to send progress notification:', error);
+        }
     }
 }
 export function createProgressReporter(extra) {
-    if (!canSendProgress(extra)) {
+    if (!canReportProgress(extra)) {
         return () => { };
     }
-    const token = extra._meta.progressToken;
     // State for monotonic enforcement and rate-limiting.
     let lastProgress = -1;
     let lastSentMs = 0;
@@ -251,52 +284,41 @@ export function createProgressReporter(extra) {
             return;
         lastProgress = current;
         lastSentMs = now;
-        void sendProgressNotification(extra, {
-            progressToken: token,
-            progress: current,
+        void reportProgress(extra, {
+            current,
             ...(total !== undefined ? { total } : {}),
             ...(message !== undefined ? { message } : {}),
         });
     };
 }
 export function notifyProgress(extra, progress) {
-    if (!canSendProgress(extra))
+    if (!canReportProgress(extra))
         return;
-    const token = extra._meta.progressToken;
-    void sendProgressNotification(extra, {
-        progressToken: token,
-        progress: progress.current,
-        ...(progress.total !== undefined ? { total: progress.total } : {}),
-        ...(progress.message !== undefined ? { message: progress.message } : {}),
-    });
+    void reportProgress(extra, progress);
 }
 async function withProgress(message, extra, run, getCompletionMessage) {
-    if (!canSendProgress(extra)) {
+    if (!canReportProgress(extra)) {
         return run();
     }
-    const token = extra._meta.progressToken;
     const total = 1;
-    await sendProgressNotification(extra, {
-        progressToken: token,
-        progress: 0,
+    await reportProgress(extra, {
+        current: 0,
         total,
         message,
     });
     try {
         const result = await run();
         const endMessage = getCompletionMessage?.(result) ?? message;
-        await sendProgressNotification(extra, {
-            progressToken: token,
-            progress: total,
+        await reportProgress(extra, {
+            current: total,
             total,
             message: endMessage,
         });
         return result;
     }
     catch (error) {
-        void sendProgressNotification(extra, {
-            progressToken: token,
-            progress: total,
+        void reportProgress(extra, {
+            current: total,
             total,
             message: `${message} • failed`,
         });

package/dist/tools/stat-many.js

@@ -13,6 +13,7 @@ export const GET_MULTIPLE_FILE_INFO_TOOL = {
     inputSchema: GetMultipleFileInfoInputSchema,
     outputSchema: GetMultipleFileInfoOutputSchema,
     annotations: READ_ONLY_TOOL_ANNOTATIONS,
+    taskSupport: 'required',
     nuances: ['Use before read/search when file size/type uncertainty exists.'],
 };
 function formatFileInfoDetail(info) {

package/dist/tools/task-support.js

@@ -304,7 +304,12 @@ export function tryRegisterToolTask(server, toolName, toolDef, taskHandler, icon
     const tasks = getExperimentalTaskRegistration(server);
     if (!tasks?.registerToolTask)
         return false;
-    tasks.registerToolTask(toolName, withDefaultIcons({ ...toolDef, execution: { taskSupport: 'optional' } }, iconInfo), taskHandler);
+    const def = toolDef;
+    const existingExecution = def.execution ?? {};
+    const taskSupport = def.taskSupport ??
+        existingExecution.taskSupport ??
+        'optional';
+    tasks.registerToolTask(toolName, withDefaultIcons({ ...toolDef, execution: { ...existingExecution, taskSupport } }, iconInfo), taskHandler);
     return true;
 }
 export function registerToolTaskIfAvailable(server, toolName, toolDef, run, iconInfo, guard) {

package/dist/tools/tree.js

@@ -14,6 +14,7 @@ export const TREE_TOOL = {
     inputSchema: TreeInputSchema,
     outputSchema: TreeOutputSchema,
     annotations: READ_ONLY_TOOL_ANNOTATIONS,
+    taskSupport: 'required',
     gotchas: ['`maxDepth=0` returns only the root node.'],
 };
 async function handleTree(args, signal, onProgress) {

package/package.json

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