it-tools-mcp 3.0.23 → 3.1.0

package/build/tools/encoding.js

@@ -1,240 +0,0 @@
-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

@@ -1,180 +0,0 @@
-import { randomUUID } from "crypto";
-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 {
-            const QRCode = (await import("qrcode")).default;
-            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];
-            const markdown = `![QR Code](data:image/png;base64,${base64Data})`;
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `📱 QR Code for: "${text}"
-\n📊 Data encoded: "${text}" (${text.length} characters)
-🎯 Error correction: Medium (M)
-📐 Image size: ${Math.max(256, size * 128)}x${Math.max(256, size * 128)} pixels
-\n✅ This QR code can be scanned with any QR code reader app
-💡 Generated using the 'qrcode' npm library!
-\n---\n**Markdown for inline display:**\n${markdown}`,
-                    },
-                    {
-                        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'}\n\nDebug info:\n- Text: \"${text}\"\n- Size: ${size}`,
-                    },
-                ],
-            };
-        }
-        // Fallback return in case of unexpected behavior
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: "Unknown error: No response generated by qr-generate.",
-                },
-            ],
-        };
-    });
-    // 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'}`,
-                    },
-                ],
-            };
-        }
-    });
-}