@rog0x/mcp-string-tools 1.0.0

package/dist/tools/string-transformer.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformString = transformString;
+function removeDuplicateLines(text) {
+    const lines = text.split("\n");
+    const seen = new Set();
+    const unique = [];
+    let removed = 0;
+    for (const line of lines) {
+        if (!seen.has(line)) {
+            seen.add(line);
+            unique.push(line);
+        }
+        else {
+            removed++;
+        }
+    }
+    return {
+        original: text,
+        transformed: unique.join("\n"),
+        operation: "remove_duplicate_lines",
+        details: { linesRemoved: removed, linesRemaining: unique.length },
+    };
+}
+function removeExtraWhitespace(text) {
+    const transformed = text
+        .replace(/[^\S\n]+/g, " ")
+        .replace(/\n{3,}/g, "\n\n")
+        .replace(/^ +| +$/gm, "")
+        .trim();
+    return {
+        original: text,
+        transformed,
+        operation: "remove_extra_whitespace",
+    };
+}
+function extractEmails(text) {
+    const emailRegex = /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g;
+    const matches = text.match(emailRegex) || [];
+    return {
+        original: text,
+        transformed: matches.join("\n"),
+        operation: "extract_emails",
+        details: { count: matches.length, emails: matches },
+    };
+}
+function extractUrls(text) {
+    const urlRegex = /https?:\/\/[^\s<>"{}|\\^`[\]]+/g;
+    const matches = text.match(urlRegex) || [];
+    return {
+        original: text,
+        transformed: matches.join("\n"),
+        operation: "extract_urls",
+        details: { count: matches.length, urls: matches },
+    };
+}
+function extractPhoneNumbers(text) {
+    const phoneRegex = /(?:\+?1[-.\s]?)?(?:\(?\d{3}\)?[-.\s]?)?\d{3}[-.\s]?\d{4}/g;
+    const matches = text.match(phoneRegex) || [];
+    return {
+        original: text,
+        transformed: matches.join("\n"),
+        operation: "extract_phone_numbers",
+        details: { count: matches.length, phoneNumbers: matches },
+    };
+}
+function maskSensitiveData(text, maskChar = "*") {
+    let transformed = text;
+    let maskedCount = 0;
+    // Mask emails: keep first 2 chars + domain
+    transformed = transformed.replace(/([a-zA-Z0-9._%+-]+)@([a-zA-Z0-9.-]+\.[a-zA-Z]{2,})/g, (_match, local, domain) => {
+        maskedCount++;
+        const keep = local.slice(0, 2);
+        return keep + maskChar.repeat(Math.max(local.length - 2, 3)) + "@" + domain;
+    });
+    // Mask phone numbers: keep last 4
+    transformed = transformed.replace(/(?:\+?1[-.\s]?)?(?:\(?\d{3}\)?[-.\s]?)?\d{3}[-.\s]?\d{4}/g, (match) => {
+        maskedCount++;
+        const digits = match.replace(/\D/g, "");
+        const last4 = digits.slice(-4);
+        return maskChar.repeat(digits.length - 4) + last4;
+    });
+    // Mask credit card numbers: keep last 4
+    transformed = transformed.replace(/\b\d{4}[-\s]?\d{4}[-\s]?\d{4}[-\s]?\d{4}\b/g, (match) => {
+        maskedCount++;
+        const digits = match.replace(/\D/g, "");
+        const last4 = digits.slice(-4);
+        return maskChar.repeat(12) + last4;
+    });
+    return {
+        original: text,
+        transformed,
+        operation: "mask_sensitive_data",
+        details: { maskedCount },
+    };
+}
+function truncateWithEllipsis(text, maxLength = 100, ellipsis = "...") {
+    if (text.length <= maxLength) {
+        return {
+            original: text,
+            transformed: text,
+            operation: "truncate",
+            details: { truncated: false },
+        };
+    }
+    const cutoff = maxLength - ellipsis.length;
+    // Try to cut at word boundary
+    const lastSpace = text.lastIndexOf(" ", cutoff);
+    const breakAt = lastSpace > cutoff * 0.7 ? lastSpace : cutoff;
+    return {
+        original: text,
+        transformed: text.slice(0, breakAt).trimEnd() + ellipsis,
+        operation: "truncate",
+        details: {
+            truncated: true,
+            originalLength: text.length,
+            newLength: breakAt + ellipsis.length,
+        },
+    };
+}
+function wrapText(text, width = 80) {
+    const lines = text.split("\n");
+    const wrapped = [];
+    for (const line of lines) {
+        if (line.length <= width) {
+            wrapped.push(line);
+            continue;
+        }
+        const words = line.split(" ");
+        let current = "";
+        for (const word of words) {
+            if (current.length === 0) {
+                current = word;
+            }
+            else if (current.length + 1 + word.length <= width) {
+                current += " " + word;
+            }
+            else {
+                wrapped.push(current);
+                current = word;
+            }
+        }
+        if (current.length > 0) {
+            wrapped.push(current);
+        }
+    }
+    return {
+        original: text,
+        transformed: wrapped.join("\n"),
+        operation: "wrap_text",
+        details: { width, lineCount: wrapped.length },
+    };
+}
+function transformString(options) {
+    const { operation, text, maskChar, maxLength, wrapWidth, ellipsis } = options;
+    switch (operation) {
+        case "remove_duplicate_lines":
+            return removeDuplicateLines(text);
+        case "remove_extra_whitespace":
+            return removeExtraWhitespace(text);
+        case "extract_emails":
+            return extractEmails(text);
+        case "extract_urls":
+            return extractUrls(text);
+        case "extract_phone_numbers":
+            return extractPhoneNumbers(text);
+        case "mask_sensitive_data":
+            return maskSensitiveData(text, maskChar);
+        case "truncate":
+            return truncateWithEllipsis(text, maxLength, ellipsis);
+        case "wrap_text":
+            return wrapText(text, wrapWidth);
+        default:
+            throw new Error(`Unknown operation: ${operation}. Available: remove_duplicate_lines, remove_extra_whitespace, extract_emails, extract_urls, extract_phone_numbers, mask_sensitive_data, truncate, wrap_text`);
+    }
+}
+//# sourceMappingURL=string-transformer.js.map

package/dist/tools/template-engine.d.ts

@@ -0,0 +1,8 @@
+export interface TemplateResult {
+    template: string;
+    rendered: string;
+    variablesUsed: string[];
+    variablesMissing: string[];
+}
+export declare function renderTemplate(template: string, data: Record<string, unknown>): TemplateResult;
+//# sourceMappingURL=template-engine.d.ts.map

package/dist/tools/template-engine.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderTemplate = renderTemplate;
+function getNestedValue(obj, path) {
+    const parts = path.split(".");
+    let current = obj;
+    for (const part of parts) {
+        if (current === null || current === undefined || typeof current !== "object") {
+            return undefined;
+        }
+        current = current[part];
+    }
+    return current;
+}
+function isTruthy(value) {
+    if (Array.isArray(value))
+        return value.length > 0;
+    if (typeof value === "object" && value !== null)
+        return Object.keys(value).length > 0;
+    return Boolean(value);
+}
+function processConditionals(template, data) {
+    // {{#if varName}}...content...{{/if}}
+    // {{#if varName}}...content...{{#else}}...alt...{{/if}}
+    const ifRegex = /\{\{#if\s+([^}]+)\}\}([\s\S]*?)\{\{\/if\}\}/g;
+    let result = template;
+    let prevResult = "";
+    // Iterate until stable (handles nested conditionals)
+    while (result !== prevResult) {
+        prevResult = result;
+        result = result.replace(ifRegex, (_match, varName, body) => {
+            const trimmedVar = varName.trim();
+            const value = getNestedValue(data, trimmedVar);
+            const elseParts = body.split(/\{\{#else\}\}/);
+            const trueBranch = elseParts[0];
+            const falseBranch = elseParts.length > 1 ? elseParts[1] : "";
+            return isTruthy(value) ? trueBranch : falseBranch;
+        });
+    }
+    return result;
+}
+function processLoops(template, data) {
+    // {{#each items}}...{{this}}...{{@index}}...{{/each}}
+    const eachRegex = /\{\{#each\s+([^}]+)\}\}([\s\S]*?)\{\{\/each\}\}/g;
+    let result = template;
+    let prevResult = "";
+    while (result !== prevResult) {
+        prevResult = result;
+        result = result.replace(eachRegex, (_match, varName, body) => {
+            const trimmedVar = varName.trim();
+            const value = getNestedValue(data, trimmedVar);
+            if (!Array.isArray(value)) {
+                return "";
+            }
+            return value
+                .map((item, index) => {
+                let rendered = body;
+                // Replace {{this}} with current item
+                rendered = rendered.replace(/\{\{this\}\}/g, String(item));
+                // Replace {{@index}} with current index
+                rendered = rendered.replace(/\{\{@index\}\}/g, String(index));
+                // If item is object, allow {{this.prop}}
+                if (typeof item === "object" && item !== null) {
+                    rendered = rendered.replace(/\{\{this\.([^}]+)\}\}/g, (_m, prop) => {
+                        const val = item[prop.trim()];
+                        return val !== undefined ? String(val) : "";
+                    });
+                }
+                return rendered;
+            })
+                .join("");
+        });
+    }
+    return result;
+}
+function processVariables(template, data) {
+    const used = [];
+    const missing = [];
+    const rendered = template.replace(/\{\{([^#/][^}]*)\}\}/g, (_match, varName) => {
+        const trimmed = varName.trim();
+        // Skip special variables
+        if (trimmed === "this" || trimmed.startsWith("@") || trimmed.startsWith("this.")) {
+            return _match;
+        }
+        const value = getNestedValue(data, trimmed);
+        if (value !== undefined) {
+            used.push(trimmed);
+            return String(value);
+        }
+        else {
+            missing.push(trimmed);
+            return "";
+        }
+    });
+    return { rendered, used, missing };
+}
+function renderTemplate(template, data) {
+    // Process in order: conditionals, loops, then variables
+    let result = processConditionals(template, data);
+    result = processLoops(result, data);
+    const { rendered, used, missing } = processVariables(result, data);
+    return {
+        template,
+        rendered,
+        variablesUsed: [...new Set(used)],
+        variablesMissing: [...new Set(missing)],
+    };
+}
+//# sourceMappingURL=template-engine.js.map

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@rog0x/mcp-string-tools",
+  "version": "1.0.0",
+  "description": "Advanced string manipulation tools for AI agents via MCP",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js"
+  },
+  "keywords": ["mcp", "string", "tools", "ai", "agents"],
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.1"
+  },
+  "devDependencies": {
+    "typescript": "^5.7.3",
+    "@types/node": "^22.13.10"
+  }
+}

package/src/index.ts

@@ -0,0 +1,186 @@
+#!/usr/bin/env node
+
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+
+import { analyzeString } from "./tools/string-analyzer.js";
+import { transformString } from "./tools/string-transformer.js";
+import { diffStrings } from "./tools/string-diff.js";
+import { renderTemplate } from "./tools/template-engine.js";
+import { generateSlug } from "./tools/slug-generator.js";
+
+const server = new 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: z.string().describe("The text to analyze"),
+  },
+  async ({ text }) => {
+    const result = 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: z.string().describe("The text to transform"),
+    operation: 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: z
+      .string()
+      .optional()
+      .default("*")
+      .describe("Character used for masking (mask_sensitive_data only)"),
+    max_length: z
+      .number()
+      .optional()
+      .default(100)
+      .describe("Maximum length for truncation (truncate only)"),
+    wrap_width: z
+      .number()
+      .optional()
+      .default(80)
+      .describe("Column width for text wrapping (wrap_text only)"),
+    ellipsis: z
+      .string()
+      .optional()
+      .default("...")
+      .describe("Ellipsis string for truncation (truncate only)"),
+  },
+  async ({ text, operation, mask_char, max_length, wrap_width, ellipsis }) => {
+    const result = 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: z.string().describe("The original text"),
+    new_text: z.string().describe("The new/modified text"),
+    mode: z
+      .enum(["character", "word", "line"])
+      .optional()
+      .default("word")
+      .describe("Diff granularity: character, word, or line"),
+  },
+  async ({ old_text, new_text, mode }) => {
+    const result = 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: z.string().describe("Template string with {{variable}} placeholders"),
+    data: z
+      .string()
+      .describe(
+        "JSON string of key-value pairs to substitute into the template"
+      ),
+  },
+  async ({ template, data }) => {
+    let parsedData: Record<string, unknown>;
+    try {
+      parsedData = JSON.parse(data);
+    } catch {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ error: "Invalid JSON in data parameter" }),
+          },
+        ],
+        isError: true,
+      };
+    }
+    const result = 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: z.string().describe("The text to convert to a slug"),
+    separator: z
+      .string()
+      .optional()
+      .default("-")
+      .describe("Character to use as word separator (default: -)"),
+    max_length: z
+      .number()
+      .optional()
+      .default(0)
+      .describe("Maximum slug length (0 = unlimited)"),
+    lowercase: z
+      .boolean()
+      .optional()
+      .default(true)
+      .describe("Convert to lowercase (default: true)"),
+  },
+  async ({ text, separator, max_length, lowercase }) => {
+    const result = generateSlug({
+      text,
+      separator,
+      maxLength: max_length,
+      lowercase,
+    });
+    return {
+      content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+    };
+  }
+);
+
+async function main(): Promise<void> {
+  const transport = new 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);
+});

package/src/tools/slug-generator.ts

@@ -0,0 +1,108 @@
+export interface SlugOptions {
+  text: string;
+  separator?: string;
+  maxLength?: number;
+  lowercase?: boolean;
+}
+
+export interface SlugResult {
+  original: string;
+  slug: string;
+  length: number;
+  wasTruncated: boolean;
+}
+
+const TRANSLITERATION_MAP: Record<string, string> = {
+  "\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: string): string {
+  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;
+}
+
+export function generateSlug(options: SlugOptions): SlugResult {
+  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,
+  };
+}