@utilix-tech/mcp 0.1.0 → 0.3.0

package/README.md

@@ -1,6 +1,6 @@
 # @utilix-tech/mcp
 
-MCP server exposing 51 developer utility tools to Claude, Cursor, VS Code Copilot, and any [Model Context Protocol](https://modelcontextprotocol.io) compatible AI assistant.
+MCP server exposing 70 developer utility tools to Claude, Cursor, VS Code Copilot, and any [Model Context Protocol](https://modelcontextprotocol.io) compatible AI assistant.
 
 No API key required. All tools run locally.
 
@@ -91,14 +91,16 @@ Add to `.vscode/mcp.json`:
 | `bcrypt_hash` | Hash a password using bcrypt |
 | `bcrypt_verify` | Verify a password against a bcrypt hash |
 
-### Generators (3 tools)
+### Generators (5 tools)
 | Tool | Description |
 |------|-------------|
 | `generate_uuid` | Generate UUID v4 or v7 |
 | `generate_ulid` | Generate a ULID |
 | `generate_password` | Generate a secure random password |
+| `generate_qr` | Generate a QR code as an SVG string |
+| `generate_random_data` | Generate random mock data: names, emails, UUIDs, IPs, etc. |
 
-### Text (8 tools)
+### Text (9 tools)
 | Tool | Description |
 |------|-------------|
 | `convert_case` | Convert text case: camelCase, snake_case, PascalCase, etc. |
@@ -107,8 +109,11 @@ Add to `.vscode/mcp.json`:
 | `escape_string` | Escape characters for JSON, JavaScript, HTML, URL, or CSV |
 | `unescape_string` | Unescape JSON, JavaScript, HTML, URL, or CSV strings |
 | `lorem_ipsum` | Generate Lorem Ipsum placeholder text |
+| `text_diff` | Diff two text blocks line-by-line |
+| `html_to_markdown` | Convert HTML to Markdown |
+| `line_operations` | Sort, deduplicate, reverse, shuffle, trim, or number lines |
 
-### Time (4 tools)
+### Time (5 tools)
 | Tool | Description |
 |------|-------------|
 | `unix_timestamp` | Convert a Unix timestamp to human-readable date |
@@ -123,31 +128,53 @@ Add to `.vscode/mcp.json`:
 | `convert_bytes` | Convert between B, KB, MB, GB, TB, KiB, MiB, GiB, TiB |
 | `px_to_units` | Convert pixels to rem, em, pt, and vw |
 
-### API / Network (3 tools)
+### API / Network (4 tools)
 | Tool | Description |
 |------|-------------|
 | `decode_jwt` | Decode a JWT — header, payload, and expiry |
 | `build_curl` | Build a cURL command from method, URL, headers, and body |
 | `curl_to_code` | Convert a cURL command to fetch, axios, Python, Go, PHP, or Ruby |
+| `cors_headers` | Generate CORS response headers for a configuration |
 
-### Color (1 tool)
+### Color (4 tools)
 | Tool | Description |
 |------|-------------|
 | `convert_color` | Convert a color between HEX, RGB, HSL, and HSV |
+| `check_contrast` | Check WCAG contrast ratio between two colors |
+| `color_palette` | Generate a color palette from a base color |
+| `color_shades` | Generate shades or tints from a base color |
 
-### Code (3 tools)
+### Code (7 tools)
 | Tool | Description |
 |------|-------------|
 | `format_sql` | Format a SQL query with proper indentation |
 | `format_html` | Format and indent HTML markup |
 | `test_regex` | Test a regular expression and return all matches |
+| `minify_js` | Minify JavaScript by removing whitespace and comments |
+| `format_graphql` | Format or minify a GraphQL query or schema |
+| `parse_env` | Parse a .env file and return all key-value pairs |
+| `parse_docker_image` | Parse a Docker image reference into its components |
 
-### Data (3 tools)
+### Data (4 tools)
 | Tool | Description |
 |------|-------------|
 | `validate_yaml` | Validate YAML syntax |
 | `toml_to_json` | Convert TOML to JSON |
 | `xml_to_json` | Convert XML to JSON |
+| `parse_csv` | Parse a CSV string and return the data as JSON |
+
+### CSS (2 tools)
+| Tool | Description |
+|------|-------------|
+| `minify_css` | Minify CSS by removing whitespace and comments |
+| `css_gradient` | Generate a CSS gradient from color stops |
+
+### Misc (3 tools)
+| Tool | Description |
+|------|-------------|
+| `number_to_words` | Convert a number to English words, Roman numerals, or ordinal |
+| `unicode_inspect` | Inspect Unicode code points of a string |
+| `optimize_svg` | Optimize and minify an SVG string |
 
 ## Requirements
 

package/dist/index.js

@@ -7,7 +7,6 @@ import { z } from "zod";
 import {
   parseJson,
   minifyJson,
-  diffJson,
   jsonToCsv,
   csvToJson,
   evaluateJsonPath,
@@ -38,7 +37,9 @@ import {
 import {
   generateUuid,
   generatePassword,
-  generateUlid
+  generateUlid,
+  generateData,
+  generateQrSvg
 } from "@utilix-tech/sdk/generators";
 import {
   countWords,
@@ -46,7 +47,10 @@ import {
   slugify,
   generate as loremGenerate,
   escapeString,
-  unescapeString
+  unescapeString,
+  diffLines,
+  htmlToMarkdown,
+  applyOps
 } from "@utilix-tech/sdk/text";
 import {
   fromUnix,
@@ -60,11 +64,16 @@ import {
   decodeJwt,
   buildCurl,
   parseCurlCommand,
-  convertToCode
+  convertToCode,
+  generateCors,
+  DEFAULT_CORS_CONFIG
 } from "@utilix-tech/sdk/api";
-import { parseColor } from "@utilix-tech/sdk/color";
-import { formatSql, formatHtml, testRegex } from "@utilix-tech/sdk/code";
-import { validateYaml, tomlToJson, xmlToJson } from "@utilix-tech/sdk/data";
+import { parseColor, checkContrast, generatePalette, generateShades } from "@utilix-tech/sdk/color";
+import { formatSql, formatHtml, testRegex, minifyJs, formatGql, parseDockerImage, parseEnv as parseEnvFile } from "@utilix-tech/sdk/code";
+import { validateYaml, tomlToJson, xmlToJson, parseCsv } from "@utilix-tech/sdk/data";
+import { generateGradient, minifyCss } from "@utilix-tech/sdk/css";
+import { optimizeSvg, charToCodePoint, numberToWords } from "@utilix-tech/sdk/misc";
+import { estimateTokens, estimateCost, detectPii, redactPii, detectSecrets, detectPromptInjection, repairJson, trimToTokens, chunkText, extractUrls, sanitizeHtml, flattenJson, unflattenJson, mergeJson, extractJson, deduplicateLines, extractKeywords, validateJsonSchema, diffJson, extractTables, extractEntities, compressHtml, compressMarkdown, compressJson, rerankChunks, scoreRelevance, expandQuery, summarizeForLlm } from "@utilix-tech/sdk/ai_agent";
 var CRON_DAY_MAP = {
   SUN: "0",
   MON: "1",
@@ -739,5 +748,399 @@ server.tool(
     return text(result);
   }
 );
+server.tool(
+  "text_diff",
+  "Diff two text blocks line-by-line and show added, removed, and unchanged lines.",
+  {
+    left: z.string().describe("Original text"),
+    right: z.string().describe("New/modified text")
+  },
+  async ({ left, right }) => {
+    const r = diffLines(left, right);
+    const lines = r.lines.map((l) => {
+      const prefix = l.type === "added" ? "+ " : l.type === "removed" ? "- " : "  ";
+      return `${prefix}${l.text}`;
+    });
+    return text(`${r.addedCount} added, ${r.removedCount} removed, ${r.unchangedCount} unchanged
+
+${lines.join("\n")}`);
+  }
+);
+server.tool(
+  "html_to_markdown",
+  "Convert HTML to Markdown.",
+  { input: z.string().describe("HTML string to convert") },
+  async ({ input }) => text(htmlToMarkdown(input))
+);
+server.tool(
+  "line_operations",
+  "Sort, deduplicate, reverse, shuffle, trim, or number lines of text.",
+  {
+    input: z.string().describe("Multi-line text"),
+    operation: z.enum(["sort-asc", "sort-desc", "sort-natural", "reverse", "dedupe", "dedupe-ci", "shuffle", "trim", "remove-empty", "number-lines"]).describe("Operation to apply")
+  },
+  async ({ input, operation }) => text(applyOps(input, [operation]))
+);
+server.tool(
+  "number_to_words",
+  "Convert a number to its English words representation, Roman numerals, or ordinal form.",
+  {
+    number: z.number().describe("Number to convert"),
+    format: z.enum(["words", "roman", "ordinal"]).default("words").describe("Output format")
+  },
+  async ({ number: n, format }) => {
+    if (format === "roman") {
+      const { numberToRoman } = await import("@utilix-tech/sdk/misc");
+      const r = numberToRoman(n);
+      return typeof r === "string" ? text(r) : text(`Error: ${r}`);
+    }
+    if (format === "ordinal") {
+      const { numberToOrdinal } = await import("@utilix-tech/sdk/misc");
+      return text(numberToOrdinal(n));
+    }
+    return text(numberToWords(n));
+  }
+);
+server.tool(
+  "unicode_inspect",
+  "Inspect the Unicode code point(s) of a character or string.",
+  { input: z.string().min(1).describe("Character or string to inspect") },
+  async ({ input }) => {
+    const chars = [...input].slice(0, 50);
+    const lines = chars.map((c) => {
+      const cp = charToCodePoint(c);
+      const hex = cp.toString(16).toUpperCase().padStart(4, "0");
+      return `U+${hex}  ${JSON.stringify(c)}  (decimal ${cp})`;
+    });
+    return text(lines.join("\n"));
+  }
+);
+server.tool(
+  "minify_css",
+  "Minify CSS by removing whitespace and comments.",
+  { input: z.string().describe("CSS to minify") },
+  async ({ input }) => {
+    const r = minifyCss(input);
+    return text(`${r.output}
+
+(${r.originalSize}B \u2192 ${r.outputSize}B, saved ${r.savingsPercent}%)`);
+  }
+);
+server.tool(
+  "css_gradient",
+  "Generate a CSS gradient from stops.",
+  {
+    type: z.enum(["linear", "radial", "conic"]).default("linear").describe("Gradient type"),
+    angle: z.number().default(90).describe("Angle in degrees (linear only)"),
+    stops: z.array(z.object({
+      color: z.string().describe("CSS color value"),
+      position: z.number().min(0).max(100).describe("Position 0\u2013100")
+    })).min(2).describe("Color stops")
+  },
+  async ({ type, angle, stops }) => {
+    const css = generateGradient({ type, angle, stops });
+    return text(css);
+  }
+);
+server.tool(
+  "check_contrast",
+  "Check WCAG contrast ratio between two colors.",
+  {
+    foreground: z.string().describe("Foreground color (HEX, RGB, or named)"),
+    background: z.string().describe("Background color (HEX, RGB, or named)")
+  },
+  async ({ foreground, background }) => {
+    const r = checkContrast(foreground, background);
+    return text(
+      `Ratio: ${r.ratioString}
+Level: ${r.level}
+AA normal: ${r.aa.normal ? "\u2713" : "\u2717"}  AA large: ${r.aa.large ? "\u2713" : "\u2717"}  AA UI: ${r.aa.ui ? "\u2713" : "\u2717"}
+AAA normal: ${r.aaa.normal ? "\u2713" : "\u2717"}  AAA large: ${r.aaa.large ? "\u2713" : "\u2717"}`
+    );
+  }
+);
+server.tool(
+  "color_palette",
+  "Generate a color palette (analogous, complementary, triadic, etc.) from a base color.",
+  {
+    color: z.string().describe("Base color in HEX format"),
+    type: z.enum(["analogous", "complementary", "triadic", "tetradic", "split-complementary"]).default("analogous")
+  },
+  async ({ color, type }) => {
+    const r = generatePalette(color, type);
+    const colors = r.colors;
+    return text(colors.map((c) => `${c.hex}  ${c.label}`).join("\n"));
+  }
+);
+server.tool(
+  "color_shades",
+  "Generate a scale of shades (darker) or tints (lighter) from a base color.",
+  {
+    color: z.string().describe("Base color in HEX format"),
+    count: z.number().int().min(2).max(20).default(5).describe("Number of shades to generate")
+  },
+  async ({ color, count }) => {
+    const shades = generateShades(color, count);
+    return text(shades.join("\n"));
+  }
+);
+server.tool(
+  "cors_headers",
+  "Generate CORS response headers for a given configuration.",
+  {
+    origins: z.array(z.string()).default(["*"]).describe("Allowed origins"),
+    methods: z.array(z.string()).default(["GET", "POST", "PUT", "DELETE", "OPTIONS"]).describe("Allowed HTTP methods"),
+    headers: z.array(z.string()).default(["Content-Type", "Authorization"]).describe("Allowed request headers"),
+    credentials: z.boolean().default(false).describe("Allow credentials"),
+    max_age: z.number().int().default(86400).describe("Preflight cache duration in seconds")
+  },
+  async ({ origins, methods, headers: hdrs, credentials, max_age }) => {
+    const r = generateCors({
+      ...DEFAULT_CORS_CONFIG,
+      allowedOrigins: origins,
+      allowedMethods: methods,
+      allowedHeaders: hdrs,
+      allowCredentials: credentials,
+      maxAge: max_age
+    });
+    const headerLines = Object.entries(r.headers).map(([k, v]) => `${k}: ${v}`).join("\n");
+    return text(`Headers:
+${headerLines}
+
+Express:
+${r.expressCode}`);
+  }
+);
+server.tool(
+  "minify_js",
+  "Minify JavaScript by removing whitespace and comments.",
+  { input: z.string().describe("JavaScript code to minify") },
+  async ({ input }) => {
+    const r = minifyJs(input);
+    return text(`${r.minified}
+
+(${r.originalSize}B \u2192 ${r.minifiedSize}B, saved ${r.savedBytes}B)`);
+  }
+);
+server.tool(
+  "format_graphql",
+  "Format or minify a GraphQL query or schema.",
+  {
+    input: z.string().describe("GraphQL query or schema string"),
+    minify: z.boolean().default(false).describe("Minify instead of format")
+  },
+  async ({ input, minify }) => {
+    if (minify) {
+      const { minifyGql } = await import("@utilix-tech/sdk/code");
+      const r2 = minifyGql(input);
+      if (!r2.valid) return text("Error: invalid GraphQL");
+      return text(r2.output);
+    }
+    const r = formatGql(input);
+    if (!r.valid) return text("Error: invalid GraphQL");
+    return text(r.output);
+  }
+);
+server.tool(
+  "parse_env",
+  "Parse a .env file and return all key-value pairs with validation.",
+  { input: z.string().describe(".env file contents") },
+  async ({ input }) => {
+    const r = parseEnvFile(input);
+    if (r.errors.length) {
+      return text(`Errors:
+${r.errors.map((e) => `  Line ${e.line}: ${e.message}`).join("\n")}
+
+Parsed ${r.entries.length} entries.`);
+    }
+    const lines = r.entries.map((e) => `${e.key}=${e.value}`);
+    return text(`${lines.join("\n")}
+
+(${r.entries.length} entries, ${r.comments.length} comments)`);
+  }
+);
+server.tool(
+  "parse_docker_image",
+  "Parse a Docker image reference into registry, namespace, repository, tag, and digest.",
+  { input: z.string().describe('Docker image reference e.g. "nginx:1.21-alpine"') },
+  async ({ input }) => {
+    const r = parseDockerImage(input);
+    return text(
+      `Registry:   ${r.registry}
+Namespace:  ${r.namespace}
+Repository: ${r.repository}
+Tag:        ${r.tag || "latest"}
+Digest:     ${r.digest || "none"}
+Official:   ${r.isOfficial}`
+    );
+  }
+);
+server.tool(
+  "generate_qr",
+  "Generate a QR code as an SVG string.",
+  {
+    input: z.string().describe("Text or URL to encode"),
+    size: z.number().int().min(100).max(1e3).default(300).describe("SVG size in px")
+  },
+  async ({ input, size }) => {
+    const svg = await generateQrSvg(input, { size });
+    return text(svg);
+  }
+);
+server.tool(
+  "generate_random_data",
+  "Generate random mock data: names, emails, UUIDs, phone numbers, dates, colors, IPs, etc.",
+  {
+    type: z.enum(["name", "email", "uuid", "phone", "date", "number", "boolean", "color", "url", "ipv4", "sentence", "paragraph"]).describe("Data type to generate"),
+    count: z.number().int().min(1).max(50).default(5).describe("Number of items")
+  },
+  async ({ type, count }) => {
+    const items = generateData({ type, count });
+    const valid = items.filter(Boolean);
+    if (!valid.length) return text("Error: could not generate data for this type");
+    return text(valid.join("\n"));
+  }
+);
+server.tool(
+  "parse_csv",
+  "Parse a CSV string and return the data as JSON.",
+  {
+    input: z.string().describe("CSV content"),
+    delimiter: z.string().default(",").describe("Field delimiter")
+  },
+  async ({ input, delimiter }) => {
+    const r = parseCsv(input, { delimiter });
+    return text(JSON.stringify({ headers: r.headers, rows: r.rows, totalRows: r.totalRows }, null, 2));
+  }
+);
+server.tool(
+  "optimize_svg",
+  "Optimize and minify an SVG string.",
+  { input: z.string().describe("SVG content to optimize") },
+  async ({ input }) => {
+    const result = optimizeSvg(input);
+    const original = new TextEncoder().encode(input).length;
+    const optimized = new TextEncoder().encode(result).length;
+    const saved = Math.round((1 - optimized / original) * 100);
+    return text(`${result}
+
+(${original}B \u2192 ${optimized}B, saved ${saved}%)`);
+  }
+);
+server.tool(
+  "estimate_tokens",
+  "Estimate the token count and API cost for a text string across popular LLMs (GPT-4o, Claude, Gemini, etc.).",
+  {
+    text: z.string().describe("Text to estimate tokens for"),
+    model: z.string().optional().describe("Model slug (e.g. gpt-4o, claude-sonnet-4) \u2014 omit for all models"),
+    output_tokens: z.number().int().min(0).optional().describe("Expected output tokens (defaults to same as input)")
+  },
+  async ({ text: text2, model, output_tokens }) => {
+    const est = estimateTokens(text2);
+    const result = estimateCost(est.tokens, output_tokens, model);
+    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+  }
+);
+server.tool(
+  "detect_pii",
+  "Detect personally identifiable information (emails, phones, SSNs, credit cards, IPs, IBANs, crypto wallets) in text.",
+  {
+    text: z.string().describe("Text to scan for PII"),
+    redact: z.boolean().default(false).describe("If true, return redacted text instead of findings list"),
+    replacement: z.string().default("[REDACTED]").describe("Replacement string when redacting")
+  },
+  async ({ text: text2, redact, replacement }) => {
+    const result = redact ? redactPii(text2, replacement) : detectPii(text2);
+    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+  }
+);
+server.tool(
+  "detect_secrets",
+  "Scan text for leaked API keys, tokens, and credentials (OpenAI, Anthropic, AWS, GitHub, Stripe, etc.).",
+  { text: z.string().describe("Text or code to scan for secrets") },
+  async ({ text: text2 }) => {
+    const result = detectSecrets(text2);
+    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+  }
+);
+server.tool(
+  "detect_prompt_injection",
+  "Detect prompt injection and jailbreak attempts in user-provided text before passing to an LLM.",
+  { text: z.string().describe("User-provided text to check for injection attempts") },
+  async ({ text: text2 }) => {
+    const result = detectPromptInjection(text2);
+    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+  }
+);
+server.tool(
+  "repair_json",
+  "Fix malformed JSON: unquoted keys, single quotes, trailing commas, JS comments, undefined/NaN values, unclosed brackets.",
+  { input: z.string().describe("Malformed JSON string to repair") },
+  async ({ input }) => {
+    const result = repairJson(input);
+    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+  }
+);
+server.tool("trim_to_tokens", "Truncate text to a token budget (end/start/middle strategy).", { text: z.string(), max_tokens: z.number().int().min(1), strategy: z.enum(["end", "start", "middle"]).default("end") }, async ({ text: text2, max_tokens, strategy }) => {
+  return { content: [{ type: "text", text: JSON.stringify(trimToTokens(text2, max_tokens, strategy), null, 2) }] };
+});
+server.tool("chunk_text", "Split text into overlapping chunks for RAG.", { text: z.string(), chunk_size: z.number().int().min(10).default(200), overlap: z.number().int().min(0).default(20), strategy: z.enum(["paragraph", "sentence", "fixed"]).default("paragraph") }, async ({ text: text2, chunk_size, overlap, strategy }) => {
+  return { content: [{ type: "text", text: JSON.stringify(chunkText(text2, chunk_size, overlap, strategy), null, 2) }] };
+});
+server.tool("extract_urls", "Extract all URLs from text or HTML.", { text: z.string() }, async ({ text: text2 }) => {
+  return { content: [{ type: "text", text: JSON.stringify(extractUrls(text2), null, 2) }] };
+});
+server.tool("sanitize_html", "Strip HTML tags, scripts, and event handlers for LLM ingestion.", { html: z.string(), keep_links: z.boolean().default(false) }, async ({ html, keep_links }) => {
+  return { content: [{ type: "text", text: JSON.stringify(sanitizeHtml(html, keep_links), null, 2) }] };
+});
+server.tool("flatten_json", "Flatten nested JSON to dot-notation keys.", { json: z.unknown(), separator: z.string().default("."), unflatten: z.boolean().default(false) }, async ({ json, separator, unflatten }) => {
+  const result = unflatten ? unflattenJson(json, separator) : flattenJson(json, separator);
+  return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+});
+server.tool("merge_json", "Deep merge two JSON objects.", { base: z.unknown(), override: z.unknown(), strategy: z.enum(["deep", "shallow", "replace-arrays"]).default("deep") }, async ({ base, override, strategy }) => {
+  return { content: [{ type: "text", text: JSON.stringify(mergeJson(base, override, strategy), null, 2) }] };
+});
+server.tool("extract_json", "Extract JSON blocks from mixed LLM output text.", { text: z.string() }, async ({ text: text2 }) => {
+  return { content: [{ type: "text", text: JSON.stringify(extractJson(text2), null, 2) }] };
+});
+server.tool("deduplicate_lines", "Remove duplicate lines from text.", { text: z.string(), strategy: z.enum(["exact", "case-insensitive", "trimmed", "normalized"]).default("exact") }, async ({ text: text2, strategy }) => {
+  return { content: [{ type: "text", text: JSON.stringify(deduplicateLines(text2, strategy), null, 2) }] };
+});
+server.tool("extract_keywords", "Extract top keywords using TF-IDF scoring.", { text: z.string(), max_keywords: z.number().int().min(1).max(100).default(20), min_word_len: z.number().int().min(2).default(3) }, async ({ text: text2, max_keywords, min_word_len }) => {
+  return { content: [{ type: "text", text: JSON.stringify(extractKeywords(text2, max_keywords, min_word_len), null, 2) }] };
+});
+server.tool("validate_json_schema", "Validate JSON data against a JSON Schema (Draft-07).", { data: z.unknown(), schema: z.record(z.unknown()) }, async ({ data, schema }) => {
+  return { content: [{ type: "text", text: JSON.stringify(validateJsonSchema(data, schema), null, 2) }] };
+});
+server.tool("diff_json", "Diff two JSON objects \u2014 returns added, removed, changed, and unchanged paths.", { a: z.unknown(), b: z.unknown() }, async ({ a, b }) => {
+  return { content: [{ type: "text", text: JSON.stringify(diffJson(a, b), null, 2) }] };
+});
+server.tool("extract_tables", "Extract HTML tables into JSON arrays with headers and rows.", { html: z.string() }, async ({ html }) => {
+  return { content: [{ type: "text", text: JSON.stringify(extractTables(html), null, 2) }] };
+});
+server.tool("extract_entities", "Extract emails, phones, dates, IPs, currencies, hashtags from text.", { text: z.string() }, async ({ text: text2 }) => {
+  return { content: [{ type: "text", text: JSON.stringify(extractEntities(text2), null, 2) }] };
+});
+server.tool("compress_html", "Strip scripts, styles, classes, and whitespace from HTML to minimize tokens.", { html: z.string(), remove_comments: z.boolean().default(true), remove_scripts: z.boolean().default(true), remove_styles: z.boolean().default(true), collapse_whitespace: z.boolean().default(true) }, async ({ html, remove_comments, remove_scripts, remove_styles, collapse_whitespace }) => {
+  return { content: [{ type: "text", text: JSON.stringify(compressHtml(html, { removeComments: remove_comments, removeScripts: remove_scripts, removeStyles: remove_styles, collapseWhitespace: collapse_whitespace }), null, 2) }] };
+});
+server.tool("compress_markdown", "Normalize and compress markdown to reduce token count.", { markdown: z.string(), collapse_blank_lines: z.boolean().default(true), remove_comments: z.boolean().default(true), strip_frontmatter: z.boolean().default(false) }, async ({ markdown, collapse_blank_lines, remove_comments, strip_frontmatter }) => {
+  return { content: [{ type: "text", text: JSON.stringify(compressMarkdown(markdown, { collapseBlankLines: collapse_blank_lines, removeComments: remove_comments, stripFrontmatter: strip_frontmatter }), null, 2) }] };
+});
+server.tool("compress_json", "Remove nulls, empty arrays, and empty objects from JSON to reduce tokens.", { json: z.unknown(), remove_nulls: z.boolean().default(true), remove_empty_arrays: z.boolean().default(true), remove_empty_objects: z.boolean().default(true), sort_keys: z.boolean().default(false) }, async ({ json, remove_nulls, remove_empty_arrays, remove_empty_objects, sort_keys }) => {
+  return { content: [{ type: "text", text: JSON.stringify(compressJson(json, { removeNulls: remove_nulls, removeEmptyArrays: remove_empty_arrays, removeEmptyObjects: remove_empty_objects, sortKeys: sort_keys }), null, 2) }] };
+});
+server.tool("rerank_chunks", "Score and rerank text chunks by TF-IDF relevance to a query.", { query: z.string(), chunks: z.array(z.string()), top_k: z.number().int().min(1).optional() }, async ({ query, chunks, top_k }) => {
+  return { content: [{ type: "text", text: JSON.stringify(rerankChunks(query, chunks, top_k), null, 2) }] };
+});
+server.tool("score_relevance", "Score a passage relevance to a query (0-1 score with grade).", { query: z.string(), passage: z.string() }, async ({ query, passage }) => {
+  return { content: [{ type: "text", text: JSON.stringify(scoreRelevance(query, passage), null, 2) }] };
+});
+server.tool("expand_query", "Expand a search query with synonyms and stemmed variants for better retrieval.", { query: z.string(), max_synonyms: z.number().int().min(1).max(5).default(2) }, async ({ query, max_synonyms }) => {
+  return { content: [{ type: "text", text: JSON.stringify(expandQuery(query, max_synonyms), null, 2) }] };
+});
+server.tool("summarize_for_llm", "Extractive summarization \u2014 pick key sentences to fit a token budget.", { text: z.string(), max_tokens: z.number().int().min(10).default(200), strategy: z.enum(["extractive", "first", "last"]).default("extractive") }, async ({ text: text2, max_tokens, strategy }) => {
+  return { content: [{ type: "text", text: JSON.stringify(summarizeForLlm(text2, max_tokens, strategy), null, 2) }] };
+});
 var transport = new StdioServerTransport();
 await server.connect(transport);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@utilix-tech/mcp",
-  "version": "0.1.0",
-  "description": "MCP server exposing 107 Utilix developer tools to Claude, Cursor, VS Code Copilot, and any MCP-compatible AI assistant.",
+  "version": "0.3.0",
+  "description": "MCP server exposing 70 Utilix developer tools to Claude, Cursor, VS Code Copilot, and any MCP-compatible AI assistant.",
   "author": "Utilix <hello@utilix.tech>",
   "license": "MIT",
   "homepage": "https://utilix.tech/docs",

package/smithery.yaml

@@ -1,5 +1,5 @@
 name: utilix
-description: 107 developer utility tools — JSON, hashing, encoding, JWT, UUID, cron, color, SQL, regex and more. All run locally, no API key required.
+description: 70 developer utility tools — JSON, hashing, encoding, JWT, UUID, cron, color, SQL, regex, CSS, QR codes and more. All run locally, no API key required.
 homepage: https://utilix.tech
 license: MIT
 
@@ -61,3 +61,22 @@ tools:
   - validate_yaml
   - toml_to_json
   - xml_to_json
+  - text_diff
+  - html_to_markdown
+  - line_operations
+  - number_to_words
+  - unicode_inspect
+  - minify_css
+  - css_gradient
+  - check_contrast
+  - color_palette
+  - color_shades
+  - cors_headers
+  - minify_js
+  - format_graphql
+  - parse_env
+  - parse_docker_image
+  - generate_qr
+  - generate_random_data
+  - parse_csv
+  - optimize_svg