it-tools-mcp 3.0.23 → 3.1.0

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'}`
+                    }]
+            };
+        }
+    });
+}

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

@@ -0,0 +1,74 @@
+import { z } from "zod";
+export function registerJavascriptPrettifier(server) {
+    server.tool("javascript-prettifier", "Format and beautify JavaScript/CSS code", {
+        code: z.string().describe("JavaScript or CSS code to prettify"),
+        type: z.enum(["javascript", "css"]).describe("Type of code to format"),
+        indentSize: z.number().optional().default(2).describe("Number of spaces for indentation")
+    }, async ({ code, type, indentSize }) => {
+        try {
+            let formatted = code;
+            const indent = ' '.repeat(indentSize);
+            if (type === "javascript") {
+                // Basic JS formatting
+                formatted = formatted
+                    .replace(/\s*{\s*/g, ' {\n')
+                    .replace(/\s*}\s*/g, '\n}\n')
+                    .replace(/;\s*/g, ';\n')
+                    .replace(/,\s*/g, ', ')
+                    .split('\n')
+                    .map(line => line.trim())
+                    .filter(line => line.length > 0)
+                    .map((line, index, lines) => {
+                    let indentLevel = 0;
+                    for (let i = 0; i < index; i++) {
+                        if (lines[i].includes('{'))
+                            indentLevel++;
+                        if (lines[i].includes('}'))
+                            indentLevel--;
+                    }
+                    if (line.includes('}'))
+                        indentLevel--;
+                    return indent.repeat(Math.max(0, indentLevel)) + line;
+                })
+                    .join('\n');
+            }
+            else if (type === "css") {
+                // Basic CSS formatting
+                formatted = formatted
+                    .replace(/\s*{\s*/g, ' {\n')
+                    .replace(/\s*}\s*/g, '\n}\n')
+                    .replace(/;\s*/g, ';\n')
+                    .replace(/:\s*/g, ': ')
+                    .split('\n')
+                    .map(line => line.trim())
+                    .filter(line => line.length > 0)
+                    .map((line, index, lines) => {
+                    if (line.includes('}'))
+                        return line;
+                    if (line.includes('{'))
+                        return line;
+                    return indent + line;
+                })
+                    .join('\n');
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: `Prettified ${type.toUpperCase()}:
+
+\`\`\`${type}
+${formatted}
+\`\`\``
+                    }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Error formatting ${type}: ${error instanceof Error ? error.message : 'Unknown error'}`
+                    }]
+            };
+        }
+    });
+}

package/build/tools/development/list-converter/index.js

@@ -0,0 +1,62 @@
+import { z } from "zod";
+export function registerListConverter(server) {
+    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/markdown-toc-generator/index.js

@@ -0,0 +1,53 @@
+import { z } from "zod";
+export function registerMarkdownTocGenerator(server) {
+    server.tool("markdown-toc-generator", "Generate a table of contents from Markdown headers", {
+        markdown: z.string().describe("Markdown content to generate TOC from"),
+        maxLevel: z.number().optional().default(6).describe("Maximum header level to include (1-6)"),
+        generateAnchors: z.boolean().optional().default(true).describe("Whether to generate anchor links")
+    }, async ({ markdown, maxLevel, generateAnchors }) => {
+        // Extract headers from markdown
+        const headerRegex = /^(#{1,6})\s+(.+)$/gm;
+        const headers = [];
+        let match;
+        while ((match = headerRegex.exec(markdown)) !== null) {
+            const level = match[1].length;
+            if (level <= maxLevel) {
+                const text = match[2].trim();
+                // Generate anchor from text
+                const anchor = text
+                    .toLowerCase()
+                    .replace(/[^\w\s-]/g, '')
+                    .replace(/\s+/g, '-')
+                    .replace(/-+/g, '-')
+                    .replace(/^-|-$/g, '');
+                headers.push({ level, text, anchor });
+            }
+        }
+        if (headers.length === 0) {
+            return {
+                content: [{
+                        type: "text",
+                        text: "No headers found in the markdown content."
+                    }]
+            };
+        }
+        // Generate TOC
+        const tocLines = [];
+        headers.forEach(header => {
+            const indent = '  '.repeat(header.level - 1);
+            const link = generateAnchors ? `[${header.text}](#${header.anchor})` : header.text;
+            tocLines.push(`${indent}- ${link}`);
+        });
+        const toc = tocLines.join('\n');
+        return {
+            content: [{
+                    type: "text",
+                    text: `Table of Contents:
+
+${toc}
+
+${generateAnchors ? '\nAnchors have been generated based on header text.' : ''}`
+                }]
+        };
+    });
+}

package/build/tools/development/regex-tester/index.js

@@ -0,0 +1,69 @@
+import { z } from "zod";
+export function registerRegexTester(server) {
+    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`,
+                    },
+                ],
+            };
+        }
+    });
+}

package/build/tools/docker/docker-compose-to-docker-run/index.js

@@ -0,0 +1,138 @@
+import { z } from "zod";
+import yaml from "js-yaml";
+export function registerDockerComposeToRun(server) {
+    server.tool("docker-compose-to-docker-run", "Convert Docker Compose files to docker run commands", {
+        content: z.string().describe("Docker Compose file content to convert"),
+    }, async ({ content }) => {
+        if (!content?.trim()) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Please provide a Docker Compose file content to convert",
+                    },
+                ],
+            };
+        }
+        try {
+            const parsed = yaml.load(content);
+            if (!parsed?.services) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "Invalid Docker Compose file: missing services section",
+                        },
+                    ],
+                };
+            }
+            const commands = [];
+            for (const [serviceName, service] of Object.entries(parsed.services)) {
+                const serviceObj = service;
+                let command = 'docker run';
+                // Add detached mode by default
+                command += ' -d';
+                // Add name
+                command += ` --name ${serviceName}`;
+                // Add ports
+                if (serviceObj.ports) {
+                    for (const port of serviceObj.ports) {
+                        if (typeof port === 'string') {
+                            command += ` -p ${port}`;
+                        }
+                        else if (typeof port === 'object' && port.published && port.target) {
+                            command += ` -p ${port.published}:${port.target}`;
+                        }
+                    }
+                }
+                // Add volumes
+                if (serviceObj.volumes) {
+                    for (const volume of serviceObj.volumes) {
+                        if (typeof volume === 'string') {
+                            command += ` -v ${volume}`;
+                        }
+                        else if (typeof volume === 'object' && volume.source && volume.target) {
+                            command += ` -v ${volume.source}:${volume.target}`;
+                            if (volume.read_only) {
+                                command += ':ro';
+                            }
+                        }
+                    }
+                }
+                // Add environment variables
+                if (serviceObj.environment) {
+                    if (Array.isArray(serviceObj.environment)) {
+                        for (const env of serviceObj.environment) {
+                            command += ` -e "${env}"`;
+                        }
+                    }
+                    else if (typeof serviceObj.environment === 'object') {
+                        for (const [key, value] of Object.entries(serviceObj.environment)) {
+                            command += ` -e "${key}=${value}"`;
+                        }
+                    }
+                }
+                // Add restart policy
+                if (serviceObj.restart) {
+                    command += ` --restart ${serviceObj.restart}`;
+                }
+                // Add networks
+                if (serviceObj.networks) {
+                    if (Array.isArray(serviceObj.networks)) {
+                        for (const network of serviceObj.networks) {
+                            command += ` --network ${network}`;
+                        }
+                    }
+                    else if (typeof serviceObj.networks === 'object') {
+                        for (const networkName of Object.keys(serviceObj.networks)) {
+                            command += ` --network ${networkName}`;
+                        }
+                    }
+                }
+                // Add working directory
+                if (serviceObj.working_dir) {
+                    command += ` -w ${serviceObj.working_dir}`;
+                }
+                // Add user
+                if (serviceObj.user) {
+                    command += ` --user ${serviceObj.user}`;
+                }
+                // Add image
+                if (serviceObj.image) {
+                    command += ` ${serviceObj.image}`;
+                }
+                else {
+                    command += ` <image-name>`;
+                }
+                // Add command/entrypoint
+                if (serviceObj.command) {
+                    if (Array.isArray(serviceObj.command)) {
+                        command += ` ${serviceObj.command.join(' ')}`;
+                    }
+                    else {
+                        command += ` ${serviceObj.command}`;
+                    }
+                }
+                commands.push(command);
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: commands.join('\n\n'),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error converting Docker Compose to run commands: ${error.message}`,
+                    },
+                ],
+            };
+        }
+    });
+}