it-tools-mcp 3.0.4 → 3.0.6

package/build/index.js

@@ -2,37 +2,45 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { getResourceUsage } from "./security.js";
-// Import tool modules
-import { registerEncodingTools } from "./tools/encoding.js";
-import { registerCryptoTools } from "./tools/crypto.js";
-import { registerDataFormatTools } from "./tools/dataFormat.js";
-import { registerTextTools } from "./tools/text.js";
-import { registerIdGeneratorTools } from "./tools/idGenerators.js";
-import { registerNetworkTools } from "./tools/network.js";
-import { registerMathTools } from "./tools/math.js";
-import { registerUtilityTools } from "./tools/utility.js";
-import { registerDevelopmentTools } from "./tools/development.js";
-import { registerColorTools } from "./tools/color.js";
+import fs from 'fs';
+import path from 'path';
+// Helper to read version from package.json at runtime (ESM compatible)
+function getPackageVersion() {
+    // Use import.meta.url to get the directory in ESM
+    const __dirname = path.dirname(new URL(import.meta.url).pathname);
+    const pkgPath = path.resolve(__dirname, '../package.json');
+    const pkgRaw = fs.readFileSync(pkgPath, 'utf-8');
+    return JSON.parse(pkgRaw).version;
+}
 // Create server instance
 const server = new McpServer({
     name: "it-tools-mcp",
-    version: "3.0.0",
+    version: getPackageVersion(),
     capabilities: {
         resources: {},
         tools: {},
     },
 });
-// Register all tool modules
-registerEncodingTools(server);
-registerCryptoTools(server);
-registerDataFormatTools(server);
-registerTextTools(server);
-registerIdGeneratorTools(server);
-registerNetworkTools(server);
-registerMathTools(server);
-registerUtilityTools(server);
-registerDevelopmentTools(server);
-registerColorTools(server);
+// Register all tool modules (dynamically for faster startup, with per-module timing)
+async function registerAllTools(server) {
+    const modules = [
+        { name: 'encoding', fn: () => import('./tools/encoding.js').then(m => m.registerEncodingTools(server)) },
+        { name: 'crypto', fn: () => import('./tools/crypto.js').then(m => m.registerCryptoTools(server)) },
+        { name: 'dataFormat', fn: () => import('./tools/dataFormat.js').then(m => m.registerDataFormatTools(server)) },
+        { name: 'text', fn: () => import('./tools/text.js').then(m => m.registerTextTools(server)) },
+        { name: 'idGenerators', fn: () => import('./tools/idGenerators.js').then(m => m.registerIdGeneratorTools(server)) },
+        { name: 'network', fn: () => import('./tools/network.js').then(m => m.registerNetworkTools(server)) },
+        { name: 'math', fn: () => import('./tools/math.js').then(m => m.registerMathTools(server)) },
+        { name: 'utility', fn: () => import('./tools/utility.js').then(m => m.registerUtilityTools(server)) },
+        { name: 'development', fn: () => import('./tools/development.js').then(m => m.registerDevelopmentTools(server)) },
+        { name: 'color', fn: () => import('./tools/color.js').then(m => m.registerColorTools(server)) },
+    ];
+    for (const mod of modules) {
+        console.time(`register:${mod.name}`);
+        await mod.fn();
+        console.timeEnd(`register:${mod.name}`);
+    }
+}
 // Add resource monitoring tool
 server.tool("system-info", "Get system resource usage and server information", {}, async () => {
     const usage = getResourceUsage();
@@ -42,7 +50,7 @@ server.tool("system-info", "Get system resource usage and server information", {
                 type: "text",
                 text: JSON.stringify({
                     server: "IT Tools MCP Server",
-                    version: "3.0.0",
+                    version: getPackageVersion(),
                     uptime: `${Math.floor(usage.uptimeSeconds)} seconds`,
                     memory: usage.memory,
                     timestamp: new Date().toISOString(),
@@ -53,8 +61,13 @@ server.tool("system-info", "Get system resource usage and server information", {
 });
 // Run the server
 async function main() {
+    console.time("Tool registration");
+    await registerAllTools(server);
+    console.timeEnd("Tool registration");
     const transport = new StdioServerTransport();
+    console.time("Server connect");
     await server.connect(transport);
+    console.timeEnd("Server connect");
     // Log startup with resource info
     console.error("IT Tools MCP Server running on stdio");
     console.error("Resource usage:", JSON.stringify(getResourceUsage(), null, 2));
@@ -68,7 +81,9 @@ async function main() {
             }
         }, 5 * 60 * 1000);
     }
+    console.timeEnd("Total startup");
 }
+console.time("Total startup");
 main().catch((error) => {
     console.error("Fatal error in main():", error);
     process.exit(1);

package/build/tools/dataFormat.js

@@ -1,10 +1,3 @@
-import * as toml from "@iarna/toml";
-import * as YAML from "js-yaml";
-import Papa from "papaparse";
-import { format as formatSQL } from "sql-formatter";
-import formatXML from "xml-formatter";
-import { marked } from "marked";
-import TurndownService from "turndown";
 import { z } from "zod";
 export function registerDataFormatTools(server) {
     // JSON formatting tool
@@ -132,12 +125,13 @@ Examples of supported formats:
             };
         }
     });
-    // JSON to CSV converter
+    // CSV converter (using papaparse)
     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(),
     }, async ({ json, delimiter = "," }) => {
         try {
+            const Papa = (await import("papaparse")).default;
             const data = JSON.parse(json);
             if (!Array.isArray(data)) {
                 throw new Error("JSON must be an array of objects");
@@ -163,54 +157,12 @@ Examples of supported formats:
             };
         }
     });
-    // XML formatter tool
-    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(),
-    }, async ({ xml, indent = 2 }) => {
-        try {
-            const formatted = formatXML(xml, {
-                indentation: ' '.repeat(indent),
-                filter: (node) => node.type !== 'Comment',
-                collapseContent: true,
-                lineSeparator: '\n'
-            });
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Formatted XML:
-
-${formatted}
-
-✅ XML formatted successfully
-🎯 Features: ${indent}-space indentation, collapsed content, clean structure`,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error formatting XML: ${error instanceof Error ? error.message : 'Unknown error'}
-
-💡 Common XML issues:
-• Check that all tags are properly closed
-• Ensure proper nesting of elements
-• Validate attribute syntax (key="value")
-• Check for special character encoding`,
-                    },
-                ],
-            };
-        }
-    });
     // YAML formatter tool
     server.tool("yaml-format", "Format and prettify YAML", {
         yaml: z.string().describe("YAML string to format"),
     }, async ({ yaml }) => {
         try {
+            const YAML = await import("js-yaml");
             // Parse YAML to validate and then dump with proper formatting
             const parsed = YAML.load(yaml);
             // Format with proper indentation and options
@@ -261,18 +213,56 @@ ${formatted.trim()}
             };
         }
     });
+    // XML formatter tool
+    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(),
+    }, async ({ xml, indent = 2 }) => {
+        try {
+            const formatXML = (await import("xml-formatter")).default;
+            const formatted = formatXML(xml, {
+                indentation: ' '.repeat(indent),
+                collapseContent: true,
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Formatted XML:
+
+${formatted}
+
+✅ XML formatted successfully
+🎯 Features: ${indent}-space indentation, collapsed content, clean structure`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error formatting XML: ${error instanceof Error ? error.message : 'Unknown error'}
+
+💡 Common XML issues:
+• Check that all tags are properly closed
+• Ensure proper nesting of elements
+• Validate attribute syntax (key="value")
+• Check for special character encoding`,
+                    },
+                ],
+            };
+        }
+    });
     // SQL formatter tool
     server.tool("sql-format", "Format and prettify SQL queries", {
         sql: z.string().describe("SQL query to format"),
     }, async ({ sql }) => {
         try {
+            const { format: formatSQL } = await import("sql-formatter");
             const formatted = formatSQL(sql, {
-                language: 'sql',
-                tabWidth: 2,
-                useTabs: false,
-                keywordCase: 'upper',
-                identifierCase: 'lower',
-                functionCase: 'upper'
+                language: "sql"
             });
             return {
                 content: [
@@ -310,6 +300,7 @@ ${formatted}
         toml: z.string().describe("TOML string to convert"),
     }, async ({ toml: tomlString }) => {
         try {
+            const toml = await import("@iarna/toml");
             const result = toml.parse(tomlString);
             return {
                 content: [
@@ -336,6 +327,7 @@ ${formatted}
         json: z.string().describe("JSON string to convert"),
     }, async ({ json }) => {
         try {
+            const toml = await import("@iarna/toml");
             const data = JSON.parse(json);
             const tomlResult = toml.stringify(data);
             return {
@@ -363,7 +355,7 @@ ${formatted}
         markdown: z.string().describe("Markdown content to convert to HTML"),
     }, async ({ markdown }) => {
         try {
-            // Use marked with basic configuration (marked is synchronous)
+            const { marked } = await import("marked");
             const html = marked(markdown, {
                 breaks: true,
                 gfm: true
@@ -393,13 +385,11 @@ ${formatted}
         html: z.string().describe("HTML content to convert to Markdown"),
     }, async ({ html }) => {
         try {
-            // Configure turndown for better output
+            const TurndownService = (await import("turndown")).default;
             const turndownService = new TurndownService({
                 headingStyle: 'atx',
                 codeBlockStyle: 'fenced',
-                bulletListMarker: '-',
                 emDelimiter: '*',
-                strongDelimiter: '**'
             });
             const markdown = turndownService.turndown(html);
             return {

package/build/tools/idGenerators.js

@@ -1,5 +1,4 @@
 import { randomUUID } from "crypto";
-import QRCode from "qrcode";
 import { z } from "zod";
 export function registerIdGeneratorTools(server) {
     // UUID generation tool
@@ -53,6 +52,7 @@ For production use, please use a proper ULID library.`,
         size: z.number().describe("Size multiplier (1-3)").optional(),
     }, async ({ text, size = 1 }) => {
         try {
+            const QRCode = (await import("qrcode")).default;
             if (size < 1 || size > 3) {
                 return {
                     content: [
@@ -105,12 +105,7 @@ For production use, please use a proper ULID library.`,
                 content: [
                     {
                         type: "text",
-                        text: `Error generating QR code: ${error instanceof Error ? error.message : 'Unknown error'}
-
-Debug info:
-- Text: "${text}"
-- Size: ${size}
-- QRCode library available: ${typeof QRCode !== 'undefined' ? 'Yes' : 'No'}`,
+                        text: `Error generating QR code: ${error instanceof Error ? error.message : 'Unknown error'}\n\nDebug info:\n- Text: \"${text}\"\n- Size: ${size}`,
                     },
                 ],
             };

package/build/tools/math.js

@@ -1,4 +1,3 @@
-import { evaluate } from "mathjs";
 import { z } from "zod";
 export function registerMathTools(server) {
     // Math expression evaluator
@@ -6,6 +5,8 @@ export function registerMathTools(server) {
         expression: z.string().describe("Mathematical expression to evaluate (e.g., '2 + 3 * 4')")
     }, async ({ expression }) => {
         try {
+            // Dynamically import mathjs only when needed
+            const { evaluate } = await import("mathjs");
             const result = evaluate(expression);
             return {
                 content: [

package/build/tools/network.js

@@ -1,5 +1,3 @@
-import { isValidPhoneNumber, parsePhoneNumber } from "libphonenumber-js";
-import IBAN from "iban";
 import { z } from "zod";
 export function registerNetworkTools(server) {
     // IP address tools
@@ -448,6 +446,7 @@ ${prefix ? `Used prefix: ${prefix}` : 'Randomly generated'}`,
         countryCode: z.string().optional().describe("Country code (e.g., 'US', 'GB', 'FR')"),
     }, async ({ phoneNumber, countryCode }) => {
         try {
+            const { isValidPhoneNumber, parsePhoneNumber } = await import("libphonenumber-js");
             // First check if it's a valid phone number
             if (!isValidPhoneNumber(phoneNumber, countryCode)) {
                 throw new Error("Invalid phone number format");
@@ -500,6 +499,7 @@ Valid: ${parsedNumber.isValid()}
         iban: z.string().describe("IBAN to validate and parse"),
     }, async ({ iban }) => {
         try {
+            const IBAN = (await import("iban")).default;
             // Clean the input
             const cleanIban = iban.replace(/\s/g, '').toUpperCase();
             // Validate using the IBAN library

package/package.json

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