@structured-world/gitlab-mcp 6.8.0 → 6.10.0

package/dist/src/cli/list-tools.js

@@ -0,0 +1,768 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const registry_manager_1 = require("../registry-manager");
+const ToolAvailability_1 = require("../services/ToolAvailability");
+function parseArgs() {
+    const args = process.argv.slice(2);
+    const options = {
+        format: "markdown",
+        showEnv: false,
+        verbose: false,
+        detail: false,
+        noExamples: false,
+        toc: false,
+    };
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        switch (arg) {
+            case "--json":
+                options.format = "json";
+                break;
+            case "--simple":
+                options.format = "simple";
+                break;
+            case "--export":
+                options.format = "export";
+                break;
+            case "--entity":
+                if (i + 1 >= args.length) {
+                    console.error("Error: --entity flag requires a value.");
+                    console.error("Usage: yarn list-tools --entity <entity_name>");
+                    process.exit(1);
+                }
+                options.entity = args[++i];
+                break;
+            case "--tool":
+                if (i + 1 >= args.length) {
+                    console.error("Error: --tool flag requires a value.");
+                    console.error("Usage: yarn list-tools --tool <tool_name>");
+                    process.exit(1);
+                }
+                options.tool = args[++i];
+                break;
+            case "--env":
+                options.showEnv = true;
+                break;
+            case "--verbose":
+            case "-v":
+                options.verbose = true;
+                break;
+            case "--detail":
+                options.detail = true;
+                break;
+            case "--no-examples":
+                options.noExamples = true;
+                break;
+            case "--toc":
+                options.toc = true;
+                break;
+            case "--help":
+            case "-h":
+                printHelp();
+                process.exit(0);
+                break;
+            default:
+                if (arg.startsWith("-")) {
+                    console.error(`Error: Unrecognized option '${arg}'.`);
+                    console.error("Use '--help' to see available options.");
+                    process.exit(1);
+                }
+                break;
+        }
+    }
+    return options;
+}
+function printHelp() {
+    console.log(`
+GitLab MCP Tool Lister
+
+Usage: yarn list-tools [options]
+
+Options:
+  --json              Output in JSON format
+  --simple            Simple list of tool names
+  --export            Generate complete TOOLS.md documentation
+  --entity <name>     Filter by entity (e.g., workitems, labels, mrs)
+  --tool <name>       Show details for specific tool
+  --env               Show environment configuration
+  --verbose, -v       Show additional details
+  --detail            Show all tools with their input schemas
+  --no-examples       Skip example JSON blocks (for --export)
+  --toc               Include table of contents (for --export)
+  --help, -h          Show this help
+
+Examples:
+  yarn list-tools                                # List all tools in markdown
+  yarn list-tools --json                         # JSON output
+  yarn list-tools --export                       # Generate TOOLS.md to stdout
+  yarn list-tools --export > docs/TOOLS.md       # Generate TOOLS.md to file
+  yarn list-tools --export --toc                 # With table of contents
+  yarn list-tools --export --no-examples         # Skip example JSON blocks
+  yarn list-tools --entity workitems             # Only work items tools
+  yarn list-tools --tool list_work_items         # Specific tool details
+  GITLAB_READONLY=true yarn list-tools           # Show read-only tools
+  GITLAB_DENIED_TOOLS_REGEX="^create" yarn list-tools  # Test filtering
+
+Environment Variables:
+  GITLAB_READONLY              Show only read-only tools
+  GITLAB_DENIED_TOOLS_REGEX    Regex pattern to exclude tools
+  GITLAB_ALLOWED_TOOLS_REGEX   Regex pattern to include tools
+  `);
+}
+function resolveJsonSchemaType(prop, schema) {
+    if (prop.$ref) {
+        const refPath = prop.$ref.replace("#/properties/", "");
+        const referencedProp = schema.properties?.[refPath];
+        if (referencedProp) {
+            return resolveJsonSchemaType(referencedProp, schema);
+        }
+        return "reference";
+    }
+    if (prop.type) {
+        if (prop.type === "array" && prop.items) {
+            const itemType = resolveJsonSchemaType(prop.items, schema);
+            return `${itemType}[]`;
+        }
+        return prop.type;
+    }
+    if (prop.enum) {
+        return "enum";
+    }
+    if (prop.oneOf ?? prop.anyOf) {
+        const unionTypes = (prop.oneOf ?? prop.anyOf)?.map(option => resolveJsonSchemaType(option, schema)) ?? [];
+        return unionTypes.join(" | ");
+    }
+    return "unknown";
+}
+function getParameterDescription(schema) {
+    const params = [];
+    if (schema.properties) {
+        for (const [key, value] of Object.entries(schema.properties)) {
+            const prop = value;
+            const required = schema.required?.includes(key) ?? false;
+            const type = resolveJsonSchemaType(prop, schema);
+            const description = prop.description ?? "";
+            let paramStr = `  - \`${key}\` (${type}${required ? ", required" : ", optional"})`;
+            if (description) {
+                paramStr += `: ${description}`;
+            }
+            params.push(paramStr);
+        }
+    }
+    if (schema._def?.schema?._def?.checks) {
+        const checks = schema._def.schema._def.checks;
+        for (const check of checks) {
+            if (check.message) {
+                params.push(`  - **Validation**: ${check.message}`);
+            }
+        }
+    }
+    return params;
+}
+function printEnvironmentInfo() {
+    console.log("=== Environment Configuration ===\n");
+    console.log(`GITLAB_READONLY: ${process.env.GITLAB_READONLY ?? "false"}`);
+    console.log(`GITLAB_DENIED_TOOLS_REGEX: ${process.env.GITLAB_DENIED_TOOLS_REGEX ?? "(not set)"}`);
+    console.log(`GITLAB_ALLOWED_TOOLS_REGEX: ${process.env.GITLAB_ALLOWED_TOOLS_REGEX ?? "(not set)"}`);
+    console.log(`GITLAB_API_URL: ${process.env.GITLAB_API_URL ?? "https://gitlab.com"}`);
+    console.log();
+}
+function getToolTierInfo(toolName) {
+    const requirement = ToolAvailability_1.ToolAvailability.getToolRequirement(toolName);
+    if (!requirement)
+        return "";
+    const tierBadge = {
+        free: "Free",
+        premium: "Premium",
+        ultimate: "Ultimate",
+    }[requirement.requiredTier] ?? requirement.requiredTier;
+    return `[tier: ${tierBadge}]`;
+}
+const ENTITY_TOOLS = {
+    Core: [
+        "browse_projects",
+        "browse_namespaces",
+        "browse_commits",
+        "browse_events",
+        "create_branch",
+        "create_group",
+        "manage_repository",
+        "list_project_members",
+        "list_group_iterations",
+        "download_attachment",
+        "get_users",
+    ],
+    "Work Items": ["browse_work_items", "manage_work_item"],
+    "Merge Requests": [
+        "browse_merge_requests",
+        "browse_mr_discussions",
+        "manage_merge_request",
+        "manage_mr_discussion",
+        "manage_draft_notes",
+    ],
+    Labels: ["browse_labels", "manage_label"],
+    Wiki: ["browse_wiki", "manage_wiki"],
+    Pipelines: ["browse_pipelines", "manage_pipeline", "manage_pipeline_job"],
+    Variables: ["browse_variables", "manage_variable"],
+    Milestones: ["browse_milestones", "manage_milestone"],
+    Files: ["browse_files", "manage_files"],
+    Snippets: ["browse_snippets", "manage_snippet"],
+    Webhooks: ["list_webhooks", "manage_webhook"],
+    Integrations: ["list_integrations", "manage_integration"],
+    Todos: ["list_todos", "manage_todos"],
+};
+function groupToolsByEntity(tools) {
+    const grouped = new Map();
+    const toolToEntity = new Map();
+    for (const [entity, toolNames] of Object.entries(ENTITY_TOOLS)) {
+        for (const toolName of toolNames) {
+            toolToEntity.set(toolName, entity);
+        }
+    }
+    for (const tool of tools) {
+        const entity = toolToEntity.get(tool.name) ?? "Other";
+        if (!grouped.has(entity)) {
+            grouped.set(entity, []);
+        }
+        grouped.get(entity).push(tool);
+    }
+    const entityOrder = [
+        "Core",
+        "Work Items",
+        "Merge Requests",
+        "Labels",
+        "Milestones",
+        "Pipelines",
+        "Variables",
+        "Files",
+        "Wiki",
+        "Snippets",
+        "Webhooks",
+        "Integrations",
+        "Todos",
+        "Other",
+    ];
+    const sortedGrouped = new Map();
+    for (const entity of entityOrder) {
+        if (grouped.has(entity)) {
+            sortedGrouped.set(entity, grouped.get(entity));
+        }
+    }
+    return sortedGrouped;
+}
+const ACTION_DESCRIPTIONS = {
+    list: "List items with filtering and pagination",
+    get: "Get a single item by ID",
+    create: "Create a new item",
+    update: "Update an existing item",
+    delete: "Delete an item",
+    search: "Search for items",
+    diffs: "Get file changes/diffs",
+    compare: "Compare two branches or commits",
+    merge: "Merge a merge request",
+    approve: "Approve a merge request",
+    unapprove: "Remove approval from a merge request",
+    rebase: "Rebase a merge request",
+    cancel: "Cancel a running operation",
+    retry: "Retry a failed operation",
+    play: "Run a manual job",
+    publish: "Publish draft notes",
+    drafts: "List draft notes",
+    draft: "Get a single draft note",
+    resolve: "Resolve a discussion thread",
+    unresolve: "Unresolve a discussion thread",
+    note: "Add a note/comment",
+    mark_done: "Mark as done",
+    mark_pending: "Mark as pending",
+    disable: "Disable the integration",
+    test: "Test a webhook",
+    read: "Read item details",
+};
+function extractActions(schema) {
+    const actions = [];
+    if (schema.oneOf && Array.isArray(schema.oneOf)) {
+        for (const branch of schema.oneOf) {
+            const actionProp = branch.properties?.action;
+            const actionName = actionProp?.const;
+            if (actionName) {
+                const description = actionProp?.description ??
+                    ACTION_DESCRIPTIONS[actionName] ??
+                    `Perform ${actionName} operation`;
+                actions.push({ name: actionName, description });
+            }
+        }
+        return actions;
+    }
+    const actionProp = schema.properties?.action;
+    if (actionProp?.enum && Array.isArray(actionProp.enum)) {
+        for (const actionName of actionProp.enum) {
+            if (typeof actionName === "string") {
+                const description = ACTION_DESCRIPTIONS[actionName] ?? `Perform ${actionName} operation`;
+                actions.push({ name: actionName, description });
+            }
+        }
+    }
+    return actions;
+}
+function extractParameters(schema) {
+    if (!schema.properties)
+        return [];
+    const requiredFields = schema.required ?? [];
+    const params = [];
+    for (const [name, prop] of Object.entries(schema.properties)) {
+        params.push({
+            name,
+            type: resolveJsonSchemaType(prop, schema),
+            required: requiredFields.includes(name),
+            description: prop.description ?? "",
+        });
+    }
+    return sortParameters(params);
+}
+function sortParameters(params) {
+    return params.sort((a, b) => {
+        if (a.required && !b.required)
+            return -1;
+        if (!a.required && b.required)
+            return 1;
+        if (a.name === "action")
+            return -1;
+        if (b.name === "action")
+            return 1;
+        return a.name.localeCompare(b.name);
+    });
+}
+function extractParametersGrouped(schema) {
+    const result = {
+        common: [],
+        byAction: new Map(),
+    };
+    if (!schema.oneOf || !Array.isArray(schema.oneOf)) {
+        result.common = extractParameters(schema);
+        return result;
+    }
+    const totalActions = schema.oneOf.length;
+    const paramOccurrences = new Map();
+    for (const branch of schema.oneOf) {
+        const actionName = branch.properties?.action?.const;
+        if (!actionName || !branch.properties)
+            continue;
+        const requiredFields = branch.required ?? [];
+        for (const [name, prop] of Object.entries(branch.properties)) {
+            if (name === "action")
+                continue;
+            const type = resolveJsonSchemaType(prop, branch);
+            const required = requiredFields.includes(name);
+            const description = prop.description ?? "";
+            if (!paramOccurrences.has(name)) {
+                paramOccurrences.set(name, {
+                    actions: new Map(),
+                    type,
+                    description,
+                });
+            }
+            const occurrence = paramOccurrences.get(name);
+            occurrence.actions.set(actionName, { required, type, description });
+            if (description.length > occurrence.description.length) {
+                occurrence.description = description;
+            }
+        }
+    }
+    for (const [name, data] of paramOccurrences) {
+        if (data.actions.size === totalActions) {
+            const requiredInAll = Array.from(data.actions.values()).every(a => a.required);
+            result.common.push({
+                name,
+                type: data.type,
+                required: requiredInAll,
+                description: data.description,
+            });
+        }
+        else {
+            for (const [actionName, actionData] of data.actions) {
+                if (!result.byAction.has(actionName)) {
+                    result.byAction.set(actionName, []);
+                }
+                result.byAction.get(actionName).push({
+                    name,
+                    type: actionData.type,
+                    required: actionData.required,
+                    requiredForAction: actionData.required,
+                    description: actionData.description || data.description,
+                });
+            }
+        }
+    }
+    result.common = sortParameters(result.common);
+    for (const [action, params] of result.byAction) {
+        result.byAction.set(action, params.sort((a, b) => {
+            if (a.requiredForAction && !b.requiredForAction)
+                return -1;
+            if (!a.requiredForAction && b.requiredForAction)
+                return 1;
+            return a.name.localeCompare(b.name);
+        }));
+    }
+    return result;
+}
+function generateExample(schema) {
+    const example = {};
+    const actions = extractActions(schema);
+    if (actions.length > 0) {
+        example.action = actions[0].name;
+    }
+    let targetSchema = schema;
+    let requiredFields = [];
+    if (schema.oneOf && Array.isArray(schema.oneOf) && schema.oneOf.length > 0) {
+        targetSchema = schema.oneOf[0];
+        requiredFields = targetSchema.required ?? [];
+    }
+    else if (schema.properties) {
+        requiredFields = schema.required ?? [];
+    }
+    else {
+        return example;
+    }
+    if (!targetSchema.properties)
+        return example;
+    for (const [name, prop] of Object.entries(targetSchema.properties)) {
+        if (name === "action")
+            continue;
+        const isRequired = requiredFields.includes(name);
+        const description = (prop.description ?? "").toLowerCase();
+        if (!isRequired)
+            continue;
+        if (prop.enum && Array.isArray(prop.enum) && prop.enum.length > 0) {
+            example[name] = prop.enum[0];
+        }
+        else if (name.includes("project_id") || name === "projectId") {
+            example[name] = "my-group/my-project";
+        }
+        else if (name.includes("group_id") || name === "groupId") {
+            example[name] = "my-group";
+        }
+        else if (name.includes("namespace")) {
+            example[name] = "my-group/my-project";
+        }
+        else if (name.includes("_iid") || name === "iid") {
+            example[name] = "1";
+        }
+        else if (name.includes("_id") || name === "id") {
+            example[name] = "123";
+        }
+        else if (name === "title") {
+            example[name] = "Example title";
+        }
+        else if (name === "description") {
+            example[name] = "Example description";
+        }
+        else if (name === "url") {
+            example[name] = "https://example.com/webhook";
+        }
+        else if (name === "content") {
+            example[name] = "File content here";
+        }
+        else if (name === "file_path" || name === "path") {
+            example[name] = "path/to/file.txt";
+        }
+        else if (name === "ref" || name === "branch") {
+            example[name] = "main";
+        }
+        else if (name === "from" || name === "to") {
+            example[name] = name === "from" ? "main" : "feature-branch";
+        }
+        else if (description.includes("boolean") || prop.type === "boolean") {
+            example[name] = true;
+        }
+        else if (prop.type === "number" || prop.type === "integer") {
+            example[name] = 10;
+        }
+        else if (prop.type === "array") {
+            example[name] = [];
+        }
+        else {
+            example[name] = `example_${name}`;
+        }
+    }
+    return example;
+}
+function getPackageVersion() {
+    try {
+        let dir = process.cwd();
+        let fallbackVersion = null;
+        for (let i = 0; i < 5; i++) {
+            const pkgPath = path.join(dir, "package.json");
+            if (fs.existsSync(pkgPath)) {
+                const content = fs.readFileSync(pkgPath, "utf8");
+                const pkg = JSON.parse(content);
+                if (fallbackVersion === null && pkg.version) {
+                    fallbackVersion = pkg.version;
+                }
+                if (pkg.name === "@structured-world/gitlab-mcp") {
+                    return pkg.version ?? "unknown";
+                }
+            }
+            const parent = path.dirname(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+        return fallbackVersion ?? "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+}
+function generateExportMarkdown(tools, options) {
+    const lines = [];
+    const version = getPackageVersion();
+    const timestamp = new Date().toISOString().split("T")[0];
+    lines.push("# GitLab MCP Tools Reference");
+    lines.push("");
+    lines.push("> Auto-generated from source code. Do not edit manually.");
+    lines.push(`> Generated: ${timestamp} | Tools: ${tools.length} | Version: ${version}`);
+    lines.push("");
+    const grouped = groupToolsByEntity(tools);
+    if (options.toc) {
+        lines.push("## Table of Contents");
+        lines.push("");
+        for (const [entity, entityTools] of grouped) {
+            const anchor = entity.toLowerCase().replace(/\s+/g, "-");
+            lines.push(`- [${entity} (${entityTools.length})](#${anchor})`);
+        }
+        lines.push("");
+        lines.push("---");
+        lines.push("");
+    }
+    for (const [entity, entityTools] of grouped) {
+        lines.push(`## ${entity}`);
+        lines.push("");
+        for (const tool of entityTools) {
+            const tierInfo = getToolTierInfo(tool.name);
+            const tierDisplay = tierInfo ? ` ${tierInfo}` : "";
+            lines.push(`### ${tool.name}${tierDisplay}`);
+            lines.push("");
+            lines.push(tool.description);
+            lines.push("");
+            const actions = extractActions(tool.inputSchema);
+            if (actions.length > 0) {
+                lines.push("#### Actions");
+                lines.push("");
+                lines.push("| Action | Description |");
+                lines.push("|--------|-------------|");
+                for (const action of actions) {
+                    lines.push(`| \`${action.name}\` | ${action.description} |`);
+                }
+                lines.push("");
+            }
+            const groupedParams = extractParametersGrouped(tool.inputSchema);
+            const hasParams = groupedParams.common.length > 0 || groupedParams.byAction.size > 0;
+            if (hasParams) {
+                lines.push("#### Parameters");
+                lines.push("");
+                if (groupedParams.common.length > 0) {
+                    if (groupedParams.byAction.size > 0) {
+                        lines.push("**Common** (all actions):");
+                        lines.push("");
+                    }
+                    lines.push("| Parameter | Type | Required | Description |");
+                    lines.push("|-----------|------|----------|-------------|");
+                    for (const param of groupedParams.common) {
+                        const req = param.required ? "Yes" : "No";
+                        const desc = param.description || "-";
+                        lines.push(`| \`${param.name}\` | ${param.type} | ${req} | ${desc} |`);
+                    }
+                    lines.push("");
+                }
+                if (groupedParams.byAction.size > 0) {
+                    const sortedActions = Array.from(groupedParams.byAction.keys()).sort();
+                    for (const actionName of sortedActions) {
+                        const actionParams = groupedParams.byAction.get(actionName);
+                        if (actionParams.length === 0)
+                            continue;
+                        lines.push(`**Action \`${actionName}\`**:`);
+                        lines.push("");
+                        lines.push("| Parameter | Type | Required | Description |");
+                        lines.push("|-----------|------|----------|-------------|");
+                        for (const param of actionParams) {
+                            const req = param.requiredForAction ? "Yes" : "No";
+                            const desc = param.description || "-";
+                            lines.push(`| \`${param.name}\` | ${param.type} | ${req} | ${desc} |`);
+                        }
+                        lines.push("");
+                    }
+                }
+            }
+            if (!options.noExamples && tool.inputSchema) {
+                const example = generateExample(tool.inputSchema);
+                if (Object.keys(example).length > 0) {
+                    lines.push("#### Example");
+                    lines.push("");
+                    lines.push("```json");
+                    lines.push(JSON.stringify(example, null, 2));
+                    lines.push("```");
+                    lines.push("");
+                }
+            }
+            lines.push("---");
+            lines.push("");
+        }
+    }
+    return lines.join("\n");
+}
+async function main() {
+    const options = parseArgs();
+    if (options.showEnv) {
+        printEnvironmentInfo();
+    }
+    const registryManager = registry_manager_1.RegistryManager.getInstance();
+    const toolDefinitions = options.format === "export"
+        ? registryManager.getAllToolDefinitionsUnfiltered()
+        : registryManager.getAllToolDefinitionsTierless();
+    const tools = toolDefinitions.map(def => ({
+        name: def.name,
+        description: def.description,
+        inputSchema: def.inputSchema,
+    }));
+    let filteredTools = tools;
+    if (options.entity) {
+        const grouped = groupToolsByEntity(tools);
+        const entityKey = Array.from(grouped.keys()).find(k => k.toLowerCase().replace(/ /g, "") === options.entity.toLowerCase().replace(/ /g, ""));
+        filteredTools = entityKey ? (grouped.get(entityKey) ?? []) : [];
+        if (filteredTools.length === 0) {
+            console.error(`No tools found for entity: ${options.entity}`);
+            process.exit(1);
+        }
+    }
+    if (options.tool) {
+        filteredTools = filteredTools.filter(t => t.name === options.tool);
+        if (filteredTools.length === 0) {
+            console.error(`Tool not found: ${options.tool}`);
+            process.exit(1);
+        }
+    }
+    switch (options.format) {
+        case "json":
+            const output = filteredTools.map(tool => ({
+                name: tool.name,
+                description: tool.description,
+                tier: ToolAvailability_1.ToolAvailability.getToolRequirement(tool.name)?.requiredTier ?? "unknown",
+                minVersion: ToolAvailability_1.ToolAvailability.getToolRequirement(tool.name)?.minVersion,
+                parameters: tool.inputSchema,
+            }));
+            console.log(JSON.stringify(output, null, 2));
+            break;
+        case "simple":
+            filteredTools.forEach(tool => {
+                console.log(tool.name);
+            });
+            break;
+        case "export":
+            const markdown = generateExportMarkdown(filteredTools, {
+                noExamples: options.noExamples,
+                toc: options.toc,
+            });
+            console.log(markdown);
+            break;
+        case "markdown":
+        default:
+            if (!options.entity && !options.tool) {
+                console.log("# GitLab MCP Tools\n");
+                console.log(`Total tools available: ${filteredTools.length}\n`);
+                const grouped = groupToolsByEntity(filteredTools);
+                console.log("## Categories\n");
+                for (const [entity, entityTools] of grouped) {
+                    console.log(`- **${entity}**: ${entityTools.length} tools`);
+                }
+                console.log();
+                for (const [entity, entityTools] of grouped) {
+                    console.log(`## ${entity}\n`);
+                    for (const tool of entityTools) {
+                        const tierInfo = getToolTierInfo(tool.name);
+                        const tierDisplay = tierInfo ? ` ${tierInfo}` : "";
+                        console.log(`### ${tool.name}${tierDisplay}`);
+                        console.log(`**Description**: ${tool.description}\n`);
+                        if ((options.verbose || options.detail) && tool.inputSchema) {
+                            console.log("**Parameters**:");
+                            const params = getParameterDescription(tool.inputSchema);
+                            if (params.length > 0) {
+                                params.forEach(p => console.log(p));
+                            }
+                            else {
+                                console.log("  (no parameters)");
+                            }
+                            console.log();
+                        }
+                    }
+                }
+            }
+            else {
+                for (const tool of filteredTools) {
+                    const tierInfo = getToolTierInfo(tool.name);
+                    const tierDisplay = tierInfo ? ` ${tierInfo}` : "";
+                    console.log(`## ${tool.name}${tierDisplay}\n`);
+                    console.log(`**Description**: ${tool.description}\n`);
+                    if (tool.inputSchema) {
+                        console.log("**Parameters**:\n");
+                        const params = getParameterDescription(tool.inputSchema);
+                        if (params.length > 0) {
+                            params.forEach(p => console.log(p));
+                        }
+                        else {
+                            console.log("(no parameters)");
+                        }
+                    }
+                    console.log();
+                }
+            }
+            break;
+    }
+    if (options.showEnv && options.format === "markdown") {
+        console.log("\n---\n");
+        console.log("*Note: Tool availability may be affected by environment variables shown above.*");
+    }
+}
+if (!process.env.NODE_ENV || process.env.NODE_ENV !== "test") {
+    main().catch(error => {
+        console.error("Error:", error);
+        process.exit(1);
+    });
+}
+//# sourceMappingURL=list-tools.js.map