@utilix-tech/mcp 0.1.0 → 0.2.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

@@ -38,7 +38,9 @@ import {
 import {
   generateUuid,
   generatePassword,
-  generateUlid
+  generateUlid,
+  generateData,
+  generateQrSvg
 } from "@utilix-tech/sdk/generators";
 import {
   countWords,
@@ -46,7 +48,10 @@ import {
   slugify,
   generate as loremGenerate,
   escapeString,
-  unescapeString
+  unescapeString,
+  diffLines,
+  htmlToMarkdown,
+  applyOps
 } from "@utilix-tech/sdk/text";
 import {
   fromUnix,
@@ -60,11 +65,15 @@ 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";
 var CRON_DAY_MAP = {
   SUN: "0",
   MON: "1",
@@ -739,5 +748,284 @@ 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}%)`);
+  }
+);
 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.2.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