@rog0x/mcp-string-tools 1.0.0

package/README.md

@@ -0,0 +1,73 @@
+# @rog0x/mcp-string-tools
+
+Advanced string manipulation tools for AI agents, served over the Model Context Protocol (MCP).
+
+## Tools
+
+### analyze_string
+Analyze text to get detailed metrics:
+- Character count (with and without spaces)
+- Word, sentence, and paragraph counts
+- Estimated reading time
+- Flesch-Kincaid reading level score and grade
+- Unique word count and most common words
+- Longest word
+
+### transform_string
+Transform text with various operations:
+- **remove_duplicate_lines** - Remove duplicate lines from text
+- **remove_extra_whitespace** - Collapse extra whitespace and blank lines
+- **extract_emails** - Extract all email addresses from text
+- **extract_urls** - Extract all URLs from text
+- **extract_phone_numbers** - Extract phone numbers from text
+- **mask_sensitive_data** - Mask emails, phone numbers, and credit card numbers
+- **truncate** - Truncate text with ellipsis at word boundaries
+- **wrap_text** - Wrap text at a specified column width
+
+### diff_strings
+Compare two strings and see the differences:
+- **character** mode - Character-by-character diff
+- **word** mode - Word-by-word diff (default)
+- **line** mode - Line-by-line diff
+- Shows additions, deletions, and unchanged segments with positions
+
+### render_template
+Simple template engine:
+- Replace `{{variables}}` with values from a JSON data object
+- Conditionals: `{{#if var}}...{{#else}}...{{/if}}`
+- Loops: `{{#each arr}}...{{this}}...{{@index}}...{{/each}}`
+- Nested property access: `{{user.name}}`
+
+### generate_slug
+Generate URL-friendly slugs:
+- Transliterates accented characters (e.g., `cafe` from `cafe`)
+- Removes special characters
+- Configurable separator (default: `-`)
+- Optional max length with clean truncation
+- Optional lowercase toggle
+
+## Setup
+
+```bash
+npm install
+npm run build
+```
+
+## Usage with Claude Desktop
+
+Add to your `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "string-tools": {
+      "command": "node",
+      "args": ["D:/products/mcp-servers/mcp-string-tools/dist/index.js"]
+    }
+  }
+}
+```
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,153 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const zod_1 = require("zod");
+const string_analyzer_js_1 = require("./tools/string-analyzer.js");
+const string_transformer_js_1 = require("./tools/string-transformer.js");
+const string_diff_js_1 = require("./tools/string-diff.js");
+const template_engine_js_1 = require("./tools/template-engine.js");
+const slug_generator_js_1 = require("./tools/slug-generator.js");
+const server = new mcp_js_1.McpServer({
+    name: "mcp-string-tools",
+    version: "1.0.0",
+});
+// Tool 1: String Analyzer
+server.tool("analyze_string", "Analyze text to get character count, word count, sentence count, paragraph count, reading time, Flesch-Kincaid reading level, unique words, most common words, and longest word.", {
+    text: zod_1.z.string().describe("The text to analyze"),
+}, async ({ text }) => {
+    const result = (0, string_analyzer_js_1.analyzeString)(text);
+    return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+    };
+});
+// Tool 2: String Transformer
+server.tool("transform_string", "Transform text with operations: remove_duplicate_lines, remove_extra_whitespace, extract_emails, extract_urls, extract_phone_numbers, mask_sensitive_data, truncate, wrap_text.", {
+    text: zod_1.z.string().describe("The text to transform"),
+    operation: zod_1.z
+        .enum([
+        "remove_duplicate_lines",
+        "remove_extra_whitespace",
+        "extract_emails",
+        "extract_urls",
+        "extract_phone_numbers",
+        "mask_sensitive_data",
+        "truncate",
+        "wrap_text",
+    ])
+        .describe("The transformation operation to apply"),
+    mask_char: zod_1.z
+        .string()
+        .optional()
+        .default("*")
+        .describe("Character used for masking (mask_sensitive_data only)"),
+    max_length: zod_1.z
+        .number()
+        .optional()
+        .default(100)
+        .describe("Maximum length for truncation (truncate only)"),
+    wrap_width: zod_1.z
+        .number()
+        .optional()
+        .default(80)
+        .describe("Column width for text wrapping (wrap_text only)"),
+    ellipsis: zod_1.z
+        .string()
+        .optional()
+        .default("...")
+        .describe("Ellipsis string for truncation (truncate only)"),
+}, async ({ text, operation, mask_char, max_length, wrap_width, ellipsis }) => {
+    const result = (0, string_transformer_js_1.transformString)({
+        text,
+        operation,
+        maskChar: mask_char,
+        maxLength: max_length,
+        wrapWidth: wrap_width,
+        ellipsis,
+    });
+    return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+    };
+});
+// Tool 3: String Diff
+server.tool("diff_strings", "Compare two strings showing additions, deletions, and unchanged segments with positions. Supports character-level, word-level, and line-level diff modes.", {
+    old_text: zod_1.z.string().describe("The original text"),
+    new_text: zod_1.z.string().describe("The new/modified text"),
+    mode: zod_1.z
+        .enum(["character", "word", "line"])
+        .optional()
+        .default("word")
+        .describe("Diff granularity: character, word, or line"),
+}, async ({ old_text, new_text, mode }) => {
+    const result = (0, string_diff_js_1.diffStrings)(old_text, new_text, mode);
+    return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+    };
+});
+// Tool 4: Template Engine
+server.tool("render_template", "Render a template string by replacing {{variables}} with values from a data object. Supports {{#if var}}...{{#else}}...{{/if}} conditionals and {{#each arr}}...{{/each}} loops with {{this}}, {{@index}}, and {{this.prop}}.", {
+    template: zod_1.z.string().describe("Template string with {{variable}} placeholders"),
+    data: zod_1.z
+        .string()
+        .describe("JSON string of key-value pairs to substitute into the template"),
+}, async ({ template, data }) => {
+    let parsedData;
+    try {
+        parsedData = JSON.parse(data);
+    }
+    catch {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({ error: "Invalid JSON in data parameter" }),
+                },
+            ],
+            isError: true,
+        };
+    }
+    const result = (0, template_engine_js_1.renderTemplate)(template, parsedData);
+    return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+    };
+});
+// Tool 5: Slug Generator
+server.tool("generate_slug", "Generate a URL-friendly slug from text. Removes special characters, lowercases, replaces spaces with hyphens, transliterates accented characters. Configurable separator and max length.", {
+    text: zod_1.z.string().describe("The text to convert to a slug"),
+    separator: zod_1.z
+        .string()
+        .optional()
+        .default("-")
+        .describe("Character to use as word separator (default: -)"),
+    max_length: zod_1.z
+        .number()
+        .optional()
+        .default(0)
+        .describe("Maximum slug length (0 = unlimited)"),
+    lowercase: zod_1.z
+        .boolean()
+        .optional()
+        .default(true)
+        .describe("Convert to lowercase (default: true)"),
+}, async ({ text, separator, max_length, lowercase }) => {
+    const result = (0, slug_generator_js_1.generateSlug)({
+        text,
+        separator,
+        maxLength: max_length,
+        lowercase,
+    });
+    return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+    };
+});
+async function main() {
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+    console.error("mcp-string-tools server running on stdio");
+}
+main().catch((err) => {
+    console.error("Fatal error:", err);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map

package/dist/tools/slug-generator.d.ts

@@ -0,0 +1,14 @@
+export interface SlugOptions {
+    text: string;
+    separator?: string;
+    maxLength?: number;
+    lowercase?: boolean;
+}
+export interface SlugResult {
+    original: string;
+    slug: string;
+    length: number;
+    wasTruncated: boolean;
+}
+export declare function generateSlug(options: SlugOptions): SlugResult;
+//# sourceMappingURL=slug-generator.d.ts.map

package/dist/tools/slug-generator.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSlug = generateSlug;
+const TRANSLITERATION_MAP = {
+    "\u00e0": "a", "\u00e1": "a", "\u00e2": "a", "\u00e3": "a", "\u00e4": "a", "\u00e5": "a",
+    "\u00e6": "ae",
+    "\u00e7": "c",
+    "\u00e8": "e", "\u00e9": "e", "\u00ea": "e", "\u00eb": "e",
+    "\u00ec": "i", "\u00ed": "i", "\u00ee": "i", "\u00ef": "i",
+    "\u00f0": "d",
+    "\u00f1": "n",
+    "\u00f2": "o", "\u00f3": "o", "\u00f4": "o", "\u00f5": "o", "\u00f6": "o", "\u00f8": "o",
+    "\u00f9": "u", "\u00fa": "u", "\u00fb": "u", "\u00fc": "u",
+    "\u00fd": "y", "\u00ff": "y",
+    "\u00fe": "th",
+    "\u00df": "ss",
+    "\u0100": "a", "\u0101": "a", "\u0102": "a", "\u0103": "a", "\u0104": "a", "\u0105": "a",
+    "\u0106": "c", "\u0107": "c", "\u0108": "c", "\u0109": "c", "\u010a": "c", "\u010b": "c", "\u010c": "c", "\u010d": "c",
+    "\u010e": "d", "\u010f": "d", "\u0110": "d", "\u0111": "d",
+    "\u0112": "e", "\u0113": "e", "\u0114": "e", "\u0115": "e", "\u0116": "e", "\u0117": "e", "\u0118": "e", "\u0119": "e", "\u011a": "e", "\u011b": "e",
+    "\u011c": "g", "\u011d": "g", "\u011e": "g", "\u011f": "g", "\u0120": "g", "\u0121": "g", "\u0122": "g", "\u0123": "g",
+    "\u0124": "h", "\u0125": "h", "\u0126": "h", "\u0127": "h",
+    "\u0128": "i", "\u0129": "i", "\u012a": "i", "\u012b": "i", "\u012c": "i", "\u012d": "i", "\u012e": "i", "\u012f": "i", "\u0130": "i", "\u0131": "i",
+    "\u0139": "l", "\u013a": "l", "\u013b": "l", "\u013c": "l", "\u013d": "l", "\u013e": "l", "\u0141": "l", "\u0142": "l",
+    "\u0143": "n", "\u0144": "n", "\u0145": "n", "\u0146": "n", "\u0147": "n", "\u0148": "n",
+    "\u014c": "o", "\u014d": "o", "\u014e": "o", "\u014f": "o", "\u0150": "o", "\u0151": "o", "\u0152": "oe", "\u0153": "oe",
+    "\u0154": "r", "\u0155": "r", "\u0156": "r", "\u0157": "r", "\u0158": "r", "\u0159": "r",
+    "\u015a": "s", "\u015b": "s", "\u015c": "s", "\u015d": "s", "\u015e": "s", "\u015f": "s", "\u0160": "s", "\u0161": "s",
+    "\u0162": "t", "\u0163": "t", "\u0164": "t", "\u0165": "t", "\u0166": "t", "\u0167": "t",
+    "\u0168": "u", "\u0169": "u", "\u016a": "u", "\u016b": "u", "\u016c": "u", "\u016d": "u", "\u016e": "u", "\u016f": "u", "\u0170": "u", "\u0171": "u", "\u0172": "u", "\u0173": "u",
+    "\u0174": "w", "\u0175": "w",
+    "\u0176": "y", "\u0177": "y", "\u0178": "y",
+    "\u0179": "z", "\u017a": "z", "\u017b": "z", "\u017c": "z", "\u017d": "z", "\u017e": "z",
+};
+function transliterate(text) {
+    let result = "";
+    for (const char of text) {
+        const lower = char.toLowerCase();
+        if (TRANSLITERATION_MAP[lower]) {
+            const replacement = TRANSLITERATION_MAP[lower];
+            // Preserve case for first letter
+            if (char === char.toUpperCase() && char !== char.toLowerCase()) {
+                result += replacement.charAt(0).toUpperCase() + replacement.slice(1);
+            }
+            else {
+                result += replacement;
+            }
+        }
+        else {
+            result += char;
+        }
+    }
+    return result;
+}
+function generateSlug(options) {
+    const { text, separator = "-", maxLength = 0, lowercase = true, } = options;
+    let slug = transliterate(text);
+    if (lowercase) {
+        slug = slug.toLowerCase();
+    }
+    // Replace non-alphanumeric chars (except separator) with separator
+    const escapedSep = separator.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    slug = slug.replace(/[^a-zA-Z0-9]+/g, separator);
+    // Remove leading/trailing separators
+    const trimRegex = new RegExp(`^${escapedSep}+|${escapedSep}+$`, "g");
+    slug = slug.replace(trimRegex, "");
+    // Collapse multiple consecutive separators
+    const multiRegex = new RegExp(`${escapedSep}{2,}`, "g");
+    slug = slug.replace(multiRegex, separator);
+    let wasTruncated = false;
+    if (maxLength > 0 && slug.length > maxLength) {
+        wasTruncated = true;
+        slug = slug.slice(0, maxLength);
+        // Don't end on a separator
+        const endTrimRegex = new RegExp(`${escapedSep}+$`);
+        slug = slug.replace(endTrimRegex, "");
+    }
+    return {
+        original: text,
+        slug,
+        length: slug.length,
+        wasTruncated,
+    };
+}
+//# sourceMappingURL=slug-generator.js.map

package/dist/tools/string-analyzer.d.ts

@@ -0,0 +1,21 @@
+export interface AnalysisResult {
+    charCount: number;
+    charCountNoSpaces: number;
+    wordCount: number;
+    sentenceCount: number;
+    paragraphCount: number;
+    readingTimeMinutes: number;
+    readingLevel: {
+        score: number;
+        grade: string;
+        description: string;
+    };
+    uniqueWordCount: number;
+    mostCommonWords: Array<{
+        word: string;
+        count: number;
+    }>;
+    longestWord: string;
+}
+export declare function analyzeString(text: string): AnalysisResult;
+//# sourceMappingURL=string-analyzer.d.ts.map

package/dist/tools/string-analyzer.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeString = analyzeString;
+function countSyllables(word) {
+    const w = word.toLowerCase().replace(/[^a-z]/g, "");
+    if (w.length <= 2)
+        return 1;
+    let count = 0;
+    const vowels = "aeiouy";
+    let prevVowel = false;
+    for (let i = 0; i < w.length; i++) {
+        const isVowel = vowels.includes(w[i]);
+        if (isVowel && !prevVowel) {
+            count++;
+        }
+        prevVowel = isVowel;
+    }
+    // Silent e
+    if (w.endsWith("e") && count > 1) {
+        count--;
+    }
+    // -le ending
+    if (w.endsWith("le") && w.length > 2 && !vowels.includes(w[w.length - 3])) {
+        count++;
+    }
+    return Math.max(count, 1);
+}
+function analyzeString(text) {
+    const charCount = text.length;
+    const charCountNoSpaces = text.replace(/\s/g, "").length;
+    const words = text.split(/\s+/).filter((w) => w.length > 0);
+    const wordCount = words.length;
+    const sentences = text.split(/[.!?]+/).filter((s) => s.trim().length > 0);
+    const sentenceCount = sentences.length;
+    const paragraphs = text.split(/\n\s*\n/).filter((p) => p.trim().length > 0);
+    const paragraphCount = Math.max(paragraphs.length, text.trim().length > 0 ? 1 : 0);
+    const readingTimeMinutes = Math.max(Math.ceil(wordCount / 200), wordCount > 0 ? 1 : 0);
+    // Flesch-Kincaid
+    const totalSyllables = words.reduce((sum, w) => sum + countSyllables(w), 0);
+    let fkScore = 0;
+    let fkGrade = "N/A";
+    let fkDescription = "Text too short to analyze";
+    if (wordCount > 0 && sentenceCount > 0) {
+        fkScore =
+            206.835 -
+                1.015 * (wordCount / sentenceCount) -
+                84.6 * (totalSyllables / wordCount);
+        fkScore = Math.round(fkScore * 10) / 10;
+        if (fkScore >= 90) {
+            fkGrade = "5th grade";
+            fkDescription = "Very easy to read";
+        }
+        else if (fkScore >= 80) {
+            fkGrade = "6th grade";
+            fkDescription = "Easy to read";
+        }
+        else if (fkScore >= 70) {
+            fkGrade = "7th grade";
+            fkDescription = "Fairly easy to read";
+        }
+        else if (fkScore >= 60) {
+            fkGrade = "8th-9th grade";
+            fkDescription = "Plain English";
+        }
+        else if (fkScore >= 50) {
+            fkGrade = "10th-12th grade";
+            fkDescription = "Fairly difficult to read";
+        }
+        else if (fkScore >= 30) {
+            fkGrade = "College";
+            fkDescription = "Difficult to read";
+        }
+        else {
+            fkGrade = "College graduate";
+            fkDescription = "Very difficult to read";
+        }
+    }
+    // Word frequency
+    const wordFreq = new Map();
+    for (const w of words) {
+        const lower = w.toLowerCase().replace(/[^a-z0-9'-]/g, "");
+        if (lower.length > 0) {
+            wordFreq.set(lower, (wordFreq.get(lower) || 0) + 1);
+        }
+    }
+    const uniqueWordCount = wordFreq.size;
+    const mostCommonWords = Array.from(wordFreq.entries())
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 10)
+        .map(([word, count]) => ({ word, count }));
+    const longestWord = words.reduce((longest, w) => (w.length > longest.length ? w : longest), "");
+    return {
+        charCount,
+        charCountNoSpaces,
+        wordCount,
+        sentenceCount,
+        paragraphCount,
+        readingTimeMinutes,
+        readingLevel: {
+            score: fkScore,
+            grade: fkGrade,
+            description: fkDescription,
+        },
+        uniqueWordCount,
+        mostCommonWords,
+        longestWord,
+    };
+}
+//# sourceMappingURL=string-analyzer.js.map

package/dist/tools/string-diff.d.ts

@@ -0,0 +1,20 @@
+export type DiffType = "addition" | "deletion" | "unchanged";
+export interface DiffSegment {
+    type: DiffType;
+    value: string;
+    position: {
+        start: number;
+        end: number;
+    };
+}
+export interface DiffResult {
+    mode: "character" | "word" | "line";
+    segments: DiffSegment[];
+    summary: {
+        additions: number;
+        deletions: number;
+        unchanged: number;
+    };
+}
+export declare function diffStrings(oldStr: string, newStr: string, mode?: "character" | "word" | "line"): DiffResult;
+//# sourceMappingURL=string-diff.d.ts.map

package/dist/tools/string-diff.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diffStrings = diffStrings;
+function lcs(a, b) {
+    const m = a.length;
+    const n = b.length;
+    const dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+    for (let i = 1; i <= m; i++) {
+        for (let j = 1; j <= n; j++) {
+            if (a[i - 1] === b[j - 1]) {
+                dp[i][j] = dp[i - 1][j - 1] + 1;
+            }
+            else {
+                dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+            }
+        }
+    }
+    const result = [];
+    let i = m;
+    let j = n;
+    while (i > 0 && j > 0) {
+        if (a[i - 1] === b[j - 1]) {
+            result.unshift(a[i - 1]);
+            i--;
+            j--;
+        }
+        else if (dp[i - 1][j] > dp[i][j - 1]) {
+            i--;
+        }
+        else {
+            j--;
+        }
+    }
+    return result;
+}
+function computeDiff(oldTokens, newTokens) {
+    const common = lcs(oldTokens, newTokens);
+    const segments = [];
+    let oi = 0;
+    let ni = 0;
+    let ci = 0;
+    let pos = 0;
+    while (ci < common.length) {
+        // Deletions from old
+        while (oi < oldTokens.length && oldTokens[oi] !== common[ci]) {
+            const start = pos;
+            const value = oldTokens[oi];
+            segments.push({
+                type: "deletion",
+                value,
+                position: { start, end: start + value.length },
+            });
+            oi++;
+        }
+        // Additions from new
+        while (ni < newTokens.length && newTokens[ni] !== common[ci]) {
+            const start = pos;
+            const value = newTokens[ni];
+            segments.push({
+                type: "addition",
+                value,
+                position: { start, end: start + value.length },
+            });
+            pos += value.length;
+            ni++;
+        }
+        // Unchanged
+        if (ci < common.length) {
+            const value = common[ci];
+            const start = pos;
+            segments.push({
+                type: "unchanged",
+                value,
+                position: { start, end: start + value.length },
+            });
+            pos += value.length;
+            oi++;
+            ni++;
+            ci++;
+        }
+    }
+    // Remaining deletions
+    while (oi < oldTokens.length) {
+        const value = oldTokens[oi];
+        segments.push({
+            type: "deletion",
+            value,
+            position: { start: pos, end: pos + value.length },
+        });
+        oi++;
+    }
+    // Remaining additions
+    while (ni < newTokens.length) {
+        const value = newTokens[ni];
+        segments.push({
+            type: "addition",
+            value,
+            position: { start: pos, end: pos + value.length },
+        });
+        pos += value.length;
+        ni++;
+    }
+    return segments;
+}
+function diffStrings(oldStr, newStr, mode = "word") {
+    let oldTokens;
+    let newTokens;
+    switch (mode) {
+        case "character":
+            oldTokens = oldStr.split("");
+            newTokens = newStr.split("");
+            break;
+        case "word":
+            oldTokens = oldStr.split(/(\s+)/).filter((t) => t.length > 0);
+            newTokens = newStr.split(/(\s+)/).filter((t) => t.length > 0);
+            break;
+        case "line":
+            oldTokens = oldStr.split("\n");
+            newTokens = newStr.split("\n");
+            break;
+    }
+    const segments = computeDiff(oldTokens, newTokens);
+    const summary = {
+        additions: segments.filter((s) => s.type === "addition").length,
+        deletions: segments.filter((s) => s.type === "deletion").length,
+        unchanged: segments.filter((s) => s.type === "unchanged").length,
+    };
+    return { mode, segments, summary };
+}
+//# sourceMappingURL=string-diff.js.map

package/dist/tools/string-transformer.d.ts

@@ -0,0 +1,16 @@
+export interface TransformOptions {
+    operation: string;
+    text: string;
+    maskChar?: string;
+    maxLength?: number;
+    wrapWidth?: number;
+    ellipsis?: string;
+}
+export interface TransformResult {
+    original: string;
+    transformed: string;
+    operation: string;
+    details?: Record<string, unknown>;
+}
+export declare function transformString(options: TransformOptions): TransformResult;
+//# sourceMappingURL=string-transformer.d.ts.map