it-tools-mcp 3.0.24 → 3.1.1

package/build/tools/text/string-obfuscator/index.js

@@ -0,0 +1,49 @@
+import { z } from "zod";
+export function registerStringObfuscator(server) {
+    server.tool("string-obfuscator", "Obfuscate text by replacing characters with their HTML entities or other representations", {
+        text: z.string().describe("Text to obfuscate"),
+        method: z.enum(["html-entities", "unicode", "base64"]).describe("Obfuscation method").optional(),
+    }, async ({ text, method = "html-entities" }) => {
+        try {
+            let result = '';
+            switch (method) {
+                case 'html-entities':
+                    result = text
+                        .split('')
+                        .map(char => `&#${char.charCodeAt(0)};`)
+                        .join('');
+                    break;
+                case 'unicode':
+                    result = text
+                        .split('')
+                        .map(char => `\\u${char.charCodeAt(0).toString(16).padStart(4, '0')}`)
+                        .join('');
+                    break;
+                case 'base64':
+                    result = Buffer.from(text, 'utf-8').toString('base64');
+                    break;
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Obfuscated Text (${method}):
+
+Original: ${text}
+Obfuscated: ${result}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error obfuscating text: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                    },
+                ],
+            };
+        }
+    });
+}

package/build/tools/text/text-camelcase/index.js

@@ -0,0 +1,20 @@
+import { z } from "zod";
+export function registerTextCamelcase(server) {
+    server.tool("text-camelcase", "Convert text to camelCase", {
+        text: z.string().describe("Text to convert to camelCase"),
+    }, async ({ text }) => {
+        const camelCase = text
+            .replace(/(?:^\w|[A-Z]|\b\w)/g, (word, index) => {
+            return index === 0 ? word.toLowerCase() : word.toUpperCase();
+        })
+            .replace(/\s+/g, '');
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `camelCase: ${camelCase}`,
+                },
+            ],
+        };
+    });
+}

package/build/tools/text/text-capitalize/index.js

@@ -0,0 +1,16 @@
+import { z } from "zod";
+export function registerTextCapitalize(server) {
+    server.tool("text-capitalize", "Capitalize first letter of each word", {
+        text: z.string().describe("Text to capitalize"),
+    }, async ({ text }) => {
+        const capitalized = text.replace(/\b\w/g, l => l.toUpperCase());
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Capitalized: ${capitalized}`,
+                },
+            ],
+        };
+    });
+}

package/build/tools/text/text-diff/index.js

@@ -0,0 +1,72 @@
+import { z } from "zod";
+export function registerTextDiff(server) {
+    server.tool("text-diff", "Compare two texts and show differences", {
+        text1: z.string().describe("First text to compare"),
+        text2: z.string().describe("Second text to compare"),
+    }, async ({ text1, text2 }) => {
+        try {
+            // Simple diff implementation
+            const lines1 = text1.split('\n');
+            const lines2 = text2.split('\n');
+            const maxLines = Math.max(lines1.length, lines2.length);
+            let differences = [];
+            let same = true;
+            for (let i = 0; i < maxLines; i++) {
+                const line1 = lines1[i] || '';
+                const line2 = lines2[i] || '';
+                if (line1 !== line2) {
+                    same = false;
+                    if (line1 && line2) {
+                        differences.push(`Line ${i + 1}: Changed`);
+                        differences.push(`  - ${line1}`);
+                        differences.push(`  + ${line2}`);
+                    }
+                    else if (line1) {
+                        differences.push(`Line ${i + 1}: Removed`);
+                        differences.push(`  - ${line1}`);
+                    }
+                    else {
+                        differences.push(`Line ${i + 1}: Added`);
+                        differences.push(`  + ${line2}`);
+                    }
+                }
+            }
+            if (same) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "✅ Texts are identical - no differences found.",
+                        },
+                    ],
+                };
+            }
+            else {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `❌ Found differences:
+
+${differences.join('\n')}
+
+Summary:
+Lines in text 1: ${lines1.length}
+Lines in text 2: ${lines2.length}`,
+                        },
+                    ],
+                };
+            }
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error comparing texts: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                    },
+                ],
+            };
+        }
+    });
+}

package/build/tools/text/text-kebabcase/index.js

@@ -0,0 +1,20 @@
+import { z } from "zod";
+export function registerTextKebabcase(server) {
+    server.tool("text-kebabcase", "Convert text to kebab-case", {
+        text: z.string().describe("Text to convert to kebab-case"),
+    }, async ({ text }) => {
+        const kebabCase = text
+            .replace(/([a-z])([A-Z])/g, '$1-$2')
+            .replace(/[^a-zA-Z0-9]+/g, '-')
+            .toLowerCase()
+            .replace(/^-+|-+$/g, '');
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `kebab-case: ${kebabCase}`,
+                },
+            ],
+        };
+    });
+}

package/build/tools/text/text-lowercase/index.js

@@ -0,0 +1,15 @@
+import { z } from "zod";
+export function registerTextLowercase(server) {
+    server.tool("text-lowercase", "Convert text to lowercase", {
+        text: z.string().describe("Text to convert to lowercase"),
+    }, async ({ text }) => {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Lowercase: ${text.toLowerCase()}`,
+                },
+            ],
+        };
+    });
+}

package/build/tools/text/text-pascalcase/index.js

@@ -0,0 +1,18 @@
+import { z } from "zod";
+export function registerTextPascalcase(server) {
+    server.tool("text-pascalcase", "Convert text to PascalCase", {
+        text: z.string().describe("Text to convert to PascalCase"),
+    }, async ({ text }) => {
+        const pascalCase = text
+            .replace(/(?:^\w|[A-Z]|\b\w)/g, word => word.toUpperCase())
+            .replace(/\s+/g, '');
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `PascalCase: ${pascalCase}`,
+                },
+            ],
+        };
+    });
+}

package/build/tools/text/text-snakecase/index.js

@@ -0,0 +1,20 @@
+import { z } from "zod";
+export function registerTextSnakecase(server) {
+    server.tool("text-snakecase", "Convert text to snake_case", {
+        text: z.string().describe("Text to convert to snake_case"),
+    }, async ({ text }) => {
+        const snakeCase = text
+            .replace(/([a-z])([A-Z])/g, '$1_$2')
+            .replace(/[^a-zA-Z0-9]+/g, '_')
+            .toLowerCase()
+            .replace(/^_+|_+$/g, '');
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `snake_case: ${snakeCase}`,
+                },
+            ],
+        };
+    });
+}

package/build/tools/text/text-stats/index.js

@@ -0,0 +1,29 @@
+import { z } from "zod";
+export function registerTextStats(server) {
+    server.tool("text-stats", "Get statistics about text (character count, word count, etc.)", {
+        text: z.string().describe("Text to analyze"),
+    }, async ({ text }) => {
+        const lines = text.split('\n');
+        const words = text.trim().split(/\s+/).filter(word => word.length > 0);
+        const characters = text.length;
+        const charactersNoSpaces = text.replace(/\s/g, '').length;
+        const paragraphs = text.split(/\n\s*\n/).filter(para => para.trim().length > 0);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Text Statistics:
+
+Characters: ${characters}
+Characters (no spaces): ${charactersNoSpaces}
+Words: ${words.length}
+Lines: ${lines.length}
+Paragraphs: ${paragraphs.length}
+
+Reading time: ~${Math.ceil(words.length / 200)} minutes (200 WPM)
+Speaking time: ~${Math.ceil(words.length / 150)} minutes (150 WPM)`,
+                },
+            ],
+        };
+    });
+}

package/build/tools/text/text-to-nato-alphabet/index.js

@@ -0,0 +1,57 @@
+import { z } from "zod";
+export function registerTextToNatoAlphabet(server) {
+    server.tool("text-to-nato-alphabet", "Convert text to NATO phonetic alphabet", {
+        text: z.string().describe("Text to convert to NATO phonetic alphabet"),
+        language: z.string().optional().default("International").describe("Language/country variant (International, France, Germany, etc.)")
+    }, async ({ text, language }) => {
+        // NATO phonetic alphabet mappings
+        const natoAlphabets = {
+            International: {
+                'A': 'ALFA', 'B': 'BRAVO', 'C': 'CHARLIE', 'D': 'DELTA', 'E': 'ECHO', 'F': 'FOXTROT',
+                'G': 'GOLF', 'H': 'HOTEL', 'I': 'INDIA', 'J': 'JULIET', 'K': 'KILO', 'L': 'LIMA',
+                'M': 'MIKE', 'N': 'NOVEMBER', 'O': 'OSCAR', 'P': 'PAPA', 'Q': 'QUEBEC', 'R': 'ROMEO',
+                'S': 'SIERRA', 'T': 'TANGO', 'U': 'UNIFORM', 'V': 'VICTOR', 'W': 'WHISKEY', 'X': 'XRAY',
+                'Y': 'YANKEE', 'Z': 'ZULU'
+            },
+            France: {
+                'A': 'ANATOLE', 'B': 'BERTHE', 'C': 'CELESTIN', 'D': 'DESIRE', 'E': 'EUGENE', 'F': 'FRANCOIS',
+                'G': 'GASTON', 'H': 'HENRI', 'I': 'IRMA', 'J': 'JOSEPH', 'K': 'KLEBER', 'L': 'LOUIS',
+                'M': 'MARCEL', 'N': 'NICOLAS', 'O': 'OSCAR', 'P': 'PIERRE', 'Q': 'QUINTAL', 'R': 'RAOUL',
+                'S': 'SUZANNE', 'T': 'THERESE', 'U': 'URSULE', 'V': 'VICTOR', 'W': 'WILLIAM', 'X': 'XAVIER',
+                'Y': 'YVONNE', 'Z': 'ZOE'
+            },
+            Germany: {
+                'A': 'ANTON', 'B': 'BERTA', 'C': 'CÄSAR', 'D': 'DORA', 'E': 'EMIL', 'F': 'FRIEDRICH',
+                'G': 'GUSTAV', 'H': 'HEINRICH', 'I': 'IDA', 'J': 'JULIUS', 'K': 'KAUFMANN', 'L': 'LUDWIG',
+                'M': 'MARTHA', 'N': 'NORDPOL', 'O': 'OTTO', 'P': 'PAULA', 'Q': 'QUELLE', 'R': 'RICHARD',
+                'S': 'SIEGFRIED', 'T': 'THEODOR', 'U': 'ULRICH', 'V': 'VIKTOR', 'W': 'WILHELM', 'X': 'XANTHIPPE',
+                'Y': 'YPSILON', 'Z': 'ZACHARIAS'
+            }
+        };
+        const selectedAlphabet = natoAlphabets[language] || natoAlphabets.International;
+        const result = text.toUpperCase().split('').map(char => {
+            if (selectedAlphabet[char]) {
+                return selectedAlphabet[char];
+            }
+            else if (/[0-9]/.test(char)) {
+                return `(digit ${char})`;
+            }
+            else if (char === ' ') {
+                return '(SPACE)';
+            }
+            else if (/[!@#$%^&*(),.?":{}|<>]/.test(char)) {
+                return `(punctuation ${char})`;
+            }
+            else {
+                return `(${char})`;
+            }
+        }).join(' ');
+        return {
+            content: [{
+                    type: "text",
+                    text: `NATO Phonetic Alphabet (${language}):
+${result}`
+                }]
+        };
+    });
+}

package/build/tools/text/text-to-unicode/index.js

@@ -0,0 +1,50 @@
+import { z } from "zod";
+export function registerTextToUnicode(server) {
+    server.tool("text-to-unicode", "Convert text to Unicode code points and vice versa", {
+        input: z.string().describe("Text to convert to Unicode or Unicode to convert to text"),
+        operation: z.enum(["encode", "decode"]).describe("Operation: encode text to Unicode or decode Unicode to text"),
+    }, async ({ input, operation }) => {
+        try {
+            if (operation === "encode") {
+                const unicode = input
+                    .split('')
+                    .map(char => `U+${char.charCodeAt(0).toString(16).toUpperCase().padStart(4, '0')}`)
+                    .join(' ');
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Text: ${input}\nUnicode: ${unicode}`,
+                        },
+                    ],
+                };
+            }
+            else {
+                // Decode Unicode to text
+                const unicodePattern = /U\+([0-9A-Fa-f]{4,6})/g;
+                const text = input.replace(unicodePattern, (match, hex) => {
+                    const decimal = parseInt(hex, 16);
+                    return String.fromCharCode(decimal);
+                });
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Unicode: ${input}\nText: ${text}`,
+                        },
+                    ],
+                };
+            }
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error converting text/Unicode: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                    },
+                ],
+            };
+        }
+    });
+}

package/build/tools/text/text-to-unicode-names/index.js

@@ -0,0 +1,34 @@
+import { z } from "zod";
+export function registerTextToUnicodeNames(server) {
+    server.tool("text-to-unicode-names", "Convert text to Unicode character names", {
+        text: z.string().describe("Text to convert to Unicode names")
+    }, async ({ text }) => {
+        const unicodeNames = [...text].map(char => {
+            const codePoint = char.codePointAt(0);
+            if (!codePoint)
+                return char;
+            const hex = codePoint.toString(16).toUpperCase().padStart(4, '0');
+            // Basic Unicode character name mapping for common characters
+            const basicNames = {
+                32: 'SPACE',
+                33: 'EXCLAMATION MARK',
+                63: 'QUESTION MARK',
+                64: 'COMMERCIAL AT',
+                65: 'LATIN CAPITAL LETTER A',
+                66: 'LATIN CAPITAL LETTER B',
+                97: 'LATIN SMALL LETTER A',
+                98: 'LATIN SMALL LETTER B',
+                // Add more as needed
+            };
+            const name = basicNames[codePoint] || 'UNKNOWN CHARACTER';
+            return `${char} (U+${hex}: ${name})`;
+        }).join('\n');
+        return {
+            content: [{
+                    type: "text",
+                    text: `Unicode Character Names:
+${unicodeNames}`
+                }]
+        };
+    });
+}

package/build/tools/text/text-uppercase/index.js

@@ -0,0 +1,15 @@
+import { z } from "zod";
+export function registerTextUppercase(server) {
+    server.tool("text-uppercase", "Convert text to uppercase", {
+        text: z.string().describe("Text to convert to uppercase"),
+    }, async ({ text }) => {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Uppercase: ${text.toUpperCase()}`,
+                },
+            ],
+        };
+    });
+}

package/build/tools/utility/css-prettifier/index.js

@@ -0,0 +1,70 @@
+import { z } from "zod";
+export function registerCssPrettifier(server) {
+    server.tool("css-prettifier", "Format and prettify CSS code", {
+        css: z.string().describe("CSS code to format"),
+        indentSize: z.number().optional().describe("Number of spaces for indentation (default: 2)")
+    }, async ({ css, indentSize = 2 }) => {
+        try {
+            // Basic CSS prettifier implementation
+            let formatted = css
+                // Remove extra whitespace
+                .replace(/\s+/g, ' ')
+                .trim()
+                // Add newlines and indentation
+                .replace(/\{/g, ' {\n' + ' '.repeat(indentSize))
+                .replace(/\}/g, '\n}\n')
+                .replace(/;/g, ';\n' + ' '.repeat(indentSize))
+                .replace(/,/g, ',\n')
+                // Clean up extra newlines
+                .replace(/\n\s*\n/g, '\n')
+                .replace(/\n\s*\}/g, '\n}')
+                // Fix selectors
+                .replace(/\n([^{]+)\{/g, '\n\n$1 {')
+                .trim();
+            // Add some basic formatting rules
+            formatted = formatted
+                .replace(/:\s*/g, ': ')
+                .replace(/,\s*/g, ', ')
+                .replace(/\s*{\s*/g, ' {\n' + ' '.repeat(indentSize))
+                .replace(/;\s*}/g, ';\n}');
+            // Count some metrics
+            const selectors = (css.match(/[^{}]+(?=\s*\{)/g) || []).length;
+            const properties = (css.match(/[^{}:;]+\s*:\s*[^{}:;]+/g) || []).length;
+            const lines = formatted.split('\n').length;
+            const originalLines = css.split('\n').length;
+            return {
+                content: [{
+                        type: "text",
+                        text: `CSS Prettifier Results:
+
+Original CSS (${css.length} characters, ${originalLines} lines):
+${css}
+
+Formatted CSS (${formatted.length} characters, ${lines} lines):
+${formatted}
+
+Statistics:
+• Selectors: ${selectors}
+• Properties: ${properties}
+• Size change: ${css.length} → ${formatted.length} characters
+• Lines: ${originalLines} → ${lines}
+• Indentation: ${indentSize} spaces
+
+Formatting Applied:
+• Proper indentation and spacing
+• Consistent selector formatting
+• Property alignment
+• Clean line breaks`
+                    }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Error prettifying CSS: ${error instanceof Error ? error.message : 'Unknown error'}`
+                    }]
+            };
+        }
+    });
+}

package/build/tools/utility/device-info/index.js

@@ -0,0 +1,44 @@
+export function registerDeviceInfo(server) {
+    server.tool("device-info", "Get basic device/system information", {}, async () => {
+        try {
+            const info = {
+                platform: process.platform,
+                arch: process.arch,
+                nodeVersion: process.version,
+                userAgent: 'IT Tools MCP Server',
+                timestamp: new Date().toISOString(),
+                timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+                language: 'en-US' // Default for server environment
+            };
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Device Information:
+
+Platform: ${info.platform}
+Architecture: ${info.arch}
+Node.js Version: ${info.nodeVersion}
+User Agent: ${info.userAgent}
+Current Time: ${info.timestamp}
+Timezone: ${info.timezone}
+Language: ${info.language}
+
+Note: This is basic server environment information.
+For detailed client device info, use a browser-based tool.`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error getting device info: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                    },
+                ],
+            };
+        }
+    });
+}

package/build/tools/utility/email-normalizer/index.js

@@ -0,0 +1,73 @@
+import { z } from "zod";
+export function registerEmailNormalizer(server) {
+    server.tool("email-normalizer", "Normalize email addresses (remove dots, plus aliases, etc.)", {
+        email: z.string().describe("Email address to normalize"),
+    }, async ({ email }) => {
+        try {
+            // Basic email validation
+            const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+            if (!emailRegex.test(email)) {
+                throw new Error("Invalid email format");
+            }
+            const [localPart, domain] = email.toLowerCase().split('@');
+            let normalizedLocal = localPart;
+            let notes = [];
+            // Handle Gmail-specific rules
+            if (domain === 'gmail.com' || domain === 'googlemail.com') {
+                // Remove dots from Gmail addresses
+                const withoutDots = normalizedLocal.replace(/\./g, '');
+                if (withoutDots !== normalizedLocal) {
+                    notes.push(`Removed dots: ${normalizedLocal} → ${withoutDots}`);
+                    normalizedLocal = withoutDots;
+                }
+                // Remove everything after + (alias)
+                const plusIndex = normalizedLocal.indexOf('+');
+                if (plusIndex !== -1) {
+                    const withoutAlias = normalizedLocal.substring(0, plusIndex);
+                    notes.push(`Removed alias: ${normalizedLocal} → ${withoutAlias}`);
+                    normalizedLocal = withoutAlias;
+                }
+            }
+            // Handle other common plus aliasing
+            const plusIndex = normalizedLocal.indexOf('+');
+            if (plusIndex !== -1 && domain !== 'gmail.com' && domain !== 'googlemail.com') {
+                const withoutAlias = normalizedLocal.substring(0, plusIndex);
+                notes.push(`Removed plus alias: ${normalizedLocal} → ${withoutAlias}`);
+                normalizedLocal = withoutAlias;
+            }
+            const normalizedEmail = `${normalizedLocal}@${domain}`;
+            const isChanged = normalizedEmail !== email.toLowerCase();
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Email Normalization:
+
+Original: ${email}
+Normalized: ${normalizedEmail}
+Changed: ${isChanged ? 'Yes' : 'No'}
+
+${notes.length > 0 ? `Transformations applied:
+${notes.map(note => `• ${note}`).join('\n')}` : 'No transformations needed'}
+
+Domain: ${domain}
+Local part: ${normalizedLocal}
+
+Note: This normalization helps identify duplicate email addresses
+that would be delivered to the same inbox.`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error normalizing email: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                    },
+                ],
+            };
+        }
+    });
+}