it-tools-mcp 3.2.12 → 4.0.0

package/build/tools/encoding/{html-encode → encode_html}/index.js

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

package/build/tools/encoding/{html-entities-extended → encode_html_entities}/index.js

@@ -1,8 +1,17 @@
 import { z } from "zod";
-export function registerHtmlEntitiesExtended(server) {
-    server.tool("html-entities-extended", "Extended HTML entity encoding/decoding", {
-        text: z.string().describe("Text to encode or decode"),
-        operation: z.enum(["encode", "decode"]).describe("Operation to perform"),
+export function registerEncodeHtmlEntities(server) {
+    server.registerTool("encode_html_entities", {
+        description: "Extended HTML entity encoding/decoding",
+        inputSchema: {
+            text: z.string().describe("Text to encode or decode"),
+            operation: z.enum(["encode", "decode"]).describe("Operation to perform"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Encode Html Entities",
+            description: "Extended HTML entity encoding/decoding",
+            readOnlyHint: false
+        }
     }, async ({ text, operation }) => {
         try {
             if (operation === "encode") {

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

@@ -0,0 +1,25 @@
+import { z } from "zod";
+export function registerEncodeUrl(server) {
+    server.registerTool("encode_url", {
+        description: "URL encode text",
+        inputSchema: {
+            text: z.string().describe("Text to URL encode"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Encode Url",
+            description: "URL encode text",
+            readOnlyHint: false
+        }
+    }, async ({ text }) => {
+        const encoded = encodeURIComponent(text);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `URL encoded: ${encoded}`,
+                },
+            ],
+        };
+    });
+}

package/build/tools/forensic/{safelink-decoder → decode_safelink}/index.js

@@ -1,7 +1,16 @@
 import { z } from "zod";
-export function registerSafelinkDecoder(server) {
-    server.tool("safelink-decoder", "Decode Microsoft Outlook SafeLink URLs", {
-        safelink: z.string().describe("SafeLink URL to decode")
+export function registerDecodeSafelink(server) {
+    server.registerTool("decode_safelink", {
+        description: "Decode Microsoft Outlook SafeLink URLs",
+        inputSchema: {
+            safelink: z.string().describe("SafeLink URL to decode")
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Decode Safelink",
+            description: "Decode Microsoft Outlook SafeLink URLs",
+            readOnlyHint: false
+        }
     }, async ({ safelink }) => {
         try {
             const url = new URL(safelink);

package/build/tools/forensic/{url-fanger → fang_url}/index.js

@@ -1,8 +1,17 @@
 import { z } from "zod";
-export function registerUrlFanger(server) {
-    server.tool("url-fanger", "Defang or refang URLs for safe sharing (security analysis)", {
-        text: z.string().describe("Text containing URLs to fang/defang"),
-        operation: z.enum(["defang", "refang"]).describe("Whether to defang (make safe) or refang (restore) URLs")
+export function registerFangUrl(server) {
+    server.registerTool("fang_url", {
+        description: "Defang or refang URLs for safe sharing (security analysis)",
+        inputSchema: {
+            text: z.string().describe("Text containing URLs to fang/defang"),
+            operation: z.enum(["defang", "refang"]).describe("Whether to defang (make safe) or refang (restore) URLs")
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Fang Url",
+            description: "Defang or refang URLs for safe sharing (security analysis)",
+            readOnlyHint: false
+        }
     }, async ({ text, operation }) => {
         try {
             let result = text;

package/build/tools/forensic/{file-type-identifier → identify_file_type}/index.js

@@ -1,9 +1,18 @@
 import { z } from "zod";
 import { Buffer } from 'buffer';
-export function registerFileTypeIdentifier(server) {
-    server.tool("file-type-identifier", "Identify file type based on magic numbers/file signatures", {
-        data: z.string().describe("Hex data or base64 data of file header"),
-        format: z.enum(["hex", "base64"]).describe("Format of the input data")
+export function registerIdentifyFileType(server) {
+    server.registerTool("identify_file_type", {
+        description: "Identify file type based on magic numbers/file signatures",
+        inputSchema: {
+            data: z.string().describe("Hex data or base64 data of file header"),
+            format: z.enum(["hex", "base64"]).describe("Format of the input data")
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Identify File Type",
+            description: "Identify file type based on magic numbers/file signatures",
+            readOnlyHint: false
+        }
     }, async ({ data, format }) => {
         try {
             let buffer;

package/build/tools/{idGenerators/qr-generate → id_generators/generate_qr_code}/index.js

@@ -1,8 +1,17 @@
 import { z } from "zod";
-export function registerQrGenerate(server) {
-    server.tool("qr-generate", "Generate QR code for any text including URLs, WiFi networks, contact info, etc.", {
-        text: z.string().describe("Text to encode in QR code (URLs, WiFi: WIFI:T:WPA;S:network;P:password;;, contact info, etc.)"),
-        size: z.number().describe("Size multiplier (1-3)").optional(),
+export function registerGenerateQr(server) {
+    server.registerTool("generate_qr_code", {
+        description: "Generate QR code for any text including URLs, WiFi networks, contact info, etc.",
+        inputSchema: {
+            text: z.string().describe("Text to encode in QR code (URLs, WiFi: WIFI:T:WPA;S:network;P:password;;, contact info, etc.)"),
+            size: z.number().describe("Size multiplier (1-3)").optional(),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Generate Qr Code",
+            description: "Generate QR code for any text including URLs, WiFi networks, contact info, etc",
+            readOnlyHint: false
+        }
     }, async ({ text, size = 1 }) => {
         try {
             const QRCode = (await import("qrcode")).default;

package/build/tools/{idGenerators/svg-placeholder-generator → id_generators/generate_svg_placeholder}/index.js

@@ -1,11 +1,20 @@
 import { z } from "zod";
-export function registerSvgPlaceholderGenerator(server) {
-    server.tool("svg-placeholder-generator", "Generate SVG placeholder images", {
-        width: z.number().describe("Width in pixels").optional(),
-        height: z.number().describe("Height in pixels").optional(),
-        backgroundColor: z.string().describe("Background color (hex)").optional(),
-        textColor: z.string().describe("Text color (hex)").optional(),
-        text: z.string().optional().describe("Custom text (default: dimensions)"),
+export function registerGenerateSvgPlaceholder(server) {
+    server.registerTool("generate_svg_placeholder", {
+        description: "Generate SVG placeholder images",
+        inputSchema: {
+            width: z.number().describe("Width in pixels").optional(),
+            height: z.number().describe("Height in pixels").optional(),
+            backgroundColor: z.string().describe("Background color (hex)").optional(),
+            textColor: z.string().describe("Text color (hex)").optional(),
+            text: z.string().optional().describe("Custom text (default: dimensions)"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Generate Svg Placeholder",
+            description: "Generate SVG placeholder images",
+            readOnlyHint: false
+        }
     }, async ({ width = 300, height = 200, backgroundColor = "#cccccc", textColor = "#666666", text }) => {
         try {
             if (width < 1 || width > 2000 || height < 1 || height > 2000) {

package/build/tools/{idGenerators/ulid-generate → id_generators/generate_ulid}/index.js

@@ -1,5 +1,14 @@
-export function registerUlidGenerate(server) {
-    server.tool("ulid-generate", "Generate Universally Unique Lexicographically Sortable Identifier", {}, async () => {
+export function registerGenerateUlid(server) {
+    server.registerTool("generate_ulid", {
+        description: "Generate Universally Unique Lexicographically Sortable Identifier (ULID). Example: creates time-sortable unique IDs like '01ARZ3NDEKTSV4RRFFQ69G5FAV'",
+        inputSchema: {},
+        // VS Code compliance annotations
+        annotations: {
+            title: "Generate ULID",
+            description: "Generate time-sortable unique identifiers (ULID)",
+            readOnlyHint: false
+        }
+    }, async () => {
         try {
             // Simplified ULID implementation
             const timestamp = Date.now();

package/build/tools/id_generators/generate_uuid/index.js

@@ -0,0 +1,23 @@
+import { randomUUID } from "crypto";
+export function registerGenerateUuid(server) {
+    server.registerTool("generate_uuid", {
+        description: 'Generate a universally unique identifier (UUID). Example: generates "550e8400-e29b-41d4-a716-446655440000"',
+        inputSchema: {},
+        // VS Code compliance annotations
+        annotations: {
+            title: "Generate Uuid",
+            description: "Generate a universally unique identifier (UUID)",
+            readOnlyHint: false
+        }
+    }, async () => {
+        const uuid = randomUUID();
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Generated UUID: ${uuid}`,
+                },
+            ],
+        };
+    });
+}

package/build/tools/math/{percentage-calculator → calculate_percentage}/index.js

@@ -1,9 +1,18 @@
 import { z } from "zod";
-export function registerPercentageCalculator(server) {
-    server.tool("percentage-calculator", "Calculate percentages, percentage of a number, or percentage change", {
-        operation: z.enum(["percentage-of", "what-percentage", "percentage-change"]).describe("Type of percentage calculation"),
-        value1: z.number().describe("First value"),
-        value2: z.number().describe("Second value")
+export function registerCalculatePercentage(server) {
+    server.registerTool("calculate_percentage", {
+        description: "Calculate percentages, percentage of a number, or percentage change",
+        inputSchema: {
+            operation: z.enum(["percentage-of", "what-percentage", "percentage-change"]).describe("Type of percentage calculation"),
+            value1: z.number().describe("First value"),
+            value2: z.number().describe("Second value")
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Calculate Percentage",
+            description: "Calculate percentages, percentage of a number, or percentage change",
+            readOnlyHint: false
+        }
     }, async ({ operation, value1, value2 }) => {
         try {
             let result;

package/build/tools/math/{number-base-converter → convert_number_base}/index.js

@@ -1,9 +1,18 @@
 import { z } from "zod";
-export function registerNumberBaseConverter(server) {
-    server.tool("number-base-converter", "Convert numbers between different bases (binary, octal, decimal, hexadecimal)", {
-        number: z.string().describe("Number to convert"),
-        fromBase: z.number().describe("Source base (2-36)"),
-        toBase: z.number().describe("Target base (2-36)")
+export function registerConvertNumberBase(server) {
+    server.registerTool("convert_number_base", {
+        description: "Convert numbers between different bases (binary, octal, decimal, hexadecimal)",
+        inputSchema: {
+            number: z.string().describe("Number to convert"),
+            fromBase: z.number().describe("Source base (2-36)"),
+            toBase: z.number().describe("Target base (2-36)")
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Convert Number Base",
+            description: "Convert numbers between different bases (binary, octal, decimal, hexadecimal)",
+            readOnlyHint: false
+        }
     }, async ({ number, fromBase, toBase }) => {
         try {
             if (fromBase < 2 || fromBase > 36 || toBase < 2 || toBase > 36) {

package/build/tools/math/{roman-numeral-converter → convert_roman_numerals}/index.js

@@ -1,7 +1,16 @@
 import { z } from "zod";
-export function registerRomanNumeralConverter(server) {
-    server.tool("roman-numeral-converter", "Convert between Arabic numbers and Roman numerals", {
-        input: z.string().describe("Number to convert (Arabic number 1-3999 or Roman numeral)")
+export function registerConvertRomanNumeral(server) {
+    server.registerTool("convert_roman_numerals", {
+        description: "Convert between Arabic numbers and Roman numerals",
+        inputSchema: {
+            input: z.string().describe("Number to convert (Arabic number 1-3999 or Roman numeral)")
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Convert Roman Numerals",
+            description: "Convert between Arabic numbers and Roman numerals",
+            readOnlyHint: false
+        }
     }, async ({ input }) => {
         try {
             // Auto-detect if input is a number or Roman numeral

package/build/tools/math/{temperature-converter → convert_temperature}/index.js

@@ -1,9 +1,18 @@
 import { z } from "zod";
-export function registerTemperatureConverter(server) {
-    server.tool("temperature-converter", "Convert temperatures between Celsius, Fahrenheit, and Kelvin", {
-        temperature: z.number().describe("Temperature value to convert"),
-        from: z.enum(["celsius", "fahrenheit", "kelvin"]).describe("Source temperature unit"),
-        to: z.enum(["celsius", "fahrenheit", "kelvin"]).describe("Target temperature unit")
+export function registerConvertTemperature(server) {
+    server.registerTool("convert_temperature", {
+        description: "Convert temperatures between Celsius, Fahrenheit, and Kelvin",
+        inputSchema: {
+            temperature: z.number().describe("Temperature value to convert"),
+            from: z.enum(["celsius", "fahrenheit", "kelvin"]).describe("Source temperature unit"),
+            to: z.enum(["celsius", "fahrenheit", "kelvin"]).describe("Target temperature unit")
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Convert Temperature",
+            description: "Convert temperatures between Celsius, Fahrenheit, and Kelvin",
+            readOnlyHint: false
+        }
     }, async ({ temperature, from, to }) => {
         try {
             // Convert to Celsius first

package/build/tools/math/{unix-timestamp-converter → convert_unix_timestamp}/index.js

@@ -1,7 +1,16 @@
 import { z } from "zod";
 export function registerUnixTimestampConverter(server) {
-    server.tool("unix-timestamp-converter", "Convert between Unix timestamps and human-readable dates", {
-        input: z.string().describe("Unix timestamp (seconds) or ISO date string")
+    server.registerTool("convert_unix_timestamp", {
+        description: "Convert between Unix timestamps and human-readable dates",
+        inputSchema: {
+            input: z.string().describe("Unix timestamp (seconds) or ISO date string")
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Unix-timestamp-converter",
+            description: "Convert between Unix timestamps and human-readable dates",
+            readOnlyHint: false
+        }
     }, async ({ input }) => {
         try {
             // Auto-detect if input is a timestamp or date string

package/build/tools/math/{math-evaluate → evaluate_math}/index.js

@@ -1,7 +1,16 @@
 import { z } from "zod";
-export function registerMathEvaluate(server) {
-    server.tool("math-evaluate", "Safely evaluate mathematical expressions", {
-        expression: z.string().describe("Mathematical expression to evaluate (e.g., '2 + 3 * 4')")
+export function registerEvaluateMath(server) {
+    server.registerTool("evaluate_math", {
+        description: "Safely evaluate mathematical expressions",
+        inputSchema: {
+            expression: z.string().describe("Mathematical expression to evaluate (e.g., '2 + 3 * 4')")
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Evaluate Math",
+            description: "Safely evaluate mathematical expressions",
+            readOnlyHint: false
+        }
     }, async ({ expression }) => {
         try {
             // @ts-ignore: Ignore missing type declarations for mathjs

package/build/tools/network/{ip-subnet-calculator → calculate_ip_subnet}/index.js

@@ -1,8 +1,17 @@
 import { z } from "zod";
 export function registerIpSubnetCalculator(server) {
-    server.tool("ip-subnet-calculator", "Calculate subnet information for IPv4", {
-        ip: z.string().describe("IPv4 address (e.g., 192.168.1.1)"),
-        cidr: z.number().describe("CIDR notation (e.g., 24)"),
+    server.registerTool("calculate_ip_subnet", {
+        description: "Calculate subnet information for IPv4",
+        inputSchema: {
+            ip: z.string().describe("IPv4 address (e.g., 192.168.1.1)"),
+            cidr: z.number().describe("CIDR notation (e.g., 24)"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Ip-subnet-calculator",
+            description: "Calculate subnet information for IPv4",
+            readOnlyHint: false
+        }
     }, async ({ ip, cidr }) => {
         try {
             if (cidr < 1 || cidr > 32) {

package/build/tools/network/{ipv4-subnet-calc → calculate_ipv4_subnet}/index.js

@@ -1,7 +1,16 @@
 import { z } from "zod";
 export function registerIpv4SubnetCalc(server) {
-    server.tool("ipv4-subnet-calc", "Calculate IPv4 subnet information", {
-        cidr: z.string().describe("IPv4 CIDR notation (e.g., 192.168.1.0/24)"),
+    server.registerTool("calculate_ipv4_subnet", {
+        description: "Calculate IPv4 subnet information",
+        inputSchema: {
+            cidr: z.string().describe("IPv4 CIDR notation (e.g., 192.168.1.0/24)"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Ipv4-subnet-calc",
+            description: "Calculate IPv4 subnet information",
+            readOnlyHint: false
+        }
     }, async ({ cidr }) => {
         try {
             const [ip, prefixLength] = cidr.split('/');

package/build/tools/network/{ipv6-subnet-calculator → calculate_ipv6_subnet}/index.js

@@ -1,8 +1,17 @@
 import { z } from "zod";
 export function registerIpv6SubnetCalculator(server) {
-    server.tool("ipv6-subnet-calculator", "Calculate IPv6 subnet information", {
-        ipv6: z.string().describe("IPv6 address and prefix (e.g., 2001:db8::/32)"),
-        newPrefix: z.number().optional().describe("New prefix length for subnetting")
+    server.registerTool("calculate_ipv6_subnet", {
+        description: "Calculate IPv6 subnet information",
+        inputSchema: {
+            ipv6: z.string().describe("IPv6 address and prefix (e.g., 2001:db8::/32)"),
+            newPrefix: z.number().optional().describe("New prefix length for subnetting")
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Ipv6-subnet-calculator",
+            description: "Calculate IPv6 subnet information",
+            readOnlyHint: false
+        }
     }, async ({ ipv6, newPrefix }) => {
         try {
             const [address, prefixStr] = ipv6.split('/');

package/build/tools/network/cat/index.js

@@ -1,8 +1,17 @@
 import { z } from "zod";
 import fs from "fs";
 export function registerCat(server) {
-    server.tool("cat", "Display content of a file", {
-        file: z.string().describe("File path")
+    server.registerTool("cat", {
+        description: "Display content of a file",
+        inputSchema: {
+            file: z.string().describe("File path")
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Cat",
+            description: "Display content of a file",
+            readOnlyHint: false
+        }
     }, async ({ file }) => {
         try {
             const data = fs.readFileSync(file, "utf8");

package/build/tools/network/{cidr-to-ip-range → convert_cidr_to_ip_range}/index.js

@@ -1,7 +1,16 @@
 import { z } from "zod";
 export function registerCidrToIpRange(server) {
-    server.tool("cidr-to-ip-range", "Convert CIDR notation to IP address range", {
-        cidr: z.string().describe("CIDR notation (e.g., 192.168.1.0/24)")
+    server.registerTool("convert_cidr_to_ip_range", {
+        description: "Convert CIDR notation to IP address range",
+        inputSchema: {
+            cidr: z.string().describe("CIDR notation (e.g., 192.168.1.0/24)")
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Cidr-to-ip-range",
+            description: "Convert CIDR notation to IP address range",
+            readOnlyHint: false
+        }
     }, async ({ cidr }) => {
         try {
             const [network, prefixLength] = cidr.split('/');

package/build/tools/network/{ip-range-to-cidr → convert_ip_range_to_cidr}/index.js

@@ -1,8 +1,17 @@
 import { z } from "zod";
 export function registerIpRangeToCidr(server) {
-    server.tool("ip-range-to-cidr", "Convert IP address range to CIDR notation(s)", {
-        startIP: z.string().describe("Starting IP address"),
-        endIP: z.string().describe("Ending IP address")
+    server.registerTool("convert_ip_range_to_cidr", {
+        description: "Convert IP address range to CIDR notation(s)",
+        inputSchema: {
+            startIP: z.string().describe("Starting IP address"),
+            endIP: z.string().describe("Ending IP address")
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Ip-range-to-cidr",
+            description: "Convert IP address range to CIDR notation(s)",
+            readOnlyHint: false
+        }
     }, async ({ startIP, endIP }) => {
         try {
             // Parse IP addresses

package/build/tools/network/curl/index.js

@@ -1,10 +1,19 @@
 import { z } from "zod";
 export function registerCurl(server) {
-    server.tool("curl", "Make HTTP requests (GET, POST, etc.) like curl", {
-        url: z.string().describe("URL to request"),
-        method: z.enum(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD"]).default("GET").describe("HTTP method"),
-        headers: z.record(z.string()).optional().describe("Request headers (object of key-value pairs)"),
-        body: z.string().optional().describe("Request body (for POST/PUT/PATCH)")
+    server.registerTool("curl", {
+        description: "Make HTTP requests to web endpoints. Example: GET request to an API or POST data to a server",
+        inputSchema: {
+            url: z.string().describe("URL to request"),
+            method: z.enum(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD"]).default("GET").describe("HTTP method"),
+            headers: z.record(z.string()).optional().describe("Request headers (object of key-value pairs)"),
+            body: z.string().optional().describe("Request body (for POST/PUT/PATCH)")
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Curl",
+            description: "Make HTTP requests to web endpoints",
+            readOnlyHint: false
+        }
     }, async ({ url, method, headers, body }) => {
         try {
             const controller = new AbortController();
@@ -27,7 +36,9 @@ export function registerCurl(server) {
         }
         catch (error) {
             if (error.name === 'AbortError') {
-                return { content: [{ type: "text", text: `curl failed: Request timeout (10s)` }] };
+                return {
+                    isError: true, content: [{ type: "text", text: `curl failed: Request timeout (10s)` }]
+                };
             }
             return { content: [{ type: "text", text: `curl failed: ${error.message || error}` }] };
         }

package/build/tools/network/dig/index.js

@@ -1,9 +1,18 @@
 import { z } from "zod";
 import dns from "dns";
 export function registerDig(server) {
-    server.tool("dig", "Perform DNS lookup with dig command", {
-        target: z.string().describe("Hostname or IP address"),
-        type: z.string().default("A").describe("DNS record type")
+    server.registerTool("dig", {
+        description: "Perform DNS lookup with dig command",
+        inputSchema: {
+            target: z.string().describe("Hostname or IP address"),
+            type: z.string().default("A").describe("DNS record type")
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Dig",
+            description: "Perform DNS lookup with dig command",
+            readOnlyHint: false
+        }
     }, async ({ target, type }) => {
         return new Promise((resolve) => {
             dns.resolve(target, type, (err, addresses) => {

package/build/tools/network/{ipv6-ula-generator → generate_ipv6_ula}/index.js

@@ -1,7 +1,16 @@
 import { z } from "zod";
 export function registerIpv6UlaGenerator(server) {
-    server.tool("ipv6-ula-generator", "Generate IPv6 Unique Local Address (ULA) prefix", {
-        globalId: z.string().optional().describe("Global ID (40 bits in hex, auto-generated if not provided)"),
+    server.registerTool("generate_ipv6_ula", {
+        description: "Generate IPv6 Unique Local Address (ULA) prefix",
+        inputSchema: {
+            globalId: z.string().optional().describe("Global ID (40 bits in hex, auto-generated if not provided)"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Ipv6-ula-generator",
+            description: "Generate IPv6 Unique Local Address (ULA) prefix",
+            readOnlyHint: false
+        }
     }, async ({ globalId }) => {
         try {
             // Generate random 40-bit Global ID if not provided

package/build/tools/network/{mac-address-generate → generate_mac_address}/index.js

@@ -1,8 +1,17 @@
 import { z } from "zod";
 export function registerMacAddressGenerate(server) {
-    server.tool("mac-address-generate", "Generate random MAC address", {
-        prefix: z.string().optional().describe("MAC address prefix (e.g., '00:1B:44')"),
-        separator: z.enum([":", "-"]).describe("Separator character").optional(),
+    server.registerTool("generate_mac_address", {
+        description: "Generate random MAC address",
+        inputSchema: {
+            prefix: z.string().optional().describe("MAC address prefix (e.g., '00:1B:44')"),
+            separator: z.enum([":", "-"]).describe("Separator character").optional(),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Mac-address-generate",
+            description: "Generate random MAC address",
+            readOnlyHint: false
+        }
     }, async ({ prefix, separator = ":" }) => {
         try {
             let macParts = [];

package/build/tools/network/{random-port → generate_random_port}/index.js

@@ -1,10 +1,19 @@
 import { z } from "zod";
 export function registerRandomPort(server) {
-    server.tool("random-port", "Generate random port numbers", {
-        count: z.number().describe("Number of ports to generate").optional(),
-        min: z.number().describe("Minimum port number").optional(),
-        max: z.number().describe("Maximum port number").optional(),
-        exclude: z.array(z.number()).optional().describe("Ports to exclude"),
+    server.registerTool("generate_random_port", {
+        description: "Generate random port numbers",
+        inputSchema: {
+            count: z.number().describe("Number of ports to generate").optional(),
+            min: z.number().describe("Minimum port number").optional(),
+            max: z.number().describe("Maximum port number").optional(),
+            exclude: z.array(z.number()).optional().describe("Ports to exclude"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Random-port",
+            description: "Generate random port numbers",
+            readOnlyHint: false
+        }
     }, async ({ count = 1, min = 1024, max = 65535, exclude = [] }) => {
         try {
             const ports = [];