@structured-world/gitlab-mcp 6.14.0 → 6.16.0

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

@@ -39,6 +39,7 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const registry_manager_1 = require("../registry-manager");
 const ToolAvailability_1 = require("../services/ToolAvailability");
+const profiles_1 = require("../profiles");
 function parseArgs() {
     const args = process.argv.slice(2);
     const options = {
@@ -49,6 +50,9 @@ function parseArgs() {
         detail: false,
         noExamples: false,
         toc: false,
+        showPresets: false,
+        showProfiles: false,
+        validate: false,
     };
     for (let i = 0; i < args.length; i++) {
         const arg = args[i];
@@ -97,6 +101,39 @@ function parseArgs() {
             case "--toc":
                 options.toc = true;
                 break;
+            case "--presets":
+                options.showPresets = true;
+                break;
+            case "--profiles":
+                options.showProfiles = true;
+                break;
+            case "--preset":
+                if (i + 1 >= args.length) {
+                    console.error("Error: --preset flag requires a value.");
+                    console.error("Usage: yarn list-tools --preset <preset_name>");
+                    process.exit(1);
+                }
+                options.preset = args[++i];
+                break;
+            case "--profile":
+                if (i + 1 >= args.length) {
+                    console.error("Error: --profile flag requires a value.");
+                    console.error("Usage: yarn list-tools --profile <profile_name>");
+                    process.exit(1);
+                }
+                options.profile = args[++i];
+                break;
+            case "--validate":
+                options.validate = true;
+                break;
+            case "--compare":
+                if (i + 1 >= args.length) {
+                    console.error("Error: --compare flag requires a value.");
+                    console.error("Usage: yarn list-tools --preset <name> --compare <other_name>");
+                    process.exit(1);
+                }
+                options.compare = args[++i];
+                break;
             case "--help":
             case "-h":
                 printHelp();
@@ -119,7 +156,7 @@ GitLab MCP Tool Lister
 
 Usage: yarn list-tools [options]
 
-Options:
+Tool Options:
   --json              Output in JSON format
   --simple            Simple list of tool names
   --export            Generate complete TOOLS.md documentation
@@ -131,6 +168,16 @@ Options:
   --detail            Show all tools with their input schemas
   --no-examples       Skip example JSON blocks (for --export)
   --toc               Include table of contents (for --export)
+
+Profile/Preset Options:
+  --presets           List all available presets (built-in and user)
+  --profiles          List user-defined profiles
+  --preset <name>     Inspect a specific preset
+  --profile <name>    Inspect a specific profile
+  --validate          Validate configuration (use with --preset or --profile)
+  --compare <name>    Compare two presets (use with --preset)
+
+General:
   --help, -h          Show this help
 
 Examples:
@@ -144,8 +191,14 @@ Examples:
   yarn list-tools --env-gates --json             # JSON output of gates
   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
+
+Profile/Preset Examples:
+  yarn list-tools --presets                      # List all presets
+  yarn list-tools --profiles                     # List user profiles
+  yarn list-tools --preset junior-dev            # Inspect preset details
+  yarn list-tools --preset junior-dev --validate # Validate preset
+  yarn list-tools --preset junior-dev --compare senior-dev  # Compare presets
+  yarn list-tools --presets --json               # JSON output of presets
 
 Environment Variables:
   GITLAB_READONLY              Show only read-only tools
@@ -715,8 +768,480 @@ function printEnvGatesMarkdown(gates, ungatedTools, format) {
     console.log("USE_PIPELINE=false");
     console.log("```");
 }
+const FEATURE_TO_TOOLS = {
+    wiki: ["browse_wiki", "manage_wiki"],
+    milestones: ["browse_milestones", "manage_milestone"],
+    pipelines: ["browse_pipelines", "manage_pipeline", "manage_pipeline_job"],
+    labels: ["browse_labels", "manage_label"],
+    mrs: [
+        "browse_merge_requests",
+        "browse_mr_discussions",
+        "manage_merge_request",
+        "manage_mr_discussion",
+        "manage_draft_notes",
+    ],
+    files: ["browse_files", "manage_files"],
+    variables: ["browse_variables", "manage_variable"],
+    workitems: ["browse_work_items", "manage_work_item"],
+    webhooks: ["list_webhooks", "manage_webhook"],
+    snippets: ["browse_snippets", "manage_snippet"],
+    integrations: ["list_integrations", "manage_integration"],
+};
+const FEATURE_NAMES = Object.keys(FEATURE_TO_TOOLS);
+function countToolsForPreset(preset, allToolNames) {
+    let enabledTools = allToolNames;
+    if (preset.read_only) {
+        enabledTools = enabledTools.filter(name => !name.startsWith("manage_"));
+    }
+    if (preset.denied_tools_regex) {
+        try {
+            const regex = new RegExp(preset.denied_tools_regex);
+            enabledTools = enabledTools.filter(name => !regex.test(name));
+        }
+        catch (error) {
+            console.warn(`Warning: invalid denied_tools_regex "${preset.denied_tools_regex}": ${error instanceof Error ? error.message : "unknown error"}`);
+        }
+    }
+    if (preset.allowed_tools && preset.allowed_tools.length > 0) {
+        const allowedSet = new Set(preset.allowed_tools);
+        enabledTools = enabledTools.filter(name => allowedSet.has(name));
+    }
+    if (preset.features) {
+        for (const [feature, tools] of Object.entries(FEATURE_TO_TOOLS)) {
+            const featureKey = feature;
+            if (preset.features[featureKey] === false) {
+                const toolSet = new Set(tools);
+                enabledTools = enabledTools.filter(name => !toolSet.has(name));
+            }
+        }
+    }
+    return enabledTools.length;
+}
+function getToolsForPreset(preset, allToolNames) {
+    let enabledTools = [...allToolNames];
+    const disabledTools = [];
+    if (preset.read_only) {
+        const manageTools = enabledTools.filter(name => name.startsWith("manage_"));
+        disabledTools.push(...manageTools);
+        enabledTools = enabledTools.filter(name => !name.startsWith("manage_"));
+    }
+    if (preset.denied_tools_regex) {
+        try {
+            const regex = new RegExp(preset.denied_tools_regex);
+            const denied = enabledTools.filter(name => regex.test(name));
+            disabledTools.push(...denied);
+            enabledTools = enabledTools.filter(name => !regex.test(name));
+        }
+        catch (error) {
+            console.warn(`Warning: invalid denied_tools_regex "${preset.denied_tools_regex}": ${error instanceof Error ? error.message : "unknown error"}`);
+        }
+    }
+    if (preset.allowed_tools && preset.allowed_tools.length > 0) {
+        const allowedSet = new Set(preset.allowed_tools);
+        const notAllowed = enabledTools.filter(name => !allowedSet.has(name));
+        disabledTools.push(...notAllowed);
+        enabledTools = enabledTools.filter(name => allowedSet.has(name));
+    }
+    if (preset.features) {
+        for (const [feature, tools] of Object.entries(FEATURE_TO_TOOLS)) {
+            const featureKey = feature;
+            if (preset.features[featureKey] === false) {
+                const toolSet = new Set(tools);
+                const disabled = enabledTools.filter(name => toolSet.has(name));
+                disabledTools.push(...disabled);
+                enabledTools = enabledTools.filter(name => !toolSet.has(name));
+            }
+        }
+    }
+    return {
+        enabled: enabledTools.sort(),
+        disabled: [...new Set(disabledTools)].sort(),
+    };
+}
+async function printPresetsList(loader, allToolNames, format) {
+    const profiles = await loader.listProfiles();
+    const presets = profiles.filter(p => p.isPreset);
+    const userProfiles = profiles.filter(p => !p.isPreset);
+    if (format === "json") {
+        const output = {
+            builtIn: await Promise.all(presets.map(async (p) => {
+                const preset = await loader.loadPreset(p.name);
+                return {
+                    name: p.name,
+                    description: p.description ?? "",
+                    readOnly: p.readOnly,
+                    toolCount: countToolsForPreset(preset, allToolNames),
+                };
+            })),
+            userPresets: userProfiles.length,
+            totalTools: allToolNames.length,
+        };
+        console.log(JSON.stringify(output, null, 2));
+        return;
+    }
+    console.log("# Available Presets\n");
+    console.log(`Total tools available: ${allToolNames.length}\n`);
+    console.log("## Built-in Presets\n");
+    console.log("| Preset | Tools | Read-Only | Description |");
+    console.log("|--------|-------|-----------|-------------|");
+    for (const p of presets) {
+        const preset = await loader.loadPreset(p.name);
+        const toolCount = countToolsForPreset(preset, allToolNames);
+        const ro = p.readOnly ? "Yes" : "No";
+        const desc = p.description ?? "-";
+        console.log(`| \`${p.name}\` | ${toolCount} | ${ro} | ${desc} |`);
+    }
+    if (userProfiles.length > 0) {
+        console.log("\n## User Profiles\n");
+        console.log(`${userProfiles.length} user profile(s) defined. Use \`--profiles\` to list them.`);
+    }
+    console.log("\nUse `yarn list-tools --preset <name>` for details.");
+}
+async function printProfilesList(loader, format) {
+    const profiles = await loader.listProfiles();
+    const userProfiles = profiles.filter(p => !p.isPreset);
+    if (format === "json") {
+        const output = userProfiles.map(p => ({
+            name: p.name,
+            host: p.host,
+            authType: p.authType,
+            readOnly: p.readOnly,
+        }));
+        console.log(JSON.stringify(output, null, 2));
+        return;
+    }
+    console.log("# User Profiles\n");
+    if (userProfiles.length === 0) {
+        console.log("No user profiles defined.\n");
+        console.log("Create profiles in: `~/.config/gitlab-mcp/profiles.yaml`\n");
+        console.log("Example:\n");
+        console.log("```yaml");
+        console.log("profiles:");
+        console.log("  work:");
+        console.log("    host: gitlab.company.com");
+        console.log("    auth:");
+        console.log("      type: pat");
+        console.log("      token_env: GITLAB_WORK_TOKEN");
+        console.log("```");
+        return;
+    }
+    console.log("| Profile | Host | Auth | Read-Only |");
+    console.log("|---------|------|------|-----------|");
+    for (const p of userProfiles) {
+        const ro = p.readOnly ? "Yes" : "No";
+        console.log(`| \`${p.name}\` | ${p.host ?? "-"} | ${p.authType ?? "-"} | ${ro} |`);
+    }
+    console.log("\nUse `yarn list-tools --profile <name>` for details.");
+}
+async function printPresetDetails(loader, presetName, allToolNames, format, validate) {
+    let preset;
+    try {
+        preset = await loader.loadPreset(presetName);
+    }
+    catch {
+        console.error(`Error: Preset '${presetName}' not found`);
+        process.exit(1);
+        return;
+    }
+    const { enabled, disabled } = getToolsForPreset(preset, allToolNames);
+    if (format === "json") {
+        const output = {
+            name: presetName,
+            type: "builtin",
+            description: preset.description ?? null,
+            readOnly: preset.read_only ?? false,
+            toolsEnabled: enabled.length,
+            toolsDisabled: disabled.length,
+            features: preset.features ?? {},
+            deniedToolsRegex: preset.denied_tools_regex ?? null,
+            allowedTools: preset.allowed_tools ?? null,
+            deniedActions: preset.denied_actions ?? null,
+            enabledTools: enabled,
+            disabledTools: disabled,
+        };
+        if (validate) {
+            const validation = await loader.validatePreset(preset);
+            output.validation = validation;
+        }
+        console.log(JSON.stringify(output, null, 2));
+        return;
+    }
+    console.log(`# Preset: ${presetName}\n`);
+    console.log(`**Type:** Built-in`);
+    console.log(`**Description:** ${preset.description ?? "-"}`);
+    console.log(`**Tools Enabled:** ${enabled.length} (of ${allToolNames.length} available)`);
+    console.log(`**Read-Only:** ${preset.read_only ? "Yes" : "No"}\n`);
+    if (preset.features) {
+        console.log("## Features\n");
+        console.log("| Feature | Status |");
+        console.log("|---------|--------|");
+        for (const f of FEATURE_NAMES) {
+            const featureKey = f;
+            const status = preset.features[featureKey] === true
+                ? "Enabled"
+                : preset.features[featureKey] === false
+                    ? "Disabled"
+                    : "-";
+            console.log(`| ${f} | ${status} |`);
+        }
+        console.log();
+    }
+    console.log("## Tool Restrictions\n");
+    if (preset.denied_tools_regex) {
+        console.log(`**Denied tools regex:** \`${preset.denied_tools_regex}\`\n`);
+    }
+    if (preset.allowed_tools && preset.allowed_tools.length > 0) {
+        console.log(`**Allowed tools (whitelist):** ${preset.allowed_tools.length} tools\n`);
+    }
+    if (preset.denied_actions && preset.denied_actions.length > 0) {
+        console.log(`**Denied actions:** ${preset.denied_actions.join(", ")}\n`);
+    }
+    if (!preset.denied_tools_regex &&
+        !preset.allowed_tools?.length &&
+        !preset.denied_actions?.length) {
+        console.log("No explicit tool restrictions.\n");
+    }
+    console.log("## Enabled Tools\n");
+    for (const tool of enabled) {
+        console.log(`- ${tool}`);
+    }
+    console.log();
+    if (disabled.length > 0) {
+        console.log("## Disabled Tools\n");
+        for (const tool of disabled) {
+            console.log(`- ${tool}`);
+        }
+        console.log();
+    }
+    if (validate) {
+        console.log("## Validation\n");
+        const validation = await loader.validatePreset(preset);
+        if (validation.valid && validation.warnings.length === 0) {
+            console.log("**Status: VALID**\n");
+        }
+        else if (validation.valid) {
+            console.log(`**Status: VALID** (${validation.warnings.length} warning(s))\n`);
+            console.log("### Warnings\n");
+            for (const w of validation.warnings) {
+                console.log(`- ${w}`);
+            }
+        }
+        else {
+            console.log(`**Status: INVALID** (${validation.errors.length} error(s))\n`);
+            console.log("### Errors\n");
+            for (const e of validation.errors) {
+                console.log(`- ${e}`);
+            }
+            if (validation.warnings.length > 0) {
+                console.log("\n### Warnings\n");
+                for (const w of validation.warnings) {
+                    console.log(`- ${w}`);
+                }
+            }
+        }
+    }
+}
+async function printProfileDetails(loader, profileName, format, validate) {
+    let profile;
+    try {
+        profile = await loader.loadProfile(profileName);
+    }
+    catch {
+        console.error(`Error: Profile '${profileName}' not found`);
+        process.exit(1);
+        return;
+    }
+    if (format === "json") {
+        const output = {
+            name: profileName,
+            type: "user",
+            host: profile.host,
+            authType: profile.auth.type,
+            readOnly: profile.read_only ?? false,
+            features: profile.features ?? {},
+            deniedToolsRegex: profile.denied_tools_regex ?? null,
+            allowedTools: profile.allowed_tools ?? null,
+            deniedActions: profile.denied_actions ?? null,
+            allowedProjects: profile.allowed_projects ?? null,
+            allowedGroups: profile.allowed_groups ?? null,
+            defaultProject: profile.default_project ?? null,
+            defaultNamespace: profile.default_namespace ?? null,
+            timeoutMs: profile.timeout_ms ?? null,
+            skipTlsVerify: profile.skip_tls_verify ?? false,
+        };
+        if (validate) {
+            const validation = await loader.validateProfile(profile);
+            output.validation = validation;
+        }
+        console.log(JSON.stringify(output, null, 2));
+        return;
+    }
+    console.log(`# Profile: ${profileName}\n`);
+    console.log(`**Type:** User-defined`);
+    console.log(`**Host:** ${profile.host}`);
+    console.log(`**Auth:** ${profile.auth.type}`);
+    console.log(`**Read-Only:** ${profile.read_only ? "Yes" : "No"}\n`);
+    console.log("## Settings\n");
+    console.log("| Setting | Value |");
+    console.log("|---------|-------|");
+    console.log(`| Timeout | ${profile.timeout_ms ?? "default"}ms |`);
+    console.log(`| TLS Verify | ${profile.skip_tls_verify ? "No" : "Yes"} |`);
+    if (profile.default_project) {
+        console.log(`| Default Project | ${profile.default_project} |`);
+    }
+    if (profile.default_namespace) {
+        console.log(`| Default Namespace | ${profile.default_namespace} |`);
+    }
+    console.log();
+    if (profile.allowed_projects?.length || profile.allowed_groups?.length) {
+        console.log("## Access Restrictions\n");
+        if (profile.allowed_projects?.length) {
+            console.log(`**Allowed Projects:** ${profile.allowed_projects.join(", ")}\n`);
+        }
+        if (profile.allowed_groups?.length) {
+            console.log(`**Allowed Groups:** ${profile.allowed_groups.join(", ")}\n`);
+        }
+    }
+    if (profile.denied_tools_regex ||
+        profile.allowed_tools?.length ||
+        profile.denied_actions?.length) {
+        console.log("## Tool Restrictions\n");
+        if (profile.denied_tools_regex) {
+            console.log(`**Denied tools regex:** \`${profile.denied_tools_regex}\`\n`);
+        }
+        if (profile.allowed_tools?.length) {
+            console.log(`**Allowed tools (whitelist):** ${profile.allowed_tools.length} tools\n`);
+        }
+        if (profile.denied_actions?.length) {
+            console.log(`**Denied actions:** ${profile.denied_actions.join(", ")}\n`);
+        }
+    }
+    if (validate) {
+        console.log("## Validation\n");
+        const validation = await loader.validateProfile(profile);
+        if (validation.valid && validation.warnings.length === 0) {
+            console.log("**Status: VALID**\n");
+        }
+        else if (validation.valid) {
+            console.log(`**Status: VALID** (${validation.warnings.length} warning(s))\n`);
+            console.log("### Warnings\n");
+            for (const w of validation.warnings) {
+                console.log(`- ${w}`);
+            }
+        }
+        else {
+            console.log(`**Status: INVALID** (${validation.errors.length} error(s))\n`);
+            console.log("### Errors\n");
+            for (const e of validation.errors) {
+                console.log(`- ${e}`);
+            }
+        }
+    }
+}
+async function comparePresets(loader, presetA, presetB, allToolNames, format) {
+    let a, b;
+    try {
+        a = await loader.loadPreset(presetA);
+    }
+    catch {
+        console.error(`Error: Preset '${presetA}' not found`);
+        process.exit(1);
+        return;
+    }
+    try {
+        b = await loader.loadPreset(presetB);
+    }
+    catch {
+        console.error(`Error: Preset '${presetB}' not found`);
+        process.exit(1);
+        return;
+    }
+    const toolsA = getToolsForPreset(a, allToolNames);
+    const toolsB = getToolsForPreset(b, allToolNames);
+    const enabledSetA = new Set(toolsA.enabled);
+    const enabledSetB = new Set(toolsB.enabled);
+    const onlyInA = toolsA.enabled.filter(t => !enabledSetB.has(t));
+    const onlyInB = toolsB.enabled.filter(t => !enabledSetA.has(t));
+    const common = toolsA.enabled.filter(t => enabledSetB.has(t));
+    if (format === "json") {
+        const output = {
+            presetA: {
+                name: presetA,
+                description: a.description ?? null,
+                toolCount: toolsA.enabled.length,
+                readOnly: a.read_only ?? false,
+            },
+            presetB: {
+                name: presetB,
+                description: b.description ?? null,
+                toolCount: toolsB.enabled.length,
+                readOnly: b.read_only ?? false,
+            },
+            comparison: {
+                commonTools: common.length,
+                onlyInA: onlyInA.length,
+                onlyInB: onlyInB.length,
+                onlyInAList: onlyInA,
+                onlyInBList: onlyInB,
+            },
+        };
+        console.log(JSON.stringify(output, null, 2));
+        return;
+    }
+    console.log(`# Comparison: ${presetA} vs ${presetB}\n`);
+    console.log("## Summary\n");
+    console.log("| | " + presetA + " | " + presetB + " |");
+    console.log("|---|---|---|");
+    console.log(`| Tools | ${toolsA.enabled.length} | ${toolsB.enabled.length} |`);
+    console.log(`| Read-Only | ${a.read_only ? "Yes" : "No"} | ${b.read_only ? "Yes" : "No"} |`);
+    console.log();
+    console.log(`**Common tools:** ${common.length}\n`);
+    if (onlyInA.length > 0) {
+        console.log(`## Only in ${presetA} (${onlyInA.length})\n`);
+        for (const t of onlyInA) {
+            console.log(`- ${t}`);
+        }
+        console.log();
+    }
+    if (onlyInB.length > 0) {
+        console.log(`## Only in ${presetB} (${onlyInB.length})\n`);
+        for (const t of onlyInB) {
+            console.log(`- ${t}`);
+        }
+        console.log();
+    }
+    if (a.features || b.features) {
+        console.log("## Feature Comparison\n");
+        console.log("| Feature | " + presetA + " | " + presetB + " |");
+        console.log("|---------|---|---|");
+        for (const f of FEATURE_NAMES) {
+            const featureKey = f;
+            const statusA = a.features?.[featureKey] === true ? "Yes" : a.features?.[featureKey] === false ? "No" : "-";
+            const statusB = b.features?.[featureKey] === true ? "Yes" : b.features?.[featureKey] === false ? "No" : "-";
+            if (statusA !== statusB) {
+                console.log(`| **${f}** | ${statusA} | ${statusB} |`);
+            }
+            else {
+                console.log(`| ${f} | ${statusA} | ${statusB} |`);
+            }
+        }
+    }
+}
 async function main() {
     const options = parseArgs();
+    if (options.compare && !options.preset) {
+        console.error("Error: --compare flag must be used with --preset.");
+        console.error("Usage: yarn list-tools --preset <name> --compare <other_name>");
+        process.exit(1);
+        return;
+    }
+    if (options.validate && !options.preset && !options.profile) {
+        console.error("Error: --validate flag must be used with --preset or --profile.");
+        console.error("Usage: yarn list-tools --preset <name> --validate");
+        console.error("   or: yarn list-tools --profile <name> --validate");
+        process.exit(1);
+        return;
+    }
     if (options.showEnv) {
         printEnvironmentInfo();
     }
@@ -728,6 +1253,34 @@ async function main() {
         printEnvGatesMarkdown(gates, ungated, options.format === "json" ? "json" : "markdown");
         return;
     }
+    const needsProfileLoader = Boolean(options.showPresets) ||
+        Boolean(options.showProfiles) ||
+        Boolean(options.preset) ||
+        Boolean(options.profile);
+    if (needsProfileLoader) {
+        const loader = new profiles_1.ProfileLoader();
+        const allToolNames = registryManager.getAllToolDefinitionsUnfiltered().map(t => t.name);
+        if (options.showPresets) {
+            await printPresetsList(loader, allToolNames, options.format === "json" ? "json" : "markdown");
+            return;
+        }
+        if (options.showProfiles) {
+            await printProfilesList(loader, options.format === "json" ? "json" : "markdown");
+            return;
+        }
+        if (options.preset && options.compare) {
+            await comparePresets(loader, options.preset, options.compare, allToolNames, options.format === "json" ? "json" : "markdown");
+            return;
+        }
+        if (options.preset) {
+            await printPresetDetails(loader, options.preset, allToolNames, options.format === "json" ? "json" : "markdown", options.validate ?? false);
+            return;
+        }
+        if (options.profile) {
+            await printProfileDetails(loader, options.profile, options.format === "json" ? "json" : "markdown", options.validate ?? false);
+            return;
+        }
+    }
     const toolDefinitions = options.format === "export"
         ? registryManager.getAllToolDefinitionsUnfiltered()
         : registryManager.getAllToolDefinitionsTierless();