it-tools-mcp 3.2.12 → 4.0.0

package/build/tools/ansible/generate_ansible_inventory/index.js

@@ -0,0 +1,221 @@
+import { z } from "zod";
+export function registerAnsibleInventoryParser(server) {
+    server.registerTool("generate_ansible_inventory", {
+        description: "Parse and validate Ansible inventory files",
+        inputSchema: {
+            inventory: z.string().describe("Ansible inventory content (INI or YAML format)"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Generate Ansible Inventory",
+            description: "Parse and validate Ansible inventory files",
+            readOnlyHint: false
+        }
+    }, async ({ inventory }) => {
+        if (!inventory?.trim()) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Please provide inventory content to parse",
+                    },
+                ],
+            };
+        }
+        try {
+            let parsed = {};
+            const trimmed = inventory.trim();
+            // Check if it's YAML format
+            if (trimmed.startsWith('{') || trimmed.includes('---') || trimmed.includes(':')) {
+                try {
+                    const yaml = await import('js-yaml');
+                    parsed = yaml.load(inventory);
+                }
+                catch (yamlError) {
+                    // Fall back to INI parsing
+                    parsed = parseINIInventory(inventory);
+                }
+            }
+            else {
+                // Parse as INI format
+                parsed = parseINIInventory(inventory);
+            }
+            // Validate and format the result
+            const result = formatInventoryResult(parsed);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: result,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error parsing inventory: ${error.message}`,
+                    },
+                ],
+            };
+        }
+    });
+}
+// Helper function to parse INI format inventory
+function parseINIInventory(inventory) {
+    const result = { all: { children: {}, hosts: {} } };
+    const lines = inventory.split('\n');
+    let currentGroup = 'all';
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // Skip empty lines and comments
+        if (!trimmed || trimmed.startsWith('#') || trimmed.startsWith(';')) {
+            continue;
+        }
+        // Group header
+        if (trimmed.startsWith('[') && trimmed.endsWith(']')) {
+            currentGroup = trimmed.slice(1, -1);
+            // Handle group variables and children sections
+            if (currentGroup.includes(':')) {
+                const [groupName, section] = currentGroup.split(':');
+                if (section === 'vars') {
+                    if (!result.all.children[groupName]) {
+                        result.all.children[groupName] = { hosts: {}, vars: {} };
+                    }
+                    currentGroup = `${groupName}:vars`;
+                }
+                else if (section === 'children') {
+                    if (!result.all.children[groupName]) {
+                        result.all.children[groupName] = { hosts: {}, children: {} };
+                    }
+                    currentGroup = `${groupName}:children`;
+                }
+            }
+            else {
+                if (!result.all.children[currentGroup]) {
+                    result.all.children[currentGroup] = { hosts: {} };
+                }
+            }
+            continue;
+        }
+        // Parse host or variable lines
+        if (currentGroup.endsWith(':vars')) {
+            // Group variables
+            const groupName = currentGroup.replace(':vars', '');
+            const [key, ...valueParts] = trimmed.split('=');
+            if (key && valueParts.length > 0) {
+                const value = valueParts.join('=');
+                if (!result.all.children[groupName].vars) {
+                    result.all.children[groupName].vars = {};
+                }
+                result.all.children[groupName].vars[key.trim()] = value.trim();
+            }
+        }
+        else if (currentGroup.endsWith(':children')) {
+            // Child groups
+            const groupName = currentGroup.replace(':children', '');
+            if (!result.all.children[groupName].children) {
+                result.all.children[groupName].children = {};
+            }
+            result.all.children[groupName].children[trimmed] = {};
+        }
+        else {
+            // Host entries
+            const [hostname, ...varParts] = trimmed.split(/\s+/);
+            const hostVars = {};
+            // Parse host variables
+            for (const varPart of varParts) {
+                const [key, ...valueParts] = varPart.split('=');
+                if (key && valueParts.length > 0) {
+                    hostVars[key] = valueParts.join('=');
+                }
+            }
+            if (currentGroup === 'all') {
+                result.all.hosts[hostname] = hostVars;
+            }
+            else {
+                result.all.children[currentGroup].hosts[hostname] = hostVars;
+            }
+        }
+    }
+    return result;
+}
+// Helper function to format inventory parsing results
+function formatInventoryResult(parsed) {
+    let result = '# Parsed Ansible Inventory\n\n';
+    try {
+        // Count totals
+        let totalHosts = 0;
+        let totalGroups = 0;
+        function countHosts(obj) {
+            let count = 0;
+            if (obj.hosts) {
+                count += Object.keys(obj.hosts).length;
+            }
+            if (obj.children) {
+                for (const child of Object.values(obj.children)) {
+                    count += countHosts(child);
+                }
+            }
+            return count;
+        }
+        function countGroups(obj) {
+            let count = 0;
+            if (obj.children) {
+                count += Object.keys(obj.children).length;
+                for (const child of Object.values(obj.children)) {
+                    count += countGroups(child);
+                }
+            }
+            return count;
+        }
+        totalHosts = countHosts(parsed.all || parsed);
+        totalGroups = countGroups(parsed.all || parsed);
+        result += `## Summary\n`;
+        result += `- Total Hosts: ${totalHosts}\n`;
+        result += `- Total Groups: ${totalGroups}\n\n`;
+        // List all groups and hosts
+        function formatGroup(groupName, group, indent = 0) {
+            const spaces = '  '.repeat(indent);
+            let output = `${spaces}## ${groupName}\n`;
+            if (group.hosts && Object.keys(group.hosts).length > 0) {
+                output += `${spaces}### Hosts:\n`;
+                for (const [hostname, vars] of Object.entries(group.hosts)) {
+                    output += `${spaces}- ${hostname}`;
+                    if (vars && typeof vars === 'object' && Object.keys(vars).length > 0) {
+                        output += ` (vars: ${Object.keys(vars).join(', ')})`;
+                    }
+                    output += '\n';
+                }
+            }
+            if (group.vars && Object.keys(group.vars).length > 0) {
+                output += `${spaces}### Variables:\n`;
+                for (const [key, value] of Object.entries(group.vars)) {
+                    output += `${spaces}- ${key}: ${value}\n`;
+                }
+            }
+            if (group.children && Object.keys(group.children).length > 0) {
+                output += `${spaces}### Child Groups:\n`;
+                for (const [childName, child] of Object.entries(group.children)) {
+                    output += formatGroup(childName, child, indent + 1);
+                }
+            }
+            return output + '\n';
+        }
+        if (parsed.all) {
+            result += formatGroup('all', parsed.all);
+        }
+        else {
+            // Handle direct group format
+            for (const [groupName, group] of Object.entries(parsed)) {
+                result += formatGroup(groupName, group);
+            }
+        }
+    }
+    catch (error) {
+        result += `Error formatting inventory: ${error.message}`;
+    }
+    return result;
+}

package/build/tools/ansible/{ansible-inventory-generator → parse_ansible_inventory}/index.js

@@ -1,7 +1,16 @@
 import { z } from "zod";
 export function registerAnsibleInventoryParser(server) {
-    server.tool("ansible-inventory-parser", "Parse and validate Ansible inventory files", {
-        inventory: z.string().describe("Ansible inventory content (INI or YAML format)"),
+    server.registerTool("parse_ansible_inventory", {
+        description: "Parse and validate Ansible inventory files",
+        inputSchema: {
+            inventory: z.string().describe("Ansible inventory content (INI or YAML format)"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Generate Ansible Inventory",
+            description: "Parse and validate Ansible inventory files",
+            readOnlyHint: false
+        }
     }, async ({ inventory }) => {
         if (!inventory?.trim()) {
             return {

package/build/tools/ansible/{ansible-reference → show_ansible_reference}/index.js

@@ -1,5 +1,14 @@
-export function registerAnsibleReference(server) {
-    server.tool("ansible-reference", "Get Ansible commands reference and cheatsheet", {}, async () => {
+export function registerReferenceAnsible(server) {
+    server.registerTool("show_ansible_reference", {
+        description: "Get Ansible commands reference and cheatsheet",
+        inputSchema: {},
+        // VS Code compliance annotations
+        annotations: {
+            title: "Show Ansible Reference",
+            description: "Get Ansible commands reference and cheatsheet",
+            readOnlyHint: true
+        }
+    }, async () => {
         const reference = `# Ansible Quick Reference
 
 ## Installation

package/build/tools/ansible/{ansible-playbook-validator → validate_ansible_playbook}/index.js

@@ -1,7 +1,16 @@
 import { z } from "zod";
-export function registerAnsiblePlaybookValidator(server) {
-    server.tool("ansible-playbook-validator", "Validate Ansible playbook syntax and structure", {
-        playbook: z.string().describe("Ansible playbook YAML content"),
+export function registerValidateAnsiblePlaybook(server) {
+    server.registerTool("validate_ansible_playbook", {
+        description: "Validate Ansible playbook syntax and structure",
+        inputSchema: {
+            playbook: z.string().describe("Ansible playbook YAML content"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Validate Ansible Playbook",
+            description: "Validate Ansible playbook syntax and structure",
+            readOnlyHint: false
+        }
     }, async ({ playbook }) => {
         if (!playbook?.trim()) {
             return {

package/build/tools/color/{color-hex-to-rgb → convert_hex_to_rgb}/index.js

@@ -1,8 +1,17 @@
 import Color from "color";
 import { z } from "zod";
-export function registerColorHexToRgb(server) {
-    server.tool("color-hex-to-rgb", "Convert HEX color to RGB", {
-        hex: z.string().describe("HEX color code (e.g., #FF5733 or FF5733)"),
+export function registerConvertHexRgb(server) {
+    server.registerTool("convert_hex_to_rgb", {
+        description: "Convert HEX color to RGB",
+        inputSchema: {
+            hex: z.string().describe("HEX color code (e.g., #FF5733 or FF5733)"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Convert Hex To Rgb",
+            description: "Convert HEX color to RGB",
+            readOnlyHint: false
+        }
     }, async ({ hex }) => {
         try {
             const rgb = Color(hex).rgb().array();

package/build/tools/color/{color-rgb-to-hex → convert_rgb_to_hex}/index.js

@@ -1,10 +1,19 @@
 import Color from "color";
 import { z } from "zod";
-export function registerColorRgbToHex(server) {
-    server.tool("color-rgb-to-hex", "Convert RGB color to HEX", {
-        r: z.number().describe("Red value (0-255)"),
-        g: z.number().describe("Green value (0-255)"),
-        b: z.number().describe("Blue value (0-255)"),
+export function registerConvertRgbHex(server) {
+    server.registerTool("convert_rgb_to_hex", {
+        description: "Convert RGB color to HEX",
+        inputSchema: {
+            r: z.number().describe("Red value (0-255)"),
+            g: z.number().describe("Green value (0-255)"),
+            b: z.number().describe("Blue value (0-255)"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Convert Rgb To Hex",
+            description: "Convert RGB color to HEX",
+            readOnlyHint: false
+        }
     }, async ({ r, g, b }) => {
         try {
             if (r < 0 || r > 255 || g < 0 || g > 255 || b < 0 || b > 255) {

package/build/tools/crypto/{jwt-decode → decode_jwt}/index.js

@@ -1,7 +1,16 @@
 import { z } from "zod";
-export function registerJwtDecode(server) {
-    server.tool("jwt-decode", "Decode JWT token (header and payload only)", {
-        token: z.string().describe("JWT token to decode"),
+export function registerDecodeJwt(server) {
+    server.registerTool("decode_jwt", {
+        description: "Decode JWT token (header and payload only)",
+        inputSchema: {
+            token: z.string().describe("JWT token to decode"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Decode Jwt",
+            description: "Decode JWT token (header and payload only)",
+            readOnlyHint: false
+        }
     }, async ({ token }) => {
         try {
             const parts = token.split('.');

package/build/tools/crypto/{basic-auth-generator → generate_basic_auth}/index.js

@@ -1,8 +1,17 @@
 import { z } from "zod";
-export function registerBasicAuthGenerator(server) {
-    server.tool("basic-auth-generator", "Generate HTTP Basic Authentication header", {
-        username: z.string().describe("Username"),
-        password: z.string().describe("Password"),
+export function registerGenerateAuth(server) {
+    server.registerTool("generate_basic_auth", {
+        description: "Generate HTTP Basic Authentication header",
+        inputSchema: {
+            username: z.string().describe("Username"),
+            password: z.string().describe("Password"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Generate Basic Auth",
+            description: "Generate HTTP Basic Authentication header",
+            readOnlyHint: false
+        }
     }, async ({ username, password }) => {
         try {
             const credentials = `${username}:${password}`;

package/build/tools/crypto/{bip39-generate → generate_bip39}/index.js

@@ -1,8 +1,17 @@
 import * as bip39 from "bip39";
 import { z } from "zod";
-export function registerBip39Generate(server) {
-    server.tool("bip39-generate", "Generate BIP39 mnemonic phrases", {
-        wordCount: z.enum(["12", "15", "18", "21", "24"]).describe("Number of words in the mnemonic").optional(),
+export function registerGenerateBip39(server) {
+    server.registerTool("generate_bip39", {
+        description: "Generate BIP39 mnemonic phrases",
+        inputSchema: {
+            wordCount: z.enum(["12", "15", "18", "21", "24"]).describe("Number of words in the mnemonic").optional(),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Generate Bip39",
+            description: "Generate BIP39 mnemonic phrases",
+            readOnlyHint: false
+        }
     }, async ({ wordCount = "12" }) => {
         try {
             const count = parseInt(wordCount);

package/build/tools/crypto/{hmac-generator → generate_hmac}/index.js

@@ -1,10 +1,19 @@
 import { createHmac } from "crypto";
 import { z } from "zod";
-export function registerHmacGenerator(server) {
-    server.tool("hmac-generator", "Generate HMAC (Hash-based Message Authentication Code)", {
-        message: z.string().describe("Message to authenticate"),
-        key: z.string().describe("Secret key for HMAC"),
-        algorithm: z.enum(["sha1", "sha256", "sha512"]).describe("Hash algorithm").optional(),
+export function registerGenerateHmac(server) {
+    server.registerTool("generate_hmac", {
+        description: "Generate HMAC (Hash-based Message Authentication Code)",
+        inputSchema: {
+            message: z.string().describe("Message to authenticate"),
+            key: z.string().describe("Secret key for HMAC"),
+            algorithm: z.enum(["sha1", "sha256", "sha512"]).describe("Hash algorithm").optional(),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Generate Hmac",
+            description: "Generate HMAC (Hash-based Message Authentication Code)",
+            readOnlyHint: false
+        }
     }, async ({ message, key, algorithm = "sha256" }) => {
         try {
             const hmac = createHmac(algorithm, key);

package/build/tools/crypto/{otp-code-generator → generate_otp}/index.js

@@ -1,10 +1,19 @@
 import speakeasy from "speakeasy";
 import { z } from "zod";
-export function registerOtpCodeGenerator(server) {
-    server.tool("otp-code-generator", "Generate Time-based One-Time Password (TOTP) codes", {
-        secret: z.string().describe("Base32 encoded secret key"),
-        digits: z.number().describe("Number of digits in the code").optional(),
-        period: z.number().describe("Time period in seconds").optional(),
+export function registerGenerateOtp(server) {
+    server.registerTool("generate_otp", {
+        description: "Generate Time-based One-Time Password (TOTP) codes",
+        inputSchema: {
+            secret: z.string().describe("Base32 encoded secret key"),
+            digits: z.number().describe("Number of digits in the code").optional(),
+            period: z.number().describe("Time period in seconds").optional(),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Generate Otp",
+            description: "Generate Time-based One-Time Password (TOTP) codes",
+            readOnlyHint: false
+        }
     }, async ({ secret, digits = 6, period = 30 }) => {
         try {
             if (digits < 4 || digits > 10) {

package/build/tools/crypto/{password-generate → generate_password}/index.js

@@ -1,11 +1,20 @@
 import { z } from "zod";
-export function registerPasswordGenerate(server) {
-    server.tool("password-generate", "Generate a secure password", {
-        length: z.number().describe("Password length").optional(),
-        includeUppercase: z.boolean().describe("Include uppercase letters").optional(),
-        includeLowercase: z.boolean().describe("Include lowercase letters").optional(),
-        includeNumbers: z.boolean().describe("Include numbers").optional(),
-        includeSymbols: z.boolean().describe("Include symbols").optional(),
+export function registerGeneratePassword(server) {
+    server.registerTool("generate_password", {
+        description: "Generate a secure password",
+        inputSchema: {
+            length: z.number().describe("Password length").optional(),
+            includeUppercase: z.boolean().describe("Include uppercase letters").optional(),
+            includeLowercase: z.boolean().describe("Include lowercase letters").optional(),
+            includeNumbers: z.boolean().describe("Include numbers").optional(),
+            includeSymbols: z.boolean().describe("Include symbols").optional(),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Generate Password",
+            description: "Generate a secure password",
+            readOnlyHint: false
+        }
     }, async ({ length = 16, includeUppercase = true, includeLowercase = true, includeNumbers = true, includeSymbols = true }) => {
         if (length < 4 || length > 128) {
             return {

package/build/tools/crypto/{token-generator → generate_token}/index.js

@@ -1,9 +1,18 @@
 import { z } from "zod";
-export function registerTokenGenerator(server) {
-    server.tool("token-generator", "Generate secure random tokens", {
-        length: z.number().describe("Token length").optional(),
-        charset: z.enum(["alphanumeric", "hex", "base64", "custom"]).describe("Character set to use").optional(),
-        customChars: z.string().optional().describe("Custom characters (required if charset is 'custom')"),
+export function registerGenerateToken(server) {
+    server.registerTool("generate_token", {
+        description: "Generate secure random tokens",
+        inputSchema: {
+            length: z.number().describe("Token length").optional(),
+            charset: z.enum(["alphanumeric", "hex", "base64", "custom"]).describe("Character set to use").optional(),
+            customChars: z.string().optional().describe("Custom characters (required if charset is 'custom')"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Generate Token",
+            description: "Generate secure random tokens",
+            readOnlyHint: false
+        }
     }, async ({ length = 32, charset = "alphanumeric", customChars }) => {
         try {
             if (length < 8 || length > 256) {

package/build/tools/crypto/{bcrypt-hash → hash_bcrypt}/index.js

@@ -1,10 +1,19 @@
 import bcryptjs from "bcryptjs";
 import { z } from "zod";
-export function registerBcryptHash(server) {
-    server.tool("bcrypt-hash", "Generate bcrypt hash or verify password against hash", {
-        password: z.string().describe("Password to hash or verify"),
-        rounds: z.number().describe("Number of salt rounds (4-12, default 10)").optional(),
-        hash: z.string().optional().describe("Existing hash to verify against (for verification)"),
+export function registerHashBcrypt(server) {
+    server.registerTool("hash_bcrypt", {
+        description: "Generate bcrypt hash or verify password against hash",
+        inputSchema: {
+            password: z.string().describe("Password to hash or verify"),
+            rounds: z.number().describe("Number of salt rounds (4-12, default 10)").optional(),
+            hash: z.string().optional().describe("Existing hash to verify against (for verification)"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Hash Bcrypt",
+            description: "Generate bcrypt hash or verify password against hash",
+            readOnlyHint: false
+        }
     }, async ({ password, rounds = 10, hash }) => {
         try {
             if (rounds < 4 || rounds > 12) {

package/build/tools/crypto/{hash-md5 → hash_md5}/index.js

@@ -1,8 +1,17 @@
 import { createHash } from "crypto";
 import { z } from "zod";
 export function registerHashMd5(server) {
-    server.tool("hash-md5", "Generate MD5 hash", {
-        text: z.string().describe("Text to hash with MD5"),
+    server.registerTool("hash_md5", {
+        description: "Generate MD5 hash",
+        inputSchema: {
+            text: z.string().describe("Text to hash with MD5"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Hash Md5",
+            description: "Generate MD5 hash",
+            readOnlyHint: false
+        }
     }, async ({ text }) => {
         const hash = createHash('md5');
         hash.update(text);

package/build/tools/crypto/{hash-sha1 → hash_sha1}/index.js

@@ -1,8 +1,17 @@
 import { createHash } from "crypto";
 import { z } from "zod";
 export function registerHashSha1(server) {
-    server.tool("hash-sha1", "Generate SHA1 hash", {
-        text: z.string().describe("Text to hash with SHA1"),
+    server.registerTool("hash_sha1", {
+        description: "Generate SHA1 hash",
+        inputSchema: {
+            text: z.string().describe("Text to hash with SHA1"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Hash Sha1",
+            description: "Generate SHA1 hash",
+            readOnlyHint: false
+        }
     }, async ({ text }) => {
         const hash = createHash('sha1');
         hash.update(text);

package/build/tools/crypto/{hash-sha256 → hash_sha256}/index.js

@@ -1,8 +1,17 @@
 import { createHash } from "crypto";
 import { z } from "zod";
 export function registerHashSha256(server) {
-    server.tool("hash-sha256", "Generate SHA256 hash", {
-        text: z.string().describe("Text to hash with SHA256"),
+    server.registerTool("hash_sha256", {
+        description: 'Generate SHA256 hash of input text. Example: "hello" → "2cf24dba4f21d..."',
+        inputSchema: {
+            text: z.string().describe("Text to hash with SHA256"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Hash Sha256",
+            description: "Generate SHA256 hash of input text",
+            readOnlyHint: false
+        }
     }, async ({ text }) => {
         const hash = createHash('sha256');
         hash.update(text);

package/build/tools/crypto/{hash-sha512 → hash_sha512}/index.js

@@ -1,8 +1,17 @@
 import { createHash } from "crypto";
 import { z } from "zod";
 export function registerHashSha512(server) {
-    server.tool("hash-sha512", "Generate SHA512 hash", {
-        text: z.string().describe("Text to hash with SHA512"),
+    server.registerTool("hash_sha512", {
+        description: "Generate SHA512 hash",
+        inputSchema: {
+            text: z.string().describe("Text to hash with SHA512"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Hash Sha512",
+            description: "Generate SHA512 hash",
+            readOnlyHint: false
+        }
     }, async ({ text }) => {
         const hash = createHash('sha512');
         hash.update(text);

package/build/tools/{dataFormat/json-diff → data_format/compare_json}/index.js

@@ -1,8 +1,17 @@
 import { z } from "zod";
-export function registerJsonDiff(server) {
-    server.tool("json-diff", "Compare two JSON objects and show differences", {
-        json1: z.string().describe("First JSON object"),
-        json2: z.string().describe("Second JSON object"),
+export function registerDiffJson(server) {
+    server.registerTool("compare_json", {
+        description: "Compare two JSON objects and show differences",
+        inputSchema: {
+            json1: z.string().describe("First JSON object"),
+            json2: z.string().describe("Second JSON object"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Compare Json",
+            description: "Compare two JSON objects and show differences",
+            readOnlyHint: false
+        }
     }, async ({ json1, json2 }) => {
         try {
             const obj1 = JSON.parse(json1);

package/build/tools/{dataFormat/html-to-markdown → data_format/convert_html_to_markdown}/index.js

@@ -1,7 +1,16 @@
 import { z } from "zod";
-export function registerHtmlToMarkdown(server) {
-    server.tool("html-to-markdown", "Convert HTML to Markdown", {
-        html: z.string().describe("HTML content to convert to Markdown"),
+export function registerConvertHtmlMarkdown(server) {
+    server.registerTool("convert_html_to_markdown", {
+        description: "Convert HTML to Markdown",
+        inputSchema: {
+            html: z.string().describe("HTML content to convert to Markdown"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Convert Html To Markdown",
+            description: "Convert HTML to Markdown",
+            readOnlyHint: false
+        }
     }, async ({ html }) => {
         try {
             const TurndownService = (await import("turndown")).default;