it-tools-mcp 3.0.24 → 3.1.1

package/build/tools/dataFormat/json-format/index.js

@@ -0,0 +1,100 @@
+import { z } from "zod";
+export function registerJsonFormat(server) {
+    server.tool("json-format", "Format and validate JSON", {
+        json: z.string().describe("JSON string to format"),
+        indent: z.number().describe("Number of spaces for indentation").optional(),
+    }, async ({ json, indent = 2 }) => {
+        try {
+            if (indent < 0 || indent > 10) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "Indent must be between 0 and 10.",
+                        },
+                    ],
+                };
+            }
+            // Try to normalize JavaScript-style object notation to valid JSON
+            let normalizedJson = json.trim();
+            // Handle single quotes by converting to double quotes
+            // This is a simplified approach that works for most common cases
+            try {
+                // First try parsing as-is
+                const parsed = JSON.parse(normalizedJson);
+                const formatted = JSON.stringify(parsed, null, indent);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Formatted JSON:\n${formatted}`,
+                        },
+                    ],
+                };
+            }
+            catch (firstError) {
+                // If parsing fails, try to normalize the format
+                try {
+                    // Convert single quotes to double quotes for property names and string values
+                    // This handles simple cases like {'name':'John','age':30}
+                    normalizedJson = normalizedJson
+                        .replace(/'/g, '"') // Replace single quotes with double quotes
+                        .replace(/([{,]\s*)([a-zA-Z_$][a-zA-Z0-9_$]*)\s*:/g, '$1"$2":'); // Quote unquoted property names
+                    const parsed = JSON.parse(normalizedJson);
+                    const formatted = JSON.stringify(parsed, null, indent);
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Formatted JSON (normalized from JavaScript object notation):\n${formatted}`,
+                            },
+                        ],
+                    };
+                }
+                catch (secondError) {
+                    // If normalization fails, try using Function constructor for JavaScript object literals
+                    try {
+                        const evaluated = new Function('return ' + json)();
+                        const formatted = JSON.stringify(evaluated, null, indent);
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `Formatted JSON (converted from JavaScript object):\n${formatted}`,
+                                },
+                            ],
+                        };
+                    }
+                    catch (evalError) {
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `Error parsing JSON: ${firstError instanceof Error ? firstError.message : 'Unknown error'}
+
+Tried to normalize JavaScript object notation but failed.
+Please ensure your input is valid JSON or JavaScript object notation.
+
+Examples of supported formats:
+- Valid JSON: {"name":"John","age":30}
+- JavaScript object: {'name':'John','age':30}
+- Unquoted keys: {name:'John',age:30}`,
+                                },
+                            ],
+                        };
+                    }
+                }
+            }
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error formatting JSON: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                    },
+                ],
+            };
+        }
+    });
+}

package/build/tools/dataFormat/json-minify/index.js

@@ -0,0 +1,29 @@
+import { z } from "zod";
+export function registerJsonMinify(server) {
+    server.tool("json-minify", "Minify JSON by removing whitespace", {
+        json: z.string().describe("JSON string to minify"),
+    }, async ({ json }) => {
+        try {
+            const parsed = JSON.parse(json);
+            const minified = JSON.stringify(parsed);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Minified JSON: ${minified}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error parsing JSON: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                    },
+                ],
+            };
+        }
+    });
+}

package/build/tools/dataFormat/json-to-csv/index.js

@@ -0,0 +1,34 @@
+import { z } from "zod";
+export function registerJsonToCsv(server) {
+    server.tool("json-to-csv", "Convert JSON to CSV format", {
+        json: z.string().describe("JSON string to convert to CSV"),
+        delimiter: z.string().describe("CSV delimiter").optional(),
+    }, 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");
+            }
+            const csv = Papa.unparse(data, { delimiter });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `CSV:\n${csv}\n\nConversion Summary:\nRows: ${data.length}\nDelimiter: \"${delimiter}\"`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error converting JSON to CSV: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                    },
+                ],
+            };
+        }
+    });
+}

package/build/tools/dataFormat/json-to-toml/index.js

@@ -0,0 +1,30 @@
+import { z } from "zod";
+export function registerJsonToToml(server) {
+    server.tool("json-to-toml", "Convert JSON to TOML format", {
+        json: z.string().describe("JSON string to convert"),
+    }, async ({ json }) => {
+        try {
+            const toml = await import("@iarna/toml");
+            const data = JSON.parse(json);
+            const tomlResult = toml.stringify(data);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `TOML result:\n${tomlResult}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error converting JSON to TOML: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                    },
+                ],
+            };
+        }
+    });
+}

package/build/tools/dataFormat/markdown-to-html/index.js

@@ -0,0 +1,32 @@
+import { z } from "zod";
+export function registerMarkdownToHtml(server) {
+    server.tool("markdown-to-html", "Convert Markdown to HTML", {
+        markdown: z.string().describe("Markdown content to convert to HTML"),
+    }, async ({ markdown }) => {
+        try {
+            const { marked } = await import("marked");
+            const html = marked(markdown, {
+                breaks: true,
+                gfm: true
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `HTML result:\n${html}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error converting Markdown to HTML: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                    },
+                ],
+            };
+        }
+    });
+}

package/build/tools/dataFormat/phone-format/index.js

@@ -0,0 +1,35 @@
+import { z } from "zod";
+export function registerPhoneFormat(server) {
+    server.tool("phone-format", "Parse and format phone numbers", {
+        phoneNumber: z.string().describe("Phone number to parse and format"),
+        countryCode: z.string().optional().describe("Country code (e.g., 'US', 'GB', 'FR')"),
+    }, 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");
+            }
+            // Parse the phone number
+            const parsedNumber = parsePhoneNumber(phoneNumber, countryCode);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Phone Number Formatting:\n\nOriginal: ${phoneNumber}\nCountry: ${parsedNumber.country || 'Unknown'}\nNational: ${parsedNumber.formatNational()}\nInternational: ${parsedNumber.formatInternational()}\nE.164: ${parsedNumber.format('E.164')}\nURI: ${parsedNumber.getURI()}\n\nDetails:\nType: ${parsedNumber.getType() || 'Unknown'}\nCountry Code: +${parsedNumber.countryCallingCode}\nNational Number: ${parsedNumber.nationalNumber}\nValid: ${parsedNumber.isValid()}\n\n✅ Formatted using libphonenumber-js library for accuracy.`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error formatting phone number: ${error instanceof Error ? error.message : 'Unknown error'}\n\n💡 Tips:\n• Include country code (e.g., +1 555-123-4567)\n• Use standard formats (e.g., (555) 123-4567)\n• Specify country code parameter if needed\n• Examples: "+1-555-123-4567", "555-123-4567" with countryCode="US"`,
+                    },
+                ],
+            };
+        }
+    });
+}

package/build/tools/dataFormat/sql-format/index.js

@@ -0,0 +1,37 @@
+import { z } from "zod";
+export function registerSqlFormat(server) {
+    server.tool("sql-format", "Format and prettify SQL queries", {
+        sql: z.string().describe("SQL query to format"),
+        dialect: z.string().optional().describe("SQL dialect to use for formatting (e.g., 'sql', 'mysql', 'postgresql', 'sqlite', 'mariadb', 'db2', 'plsql', 'n1ql', 'redshift', 'spark', 'tsql', 'trino', 'bigquery'). Default is 'sql'."),
+    }, async ({ sql, dialect = "sql" }) => {
+        try {
+            const { format: formatSQL } = await import("sql-formatter");
+            // Validate dialect and cast to correct type
+            const supportedDialects = [
+                "sql", "mysql", "postgresql", "sqlite", "mariadb", "db2", "plsql", "n1ql", "redshift", "spark", "tsql", "trino", "bigquery"
+            ];
+            const language = supportedDialects.includes(dialect) ? dialect : "sql";
+            const formatted = formatSQL(sql, {
+                language
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Formatted SQL (dialect: ${language}):\n\n${formatted}\n\n✅ SQL formatted successfully\n🎯 Features: uppercase keywords, proper indentation, clean structure`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error formatting SQL: ${error instanceof Error ? error.message : 'Unknown error'}\n\n💡 Common SQL issues:\n• Check syntax for missing semicolons\n• Ensure proper table and column names\n• Validate string quoting (single quotes for strings)\n• Check for balanced parentheses in subqueries`,
+                    },
+                ],
+            };
+        }
+    });
+}

package/build/tools/dataFormat/toml-to-json/index.js

@@ -0,0 +1,29 @@
+import { z } from "zod";
+export function registerTomlToJson(server) {
+    server.tool("toml-to-json", "Convert TOML to JSON format", {
+        toml: z.string().describe("TOML string to convert"),
+    }, async ({ toml: tomlString }) => {
+        try {
+            const toml = await import("@iarna/toml");
+            const result = toml.parse(tomlString);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `JSON result:\n${JSON.stringify(result, null, 2)}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error converting TOML to JSON: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                    },
+                ],
+            };
+        }
+    });
+}

package/build/tools/dataFormat/xml-format/index.js

@@ -0,0 +1,44 @@
+import { z } from "zod";
+export function registerXmlFormat(server) {
+    server.tool("xml-format", "Format and prettify XML", {
+        xml: z.string().describe("XML string to format"),
+        indent: z.number().describe("Number of spaces for indentation").optional(),
+    }, 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`,
+                    },
+                ],
+            };
+        }
+    });
+}

package/build/tools/dataFormat/yaml-format/index.js

@@ -0,0 +1,58 @@
+import { z } from "zod";
+export function registerYamlFormat(server) {
+    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
+            const formatted = YAML.dump(parsed, {
+                indent: 2,
+                lineWidth: 80,
+                noRefs: false,
+                noCompatMode: false,
+                condenseFlow: false,
+                quotingType: '"',
+                forceQuotes: false,
+                sortKeys: false,
+                skipInvalid: false,
+            });
+            // Count lines and detect any issues
+            const inputLines = yaml.split('\n').length;
+            const outputLines = formatted.split('\n').length;
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Formatted YAML:
+
+${formatted.trim()}
+
+✅ YAML is valid and properly formatted
+📊 Input: ${inputLines} lines → Output: ${outputLines} lines
+🎯 Features: 2-space indentation, proper line width, preserved structure`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error formatting YAML: ${error instanceof Error ? error.message : 'Unknown error'}
+
+💡 Common YAML issues:
+• Check indentation (use spaces, not tabs)
+• Ensure proper key-value syntax (key: value)
+• Validate string quoting
+• Check list formatting (- item)
+• Verify nested structure alignment`,
+                    },
+                ],
+            };
+        }
+    });
+}

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

@@ -1,74 +1,6 @@
 import { z } from "zod";
 import { CronExpressionParser } from 'cron-parser';
-export function registerDevelopmentTools(server) {
-    // Regex tester
-    server.tool("regex-tester", "Test regular expressions against text", {
-        pattern: z.string().describe("Regular expression pattern"),
-        text: z.string().describe("Text to test against the regex"),
-        flags: z.string().optional().describe("Regex flags (g, i, m, s, u, y)"),
-    }, async ({ pattern, text, flags }) => {
-        try {
-            const regex = new RegExp(pattern, flags);
-            const matches = text.match(regex);
-            const globalMatches = flags?.includes('g') ? [...text.matchAll(new RegExp(pattern, flags))] : null;
-            const isMatch = regex.test(text);
-            let result = `Regex Test Results:
-
-Pattern: ${pattern}
-Flags: ${flags || 'none'}
-Text: ${text}
-
-Match: ${isMatch ? '✅ Yes' : '❌ No'}`;
-            if (matches) {
-                result += `\n\nFirst Match: ${matches[0]}`;
-                if (matches.length > 1) {
-                    result += `\nCapture Groups: ${matches.slice(1).join(', ')}`;
-                }
-            }
-            if (globalMatches && globalMatches.length > 0) {
-                result += `\n\nAll Matches (${globalMatches.length}):`;
-                globalMatches.forEach((match, index) => {
-                    result += `\n${index + 1}. "${match[0]}" at position ${match.index}`;
-                    if (match.length > 1) {
-                        result += ` (groups: ${match.slice(1).join(', ')})`;
-                    }
-                });
-            }
-            result += `\n\nCommon Regex Patterns:
-• Email: ^[\\w\\.-]+@[\\w\\.-]+\\.[a-zA-Z]{2,}$
-• Phone: ^\\+?[1-9]\\d{1,14}$
-• URL: ^https?:\\/\\/.+
-• IPv4: ^\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}$
-• Date (YYYY-MM-DD): ^\\d{4}-\\d{2}-\\d{2}$`;
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: result,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error testing regex: ${error instanceof Error ? error.message : 'Unknown error'}
-
-Common regex flags:
-• g - Global (find all matches)
-• i - Case insensitive
-• m - Multiline
-• s - Dot matches newline
-• u - Unicode
-• y - Sticky`,
-                    },
-                ],
-            };
-        }
-    });
-    // Crontab generator
+export function registerCrontabGenerate(server) {
     server.tool("crontab-generate", "Generate crontab expressions", {
         minute: z.string().describe("Minute (0-59, *, */n, n-m)").optional(),
         hour: z.string().describe("Hour (0-23, *, */n, n-m)").optional(),
@@ -204,64 +136,4 @@ Note: Use 'crontab -e' to edit your crontab file.`,
             };
         }
     });
-    // List converter
-    server.tool("list-converter", "Convert between different list formats (comma-separated, line-separated, etc.)", {
-        list: z.string().describe("Input list to convert"),
-        inputFormat: z.enum(["comma", "semicolon", "newline", "space", "pipe"]).describe("Input format"),
-        outputFormat: z.enum(["comma", "semicolon", "newline", "space", "pipe", "json", "quoted"]).describe("Output format"),
-        trim: z.boolean().describe("Trim whitespace from items").optional(),
-    }, async ({ list, inputFormat, outputFormat, trim = true }) => {
-        try {
-            const separators = {
-                comma: ',',
-                semicolon: ';',
-                newline: '\n',
-                space: ' ',
-                pipe: '|'
-            };
-            // Parse input list
-            const inputSeparator = separators[inputFormat];
-            let items = list.split(inputSeparator);
-            if (trim) {
-                items = items.map(item => item.trim()).filter(item => item.length > 0);
-            }
-            // Convert to output format
-            let result = '';
-            switch (outputFormat) {
-                case 'json':
-                    result = JSON.stringify(items, null, 2);
-                    break;
-                case 'quoted':
-                    result = items.map(item => `"${item.replace(/"/g, '\\"')}"`).join(', ');
-                    break;
-                default:
-                    const outputSeparator = separators[outputFormat];
-                    result = items.join(outputSeparator);
-                    break;
-            }
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Converted list:
-${result}
-
-Items count: ${items.length}
-Input format: ${inputFormat}
-Output format: ${outputFormat}`,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error converting list: ${error instanceof Error ? error.message : 'Unknown error'}`,
-                    },
-                ],
-            };
-        }
-    });
 }

package/build/tools/development/html-prettifier/index.js

@@ -0,0 +1,47 @@
+import { z } from "zod";
+export function registerHtmlPrettifier(server) {
+    server.tool("html-prettifier", "Format and beautify HTML code", {
+        html: z.string().describe("HTML code to prettify"),
+        indentSize: z.number().optional().default(2).describe("Number of spaces for indentation")
+    }, async ({ html, indentSize }) => {
+        try {
+            // Simple HTML prettifier
+            let formatted = html;
+            let indentLevel = 0;
+            const indent = ' '.repeat(indentSize);
+            // Remove extra whitespace
+            formatted = formatted.replace(/>\s*</g, '><');
+            // Add line breaks and indentation
+            formatted = formatted.replace(/(<\/?[^>]+>)/g, (match) => {
+                if (match.startsWith('</') && !match.includes('/>')) {
+                    indentLevel--;
+                }
+                const result = '\n' + indent.repeat(indentLevel) + match;
+                if (!match.startsWith('</') && !match.includes('/>') && !match.includes('<input') && !match.includes('<img') && !match.includes('<br') && !match.includes('<hr')) {
+                    indentLevel++;
+                }
+                return result;
+            });
+            // Clean up
+            formatted = formatted.trim();
+            return {
+                content: [{
+                        type: "text",
+                        text: `Prettified HTML:
+
+\`\`\`html
+${formatted}
+\`\`\``
+                    }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Error formatting HTML: ${error instanceof Error ? error.message : 'Unknown error'}`
+                    }]
+            };
+        }
+    });
+}