it-tools-mcp 3.2.12 → 4.0.0

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

@@ -1,9 +1,18 @@
 import { z } from "zod";
 import fs from "fs";
 export function registerGrep(server) {
-    server.tool("grep", "Search for patterns in files", {
-        pattern: z.string().describe("Pattern to search for"),
-        file: z.string().describe("File path")
+    server.registerTool("grep", {
+        description: "Search for patterns in files",
+        inputSchema: {
+            pattern: z.string().describe("Pattern to search for"),
+            file: z.string().describe("File path")
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Grep",
+            description: "Search for patterns in files",
+            readOnlyHint: false
+        }
     }, async ({ pattern, file }) => {
         try {
             const data = fs.readFileSync(file, "utf8");

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

@@ -1,9 +1,18 @@
 import { z } from "zod";
 import fs from "fs";
 export function registerHead(server) {
-    server.tool("head", "Display the beginning of a file", {
-        file: z.string().describe("File path"),
-        lines: z.number().default(10).describe("Number of lines")
+    server.registerTool("head", {
+        description: "Display the beginning of a file",
+        inputSchema: {
+            file: z.string().describe("File path"),
+            lines: z.number().default(10).describe("Number of lines")
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Head",
+            description: "Display the beginning of a file",
+            readOnlyHint: false
+        }
     }, async ({ file, lines }) => {
         try {
             const data = fs.readFileSync(file, "utf8");

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

@@ -1,8 +1,17 @@
 import { z } from "zod";
 import dns from "dns";
 export function registerNslookup(server) {
-    server.tool("nslookup", "Perform DNS lookup on a hostname or IP address", {
-        target: z.string().describe("Hostname or IP address")
+    server.registerTool("nslookup", {
+        description: "Perform DNS lookup on a hostname or IP address",
+        inputSchema: {
+            target: z.string().describe("Hostname or IP address")
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Nslookup",
+            description: "Perform DNS lookup on a hostname or IP address",
+            readOnlyHint: false
+        }
     }, async ({ target }) => {
         return new Promise((resolve) => {
             dns.lookup(target, (err, address, family) => {

package/build/tools/network/{url-parse → parse_url}/index.js

@@ -1,7 +1,16 @@
 import { z } from "zod";
 export function registerUrlParse(server) {
-    server.tool("url-parse", "Parse URL into components", {
-        url: z.string().describe("URL to parse"),
+    server.registerTool("parse_url", {
+        description: "Parse URL into components",
+        inputSchema: {
+            url: z.string().describe("URL to parse"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Url-parse",
+            description: "Parse URL into components",
+            readOnlyHint: false
+        }
     }, async ({ url }) => {
         try {
             const urlObj = new URL(url);

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

@@ -1,9 +1,18 @@
 import { z } from "zod";
 import ping from "ping";
 export function registerPing(server) {
-    server.tool("ping", "Ping a host to check connectivity", {
-        target: z.string().describe("Host to ping"),
-        count: z.number().default(4).describe("Number of ping attempts")
+    server.registerTool("ping", {
+        description: "Test network connectivity to a host. Example: ping google.com to check if it's reachable",
+        inputSchema: {
+            target: z.string().describe("Host to ping"),
+            count: z.number().default(4).describe("Number of ping attempts")
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Ping",
+            description: "Test network connectivity to a host",
+            readOnlyHint: false
+        }
     }, async ({ target, count }) => {
         try {
             const res = await ping.promise.probe(target, { min_reply: count });
@@ -14,7 +23,9 @@ export function registerPing(server) {
             };
         }
         catch (error) {
-            return { content: [{ type: "text", text: `Ping failed: ${error instanceof Error ? error.message : error}` }] };
+            return {
+                isError: true, content: [{ type: "text", text: `Ping failed: ${error instanceof Error ? error.message : error}` }]
+            };
         }
     });
 }

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

@@ -1,6 +1,15 @@
 import psList from "ps-list";
 export function registerPs(server) {
-    server.tool("ps", "List running processes", {}, async () => {
+    server.registerTool("ps", {
+        description: "List running processes",
+        inputSchema: {},
+        // VS Code compliance annotations
+        annotations: {
+            title: "Ps",
+            description: "List running processes",
+            readOnlyHint: false
+        }
+    }, async () => {
         try {
             const processes = await psList();
             // Defensive: handle missing properties and filter out bad entries

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

@@ -37,13 +37,22 @@ function resolvePrivateKey(privateKeyArg) {
     return privateKeyArg;
 }
 export function registerScp(server) {
-    server.tool("scp", "Copy files to or from a remote host using SFTP (SCP-like)", {
-        target: z.string().describe("Target host"),
-        user: z.string().describe("Username"),
-        direction: z.enum(["upload", "download"]).describe("Direction: upload (local to remote) or download (remote to local)"),
-        localPath: z.string().describe("Local file path (source for upload, destination for download)"),
-        remotePath: z.string().describe("Remote file path (destination for upload, source for download)"),
-        privateKey: z.string().optional().describe("Private key for authentication (PEM format, optional, or path to key file)")
+    server.registerTool("scp", {
+        description: "Copy files to or from a remote host using SFTP (SCP-like)",
+        inputSchema: {
+            target: z.string().describe("Target host"),
+            user: z.string().describe("Username"),
+            direction: z.enum(["upload", "download"]).describe("Direction: upload (local to remote) or download (remote to local)"),
+            localPath: z.string().describe("Local file path (source for upload, destination for download)"),
+            remotePath: z.string().describe("Remote file path (destination for upload, source for download)"),
+            privateKey: z.string().optional().describe("Private key for authentication (PEM format, optional, or path to key file)")
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Scp",
+            description: "Copy files to or from a remote host using SFTP (SCP-like)",
+            readOnlyHint: false
+        }
     }, async ({ target, user, direction, localPath, remotePath, privateKey }) => {
         try {
             const { Client } = await import("ssh2");

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

@@ -38,11 +38,20 @@ function resolvePrivateKey(privateKeyArg) {
     return privateKeyArg;
 }
 export function registerSsh(server) {
-    server.tool("ssh", "Connect to a target via SSH", {
-        target: z.string().describe("Target host"),
-        user: z.string().describe("Username"),
-        command: z.string().describe("Command to run on remote host"),
-        privateKey: z.string().optional().describe("Private key for authentication (PEM format, optional, or path to key file)")
+    server.registerTool("ssh", {
+        description: "Connect to a target via SSH",
+        inputSchema: {
+            target: z.string().describe("Target host"),
+            user: z.string().describe("Username"),
+            command: z.string().describe("Command to run on remote host"),
+            privateKey: z.string().optional().describe("Private key for authentication (PEM format, optional, or path to key file)")
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Ssh",
+            description: "Connect to a target via SSH",
+            readOnlyHint: false
+        }
     }, async ({ target, user, command, privateKey }) => {
         return new Promise((resolve) => {
             let resolvedKey;

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

@@ -1,9 +1,18 @@
 import { z } from "zod";
 import readLastLines from "read-last-lines";
 export function registerTail(server) {
-    server.tool("tail", "Display the end of a file", {
-        file: z.string().describe("File path"),
-        lines: z.number().default(10).describe("Number of lines")
+    server.registerTool("tail", {
+        description: "Display the end of a file",
+        inputSchema: {
+            file: z.string().describe("File path"),
+            lines: z.number().default(10).describe("Number of lines")
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Tail",
+            description: "Display the end of a file",
+            readOnlyHint: false
+        }
     }, async ({ file, lines }) => {
         try {
             const out = await readLastLines.read(file, lines);

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

@@ -1,8 +1,17 @@
 import { z } from "zod";
 export function registerTelnet(server) {
-    server.tool("telnet", "Test TCP connectivity to a host and port", {
-        target: z.string().describe("Host to connect to"),
-        port: z.number().describe("Port number")
+    server.registerTool("telnet", {
+        description: "Test TCP connectivity to a host and port",
+        inputSchema: {
+            target: z.string().describe("Host to connect to"),
+            port: z.number().describe("Port number")
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Telnet",
+            description: "Test TCP connectivity to a host and port",
+            readOnlyHint: false
+        }
     }, async ({ target, port }) => {
         return new Promise(async (resolve) => {
             try {

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

@@ -1,6 +1,15 @@
 import psList from "ps-list";
 export function registerTop(server) {
-    server.tool("top", "Display system processes (snapshot)", {}, async () => {
+    server.registerTool("top", {
+        description: "Display system processes (snapshot)",
+        inputSchema: {},
+        // VS Code compliance annotations
+        annotations: {
+            title: "Top",
+            description: "Display system processes (snapshot)",
+            readOnlyHint: false
+        }
+    }, async () => {
         try {
             const processes = await psList();
             const sorted = processes.sort((a, b) => (b.cpu || 0) - (a.cpu || 0)).slice(0, 10);

package/build/tools/network/{iban-validate → validate_iban}/index.js

@@ -1,7 +1,16 @@
 import { z } from "zod";
 export function registerIbanValidate(server) {
-    server.tool("iban-validate", "Validate and parse IBAN (International Bank Account Number)", {
-        iban: z.string().describe("IBAN to validate and parse"),
+    server.registerTool("validate_iban", {
+        description: "Validate and parse IBAN (International Bank Account Number)",
+        inputSchema: {
+            iban: z.string().describe("IBAN to validate and parse"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Iban-validate",
+            description: "Validate and parse IBAN (International Bank Account Number)",
+            readOnlyHint: false
+        }
     }, async ({ iban }) => {
         try {
             const IBAN = (await import("iban")).default;

package/build/tools/physics/{angle-converter → convert_angle}/index.js

@@ -1,13 +1,22 @@
 import { z } from "zod";
 export function registerAngleConverter(server) {
-    server.tool("angle-converter", "Convert between different angle units", {
-        value: z.number().describe("Angle value to convert"),
-        fromUnit: z.enum([
-            "degree", "radian", "gradian", "turn", "arcminute", "arcsecond"
-        ]).describe("Source angle unit"),
-        toUnit: z.enum([
-            "degree", "radian", "gradian", "turn", "arcminute", "arcsecond"
-        ]).describe("Target angle unit")
+    server.registerTool("convert_angle", {
+        description: "Convert between different angle units",
+        inputSchema: {
+            value: z.number().describe("Angle value to convert"),
+            fromUnit: z.enum([
+                "degree", "radian", "gradian", "turn", "arcminute", "arcsecond"
+            ]).describe("Source angle unit"),
+            toUnit: z.enum([
+                "degree", "radian", "gradian", "turn", "arcminute", "arcsecond"
+            ]).describe("Target angle unit")
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Convert Angle",
+            description: "Convert between different angle units",
+            readOnlyHint: false
+        }
     }, async ({ value, fromUnit, toUnit }) => {
         try {
             // Conversion factors to degrees

package/build/tools/physics/{energy-converter → convert_energy}/index.js

@@ -1,15 +1,24 @@
 import { z } from "zod";
 export function registerEnergyConverter(server) {
-    server.tool("energy-converter", "Convert between different energy units", {
-        value: z.number().describe("Energy value to convert"),
-        fromUnit: z.enum([
-            "joule", "kilojoule", "calorie", "kilocalorie", "btu",
-            "watt-hour", "kilowatt-hour", "electronvolt", "foot-pound"
-        ]).describe("Source energy unit"),
-        toUnit: z.enum([
-            "joule", "kilojoule", "calorie", "kilocalorie", "btu",
-            "watt-hour", "kilowatt-hour", "electronvolt", "foot-pound"
-        ]).describe("Target energy unit")
+    server.registerTool("convert_energy", {
+        description: "Convert between different energy units",
+        inputSchema: {
+            value: z.number().describe("Energy value to convert"),
+            fromUnit: z.enum([
+                "joule", "kilojoule", "calorie", "kilocalorie", "btu",
+                "watt-hour", "kilowatt-hour", "electronvolt", "foot-pound"
+            ]).describe("Source energy unit"),
+            toUnit: z.enum([
+                "joule", "kilojoule", "calorie", "kilocalorie", "btu",
+                "watt-hour", "kilowatt-hour", "electronvolt", "foot-pound"
+            ]).describe("Target energy unit")
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Convert Energy",
+            description: "Convert between different energy units",
+            readOnlyHint: false
+        }
     }, async ({ value, fromUnit, toUnit }) => {
         try {
             // Conversion factors to joules

package/build/tools/physics/{power-converter → convert_power}/index.js

@@ -1,15 +1,24 @@
 import { z } from "zod";
 export function registerPowerConverter(server) {
-    server.tool("power-converter", "Convert between different power units", {
-        value: z.number().describe("Power value to convert"),
-        fromUnit: z.enum([
-            "watt", "kilowatt", "megawatt", "horsepower", "metric-horsepower",
-            "btu-per-hour", "calorie-per-second", "foot-pound-per-second"
-        ]).describe("Source power unit"),
-        toUnit: z.enum([
-            "watt", "kilowatt", "megawatt", "horsepower", "metric-horsepower",
-            "btu-per-hour", "calorie-per-second", "foot-pound-per-second"
-        ]).describe("Target power unit")
+    server.registerTool("convert_power", {
+        description: "Convert between different power units",
+        inputSchema: {
+            value: z.number().describe("Power value to convert"),
+            fromUnit: z.enum([
+                "watt", "kilowatt", "megawatt", "horsepower", "metric-horsepower",
+                "btu-per-hour", "calorie-per-second", "foot-pound-per-second"
+            ]).describe("Source power unit"),
+            toUnit: z.enum([
+                "watt", "kilowatt", "megawatt", "horsepower", "metric-horsepower",
+                "btu-per-hour", "calorie-per-second", "foot-pound-per-second"
+            ]).describe("Target power unit")
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Convert Power",
+            description: "Convert between different power units",
+            readOnlyHint: false
+        }
     }, async ({ value, fromUnit, toUnit }) => {
         try {
             // Conversion factors to watts

package/build/tools/text/{distinct-words → analyze_distinct_words}/index.js

@@ -1,7 +1,16 @@
 import { z } from "zod";
 export function registerDistinctWords(server) {
-    server.tool("distinct-words", "Count distinct words in text and show their frequency", {
-        text: z.string().describe("Text to analyze for distinct words")
+    server.registerTool("analyze_distinct_words", {
+        description: "Count distinct words in text and show their frequency",
+        inputSchema: {
+            text: z.string().describe("Text to analyze for distinct words")
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Analyze Distinct Words",
+            description: "Count distinct words in text and show their frequency",
+            readOnlyHint: true
+        }
     }, async ({ text }) => {
         // Remove punctuation and split into words
         const cleanedText = text.replace(/[^\w\s]/g, ' ').toLowerCase();

package/build/tools/text/{text-stats → analyze_text_stats}/index.js

@@ -1,7 +1,16 @@
 import { z } from "zod";
 export function registerTextStats(server) {
-    server.tool("text-stats", "Get statistics about text (character count, word count, etc.)", {
-        text: z.string().describe("Text to analyze"),
+    server.registerTool("analyze_text_stats", {
+        description: "Get statistics about text (character count, word count, etc.)",
+        inputSchema: {
+            text: z.string().describe("Text to analyze"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Analyze Text Stats",
+            description: "Get statistics about text (character count, word count, etc",
+            readOnlyHint: true
+        }
     }, async ({ text }) => {
         const lines = text.split('\n');
         const words = text.trim().split(/\s+/).filter(word => word.length > 0);

package/build/tools/text/capitalize_text/index.js

@@ -0,0 +1,25 @@
+import { z } from "zod";
+export function registerTextCapitalize(server) {
+    server.registerTool("capitalize_text", {
+        description: "Capitalize first letter of each word",
+        inputSchema: {
+            text: z.string().describe("Text to capitalize"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Capitalize Text",
+            description: "Capitalize first letter of each word",
+            readOnlyHint: false
+        }
+    }, async ({ text }) => {
+        const capitalized = text.replace(/\b\w/g, l => l.toUpperCase());
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Capitalized: ${capitalized}`,
+                },
+            ],
+        };
+    });
+}

package/build/tools/text/{text-diff → compare_text}/index.js

@@ -1,8 +1,17 @@
 import { z } from "zod";
 export function registerTextDiff(server) {
-    server.tool("text-diff", "Compare two texts and show differences", {
-        text1: z.string().describe("First text to compare"),
-        text2: z.string().describe("Second text to compare"),
+    server.registerTool("compare_text", {
+        description: "Compare two texts and show differences",
+        inputSchema: {
+            text1: z.string().describe("First text to compare"),
+            text2: z.string().describe("Second text to compare"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Compare Text",
+            description: "Compare two texts and show differences",
+            readOnlyHint: false
+        }
     }, async ({ text1, text2 }) => {
         try {
             // Simple diff implementation

package/build/tools/text/convert_text_to_camelcase/index.js

@@ -0,0 +1,29 @@
+import { z } from "zod";
+export function registerTextCamelcase(server) {
+    server.registerTool("convert_text_to_camelcase", {
+        description: "Convert text to camelCase format. Example: 'hello world' → 'helloWorld', 'my-variable-name' → 'myVariableName'",
+        inputSchema: {
+            text: z.string().describe("Text to convert to camelCase"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Convert to camelCase",
+            description: "Convert text to camelCase naming convention",
+            readOnlyHint: false
+        }
+    }, async ({ text }) => {
+        const camelCase = text
+            .replace(/(?:^\w|[A-Z]|\b\w)/g, (word, index) => {
+            return index === 0 ? word.toLowerCase() : word.toUpperCase();
+        })
+            .replace(/\s+/g, '');
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `camelCase: ${camelCase}`,
+                },
+            ],
+        };
+    });
+}

package/build/tools/text/{text-kebabcase → convert_text_to_kebabcase}/index.js

@@ -1,7 +1,16 @@
 import { z } from "zod";
 export function registerTextKebabcase(server) {
-    server.tool("text-kebabcase", "Convert text to kebab-case", {
-        text: z.string().describe("Text to convert to kebab-case"),
+    server.registerTool("convert_text_to_kebabcase", {
+        description: "Convert text to kebab-case",
+        inputSchema: {
+            text: z.string().describe("Text to convert to kebab-case"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Convert Text To Kebabcase",
+            description: "Convert text to kebab-case",
+            readOnlyHint: false
+        }
     }, async ({ text }) => {
         const kebabCase = text
             .replace(/([a-z])([A-Z])/g, '$1-$2')

package/build/tools/text/convert_text_to_lowercase/index.js

@@ -0,0 +1,24 @@
+import { z } from "zod";
+export function registerTextLowercase(server) {
+    server.registerTool("convert_text_to_lowercase", {
+        description: "Convert text to lowercase",
+        inputSchema: {
+            text: z.string().describe("Text to convert to lowercase"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Convert Text To Lowercase",
+            description: "Convert text to lowercase",
+            readOnlyHint: false
+        }
+    }, async ({ text }) => {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Lowercase: ${text.toLowerCase()}`,
+                },
+            ],
+        };
+    });
+}

package/build/tools/text/{text-to-nato-alphabet → convert_text_to_nato}/index.js

@@ -1,8 +1,17 @@
 import { z } from "zod";
 export function registerTextToNatoAlphabet(server) {
-    server.tool("text-to-nato-alphabet", "Convert text to NATO phonetic alphabet", {
-        text: z.string().describe("Text to convert to NATO phonetic alphabet"),
-        language: z.string().optional().default("International").describe("Language/country variant (International, France, Germany, etc.)")
+    server.registerTool("convert_text_to_nato", {
+        description: "Convert text to NATO phonetic alphabet",
+        inputSchema: {
+            text: z.string().describe("Text to convert to NATO phonetic alphabet"),
+            language: z.string().optional().default("International").describe("Language/country variant (International, France, Germany, etc.)")
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Convert Text To Nato",
+            description: "Convert text to NATO phonetic alphabet",
+            readOnlyHint: false
+        }
     }, async ({ text, language }) => {
         // NATO phonetic alphabet mappings
         const natoAlphabets = {

package/build/tools/text/{text-pascalcase → convert_text_to_pascalcase}/index.js

@@ -1,7 +1,16 @@
 import { z } from "zod";
 export function registerTextPascalcase(server) {
-    server.tool("text-pascalcase", "Convert text to PascalCase", {
-        text: z.string().describe("Text to convert to PascalCase"),
+    server.registerTool("convert_text_to_pascalcase", {
+        description: "Convert text to PascalCase",
+        inputSchema: {
+            text: z.string().describe("Text to convert to PascalCase"),
+        },
+        // VS Code compliance annotations
+        annotations: {
+            title: "Convert Text To Pascalcase",
+            description: "Convert text to PascalCase",
+            readOnlyHint: false
+        }
     }, async ({ text }) => {
         const pascalCase = text
             .replace(/(?:^\w|[A-Z]|\b\w)/g, word => word.toUpperCase())

package/build/tools/text/{text-to-unicode → convert_text_to_unicode}/index.js

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