it-tools-mcp 3.2.10 → 3.6.0

package/build/tools/physics/angle-converter/index.js

@@ -1,13 +1,16 @@
 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("angle-converter", {
+        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")
+        }
     }, async ({ value, fromUnit, toUnit }) => {
         try {
             // Conversion factors to degrees

package/build/tools/physics/energy-converter/index.js

@@ -1,15 +1,18 @@
 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("energy-converter", {
+        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")
+        }
     }, async ({ value, fromUnit, toUnit }) => {
         try {
             // Conversion factors to joules

package/build/tools/physics/power-converter/index.js

@@ -1,15 +1,18 @@
 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("power-converter", {
+        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")
+        }
     }, async ({ value, fromUnit, toUnit }) => {
         try {
             // Conversion factors to watts

package/build/tools/text/ascii-art-text/index.js

@@ -1,8 +1,11 @@
 import { z } from "zod";
 export function registerAsciiArtText(server) {
-    server.tool("ascii-art-text", "Generate ASCII art text", {
-        text: z.string().describe("Text to convert to ASCII art, or use 'LIST_FONTS' to get all available font names"),
-        font: z.string().describe("ASCII art font style. Supports all 295+ figlet fonts. Use 'standard' if unsure.").optional(),
+    server.registerTool("ascii-art-text", {
+        description: "Generate ASCII art text",
+        inputSchema: {
+            text: z.string().describe("Text to convert to ASCII art, or use 'LIST_FONTS' to get all available font names"),
+            font: z.string().describe("ASCII art font style. Supports all 295+ figlet fonts. Use 'standard' if unsure.").optional(),
+        }
     }, async ({ text, font = "standard" }) => {
         try {
             // Generate ASCII art using figlet

package/build/tools/text/distinct-words/index.js

@@ -1,7 +1,10 @@
 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("distinct-words", {
+        description: "Count distinct words in text and show their frequency",
+        inputSchema: {
+            text: z.string().describe("Text to analyze for distinct words")
+        }
     }, async ({ text }) => {
         // Remove punctuation and split into words
         const cleanedText = text.replace(/[^\w\s]/g, ' ').toLowerCase();

package/build/tools/text/emoji-search/index.js

@@ -1,7 +1,10 @@
 import { z } from "zod";
 export function registerEmojiSearch(server) {
-    server.tool("emoji-search", "Search for emojis by name or category", {
-        query: z.string().describe("Search term for emoji (name, category, or keyword)"),
+    server.registerTool("emoji-search", {
+        description: "Search for emojis by name or category",
+        inputSchema: {
+            query: z.string().describe("Search term for emoji (name, category, or keyword)"),
+        }
     }, async ({ query }) => {
         try {
             // Basic emoji database (simplified)

package/build/tools/text/lorem-ipsum-generator/index.js

@@ -1,8 +1,11 @@
 import { z } from "zod";
 export function registerLoremIpsumGenerator(server) {
-    server.tool("lorem-ipsum-generator", "Generate Lorem Ipsum placeholder text", {
-        count: z.number().describe("Number of items to generate").optional(),
-        type: z.enum(["words", "sentences", "paragraphs"]).describe("Type of content to generate").optional(),
+    server.registerTool("lorem-ipsum-generator", {
+        description: "Generate Lorem Ipsum placeholder text",
+        inputSchema: {
+            count: z.number().describe("Number of items to generate").optional(),
+            type: z.enum(["words", "sentences", "paragraphs"]).describe("Type of content to generate").optional(),
+        }
     }, async ({ count = 5, type = "sentences" }) => {
         try {
             if (count < 1 || count > 100) {

package/build/tools/text/numeronym-generator/index.js

@@ -1,7 +1,10 @@
 import { z } from "zod";
 export function registerNumeronymGenerator(server) {
-    server.tool("numeronym-generator", "Generate numeronyms (abbreviations with numbers) from text", {
-        text: z.string().describe("Text to convert to numeronym"),
+    server.registerTool("numeronym-generator", {
+        description: "Generate numeronyms (abbreviations with numbers) from text",
+        inputSchema: {
+            text: z.string().describe("Text to convert to numeronym"),
+        }
     }, async ({ text }) => {
         try {
             const words = text.trim().split(/\s+/);

package/build/tools/text/slugify-string/index.js

@@ -1,9 +1,12 @@
 import { z } from "zod";
 export function registerSlugifyString(server) {
-    server.tool("slugify-string", "Convert text to URL-friendly slug format", {
-        text: z.string().describe("Text to convert to slug"),
-        separator: z.string().describe("Character to use as separator").optional(),
-        lowercase: z.boolean().describe("Convert to lowercase").optional(),
+    server.registerTool("slugify-string", {
+        description: "Convert text to URL-friendly slug format",
+        inputSchema: {
+            text: z.string().describe("Text to convert to slug"),
+            separator: z.string().describe("Character to use as separator").optional(),
+            lowercase: z.boolean().describe("Convert to lowercase").optional(),
+        }
     }, async ({ text, separator = "-", lowercase = true }) => {
         try {
             let slug = text

package/build/tools/text/string-obfuscator/index.js

@@ -1,8 +1,11 @@
 import { z } from "zod";
 export function registerStringObfuscator(server) {
-    server.tool("string-obfuscator", "Obfuscate text by replacing characters with their HTML entities or other representations", {
-        text: z.string().describe("Text to obfuscate"),
-        method: z.enum(["html-entities", "unicode", "base64"]).describe("Obfuscation method").optional(),
+    server.registerTool("string-obfuscator", {
+        description: "Obfuscate text by replacing characters with their HTML entities or other representations",
+        inputSchema: {
+            text: z.string().describe("Text to obfuscate"),
+            method: z.enum(["html-entities", "unicode", "base64"]).describe("Obfuscation method").optional(),
+        }
     }, async ({ text, method = "html-entities" }) => {
         try {
             let result = '';

package/build/tools/text/text-camelcase/index.js

@@ -1,7 +1,10 @@
 import { z } from "zod";
 export function registerTextCamelcase(server) {
-    server.tool("text-camelcase", "Convert text to camelCase", {
-        text: z.string().describe("Text to convert to camelCase"),
+    server.registerTool("text-camelcase", {
+        description: "Convert text to camelCase",
+        inputSchema: {
+            text: z.string().describe("Text to convert to camelCase"),
+        }
     }, async ({ text }) => {
         const camelCase = text
             .replace(/(?:^\w|[A-Z]|\b\w)/g, (word, index) => {

package/build/tools/text/text-capitalize/index.js

@@ -1,7 +1,10 @@
 import { z } from "zod";
 export function registerTextCapitalize(server) {
-    server.tool("text-capitalize", "Capitalize first letter of each word", {
-        text: z.string().describe("Text to capitalize"),
+    server.registerTool("text-capitalize", {
+        description: "Capitalize first letter of each word",
+        inputSchema: {
+            text: z.string().describe("Text to capitalize"),
+        }
     }, async ({ text }) => {
         const capitalized = text.replace(/\b\w/g, l => l.toUpperCase());
         return {

package/build/tools/text/text-diff/index.js

@@ -1,8 +1,11 @@
 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("text-diff", {
+        description: "Compare two texts and show differences",
+        inputSchema: {
+            text1: z.string().describe("First text to compare"),
+            text2: z.string().describe("Second text to compare"),
+        }
     }, async ({ text1, text2 }) => {
         try {
             // Simple diff implementation

package/build/tools/text/text-kebabcase/index.js

@@ -1,7 +1,10 @@
 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("text-kebabcase", {
+        description: "Convert text to kebab-case",
+        inputSchema: {
+            text: z.string().describe("Text to convert to kebab-case"),
+        }
     }, async ({ text }) => {
         const kebabCase = text
             .replace(/([a-z])([A-Z])/g, '$1-$2')

package/build/tools/text/text-lowercase/index.js

@@ -1,7 +1,10 @@
 import { z } from "zod";
 export function registerTextLowercase(server) {
-    server.tool("text-lowercase", "Convert text to lowercase", {
-        text: z.string().describe("Text to convert to lowercase"),
+    server.registerTool("text-lowercase", {
+        description: "Convert text to lowercase",
+        inputSchema: {
+            text: z.string().describe("Text to convert to lowercase"),
+        }
     }, async ({ text }) => {
         return {
             content: [

package/build/tools/text/text-pascalcase/index.js

@@ -1,7 +1,10 @@
 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("text-pascalcase", {
+        description: "Convert text to PascalCase",
+        inputSchema: {
+            text: z.string().describe("Text to convert to PascalCase"),
+        }
     }, async ({ text }) => {
         const pascalCase = text
             .replace(/(?:^\w|[A-Z]|\b\w)/g, word => word.toUpperCase())

package/build/tools/text/text-snakecase/index.js

@@ -1,7 +1,10 @@
 import { z } from "zod";
 export function registerTextSnakecase(server) {
-    server.tool("text-snakecase", "Convert text to snake_case", {
-        text: z.string().describe("Text to convert to snake_case"),
+    server.registerTool("text-snakecase", {
+        description: "Convert text to snake_case",
+        inputSchema: {
+            text: z.string().describe("Text to convert to snake_case"),
+        }
     }, async ({ text }) => {
         const snakeCase = text
             .replace(/([a-z])([A-Z])/g, '$1_$2')

package/build/tools/text/text-stats/index.js

@@ -1,7 +1,10 @@
 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("text-stats", {
+        description: "Get statistics about text (character count, word count, etc.)",
+        inputSchema: {
+            text: z.string().describe("Text to analyze"),
+        }
     }, async ({ text }) => {
         const lines = text.split('\n');
         const words = text.trim().split(/\s+/).filter(word => word.length > 0);

package/build/tools/text/text-to-nato-alphabet/index.js

@@ -1,8 +1,11 @@
 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("text-to-nato-alphabet", {
+        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.)")
+        }
     }, async ({ text, language }) => {
         // NATO phonetic alphabet mappings
         const natoAlphabets = {

package/build/tools/text/text-to-unicode/index.js

@@ -1,8 +1,11 @@
 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("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"),
+        }
     }, async ({ input, operation }) => {
         try {
             if (operation === "encode") {

package/build/tools/text/text-to-unicode-names/index.js

@@ -1,7 +1,10 @@
 import { z } from "zod";
 export function registerTextToUnicodeNames(server) {
-    server.tool("text-to-unicode-names", "Convert text to Unicode character names", {
-        text: z.string().describe("Text to convert to Unicode names")
+    server.registerTool("text-to-unicode-names", {
+        description: "Convert text to Unicode character names",
+        inputSchema: {
+            text: z.string().describe("Text to convert to Unicode names")
+        }
     }, async ({ text }) => {
         const unicodeNames = [...text].map(char => {
             const codePoint = char.codePointAt(0);

package/build/tools/text/text-uppercase/index.js

@@ -1,7 +1,10 @@
 import { z } from "zod";
 export function registerTextUppercase(server) {
-    server.tool("text-uppercase", "Convert text to uppercase", {
-        text: z.string().describe("Text to convert to uppercase"),
+    server.registerTool("text-uppercase", {
+        description: "Convert text to uppercase",
+        inputSchema: {
+            text: z.string().describe("Text to convert to uppercase"),
+        }
     }, async ({ text }) => {
         return {
             content: [

package/build/tools/utility/css-prettifier/index.js

@@ -1,8 +1,11 @@
 import { z } from "zod";
 export function registerCssPrettifier(server) {
-    server.tool("css-prettifier", "Format and prettify CSS code", {
-        css: z.string().describe("CSS code to format"),
-        indentSize: z.number().optional().describe("Number of spaces for indentation (default: 2)")
+    server.registerTool("css-prettifier", {
+        description: "Format and prettify CSS code",
+        inputSchema: {
+            css: z.string().describe("CSS code to format"),
+            indentSize: z.number().optional().describe("Number of spaces for indentation (default: 2)")
+        }
     }, async ({ css, indentSize = 2 }) => {
         try {
             // Basic CSS prettifier implementation

package/build/tools/utility/device-info/index.js

@@ -1,5 +1,8 @@
 export function registerDeviceInfo(server) {
-    server.tool("device-info", "Get basic device/system information", {}, async () => {
+    server.registerTool("device-info", {
+        description: "Get basic device/system information",
+        inputSchema: {}
+    }, async () => {
         try {
             const info = {
                 platform: process.platform,

package/build/tools/utility/email-normalizer/index.js

@@ -1,7 +1,10 @@
 import { z } from "zod";
 export function registerEmailNormalizer(server) {
-    server.tool("email-normalizer", "Normalize email addresses (remove dots, plus aliases, etc.)", {
-        email: z.string().describe("Email address to normalize"),
+    server.registerTool("email-normalizer", {
+        description: "Normalize email addresses (remove dots, plus aliases, etc.)",
+        inputSchema: {
+            email: z.string().describe("Email address to normalize"),
+        }
     }, async ({ email }) => {
         try {
             // Basic email validation

package/build/tools/utility/http-status-codes/index.js

@@ -26,8 +26,11 @@ function getUsageHint(code) {
     return 'an unknown status';
 }
 export function registerHttpStatusCodes(server) {
-    server.tool("http-status-codes", "Get information about HTTP status codes", {
-        code: z.number().optional().describe("HTTP status code to look up (optional)"),
+    server.registerTool("http-status-codes", {
+        description: "Get information about HTTP status codes",
+        inputSchema: {
+            code: z.number().optional().describe("HTTP status code to look up (optional)"),
+        }
     }, async ({ code }) => {
         try {
             const statusCodes = {

package/build/tools/utility/mime-types/index.js

@@ -33,9 +33,12 @@ function getMimeDescription(mimeType) {
     return descriptions[mimeType] || 'No description available';
 }
 export function registerMimeTypes(server) {
-    server.tool("mime-types", "Look up MIME types for file extensions", {
-        input: z.string().describe("File extension (e.g., 'txt') or MIME type (e.g., 'text/plain')"),
-        lookupType: z.enum(["extension-to-mime", "mime-to-extension"]).describe("Lookup direction").optional(),
+    server.registerTool("mime-types", {
+        description: "Look up MIME types for file extensions",
+        inputSchema: {
+            input: z.string().describe("File extension (e.g., 'txt') or MIME type (e.g., 'text/plain')"),
+            lookupType: z.enum(["extension-to-mime", "mime-to-extension"]).describe("Lookup direction").optional(),
+        }
     }, async ({ input, lookupType = "extension-to-mime" }) => {
         try {
             if (lookupType === "extension-to-mime") {

package/build/tools/utility/port-numbers/index.js

@@ -1,7 +1,10 @@
 import { z } from "zod";
 export function registerPortNumbers(server) {
-    server.tool("port-numbers", "Look up common TCP/UDP port numbers and their services", {
-        query: z.string().describe("Port number or service name to look up")
+    server.registerTool("port-numbers", {
+        description: "Look up common TCP/UDP port numbers and their services",
+        inputSchema: {
+            query: z.string().describe("Port number or service name to look up")
+        }
     }, async ({ query }) => {
         try {
             const ports = {

package/build/tools/utility/rem-px-converter/index.js

@@ -1,9 +1,12 @@
 import { z } from "zod";
 export function registerRemPxConverter(server) {
-    server.tool("rem-px-converter", "Convert between REM and PX units for CSS", {
-        value: z.number().describe("Value to convert"),
-        fromUnit: z.enum(["rem", "px"]).describe("Source unit"),
-        rootFontSize: z.number().optional().describe("Root font size in pixels (default: 16)")
+    server.registerTool("rem-px-converter", {
+        description: "Convert between REM and PX units for CSS. Example: Convert 1.5rem to pixels, or 24px to rem units.",
+        inputSchema: {
+            value: z.number().min(0).describe("Value to convert (e.g., 1.5 for 1.5rem or 24 for 24px)"),
+            fromUnit: z.enum(["rem", "px"]).describe("Source unit - either 'rem' or 'px'"),
+            rootFontSize: z.number().min(1).max(100).default(16).describe("Root font size in pixels (default: 16px - standard browser default)")
+        }
     }, async ({ value, fromUnit, rootFontSize = 16 }) => {
         try {
             let result;
@@ -53,6 +56,7 @@ Notes:
         }
         catch (error) {
             return {
+                isError: true,
                 content: [{
                         type: "text",
                         text: `Error converting REM/PX: ${error instanceof Error ? error.message : 'Unknown error'}`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "it-tools-mcp",
-  "version": "3.2.10",
+  "version": "3.6.0",
   "description": "MCP server providing access to various IT tools and utilities for developers",
   "type": "module",
   "main": "./build/index.js",