@j0hanz/filesystem-mcp 1.11.1 → 1.12.0

package/dist/tools/search-content.js

@@ -7,12 +7,66 @@ import { formatOperationSummary, joinLines } from '../config.js';
 import { SearchContentInputSchema, SearchContentOutputSchema, } from '../schemas.js';
 import { buildResourceLink, buildToolErrorResponse, buildToolResponse, createToolProgressSession, executeToolWithDiagnostics, READ_ONLY_TOOL_ANNOTATIONS, resolveFinalProgressCurrent, resolvePathOrRoot, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
 import { registerToolTaskIfAvailable } from './task-support.js';
-const MAX_INLINE_MATCHES = parseInt(process.env['FS_CONTEXT_MAX_INLINE_MATCHES'] ?? '', 10) || 50;
-const SEARCH_COMPLETION_REASON_LABELS = {
-    timeout: 'timeout',
-    maxResults: 'max results',
-    maxFiles: 'max files',
+/**
+ * Configuration constants for the Search Content tool.
+ */
+const CONFIG = {
+    MAX_INLINE_MATCHES: parseInt(process.env['FS_CONTEXT_MAX_INLINE_MATCHES'] ?? '', 10) || 50,
+    COMPLETION_LABELS: {
+        timeout: 'timeout',
+        maxResults: 'max results',
+        maxFiles: 'max files',
+    },
 };
+const TRUTHY_SUMMARY_FIELDS = [
+    'filesMatched',
+    'skippedTooLarge',
+    'skippedBinary',
+    'skippedInaccessible',
+    'linesSkippedDueToRegexTimeout',
+];
+function buildStructuredSummaryFields(summary) {
+    const truthyFields = Object.fromEntries(TRUTHY_SUMMARY_FIELDS.flatMap((key) => {
+        const value = summary[key];
+        return value ? [[key, value]] : [];
+    }));
+    return {
+        ...truthyFields,
+        ...(summary.truncated ? { truncated: true } : {}),
+        ...(summary.stoppedReason ? { stoppedReason: summary.stoppedReason } : {}),
+    };
+}
+function buildCompletionSuffix(count, filesMatched, scope, stoppedReason) {
+    if (count === 0)
+        return `No matches in ${scope}`;
+    const matchWord = count === 1 ? 'match' : 'matches';
+    const fileWord = filesMatched === 1 ? 'file' : 'files';
+    const reasonSuffix = stoppedReason !== undefined
+        ? ` [${CONFIG.COMPLETION_LABELS[stoppedReason]}]`
+        : '';
+    return `${count} ${matchWord} in ${filesMatched} ${fileWord}${reasonSuffix}`;
+}
+function compareNormalizedMatches(left, right) {
+    const fileCompare = left.relativeFile.localeCompare(right.relativeFile);
+    if (fileCompare !== 0)
+        return fileCompare;
+    if (left.line !== right.line)
+        return left.line - right.line;
+    return left.index - right.index;
+}
+function buildSearchPreviewState(matches, payloads) {
+    const needsExternalize = matches.length > CONFIG.MAX_INLINE_MATCHES;
+    const visibleCount = needsExternalize
+        ? CONFIG.MAX_INLINE_MATCHES
+        : matches.length;
+    const visibleMatches = matches.slice(0, visibleCount);
+    return {
+        needsExternalize,
+        visibleMatches,
+        visiblePayloads: payloads.slice(0, visibleCount),
+        heading: SearchResponseBuilder.buildHeading(matches.length, visibleMatches.length),
+    };
+}
 export const SEARCH_CONTENT_TOOL = {
     name: 'grep',
     title: 'Search Content',
@@ -31,205 +85,196 @@ export const SEARCH_CONTENT_TOOL = {
     ],
     taskSupport: 'optional',
 };
-function findColumnOffset(content, pattern, matcher, caseSensitive) {
-    try {
-        if (matcher) {
-            matcher.lastIndex = 0;
-            const match = matcher.exec(content);
-            return match ? match.index : undefined;
-        }
-        if (caseSensitive) {
-            const idx = content.indexOf(pattern);
-            return idx >= 0 ? idx : undefined;
+/**
+ * Handles formatting and building the search response.
+ */
+const SearchResponseBuilder = {
+    buildHeading(totalMatches, visibleMatches) {
+        if (visibleMatches >= totalMatches) {
+            return `Found ${totalMatches}:`;
         }
-        const lowerContent = content.toLowerCase();
-        const lowerPattern = pattern.toLowerCase();
-        const idx = lowerContent.indexOf(lowerPattern);
-        return idx >= 0 ? idx : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-function buildSearchTextResult(heading, normalizedMatches, summary) {
-    if (normalizedMatches.length === 0)
-        return 'No matches';
-    const text = buildMatchListText(heading, normalizedMatches);
-    if (!summary) {
-        return text;
-    }
-    const truncatedReason = summary.truncated
-        ? resolveTruncatedReason(summary)
-        : undefined;
-    const summaryOptions = {
-        truncated: summary.truncated,
-        ...(truncatedReason ? { truncatedReason } : {}),
-    };
-    return text + formatOperationSummary(summaryOptions);
-}
-function resolveTruncatedReason(summary) {
-    if (summary.stoppedReason === 'timeout')
-        return 'timeout';
-    if (summary.stoppedReason === 'maxFiles') {
-        return `max files (${summary.filesScanned})`;
-    }
-    return `max results (${summary.matches})`;
-}
-function buildMatchListText(heading, matches) {
-    const lines = [heading];
-    for (const match of matches) {
-        lines.push(formatSearchMatchLine(match));
-    }
-    return joinLines(lines);
-}
-function buildSearchMatchPayload(match, context) {
-    const column = findColumnOffset(match.content, context.pattern, context.matcher, context.caseSensitive);
-    return {
-        file: match.relativeFile,
-        line: match.line,
-        ...(column !== undefined ? { column } : {}),
-        content: match.content,
-        matchCount: match.matchCount,
-        ...(match.contextBefore ? { contextBefore: [...match.contextBefore] } : {}),
-        ...(match.contextAfter ? { contextAfter: [...match.contextAfter] } : {}),
-    };
-}
-function formatSearchMatchLine(match) {
-    const lineNum = String(match.line).padStart(4);
-    return `  ${match.relativeFile}:${lineNum}: ${match.content}`;
-}
-function buildSearchMatchPayloads(matches, context) {
-    return matches.map((match) => buildSearchMatchPayload(match, context));
-}
-function buildStructuredSearchResult(summary, matches, options) {
-    return {
-        ok: true,
-        patternType: options.patternType,
-        caseSensitive: options.caseSensitive,
-        matches,
-        totalMatches: summary.matches,
-        filesScanned: summary.filesScanned,
-        ...(summary.truncated ? { truncated: summary.truncated } : {}),
-        ...(summary.filesMatched ? { filesMatched: summary.filesMatched } : {}),
-        ...(summary.skippedTooLarge
-            ? { skippedTooLarge: summary.skippedTooLarge }
-            : {}),
-        ...(summary.skippedBinary ? { skippedBinary: summary.skippedBinary } : {}),
-        ...(summary.skippedInaccessible
-            ? { skippedInaccessible: summary.skippedInaccessible }
-            : {}),
-        ...(summary.linesSkippedDueToRegexTimeout
-            ? { linesSkippedDueToRegexTimeout: summary.linesSkippedDueToRegexTimeout }
-            : {}),
-        ...(summary.stoppedReason ? { stoppedReason: summary.stoppedReason } : {}),
-    };
-}
-function normalizeSearchMatches(result) {
-    const relativeByFile = new Map();
-    const normalized = [];
-    let index = 0;
-    for (const match of result.matches) {
-        const cached = relativeByFile.get(match.file);
-        const relative = cached ?? path.relative(result.basePath, match.file);
-        if (!cached)
-            relativeByFile.set(match.file, relative);
-        normalized.push({
+        return `Found ${totalMatches} (showing first ${visibleMatches}):`;
+    },
+    buildText(heading, matches, summary) {
+        if (matches.length === 0)
+            return 'No matches';
+        const text = this.buildMatchList(heading, matches);
+        if (!summary)
+            return text;
+        const summaryOpts = {
+            truncated: summary.truncated,
+            ...(summary.truncated
+                ? { truncatedReason: this.resolveTruncatedReason(summary) }
+                : {}),
+        };
+        return text + formatOperationSummary(summaryOpts);
+    },
+    buildStructured(summary, matches, options) {
+        return {
+            ok: true,
+            patternType: options.patternType,
+            caseSensitive: options.caseSensitive,
+            matches,
+            totalMatches: summary.matches,
+            filesScanned: summary.filesScanned,
+            ...buildStructuredSummaryFields(summary),
+        };
+    },
+    normalizeMatches(result) {
+        const relativeByFile = new Map();
+        const getRelativeFile = (file) => {
+            const cached = relativeByFile.get(file);
+            if (cached !== undefined)
+                return cached;
+            const relative = path.relative(result.basePath, file);
+            relativeByFile.set(file, relative);
+            return relative;
+        };
+        return result.matches
+            .map((match, index) => ({
             ...match,
-            relativeFile: relative,
+            relativeFile: getRelativeFile(match.file),
             index,
+        }))
+            .sort(compareNormalizedMatches);
+    },
+    buildMatchPayloads(matches, context) {
+        return matches.map((match) => {
+            const column = this.findColumnOffset(match.content, context);
+            return {
+                file: match.relativeFile,
+                line: match.line,
+                ...(column !== undefined ? { column } : {}),
+                content: match.content,
+                matchCount: match.matchCount,
+                ...(match.contextBefore
+                    ? { contextBefore: [...match.contextBefore] }
+                    : {}),
+                ...(match.contextAfter
+                    ? { contextAfter: [...match.contextAfter] }
+                    : {}),
+            };
         });
-        index += 1;
-    }
-    normalized.sort((a, b) => {
-        const fileCompare = a.relativeFile.localeCompare(b.relativeFile);
-        if (fileCompare !== 0)
-            return fileCompare;
-        if (a.line !== b.line)
-            return a.line - b.line;
-        return a.index - b.index;
-    });
-    return normalized;
-}
-async function handleSearchContent(args, signal, resourceStore, onProgress) {
-    const basePath = resolvePathOrRoot(args.path);
-    const excludePatterns = args.includeIgnored ? [] : DEFAULT_EXCLUDE_PATTERNS;
-    const patternType = args.isRegex ? 'regex' : 'literal';
-    let regexMatcher;
-    if (args.isRegex) {
+    },
+    buildMatchList(heading, matches) {
+        const lines = [heading];
+        for (const match of matches) {
+            const lineNum = String(match.line).padStart(4);
+            lines.push(`  ${match.relativeFile}:${lineNum}: ${match.content}`);
+        }
+        return joinLines(lines);
+    },
+    resolveTruncatedReason(summary) {
+        if (summary.stoppedReason === 'timeout')
+            return 'timeout';
+        if (summary.stoppedReason === 'maxFiles') {
+            return `max files (${summary.filesScanned})`;
+        }
+        return `max results (${summary.matches})`;
+    },
+    findColumnOffset(content, context) {
+        try {
+            if (context.matcher) {
+                context.matcher.lastIndex = 0;
+                const match = context.matcher.exec(content);
+                return match ? match.index : undefined;
+            }
+            if (context.caseSensitive) {
+                const idx = content.indexOf(context.pattern);
+                return idx >= 0 ? idx : undefined;
+            }
+            // Case-insensitive literal search
+            const idx = content.toLowerCase().indexOf(context.foldedPattern ?? '');
+            return idx >= 0 ? idx : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    },
+};
+const SearchExecutor = {
+    async run(args, basePath, signal, onProgress) {
+        const excludePatterns = args.includeIgnored ? [] : DEFAULT_EXCLUDE_PATTERNS;
+        const options = {
+            includeHidden: args.includeHidden,
+            excludePatterns,
+            filePattern: args.filePattern,
+            caseSensitive: args.caseSensitive,
+            wholeWord: args.wholeWord,
+            contextLines: args.contextLines,
+            maxResults: args.maxResults,
+            isLiteral: !args.isRegex,
+            multiline: args.multiline,
+            ...(signal ? { signal } : {}),
+            ...(onProgress ? { onProgress } : {}),
+        };
+        try {
+            return await searchContent(basePath, args.pattern, options);
+        }
+        catch (error) {
+            if (error instanceof Error && /regular expression/i.test(error.message)) {
+                throw new McpError(ErrorCode.E_INVALID_PATTERN, error.message);
+            }
+            throw error;
+        }
+    },
+    createMatcher(args) {
+        if (!args.isRegex)
+            return undefined;
         try {
             const flags = (args.caseSensitive ? '' : 'i') + (args.multiline ? 'm' : '');
-            regexMatcher = new RE2(args.pattern, flags);
+            return new RE2(args.pattern, flags);
         }
         catch (error) {
             throw new McpError(ErrorCode.E_INVALID_PATTERN, `Invalid regex pattern: ${formatUnknownErrorMessage(error)}`);
         }
+    },
+    createSearchContext(args, matcher) {
+        return {
+            pattern: args.pattern,
+            caseSensitive: args.caseSensitive,
+            ...(matcher ? { matcher } : {}),
+            ...(!args.isRegex && !args.caseSensitive
+                ? { foldedPattern: args.pattern.toLowerCase() }
+                : {}),
+        };
+    },
+};
+async function handleSearchContent(args, signal, resourceStore, onProgress) {
+    const basePath = resolvePathOrRoot(args.path);
+    const patternType = args.isRegex ? 'regex' : 'literal';
+    const regexMatcher = SearchExecutor.createMatcher(args);
+    const result = await SearchExecutor.run(args, basePath, signal, onProgress);
+    const normalizedMatches = SearchResponseBuilder.normalizeMatches(result);
+    const searchContext = SearchExecutor.createSearchContext(args, regexMatcher);
+    const matchPayloads = SearchResponseBuilder.buildMatchPayloads(normalizedMatches, searchContext);
+    const fullStructured = SearchResponseBuilder.buildStructured(result.summary, matchPayloads, { patternType, caseSensitive: args.caseSensitive });
+    const preview = buildSearchPreviewState(normalizedMatches, matchPayloads);
+    if (resourceStore && preview.needsExternalize) {
+        const previewStructured = {
+            ...fullStructured,
+            matches: preview.visiblePayloads,
+            truncated: true,
+        };
+        const entry = resourceStore.putText({
+            name: 'grep:matches',
+            mimeType: 'application/json',
+            text: JSON.stringify(fullStructured),
+        });
+        previewStructured.resourceUri = entry.uri;
+        const text = SearchResponseBuilder.buildText(preview.heading, preview.visibleMatches);
+        return buildToolResponse(text, previewStructured, [
+            buildResourceLink({
+                uri: entry.uri,
+                name: entry.name,
+                mimeType: entry.mimeType,
+                description: 'Full grep results as JSON (structuredContent)',
+                expiresAt: entry.expiresAt,
+            }),
+        ]);
     }
-    const options = {
-        includeHidden: args.includeHidden,
-        excludePatterns,
-        filePattern: args.filePattern,
-        caseSensitive: args.caseSensitive,
-        wholeWord: args.wholeWord,
-        contextLines: args.contextLines,
-        maxResults: args.maxResults,
-        isLiteral: !args.isRegex,
-        multiline: args.multiline,
-    };
-    if (signal) {
-        options.signal = signal;
-    }
-    if (onProgress) {
-        options.onProgress = onProgress;
-    }
-    let result;
-    try {
-        result = await searchContent(basePath, args.pattern, options);
-    }
-    catch (error) {
-        if (error instanceof Error && /regular expression/i.test(error.message)) {
-            throw new McpError(ErrorCode.E_INVALID_PATTERN, error.message);
-        }
-        throw error;
-    }
-    const normalizedMatches = normalizeSearchMatches(result);
-    const searchContext = {
-        pattern: args.pattern,
-        matcher: regexMatcher,
-        caseSensitive: args.caseSensitive,
-    };
-    const matchPayloads = buildSearchMatchPayloads(normalizedMatches, searchContext);
-    const structuredFull = buildStructuredSearchResult(result.summary, matchPayloads, {
-        patternType,
-        caseSensitive: args.caseSensitive,
-    });
-    const needsExternalize = normalizedMatches.length > MAX_INLINE_MATCHES;
-    if (!resourceStore || !needsExternalize) {
-        return buildToolResponse(buildSearchTextResult(`Found ${normalizedMatches.length}:`, normalizedMatches, result.summary), structuredFull);
-    }
-    const previewMatches = normalizedMatches.slice(0, MAX_INLINE_MATCHES);
-    const previewPayload = buildSearchMatchPayloads(previewMatches, searchContext);
-    const previewStructured = {
-        ...structuredFull,
-        matches: previewPayload,
-        truncated: true,
-        resourceUri: undefined,
-    };
-    const entry = resourceStore.putText({
-        name: 'grep:matches',
-        mimeType: 'application/json',
-        text: JSON.stringify(structuredFull),
-    });
-    previewStructured.resourceUri = entry.uri;
-    const text = buildSearchTextResult(`Found ${normalizedMatches.length} (showing first ${MAX_INLINE_MATCHES}):`, previewMatches);
-    return buildToolResponse(text, previewStructured, [
-        buildResourceLink({
-            uri: entry.uri,
-            name: entry.name,
-            mimeType: entry.mimeType,
-            description: 'Full grep results as JSON (structuredContent)',
-            expiresAt: entry.expiresAt,
-        }),
-    ]);
+    const text = SearchResponseBuilder.buildText(preview.heading, preview.visibleMatches, result.summary);
+    return buildToolResponse(text, fullStructured);
 }
 export function registerSearchContentTool(server, options = {}) {
     const handler = (args, extra) => executeToolWithDiagnostics({
@@ -237,14 +282,14 @@ export function registerSearchContentTool(server, options = {}) {
         extra,
         context: { path: args.path ?? '.' },
         run: async (signal) => {
-            const scope = args.filePattern;
-            const { pattern } = args;
-            const progress = createToolProgressSession(extra, `🔎︎ grep: ${pattern}`);
+            const { pattern, filePattern: scope } = args;
+            const progressLabel = `🔎︎ grep: ${pattern}`;
+            const progress = createToolProgressSession(extra, progressLabel);
             const progressWithMessage = ({ current, total, }) => {
                 progress.update({
                     current,
                     ...(total !== undefined ? { total } : {}),
-                    message: `🔎︎ grep: ${pattern} [${current} files]`,
+                    message: `${progressLabel} [${current} files]`,
                 });
             };
             try {
@@ -253,18 +298,13 @@ export function registerSearchContentTool(server, options = {}) {
                 const count = sc.ok && sc.totalMatches ? sc.totalMatches : 0;
                 const filesMatched = sc.ok ? (sc.filesMatched ?? 0) : 0;
                 const stoppedReason = sc.ok ? sc.stoppedReason : undefined;
-                const suffix = buildCompletionSuffix({
-                    count,
-                    filesMatched,
-                    scope,
-                    stoppedReason,
-                });
+                const suffix = buildCompletionSuffix(count, filesMatched, scope, stoppedReason);
                 const finalCurrent = resolveFinalProgressCurrent(progress, (sc.filesScanned ?? 0) + 1);
-                progress.complete(`🔎︎ grep: ${pattern} • ${suffix}`, finalCurrent);
+                progress.complete(`${progressLabel} • ${suffix}`, finalCurrent);
                 return result;
             }
             catch (error) {
-                progress.fail(`🔎︎ grep: ${pattern} • failed`);
+                progress.fail(`${progressLabel} • failed`);
                 throw error;
             }
         },
@@ -279,14 +319,3 @@ export function registerSearchContentTool(server, options = {}) {
         return;
     server.registerTool('grep', withDefaultIcons({ ...SEARCH_CONTENT_TOOL }, options.iconInfo), validatedHandler);
 }
-function buildCompletionSuffix(params) {
-    if (params.count === 0) {
-        return `No matches in ${params.scope}`;
-    }
-    const matchWord = params.count === 1 ? 'match' : 'matches';
-    const fileWord = params.filesMatched === 1 ? 'file' : 'files';
-    const reasonSuffix = params.stoppedReason !== undefined
-        ? ` [${SEARCH_COMPLETION_REASON_LABELS[params.stoppedReason]}]`
-        : '';
-    return `${params.count} ${matchWord} in ${params.filesMatched} ${fileWord}${reasonSuffix}`;
-}

package/dist/tools/shared.js

@@ -34,6 +34,36 @@ export const IDEMPOTENT_WRITE_TOOL_ANNOTATIONS = {
     destructiveHint: false,
     openWorldHint: false,
 };
+function isTaskSupportLevel(value) {
+    return value === 'optional' || value === 'required' || value === 'forbidden';
+}
+function normalizeToolExecution(tool) {
+    const candidate = tool;
+    const topLevelTaskSupport = candidate['taskSupport'];
+    const existingExecution = candidate['execution'] && typeof candidate['execution'] === 'object'
+        ? candidate['execution']
+        : undefined;
+    const executionTaskSupport = existingExecution?.['taskSupport'];
+    const resolvedTaskSupport = isTaskSupportLevel(topLevelTaskSupport)
+        ? topLevelTaskSupport
+        : isTaskSupportLevel(executionTaskSupport)
+            ? executionTaskSupport
+            : undefined;
+    if (resolvedTaskSupport === undefined && topLevelTaskSupport === undefined) {
+        return tool;
+    }
+    const normalized = { ...candidate };
+    delete normalized['taskSupport'];
+    if (resolvedTaskSupport !== undefined || existingExecution !== undefined) {
+        normalized['execution'] = {
+            ...(existingExecution ?? {}),
+            ...(resolvedTaskSupport !== undefined
+                ? { taskSupport: resolvedTaskSupport }
+                : {}),
+        };
+    }
+    return normalized;
+}
 export function shouldStripStructuredOutput() {
     return parseTrueEnvFlag(process.env['FS_CONTEXT_STRIP_STRUCTURED']);
 }
@@ -133,15 +163,16 @@ function canReportProgress(extra) {
     return canSendProgress(extra) || hasTask;
 }
 export function withDefaultIcons(tool, iconInfo) {
+    const normalizedTool = normalizeToolExecution(tool);
     if (!iconInfo) {
-        return maybeStripOutputSchema(tool);
+        return maybeStripOutputSchema(normalizedTool);
     }
-    const existingIcons = tool.icons;
+    const existingIcons = normalizedTool.icons;
     if (existingIcons && existingIcons.length > 0) {
-        return maybeStripOutputSchema(tool);
+        return maybeStripOutputSchema(normalizedTool);
     }
     const withIcons = {
-        ...tool,
+        ...normalizedTool,
         icons: [
             {
                 src: iconInfo.src,

package/dist/tools/task-support.d.ts

@@ -1,8 +1,15 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
 import type { ToolTaskHandler } from '@modelcontextprotocol/sdk/experimental/tasks/interfaces.js';
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { AnySchema, SchemaOutput, ShapeOutput, ZodRawShapeCompat } from '@modelcontextprotocol/sdk/server/zod-compat.js';
 import type { RequestTaskStore } from '@modelcontextprotocol/sdk/shared/protocol.js';
 import type { IconInfo, ToolExtra, ToolResult } from './shared.js';
+export interface TaskContext {
+    taskId: string;
+    toolName?: string | undefined;
+    startTime: number;
+}
+export declare const taskContext: AsyncLocalStorage<TaskContext>;
 type TaskToolExtra = ToolExtra & {
     taskId?: string;
     taskStore?: RequestTaskStore;