@rog0x/mcp-string-tools 1.0.0

package/src/tools/string-analyzer.ts

@@ -0,0 +1,135 @@
+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;
+}
+
+function countSyllables(word: string): number {
+  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);
+}
+
+export function analyzeString(text: string): AnalysisResult {
+  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<string, number>();
+  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,
+  };
+}

package/src/tools/string-diff.ts

@@ -0,0 +1,163 @@
+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;
+  };
+}
+
+function lcs<T>(a: T[], b: T[]): T[] {
+  const m = a.length;
+  const n = b.length;
+  const dp: number[][] = 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: T[] = [];
+  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: string[], newTokens: string[]): DiffSegment[] {
+  const common = lcs(oldTokens, newTokens);
+  const segments: DiffSegment[] = [];
+
+  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;
+}
+
+export function diffStrings(
+  oldStr: string,
+  newStr: string,
+  mode: "character" | "word" | "line" = "word"
+): DiffResult {
+  let oldTokens: string[];
+  let newTokens: string[];
+
+  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 };
+}

package/src/tools/string-transformer.ts

@@ -0,0 +1,227 @@
+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>;
+}
+
+function removeDuplicateLines(text: string): TransformResult {
+  const lines = text.split("\n");
+  const seen = new Set<string>();
+  const unique: string[] = [];
+  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: string): TransformResult {
+  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: string): TransformResult {
+  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: string): TransformResult {
+  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: string): TransformResult {
+  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: string, maskChar: string = "*"): TransformResult {
+  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: string, domain: string) => {
+      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: string,
+  maxLength: number = 100,
+  ellipsis: string = "..."
+): TransformResult {
+  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: string, width: number = 80): TransformResult {
+  const lines = text.split("\n");
+  const wrapped: string[] = [];
+
+  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 },
+  };
+}
+
+export function transformString(options: TransformOptions): TransformResult {
+  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`
+      );
+  }
+}

package/src/tools/template-engine.ts

@@ -0,0 +1,149 @@
+export interface TemplateResult {
+  template: string;
+  rendered: string;
+  variablesUsed: string[];
+  variablesMissing: string[];
+}
+
+function getNestedValue(obj: Record<string, unknown>, path: string): unknown {
+  const parts = path.split(".");
+  let current: unknown = obj;
+  for (const part of parts) {
+    if (current === null || current === undefined || typeof current !== "object") {
+      return undefined;
+    }
+    current = (current as Record<string, unknown>)[part];
+  }
+  return current;
+}
+
+function isTruthy(value: unknown): boolean {
+  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: string,
+  data: Record<string, unknown>
+): string {
+  // {{#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: string, body: string) => {
+      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: string,
+  data: Record<string, unknown>
+): string {
+  // {{#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: string, body: string) => {
+      const trimmedVar = varName.trim();
+      const value = getNestedValue(data, trimmedVar);
+
+      if (!Array.isArray(value)) {
+        return "";
+      }
+
+      return value
+        .map((item: unknown, index: number) => {
+          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: string, prop: string) => {
+                const val = (item as Record<string, unknown>)[prop.trim()];
+                return val !== undefined ? String(val) : "";
+              }
+            );
+          }
+
+          return rendered;
+        })
+        .join("");
+    });
+  }
+
+  return result;
+}
+
+function processVariables(
+  template: string,
+  data: Record<string, unknown>
+): { rendered: string; used: string[]; missing: string[] } {
+  const used: string[] = [];
+  const missing: string[] = [];
+
+  const rendered = template.replace(
+    /\{\{([^#/][^}]*)\}\}/g,
+    (_match, varName: string) => {
+      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 };
+}
+
+export function renderTemplate(
+  template: string,
+  data: Record<string, unknown>
+): TemplateResult {
+  // 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)],
+  };
+}

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "Node16",
+    "moduleResolution": "Node16",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}