@j0hanz/filesystem-mcp 1.19.0 → 2.0.0

package/dist/resources/tool-info.js

@@ -1,206 +0,0 @@
-import { z } from 'zod';
-import { DEFAULT_SEARCH_CONTENT_RESULTS, MAX_SEARCH_RESULTS, MAX_TEXT_FILE_SIZE, } from '../lib/constants.js';
-import { ALL_TOOLS } from '../tools.js';
-function getTaskSupportLabel(taskSupport) {
-    switch (taskSupport) {
-        case 'optional':
-            return '[Task: Optional]';
-        case 'required':
-            return '[Task: Required]';
-        default:
-            return undefined;
-    }
-}
-function toEntry(contract) {
-    const annotations = [];
-    if (contract.annotations?.destructiveHint)
-        annotations.push('[Destructive]');
-    if (contract.annotations?.idempotentHint)
-        annotations.push('[Idempotent]');
-    if (contract.annotations?.readOnlyHint)
-        annotations.push('[Read-Only]');
-    const taskLabel = getTaskSupportLabel(contract.taskSupport);
-    if (taskLabel)
-        annotations.push(taskLabel);
-    return {
-        name: contract.name,
-        title: contract.title,
-        description: contract.description,
-        ...(annotations.length > 0 ? { annotations } : {}),
-        ...(contract.nuances && contract.nuances.length > 0
-            ? { nuances: contract.nuances }
-            : {}),
-        ...(contract.gotchas && contract.gotchas.length > 0
-            ? { gotchas: contract.gotchas }
-            : {}),
-    };
-}
-const ENTRIES = Object.fromEntries(ALL_TOOLS.map((contract) => [contract.name, toEntry(contract)]));
-const CONTRACTS_BY_NAME = new Map(ALL_TOOLS.map((contract) => [contract.name, contract]));
-export function getToolContracts() {
-    return ALL_TOOLS;
-}
-export function getSortedToolContracts() {
-    return [...ALL_TOOLS].sort((left, right) => left.name.localeCompare(right.name));
-}
-export function pickAvailableToolNames(names) {
-    return names.filter((name) => CONTRACTS_BY_NAME.has(name));
-}
-export function formatToolNameList(names) {
-    return names.map((name) => `\`${name}\``).join(', ');
-}
-export function getTaskCapableToolNames() {
-    return getSortedToolContracts()
-        .filter((contract) => contract.taskSupport === 'optional' ||
-        contract.taskSupport === 'required')
-        .map((contract) => contract.name);
-}
-export function buildCoreContextPack() {
-    const rows = getSortedToolContracts().map((contract) => {
-        const e = ENTRIES[contract.name];
-        if (!e)
-            return '';
-        const annotations = e.annotations ? ` ${e.annotations.join(' ')}` : '';
-        return `| \`${e.name}\` | ${e.description}${annotations} |`;
-    });
-    return `## Tool Summary\n\n| Tool | Purpose |\n|------|---------|\n${rows.join('\n')}`;
-}
-export function getSharedConstraints() {
-    return [
-        'Operate within allowed roots only (negotiated at startup via CLI).',
-        'Sensitive file paths (e.g. .env, *.pem, *id_rsa*) are denied by default.',
-        `Enforced limits: max file size ${Math.floor(MAX_TEXT_FILE_SIZE / 1024 / 1024)} MB, file search cap ${MAX_SEARCH_RESULTS} results, content search cap ${DEFAULT_SEARCH_CONTENT_RESULTS} matches.`,
-        'When a response includes `resourceUri`, call `resources/read` immediately — cached results expire on server restart.',
-    ];
-}
-function formatTaskSupportLabel(taskSupport) {
-    switch (taskSupport) {
-        case 'optional':
-            return 'optional';
-        case 'required':
-            return 'required';
-        default:
-            return 'forbidden';
-    }
-}
-function toJsonSchemaObject(schema, io = 'output') {
-    return z.toJSONSchema(schema, { io });
-}
-function summarizeArrayType(schema) {
-    if (Array.isArray(schema.prefixItems) && schema.prefixItems.length > 0) {
-        const itemTypes = schema.prefixItems.map(summarizeSchemaType).join(', ');
-        return `tuple<${itemTypes}>`;
-    }
-    const itemType = schema.items ? summarizeSchemaType(schema.items) : 'unknown';
-    return `array<${itemType}>`;
-}
-function summarizeSchemaType(schema) {
-    if (Array.isArray(schema.enum) && schema.enum.length > 0) {
-        return `enum(${schema.enum.map((value) => JSON.stringify(value)).join(', ')})`;
-    }
-    if (schema.const !== undefined) {
-        return `const(${JSON.stringify(schema.const)})`;
-    }
-    if (Array.isArray(schema.anyOf) && schema.anyOf.length > 0) {
-        return schema.anyOf.map(summarizeSchemaType).join(' | ');
-    }
-    if (Array.isArray(schema.oneOf) && schema.oneOf.length > 0) {
-        return schema.oneOf.map(summarizeSchemaType).join(' | ');
-    }
-    if (schema.type === 'array') {
-        return summarizeArrayType(schema);
-    }
-    if (schema.type === 'object' && schema.additionalProperties === false) {
-        return 'object (strict)';
-    }
-    if (typeof schema.type === 'string' && schema.type.length > 0) {
-        return schema.type;
-    }
-    return 'unknown';
-}
-function formatFieldLabel(label) {
-    return label
-        .split('_')
-        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
-        .join(' ');
-}
-function buildSchemaFieldLines(label, schema) {
-    const heading = `**${formatFieldLabel(label)}:**`;
-    if (!schema) {
-        return [heading, '- none'];
-    }
-    const io = label === 'input_fields' ? 'input' : 'output';
-    const jsonSchema = toJsonSchemaObject(schema, io);
-    const properties = jsonSchema.properties ?? {};
-    const required = new Set(jsonSchema.required ?? []);
-    const fieldNames = Object.keys(properties);
-    const lines = [heading];
-    if (typeof jsonSchema.description === 'string' &&
-        jsonSchema.description.length > 0) {
-        lines.push(`- Schema constraints: ${jsonSchema.description}`);
-    }
-    if (jsonSchema.additionalProperties === false) {
-        lines.push('- Unknown fields are rejected (`additionalProperties: false`).');
-    }
-    if (fieldNames.length === 0) {
-        lines.push('- object with no fields');
-        return lines;
-    }
-    lines.push(...fieldNames.map((fieldName) => {
-        const fieldSchema = properties[fieldName] ?? {};
-        const type = summarizeSchemaType(fieldSchema);
-        const requiredLabel = required.has(fieldName) ? 'required' : 'optional';
-        const description = typeof fieldSchema.description === 'string' &&
-            fieldSchema.description.length > 0
-            ? fieldSchema.description
-            : 'No description.';
-        return `- ${fieldName} (${type}, ${requiredLabel}): ${description}`;
-    }));
-    return lines;
-}
-export function buildToolInfo(name) {
-    const contract = CONTRACTS_BY_NAME.get(name);
-    const entry = ENTRIES[name];
-    if (!entry || !contract)
-        return undefined;
-    const annotationLines = [];
-    if (contract.annotations?.readOnlyHint)
-        annotationLines.push('- readOnlyHint: true');
-    if (contract.annotations?.idempotentHint)
-        annotationLines.push('- idempotentHint: true');
-    if (contract.annotations?.destructiveHint)
-        annotationLines.push('- destructiveHint: true');
-    if (contract.annotations?.openWorldHint)
-        annotationLines.push('- openWorldHint: true');
-    const lines = [
-        `---`,
-        `# ${entry.name}`,
-        '',
-        `**Title:** ${entry.title}`,
-        `**Description:** ${entry.description}`,
-        '',
-        '**Execution:**',
-        `- taskSupport: ${formatTaskSupportLabel(contract.taskSupport)}`,
-        '',
-        ...buildSchemaFieldLines('input_fields', contract.inputSchema),
-        '',
-        ...buildSchemaFieldLines('output_fields', contract.outputSchema),
-    ];
-    if (annotationLines.length > 0) {
-        lines.push('', '**Behavior:**', ...annotationLines);
-    }
-    if (entry.nuances && entry.nuances.length > 0) {
-        lines.push('', '**Usage Notes:**');
-        for (const nuance of entry.nuances) {
-            lines.push(`- ${nuance}`);
-        }
-    }
-    if (entry.gotchas && entry.gotchas.length > 0) {
-        lines.push('', '**Warnings:**');
-        for (const gotcha of entry.gotchas) {
-            lines.push(`- ${gotcha}`);
-        }
-    }
-    lines.push('---');
-    return lines.join('\n');
-}

package/dist/resources/workflows.d.ts

@@ -1 +0,0 @@
-export declare function buildWorkflowGuide(): string;

package/dist/resources/workflows.js

@@ -1,72 +0,0 @@
-import { formatToolNameList, pickAvailableToolNames } from './tool-info.js';
-export function buildWorkflowGuide() {
-    const exploreTools = formatToolNameList(pickAvailableToolNames([
-        'roots',
-        'ls',
-        'tree',
-        'stat',
-        'stat_many',
-        'read',
-        'read_many',
-    ]));
-    const searchTools = formatToolNameList(pickAvailableToolNames(['find', 'grep', 'read']));
-    const editTools = formatToolNameList(pickAvailableToolNames([
-        'edit',
-        'write',
-        'search_and_replace',
-        'mv',
-        'rm',
-        'mkdir',
-    ]));
-    return `## Workflows
-
-### A: Explore — Discover directory layout or file content
-
-**Tools:** ${exploreTools}
-
-1. Start with \`roots\` to identify allowed directories.
-2. Use \`ls\` or \`tree\` to map structure, then \`stat\` or \`read\` for details.
-
-> Resolve paths before acting. Never assume a path exists.
-
-### B: Search — Find files by name or content
-
-**Tools:** ${searchTools}
-
-1. Use \`find\` for file name/glob matching.
-2. Use \`grep\` for content search (supports regex).
-3. Use \`read\` to inspect matched files.
-
-> Use \`grep\` for content, \`find\` for filenames. Do not conflate them.
-
-### C: Edit — Modify files or directory layout
-
-**Tools:** ${editTools}
-
-1. Use \`edit\` for targeted single-file changes (exact text match → replace).
-2. Use \`search_and_replace\` for bulk changes across multiple files.
-3. Use \`mv\`, \`rm\`, \`mkdir\` for structural changes.
-
-> Confirm destructive operations (\`write\`, \`mv\`, \`rm\`, bulk replace) before executing.
-
-### D: Patch — Generate and apply unified diffs
-
-1. Generate: \`diff_files(original, modified)\`.
-2. Validate: \`apply_patch(patch, dryRun: true)\`.
-3. Apply: \`apply_patch(patch)\`.
-
-> Multi-file patches: set \`path\` to the base directory. Results are reported per file.
-
-### E: Task Mode — Deferred execution with polling
-
-Use task mode for long-running operations when durable polling or cancellation is needed.
-Only tools with \`execution.taskSupport: "optional"\` or \`"required"\` support this.
-
-1. Send \`tools/call\` with \`task: {}\` in the request to create a task.
-2. Poll \`tasks/get({ taskId })\` until status reaches \`completed\`, \`failed\`, or \`cancelled\`.
-3. Retrieve the final result via \`tasks/result({ taskId })\`.
-4. Cancel with \`tasks/cancel({ taskId })\` if no longer needed.
-
-> Do not send \`task\` metadata to tools with \`taskSupport: "forbidden"\` (the default).
-`;
-}