it-tools-mcp 3.0.0

package/build/tools/development.js

@@ -0,0 +1,267 @@
+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
+    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(),
+        dayOfMonth: z.string().describe("Day of month (1-31, *, */n, n-m)").optional(),
+        month: z.string().describe("Month (1-12, *, */n, n-m)").optional(),
+        dayOfWeek: z.string().describe("Day of week (0-7, *, */n, n-m)").optional(),
+    }, async ({ minute = "*", hour = "*", dayOfMonth = "*", month = "*", dayOfWeek = "*" }) => {
+        try {
+            const cronExpression = `${minute} ${hour} ${dayOfMonth} ${month} ${dayOfWeek}`;
+            // Generate human readable description
+            let description = "Runs ";
+            // Minute description
+            if (minute === "*") {
+                description += "every minute";
+            }
+            else if (minute.startsWith("*/")) {
+                description += `every ${minute.slice(2)} minutes`;
+            }
+            else if (minute.includes("-")) {
+                description += `at minutes ${minute}`;
+            }
+            else {
+                description += `at minute ${minute}`;
+            }
+            // Hour description
+            if (hour !== "*") {
+                if (hour.startsWith("*/")) {
+                    description += ` of every ${hour.slice(2)} hours`;
+                }
+                else if (hour.includes("-")) {
+                    description += ` during hours ${hour}`;
+                }
+                else {
+                    description += ` at ${hour}:00`;
+                }
+            }
+            // Day of month description
+            if (dayOfMonth !== "*") {
+                if (dayOfMonth.startsWith("*/")) {
+                    description += ` every ${dayOfMonth.slice(2)} days`;
+                }
+                else {
+                    description += ` on day ${dayOfMonth} of the month`;
+                }
+            }
+            // Month description
+            if (month !== "*") {
+                const monthNames = ["", "January", "February", "March", "April", "May", "June",
+                    "July", "August", "September", "October", "November", "December"];
+                if (month.includes(",")) {
+                    const months = month.split(",").map(m => monthNames[parseInt(m)] || m).join(", ");
+                    description += ` in ${months}`;
+                }
+                else {
+                    description += ` in ${monthNames[parseInt(month)] || month}`;
+                }
+            }
+            // Day of week description
+            if (dayOfWeek !== "*") {
+                const dayNames = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+                if (dayOfWeek.includes(",")) {
+                    const days = dayOfWeek.split(",").map(d => dayNames[parseInt(d)] || d).join(", ");
+                    description += ` on ${days}`;
+                }
+                else {
+                    description += ` on ${dayNames[parseInt(dayOfWeek)] || dayOfWeek}`;
+                }
+            }
+            // Generate next few run times using proper cron parser
+            const nextRuns = [];
+            try {
+                const interval = CronExpressionParser.parse(cronExpression);
+                for (let i = 0; i < 5; i++) {
+                    const nextRun = interval.next();
+                    nextRuns.push(nextRun.toDate().toISOString().replace('T', ' ').slice(0, 19));
+                }
+            }
+            catch (cronError) {
+                // Fall back to basic time intervals if cron parsing fails
+                const now = new Date();
+                for (let i = 0; i < 5; i++) {
+                    const nextRun = new Date(now.getTime() + (i + 1) * 60 * 1000);
+                    nextRuns.push(nextRun.toISOString().replace('T', ' ').slice(0, 19));
+                }
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Crontab Expression Generated:
+
+Expression: ${cronExpression}
+Description: ${description}
+
+Fields:
+┌─────────── minute (0-59)
+│ ┌───────── hour (0-23)
+│ │ ┌─────── day of month (1-31)
+│ │ │ ┌───── month (1-12)
+│ │ │ │ ┌─── day of week (0-6, Sunday = 0)
+│ │ │ │ │
+${minute.padEnd(2)} ${hour.padEnd(2)} ${dayOfMonth.padEnd(2)} ${month.padEnd(2)} ${dayOfWeek}
+
+Common Examples:
+• 0 9 * * *        - Every day at 9:00 AM
+• 0 9 * * 1-5      - Weekdays at 9:00 AM
+• 0 */6 * * *      - Every 6 hours
+• 0 9 1 * *        - First day of every month at 9:00 AM
+• 30 23 * * 0      - Every Sunday at 11:30 PM
+
+Special Characters:
+• * - Any value
+• , - List separator (1,3,5)
+• - - Range (1-5)
+• / - Step values (*/5)
+
+Next estimated runs (simplified):
+${nextRuns.map((run, i) => `${i + 1}. ${run}`).join('\n')}
+
+Note: Use 'crontab -e' to edit your crontab file.`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error generating crontab: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                    },
+                ],
+            };
+        }
+    });
+    // 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/encoding.js

@@ -0,0 +1,240 @@
+import { z } from "zod";
+export function registerEncodingTools(server) {
+    // Base64 encoding tool
+    server.tool("base64-encode", "Encode text to Base64", {
+        text: z.string().describe("Text to encode to Base64"),
+    }, async ({ text }) => {
+        const encoded = Buffer.from(text, 'utf-8').toString('base64');
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Base64 encoded: ${encoded}`,
+                },
+            ],
+        };
+    });
+    // Base64 decoding tool
+    server.tool("base64-decode", "Decode Base64 text", {
+        text: z.string().describe("Base64 text to decode"),
+    }, async ({ text }) => {
+        try {
+            const decoded = Buffer.from(text, 'base64').toString('utf-8');
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Base64 decoded: ${decoded}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error decoding Base64: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                    },
+                ],
+            };
+        }
+    });
+    // URL encoding tool
+    server.tool("url-encode", "URL encode text", {
+        text: z.string().describe("Text to URL encode"),
+    }, async ({ text }) => {
+        const encoded = encodeURIComponent(text);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `URL encoded: ${encoded}`,
+                },
+            ],
+        };
+    });
+    // URL decoding tool
+    server.tool("url-decode", "URL decode text", {
+        text: z.string().describe("URL encoded text to decode"),
+    }, async ({ text }) => {
+        try {
+            const decoded = decodeURIComponent(text);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `URL decoded: ${decoded}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error decoding URL: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                    },
+                ],
+            };
+        }
+    });
+    // HTML encode tool
+    server.tool("html-encode", "Encode HTML entities", {
+        text: z.string().describe("Text to HTML encode"),
+    }, async ({ text }) => {
+        const encoded = text
+            .replace(/&/g, '&')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;')
+            .replace(/"/g, '&quot;')
+            .replace(/'/g, '&#39;');
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `HTML encoded: ${encoded}`,
+                },
+            ],
+        };
+    });
+    // HTML decode tool
+    server.tool("html-decode", "Decode HTML entities", {
+        text: z.string().describe("HTML encoded text to decode"),
+    }, async ({ text }) => {
+        const decoded = text
+            .replace(/&amp;/g, '&')
+            .replace(/&lt;/g, '<')
+            .replace(/&gt;/g, '>')
+            .replace(/&quot;/g, '"')
+            .replace(/&#39;/g, "'");
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `HTML decoded: ${decoded}`,
+                },
+            ],
+        };
+    });
+    // Extended HTML entities tool
+    server.tool("html-entities-extended", "Extended HTML entity encoding/decoding", {
+        text: z.string().describe("Text to encode or decode"),
+        operation: z.enum(["encode", "decode"]).describe("Operation to perform"),
+    }, async ({ text, operation }) => {
+        try {
+            if (operation === "encode") {
+                const encoded = text
+                    .replace(/&/g, '&amp;')
+                    .replace(/</g, '&lt;')
+                    .replace(/>/g, '&gt;')
+                    .replace(/"/g, '&quot;')
+                    .replace(/'/g, '&#39;')
+                    .replace(/©/g, '&copy;')
+                    .replace(/®/g, '&reg;')
+                    .replace(/™/g, '&trade;')
+                    .replace(/€/g, '&euro;')
+                    .replace(/£/g, '&pound;')
+                    .replace(/¥/g, '&yen;')
+                    .replace(/§/g, '&sect;')
+                    .replace(/¶/g, '&para;')
+                    .replace(/†/g, '&dagger;')
+                    .replace(/‡/g, '&Dagger;');
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `HTML entities encoded: ${encoded}`,
+                        },
+                    ],
+                };
+            }
+            else {
+                const decoded = text
+                    .replace(/&amp;/g, '&')
+                    .replace(/&lt;/g, '<')
+                    .replace(/&gt;/g, '>')
+                    .replace(/&quot;/g, '"')
+                    .replace(/&#39;/g, "'")
+                    .replace(/&copy;/g, '©')
+                    .replace(/&reg;/g, '®')
+                    .replace(/&trade;/g, '™')
+                    .replace(/&euro;/g, '€')
+                    .replace(/&pound;/g, '£')
+                    .replace(/&yen;/g, '¥')
+                    .replace(/&sect;/g, '§')
+                    .replace(/&para;/g, '¶')
+                    .replace(/&dagger;/g, '†')
+                    .replace(/&Dagger;/g, '‡');
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `HTML entities decoded: ${decoded}`,
+                        },
+                    ],
+                };
+            }
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error processing HTML entities: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                    },
+                ],
+            };
+        }
+    });
+    // Text to binary converter
+    server.tool("text-to-binary", "Convert text to binary and vice versa", {
+        input: z.string().describe("Text to convert to binary, or binary to convert to text"),
+        operation: z.enum(["encode", "decode"]).describe("Operation: encode text to binary or decode binary to text"),
+    }, async ({ input, operation }) => {
+        try {
+            if (operation === "encode") {
+                const binary = input
+                    .split('')
+                    .map(char => char.charCodeAt(0).toString(2).padStart(8, '0'))
+                    .join(' ');
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Text: ${input}
+Binary: ${binary}`,
+                        },
+                    ],
+                };
+            }
+            else {
+                // Decode binary to text
+                const binaryGroups = input.replace(/\s+/g, ' ').trim().split(' ');
+                const text = binaryGroups
+                    .map(binary => String.fromCharCode(parseInt(binary, 2)))
+                    .join('');
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Binary: ${input}
+Text: ${text}`,
+                        },
+                    ],
+                };
+            }
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error converting text/binary: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                    },
+                ],
+            };
+        }
+    });
+}

package/build/tools/idGenerators.js

@@ -0,0 +1,176 @@
+import { randomUUID } from "crypto";
+import QRCode from "qrcode";
+import { z } from "zod";
+export function registerIdGeneratorTools(server) {
+    // UUID generation tool
+    server.tool("uuid-generate", "Generate a random UUID v4", {}, async () => {
+        const uuid = randomUUID();
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Generated UUID: ${uuid}`,
+                },
+            ],
+        };
+    });
+    // ULID generator
+    server.tool("ulid-generate", "Generate Universally Unique Lexicographically Sortable Identifier", {}, async () => {
+        try {
+            // Simplified ULID implementation
+            const timestamp = Date.now();
+            const randomPart = Math.random().toString(36).substring(2, 18);
+            const ulid = timestamp.toString(36).toUpperCase() + randomPart.toUpperCase();
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Generated ULID: ${ulid}
+
+Timestamp: ${timestamp}
+Generated at: ${new Date(timestamp).toISOString()}
+
+Note: This is a simplified ULID implementation.
+For production use, please use a proper ULID library.`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error generating ULID: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                    },
+                ],
+            };
+        }
+    });
+    // QR code generator (Real implementation using qrcode library)
+    server.tool("qr-generate", "Generate QR code for any text including URLs, WiFi networks, contact info, etc.", {
+        text: z.string().describe("Text to encode in QR code (URLs, WiFi: WIFI:T:WPA;S:network;P:password;;, contact info, etc.)"),
+        size: z.number().describe("Size multiplier (1-3)").optional(),
+    }, async ({ text, size = 1 }) => {
+        try {
+            if (size < 1 || size > 3) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "Size must be between 1 and 3.",
+                        },
+                    ],
+                };
+            }
+            // Generate QR code as base64 data URL
+            console.log(`[DEBUG] Generating QR code for: "${text}" with size: ${size}`);
+            const dataUrl = await QRCode.toDataURL(text, {
+                type: 'image/png',
+                errorCorrectionLevel: 'M',
+                width: Math.max(256, size * 128), // Minimum 256px, scales with size parameter
+                margin: 2,
+                color: {
+                    dark: '#000000', // Black
+                    light: '#FFFFFF' // White
+                }
+            });
+            console.log(`[DEBUG] QR code generated successfully`);
+            // Extract just the base64 data (remove the data:image/png;base64, prefix)
+            const base64Data = dataUrl.split(',')[1];
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `📱 QR Code for: "${text}"
+
+📊 Data encoded: "${text}" (${text.length} characters)
+🎯 Error correction: Medium (M)
+📐 Image size: ${Math.max(256, size * 128)}x${Math.max(256, size * 128)} pixels
+
+✅ This QR code can be scanned with any QR code reader app
+💡 Generated using the 'qrcode' npm library!`,
+                    },
+                    {
+                        type: "image",
+                        data: base64Data,
+                        mimeType: "image/png"
+                    }
+                ],
+            };
+        }
+        catch (error) {
+            console.error(`[DEBUG] QR code generation failed:`, error);
+            return {
+                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'}`,
+                    },
+                ],
+            };
+        }
+    });
+    // SVG placeholder generator
+    server.tool("svg-placeholder-generator", "Generate SVG placeholder images", {
+        width: z.number().describe("Width in pixels").optional(),
+        height: z.number().describe("Height in pixels").optional(),
+        backgroundColor: z.string().describe("Background color (hex)").optional(),
+        textColor: z.string().describe("Text color (hex)").optional(),
+        text: z.string().optional().describe("Custom text (default: dimensions)"),
+    }, async ({ width = 300, height = 200, backgroundColor = "#cccccc", textColor = "#666666", text }) => {
+        try {
+            if (width < 1 || width > 2000 || height < 1 || height > 2000) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "Width and height must be between 1 and 2000 pixels.",
+                        },
+                    ],
+                };
+            }
+            const displayText = text || `${width}×${height}`;
+            const fontSize = Math.min(width, height) / 8;
+            const svg = `<svg width="${width}" height="${height}" xmlns="http://www.w3.org/2000/svg">
+  <rect width="100%" height="100%" fill="${backgroundColor}"/>
+  <text x="50%" y="50%" font-family="Arial, sans-serif" font-size="${fontSize}" fill="${textColor}" text-anchor="middle" dy=".3em">${displayText}</text>
+</svg>`;
+            const dataUrl = `data:image/svg+xml;base64,${Buffer.from(svg).toString('base64')}`;
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `SVG Placeholder Generated:
+
+Dimensions: ${width}×${height}
+Background: ${backgroundColor}
+Text Color: ${textColor}
+Text: ${displayText}
+
+SVG Code:
+${svg}
+
+Data URL:
+${dataUrl}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error generating SVG placeholder: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                    },
+                ],
+            };
+        }
+    });
+}