it-tools-mcp 3.2.12 → 4.0.0

package/build/tools/{dataFormat/json-to-csv → data_format/convert_json_to_csv}/index.js

@@ -1,8 +1,17 @@
 import { z } from "zod";
-export function registerJsonToCsv(server) {
-    server.tool("json-to-csv", "Convert JSON to CSV format", {
-        json: z.string().describe("JSON string to convert to CSV"),
-        delimiter: z.string().describe("CSV delimiter").optional(),
+export function registerConvertJsonCsv(server) {
+    server.registerTool("convert_json_to_csv", {
+        description: "Convert JSON to CSV format",
+        inputSchema: {
+            json: z.string().describe("JSON string to convert to CSV"),
+            delimiter: z.string().describe("CSV delimiter").optional(),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Convert Json To Csv",
+            description: "Convert JSON to CSV format",
+            readOnlyHint: false
+        }
     }, async ({ json, delimiter = "," }) => {
         try {
             const Papa = (await import("papaparse")).default;

package/build/tools/{dataFormat/json-to-toml → data_format/convert_json_to_toml}/index.js

@@ -1,7 +1,16 @@
 import { z } from "zod";
-export function registerJsonToToml(server) {
-    server.tool("json-to-toml", "Convert JSON to TOML format", {
-        json: z.string().describe("JSON string to convert"),
+export function registerConvertJsonToml(server) {
+    server.registerTool("convert_json_to_toml", {
+        description: "Convert JSON to TOML format",
+        inputSchema: {
+            json: z.string().describe("JSON string to convert"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Convert Json To Toml",
+            description: "Convert JSON to TOML format",
+            readOnlyHint: false
+        }
     }, async ({ json }) => {
         try {
             const toml = await import("@iarna/toml");

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

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

package/build/tools/{dataFormat/toml-to-json → data_format/convert_toml_to_json}/index.js

@@ -1,7 +1,16 @@
 import { z } from "zod";
-export function registerTomlToJson(server) {
-    server.tool("toml-to-json", "Convert TOML to JSON format", {
-        toml: z.string().describe("TOML string to convert"),
+export function registerConvertTomlJson(server) {
+    server.registerTool("convert_toml_to_json", {
+        description: "Convert TOML to JSON format",
+        inputSchema: {
+            toml: z.string().describe("TOML string to convert"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Convert Toml To Json",
+            description: "Convert TOML to JSON format",
+            readOnlyHint: false
+        }
     }, async ({ toml: tomlString }) => {
         try {
             const toml = await import("@iarna/toml");

package/build/tools/{dataFormat/json-format → data_format/format_json}/index.js

@@ -1,8 +1,17 @@
 import { z } from "zod";
-export function registerJsonFormat(server) {
-    server.tool("json-format", "Format and validate JSON", {
-        json: z.string().describe("JSON string to format"),
-        indent: z.number().describe("Number of spaces for indentation").optional(),
+export function registerFormatJson(server) {
+    server.registerTool("format_json", {
+        description: 'Format and prettify JSON with proper indentation. Example: {"a":1,"b":2} → formatted JSON with customizable spacing',
+        inputSchema: {
+            json: z.string().describe("JSON string to format"),
+            indent: z.number().describe("Number of spaces for indentation").optional(),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Format JSON",
+            description: "Format and prettify JSON with proper indentation and customizable spacing",
+            readOnlyHint: false
+        }
     }, async ({ json, indent = 2 }) => {
         try {
             if (indent < 0 || indent > 10) {
@@ -88,6 +97,7 @@ Examples of supported formats:
         }
         catch (error) {
             return {
+                isError: true,
                 content: [
                     {
                         type: "text",

package/build/tools/{dataFormat/phone-format → data_format/format_phone}/index.js

@@ -1,8 +1,17 @@
 import { z } from "zod";
-export function registerPhoneFormat(server) {
-    server.tool("phone-format", "Parse and format phone numbers", {
-        phoneNumber: z.string().describe("Phone number to parse and format"),
-        countryCode: z.string().optional().describe("Country code (e.g., 'US', 'GB', 'FR')"),
+export function registerFormatPhone(server) {
+    server.registerTool("format_phone", {
+        description: "Parse and format phone numbers",
+        inputSchema: {
+            phoneNumber: z.string().describe("Phone number to parse and format"),
+            countryCode: z.string().optional().describe("Country code (e.g., 'US', 'GB', 'FR')"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Format Phone",
+            description: "Parse and format phone numbers",
+            readOnlyHint: false
+        }
     }, async ({ phoneNumber, countryCode }) => {
         try {
             const { isValidPhoneNumber, parsePhoneNumber } = await import("libphonenumber-js");

package/build/tools/{dataFormat/sql-format → data_format/format_sql}/index.js

@@ -1,8 +1,17 @@
 import { z } from "zod";
-export function registerSqlFormat(server) {
-    server.tool("sql-format", "Format and prettify SQL queries", {
-        sql: z.string().describe("SQL query to format"),
-        dialect: z.string().optional().describe("SQL dialect to use for formatting (e.g., 'sql', 'mysql', 'postgresql', 'sqlite', 'mariadb', 'db2', 'plsql', 'n1ql', 'redshift', 'spark', 'tsql', 'trino', 'bigquery'). Default is 'sql'."),
+export function registerFormatSql(server) {
+    server.registerTool("format_sql", {
+        description: "Format and prettify SQL queries",
+        inputSchema: {
+            sql: z.string().describe("SQL query to format"),
+            dialect: z.string().optional().describe("SQL dialect to use for formatting (e.g., 'sql', 'mysql', 'postgresql', 'sqlite', 'mariadb', 'db2', 'plsql', 'n1ql', 'redshift', 'spark', 'tsql', 'trino', 'bigquery'). Default is 'sql'."),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Format Sql",
+            description: "Format and prettify SQL queries",
+            readOnlyHint: false
+        }
     }, async ({ sql, dialect = "sql" }) => {
         try {
             const { format: formatSQL } = await import("sql-formatter");

package/build/tools/{dataFormat/xml-format → data_format/format_xml}/index.js

@@ -1,8 +1,17 @@
 import { z } from "zod";
-export function registerXmlFormat(server) {
-    server.tool("xml-format", "Format and prettify XML", {
-        xml: z.string().describe("XML string to format"),
-        indent: z.number().describe("Number of spaces for indentation").optional(),
+export function registerFormatXml(server) {
+    server.registerTool("format_xml", {
+        description: "Format and prettify XML",
+        inputSchema: {
+            xml: z.string().describe("XML string to format"),
+            indent: z.number().describe("Number of spaces for indentation").optional(),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Format Xml",
+            description: "Format and prettify XML",
+            readOnlyHint: false
+        }
     }, async ({ xml, indent = 2 }) => {
         try {
             const formatXML = (await import("xml-formatter")).default;

package/build/tools/{dataFormat/yaml-format → data_format/format_yaml}/index.js

@@ -1,7 +1,16 @@
 import { z } from "zod";
-export function registerYamlFormat(server) {
-    server.tool("yaml-format", "Format and prettify YAML", {
-        yaml: z.string().describe("YAML string to format"),
+export function registerFormatYaml(server) {
+    server.registerTool("format_yaml", {
+        description: "Format and prettify YAML",
+        inputSchema: {
+            yaml: z.string().describe("YAML string to format"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Format Yaml",
+            description: "Format and prettify YAML",
+            readOnlyHint: false
+        }
     }, async ({ yaml }) => {
         try {
             const YAML = await import("js-yaml");

package/build/tools/{dataFormat/json-minify → data_format/minify_json}/index.js

@@ -1,7 +1,16 @@
 import { z } from "zod";
-export function registerJsonMinify(server) {
-    server.tool("json-minify", "Minify JSON by removing whitespace", {
-        json: z.string().describe("JSON string to minify"),
+export function registerMinifyJson(server) {
+    server.registerTool("minify_json", {
+        description: "Minify JSON by removing whitespace and unnecessary characters. Example: formatted JSON → compact single-line JSON",
+        inputSchema: {
+            json: z.string().describe("JSON string to minify"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Minify JSON",
+            description: "Remove whitespace and minify JSON to compact format",
+            readOnlyHint: false
+        }
     }, async ({ json }) => {
         try {
             const parsed = JSON.parse(json);

package/build/tools/development/{list-converter → convert_list}/index.js

@@ -1,10 +1,19 @@
 import { z } from "zod";
-export function registerListConverter(server) {
-    server.tool("list-converter", "Convert between different list formats (comma-separated, line-separated, etc.)", {
-        list: z.string().describe("Input list to convert"),
-        inputFormat: z.enum(["comma", "semicolon", "newline", "space", "pipe"]).describe("Input format"),
-        outputFormat: z.enum(["comma", "semicolon", "newline", "space", "pipe", "json", "quoted"]).describe("Output format"),
-        trim: z.boolean().describe("Trim whitespace from items").optional(),
+export function registerConvertList(server) {
+    server.registerTool("convert_list", {
+        description: "Convert between different list formats (comma-separated, line-separated, etc.)",
+        inputSchema: {
+            list: z.string().describe("Input list to convert"),
+            inputFormat: z.enum(["comma", "semicolon", "newline", "space", "pipe"]).describe("Input format"),
+            outputFormat: z.enum(["comma", "semicolon", "newline", "space", "pipe", "json", "quoted"]).describe("Output format"),
+            trim: z.boolean().describe("Trim whitespace from items").optional(),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Convert List",
+            description: "Convert between different list formats (comma-separated, line-separated, etc",
+            readOnlyHint: false
+        }
     }, async ({ list, inputFormat, outputFormat, trim = true }) => {
         try {
             const separators = {

package/build/tools/development/{html-prettifier → format_html}/index.js

@@ -1,8 +1,17 @@
 import { z } from "zod";
-export function registerHtmlPrettifier(server) {
-    server.tool("html-prettifier", "Format and beautify HTML code", {
-        html: z.string().describe("HTML code to prettify"),
-        indentSize: z.number().optional().default(2).describe("Number of spaces for indentation")
+export function registerPrettifyHtml(server) {
+    server.registerTool("format_html", {
+        description: "Format and beautify HTML code",
+        inputSchema: {
+            html: z.string().describe("HTML code to prettify"),
+            indentSize: z.number().optional().default(2).describe("Number of spaces for indentation")
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Format Html",
+            description: "Format and beautify HTML code",
+            readOnlyHint: false
+        }
     }, async ({ html, indentSize }) => {
         try {
             // Simple HTML prettifier

package/build/tools/development/{javascript-prettifier → format_javascript}/index.js

@@ -1,9 +1,18 @@
 import { z } from "zod";
-export function registerJavascriptPrettifier(server) {
-    server.tool("javascript-prettifier", "Format and beautify JavaScript/CSS code", {
-        code: z.string().describe("JavaScript or CSS code to prettify"),
-        type: z.enum(["javascript", "css"]).describe("Type of code to format"),
-        indentSize: z.number().optional().default(2).describe("Number of spaces for indentation")
+export function registerPrettifyJavascript(server) {
+    server.registerTool("format_javascript", {
+        description: "Format and beautify JavaScript/CSS code",
+        inputSchema: {
+            code: z.string().describe("JavaScript or CSS code to prettify"),
+            type: z.enum(["javascript", "css"]).describe("Type of code to format"),
+            indentSize: z.number().optional().default(2).describe("Number of spaces for indentation")
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Format Javascript",
+            description: "Format and beautify JavaScript/CSS code",
+            readOnlyHint: false
+        }
     }, async ({ code, type, indentSize }) => {
         try {
             let formatted = code;

package/build/tools/development/{crontab-generate → generate_crontab}/index.js

@@ -1,12 +1,21 @@
 import { z } from "zod";
 import { CronExpressionParser } from 'cron-parser';
-export function registerCrontabGenerate(server) {
-    server.tool("crontab-generate", "Generate crontab expressions", {
-        minute: z.string().describe("Minute (0-59, *, */n, n-m)").optional(),
-        hour: z.string().describe("Hour (0-23, *, */n, n-m)").optional(),
-        dayOfMonth: z.string().describe("Day of month (1-31, *, */n, n-m)").optional(),
-        month: z.string().describe("Month (1-12, *, */n, n-m)").optional(),
-        dayOfWeek: z.string().describe("Day of week (0-7, *, */n, n-m)").optional(),
+export function registerGenerateCrontab(server) {
+    server.registerTool("generate_crontab", {
+        description: "Generate crontab expressions",
+        inputSchema: {
+            minute: z.string().describe("Minute (0-59, *, */n, n-m)").optional(),
+            hour: z.string().describe("Hour (0-23, *, */n, n-m)").optional(),
+            dayOfMonth: z.string().describe("Day of month (1-31, *, */n, n-m)").optional(),
+            month: z.string().describe("Month (1-12, *, */n, n-m)").optional(),
+            dayOfWeek: z.string().describe("Day of week (0-7, *, */n, n-m)").optional(),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Generate Crontab",
+            description: "Generate crontab expressions",
+            readOnlyHint: false
+        }
     }, async ({ minute = "*", hour = "*", dayOfMonth = "*", month = "*", dayOfWeek = "*" }) => {
         try {
             const cronExpression = `${minute} ${hour} ${dayOfMonth} ${month} ${dayOfWeek}`;

package/build/tools/development/{markdown-toc-generator → generate_markdown_toc}/index.js

@@ -1,9 +1,18 @@
 import { z } from "zod";
-export function registerMarkdownTocGenerator(server) {
-    server.tool("markdown-toc-generator", "Generate a table of contents from Markdown headers", {
-        markdown: z.string().describe("Markdown content to generate TOC from"),
-        maxLevel: z.number().optional().default(6).describe("Maximum header level to include (1-6)"),
-        generateAnchors: z.boolean().optional().default(true).describe("Whether to generate anchor links")
+export function registerGenerateMarkdownToc(server) {
+    server.registerTool("generate_markdown_toc", {
+        description: "Generate a table of contents from Markdown headers",
+        inputSchema: {
+            markdown: z.string().describe("Markdown content to generate TOC from"),
+            maxLevel: z.number().optional().default(6).describe("Maximum header level to include (1-6)"),
+            generateAnchors: z.boolean().optional().default(true).describe("Whether to generate anchor links")
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Generate Markdown Toc",
+            description: "Generate a table of contents from Markdown headers",
+            readOnlyHint: false
+        }
     }, async ({ markdown, maxLevel, generateAnchors }) => {
         // Extract headers from markdown
         const headerRegex = /^(#{1,6})\s+(.+)$/gm;

package/build/tools/development/{regex-tester → test_regex}/index.js

@@ -1,9 +1,18 @@
 import { z } from "zod";
-export function registerRegexTester(server) {
-    server.tool("regex-tester", "Test regular expressions against text", {
-        pattern: z.string().describe("Regular expression pattern"),
-        text: z.string().describe("Text to test against the regex"),
-        flags: z.string().optional().describe("Regex flags (g, i, m, s, u, y)"),
+export function registerTestRegex(server) {
+    server.registerTool("test_regex", {
+        description: "Test regular expressions against text",
+        inputSchema: {
+            pattern: z.string().describe("Regular expression pattern"),
+            text: z.string().describe("Text to test against the regex"),
+            flags: z.string().optional().describe("Regex flags (g, i, m, s, u, y)"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Test Regex",
+            description: "Test regular expressions against text",
+            readOnlyHint: false
+        }
     }, async ({ pattern, text, flags }) => {
         try {
             const regex = new RegExp(pattern, flags);

package/build/tools/docker/{docker-compose-to-docker-run → convert_docker_compose_to_run}/index.js

@@ -1,8 +1,17 @@
 import { z } from "zod";
 import yaml from "js-yaml";
 export function registerDockerComposeToRun(server) {
-    server.tool("docker-compose-to-docker-run", "Convert Docker Compose files to docker run commands", {
-        content: z.string().describe("Docker Compose file content to convert"),
+    server.registerTool("convert_docker_compose_to_run", {
+        description: "Convert Docker Compose files to docker run commands",
+        inputSchema: {
+            content: z.string().describe("Docker Compose file content to convert"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Convert Docker Compose To Run",
+            description: "Convert Docker Compose files to docker run commands",
+            readOnlyHint: false
+        }
     }, async ({ content }) => {
         if (!content?.trim()) {
             return {

package/build/tools/docker/{docker-run-to-docker-compose → convert_docker_run_to_compose}/index.js

@@ -1,8 +1,17 @@
 import { z } from "zod";
 import yaml from "js-yaml";
 export function registerDockerRunToCompose(server) {
-    server.tool("docker-run-to-docker-compose", "Convert docker run commands to Docker Compose format", {
-        commands: z.string().describe("Docker run commands to convert (one per line)"),
+    server.registerTool("convert_docker_run_to_compose", {
+        description: "Convert docker run commands to Docker Compose format",
+        inputSchema: {
+            commands: z.string().describe("Docker run commands to convert (one per line)"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Convert Docker Run To Compose",
+            description: "Convert docker run commands to Docker Compose format",
+            readOnlyHint: false
+        }
     }, async ({ commands }) => {
         if (!commands?.trim()) {
             return {

package/build/tools/docker/{traefik-compose-generator → generate_traefik_compose}/index.js

@@ -1,12 +1,21 @@
 import { z } from "zod";
 import yaml from "js-yaml";
-export function registerTraefikComposeGenerator(server) {
-    server.tool("traefik-compose-generator", "Generate Traefik Docker Compose configuration", {
-        domain: z.string().optional().describe("Domain for Traefik services (default: example.com)"),
-        email: z.string().optional().describe("Email for Let's Encrypt (default: admin@example.com)"),
-        network: z.string().optional().describe("Docker network name (default: traefik)"),
-        serviceName: z.string().optional().describe("Example service name (default: webapp)"),
-        serviceImage: z.string().optional().describe("Example service image (default: nginx:latest)"),
+export function registerGenerateTraefik(server) {
+    server.registerTool("generate_traefik_compose", {
+        description: "Generate Traefik Docker Compose configuration",
+        inputSchema: {
+            domain: z.string().optional().describe("Domain for Traefik services (default: example.com)"),
+            email: z.string().optional().describe("Email for Let's Encrypt (default: admin@example.com)"),
+            network: z.string().optional().describe("Docker network name (default: traefik)"),
+            serviceName: z.string().optional().describe("Example service name (default: webapp)"),
+            serviceImage: z.string().optional().describe("Example service image (default: nginx:latest)"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Generate Traefik Compose",
+            description: "Generate Traefik Docker Compose configuration",
+            readOnlyHint: false
+        }
     }, async ({ domain = 'example.com', email = 'admin@example.com', network = 'traefik', serviceName = 'webapp', serviceImage = 'nginx:latest' }) => {
         try {
             const compose = {

package/build/tools/docker/{docker-reference → show_docker_reference}/index.js

@@ -1,5 +1,14 @@
-export function registerDockerReference(server) {
-    server.tool("docker-reference", "Get Docker commands reference and cheatsheet", {}, async () => {
+export function registerReferenceDocker(server) {
+    server.registerTool("show_docker_reference", {
+        description: "Get Docker commands reference and cheatsheet",
+        inputSchema: {},
+        // VS Code compliance annotations
+        annotations: {
+            title: "Show Docker Reference",
+            description: "Get Docker commands reference and cheatsheet",
+            readOnlyHint: true
+        }
+    }, async () => {
         const reference = `# Docker Quick Reference
 
 ## Installation & Setup

package/build/tools/docker/{docker-compose-validator → validate_docker_compose}/index.js

@@ -1,8 +1,17 @@
 import { z } from "zod";
 import yaml from "js-yaml";
-export function registerDockerComposeValidator(server) {
-    server.tool("docker-compose-validator", "Validate Docker Compose files for syntax and compatibility", {
-        content: z.string().describe("Docker Compose file content to validate"),
+export function registerValidateCompose(server) {
+    server.registerTool("validate_docker_compose", {
+        description: "Validate Docker Compose files for syntax errors, compatibility issues, and best practices. Example: check YAML syntax, service configuration, network setup",
+        inputSchema: {
+            content: z.string().describe("Docker Compose file content to validate"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Validate Docker Compose",
+            description: "Validate Docker Compose syntax and configuration",
+            readOnlyHint: false
+        }
     }, async ({ content }) => {
         if (!content?.trim()) {
             return {

package/build/tools/encoding/{text-to-binary → convert_text_to_binary}/index.js

@@ -1,8 +1,17 @@
 import { z } from "zod";
-export function registerTextToBinary(server) {
-    server.tool("text-to-binary", "Convert text to binary and vice versa", {
-        input: z.string().describe("Text to convert to binary, or binary to convert to text"),
-        operation: z.enum(["encode", "decode"]).describe("Operation: encode text to binary or decode binary to text"),
+export function registerConvertTextBinary(server) {
+    server.registerTool("convert_text_to_binary", {
+        description: "Convert text to binary and vice versa",
+        inputSchema: {
+            input: z.string().describe("Text to convert to binary, or binary to convert to text"),
+            operation: z.enum(["encode", "decode"]).describe("Operation: encode text to binary or decode binary to text"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Convert Text To Binary",
+            description: "Convert text to binary and vice versa",
+            readOnlyHint: false
+        }
     }, async ({ input, operation }) => {
         try {
             if (operation === "encode") {

package/build/tools/encoding/{base64-decode → decode_base64}/index.js

@@ -1,7 +1,16 @@
 import { z } from "zod";
-export function registerBase64Decode(server) {
-    server.tool("base64-decode", "Decode Base64 text", {
-        text: z.string().describe("Base64 text to decode"),
+export function registerDecodeBase64(server) {
+    server.registerTool("decode_base64", {
+        description: 'Decode Base64 text back to original text. Example: "SGVsbG8gV29ybGQ=" → "Hello World"',
+        inputSchema: {
+            text: z.string().min(1).regex(/^[A-Za-z0-9+/]*={0,2}$/, "Invalid Base64 format").describe("Base64 text to decode"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Decode Base64",
+            description: "Decode Base64 text back to original text",
+            readOnlyHint: false
+        }
     }, async ({ text }) => {
         try {
             const decoded = Buffer.from(text, 'base64').toString('utf-8');
@@ -16,6 +25,7 @@ export function registerBase64Decode(server) {
         }
         catch (error) {
             return {
+                isError: true,
                 content: [
                     {
                         type: "text",

package/build/tools/encoding/{html-decode → decode_html}/index.js

@@ -1,7 +1,16 @@
 import { z } from "zod";
-export function registerHtmlDecode(server) {
-    server.tool("html-decode", "Decode HTML entities", {
-        text: z.string().describe("HTML encoded text to decode"),
+export function registerDecodeHtml(server) {
+    server.registerTool("decode_html", {
+        description: "Decode HTML entities",
+        inputSchema: {
+            text: z.string().describe("HTML encoded text to decode"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Decode Html",
+            description: "Decode HTML entities",
+            readOnlyHint: false
+        }
     }, async ({ text }) => {
         const decoded = text
             .replace(/&/g, '&')

package/build/tools/encoding/{url-decode → decode_url}/index.js

@@ -1,7 +1,16 @@
 import { z } from "zod";
-export function registerUrlDecode(server) {
-    server.tool("url-decode", "URL decode text", {
-        text: z.string().describe("URL encoded text to decode"),
+export function registerDecodeUrl(server) {
+    server.registerTool("decode_url", {
+        description: "URL decode text",
+        inputSchema: {
+            text: z.string().describe("URL encoded text to decode"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Decode Url",
+            description: "URL decode text",
+            readOnlyHint: false
+        }
     }, async ({ text }) => {
         try {
             const decoded = decodeURIComponent(text);

package/build/tools/encoding/encode_base64/index.js

@@ -0,0 +1,38 @@
+import { z } from "zod";
+export function registerEncodeBase64(server) {
+    server.registerTool("encode_base64", {
+        description: 'Encode text to Base64 format. Example: "Hello World" → "SGVsbG8gV29ybGQ="',
+        inputSchema: {
+            text: z.string().min(1).describe("Text to encode to Base64"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Encode Base64",
+            description: "Encode text to Base64 format",
+            readOnlyHint: false
+        }
+    }, async ({ text }) => {
+        try {
+            const encoded = Buffer.from(text, 'utf-8').toString('base64');
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Base64 encoded: ${encoded}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                isError: true,
+                content: [
+                    {
+                        type: "text",
+                        text: `Error encoding to Base64: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                    },
+                ],
+            };
+        }
+    });
+}