@utilix-tech/mcp 0.1.0

package/README.md

@@ -0,0 +1,160 @@
+# @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.
+
+No API key required. All tools run locally.
+
+## Installation
+
+### Claude Desktop
+
+Add to `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS) or `%APPDATA%\Claude\claude_desktop_config.json` (Windows):
+
+```json
+{
+  "mcpServers": {
+    "utilix": {
+      "command": "npx",
+      "args": ["-y", "@utilix-tech/mcp"]
+    }
+  }
+}
+```
+
+### Cursor
+
+Add to `.cursor/mcp.json` in your project, or `~/.cursor/mcp.json` globally:
+
+```json
+{
+  "mcpServers": {
+    "utilix": {
+      "command": "npx",
+      "args": ["-y", "@utilix-tech/mcp"]
+    }
+  }
+}
+```
+
+### VS Code Copilot
+
+Add to `.vscode/mcp.json`:
+
+```json
+{
+  "servers": {
+    "utilix": {
+      "type": "stdio",
+      "command": "npx",
+      "args": ["-y", "@utilix-tech/mcp"]
+    }
+  }
+}
+```
+
+## Tools
+
+### JSON (13 tools)
+| Tool | Description |
+|------|-------------|
+| `format_json` | Pretty-print and validate a JSON string |
+| `minify_json` | Remove all whitespace from JSON |
+| `diff_json` | Compare two JSON objects and show changes |
+| `json_to_csv` | Convert a JSON array of objects to CSV |
+| `csv_to_json` | Convert CSV text to a JSON array |
+| `jsonpath` | Evaluate a JSONPath expression |
+| `validate_json` | Validate JSON against a JSON Schema |
+| `yaml_to_json` | Convert YAML to JSON |
+| `json_to_yaml` | Convert JSON to YAML |
+| `json_to_typescript` | Generate TypeScript interfaces from JSON |
+| `json_to_go` | Generate Go structs from JSON |
+| `json_to_python` | Generate Python dataclasses from JSON |
+| `json_to_zod` | Generate a Zod schema from JSON |
+
+### Encoding (8 tools)
+| Tool | Description |
+|------|-------------|
+| `base64_encode` | Encode a string to Base64 |
+| `base64_decode` | Decode a Base64 string |
+| `url_encode` | Percent-encode a URL or component |
+| `url_decode` | Decode a percent-encoded string |
+| `html_entities_encode` | Encode HTML entities |
+| `html_entities_decode` | Decode HTML entities |
+| `base32_encode` | Encode a string to Base32 |
+| `base32_decode` | Decode a Base32 string |
+
+### Hashing (4 tools)
+| Tool | Description |
+|------|-------------|
+| `hash` | Hash a string with MD5, SHA-1, SHA-256, SHA-384, or SHA-512 |
+| `hash_all` | Hash a string with all algorithms at once |
+| `bcrypt_hash` | Hash a password using bcrypt |
+| `bcrypt_verify` | Verify a password against a bcrypt hash |
+
+### Generators (3 tools)
+| Tool | Description |
+|------|-------------|
+| `generate_uuid` | Generate UUID v4 or v7 |
+| `generate_ulid` | Generate a ULID |
+| `generate_password` | Generate a secure random password |
+
+### Text (8 tools)
+| Tool | Description |
+|------|-------------|
+| `convert_case` | Convert text case: camelCase, snake_case, PascalCase, etc. |
+| `slugify` | Convert text to a URL-friendly slug |
+| `word_count` | Count words, characters, sentences, and reading time |
+| `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 |
+
+### Time (4 tools)
+| Tool | Description |
+|------|-------------|
+| `unix_timestamp` | Convert a Unix timestamp to human-readable date |
+| `parse_cron` | Parse a cron expression into a readable description |
+| `cron_next_runs` | Show the next N scheduled run times for a cron expression |
+| `date_diff` | Calculate the difference between two dates |
+| `convert_timezone` | Convert a date/time between timezones |
+
+### Units (2 tools)
+| Tool | Description |
+|------|-------------|
+| `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)
+| 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 |
+
+### Color (1 tool)
+| Tool | Description |
+|------|-------------|
+| `convert_color` | Convert a color between HEX, RGB, HSL, and HSV |
+
+### Code (3 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 |
+
+### Data (3 tools)
+| Tool | Description |
+|------|-------------|
+| `validate_yaml` | Validate YAML syntax |
+| `toml_to_json` | Convert TOML to JSON |
+| `xml_to_json` | Convert XML to JSON |
+
+## Requirements
+
+- Node.js 18+
+
+## Links
+
+- [Utilix web app](https://utilix.tech) — use these tools in the browser
+- [Node.js SDK](https://www.npmjs.com/package/@utilix-tech/sdk) — use in your Node.js projects
+- [Python SDK](https://pypi.org/project/utilix-sdk/) — use in your Python projects

package/dist/index.js

@@ -0,0 +1,743 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import {
+  parseJson,
+  minifyJson,
+  diffJson,
+  jsonToCsv,
+  csvToJson,
+  evaluateJsonPath,
+  validateJsonString,
+  yamlToJson,
+  jsonToYaml,
+  jsonToTypescript,
+  jsonToGo,
+  jsonToPython,
+  jsonToZod
+} from "@utilix-tech/sdk/json";
+import {
+  encodeBase64,
+  decodeBase64,
+  encodeUrl,
+  decodeUrl,
+  encodeHtmlEntities,
+  decodeHtmlEntities,
+  base32Encode,
+  base32Decode
+} from "@utilix-tech/sdk/encoding";
+import {
+  hashOne,
+  hashAll,
+  hashPassword,
+  verifyPassword
+} from "@utilix-tech/sdk/hashing";
+import {
+  generateUuid,
+  generatePassword,
+  generateUlid
+} from "@utilix-tech/sdk/generators";
+import {
+  countWords,
+  convertCase,
+  slugify,
+  generate as loremGenerate,
+  escapeString,
+  unescapeString
+} from "@utilix-tech/sdk/text";
+import {
+  fromUnix,
+  parseCron,
+  getNextRuns,
+  diffDates,
+  convertTime
+} from "@utilix-tech/sdk/time";
+import { convertBytes, pxToAll } from "@utilix-tech/sdk/units";
+import {
+  decodeJwt,
+  buildCurl,
+  parseCurlCommand,
+  convertToCode
+} 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";
+var CRON_DAY_MAP = {
+  SUN: "0",
+  MON: "1",
+  TUE: "2",
+  WED: "3",
+  THU: "4",
+  FRI: "5",
+  SAT: "6"
+};
+var CRON_MON_MAP = {
+  JAN: "1",
+  FEB: "2",
+  MAR: "3",
+  APR: "4",
+  MAY: "5",
+  JUN: "6",
+  JUL: "7",
+  AUG: "8",
+  SEP: "9",
+  OCT: "10",
+  NOV: "11",
+  DEC: "12"
+};
+function normalizeCron(expr) {
+  return expr.toUpperCase().replace(/\b(SUN|MON|TUE|WED|THU|FRI|SAT)\b/g, (d) => CRON_DAY_MAP[d]).replace(/\b(JAN|FEB|MAR|APR|MAY|JUN|JUL|AUG|SEP|OCT|NOV|DEC)\b/g, (m) => CRON_MON_MAP[m]);
+}
+function text(t) {
+  return { content: [{ type: "text", text: t }] };
+}
+function errText(e) {
+  const msg = e instanceof Error ? e.message : typeof e === "object" && e !== null && "error" in e ? String(e.error) : String(e);
+  return { content: [{ type: "text", text: `Error: ${msg}` }], isError: true };
+}
+function toText(result) {
+  if (typeof result === "string") return result;
+  return JSON.stringify(result, null, 2);
+}
+function checkErr(result) {
+  return typeof result === "object" && result !== null && "error" in result;
+}
+var server = new McpServer({
+  name: "utilix",
+  version: "0.1.0"
+});
+server.tool(
+  "format_json",
+  "Parse, validate and pretty-print a JSON string. Returns formatted JSON or an error message.",
+  { input: z.string().describe("JSON string to format"), indent: z.number().int().min(1).max(8).default(2).describe("Indentation spaces (default 2)") },
+  async ({ input, indent }) => {
+    const result = parseJson(input, indent);
+    if (result.status === "error") return text(`Invalid JSON: ${result.error}`);
+    return text(result.output);
+  }
+);
+server.tool(
+  "minify_json",
+  "Minify a JSON string by removing all whitespace.",
+  { input: z.string().describe("JSON string to minify") },
+  async ({ input }) => {
+    const result = minifyJson(input);
+    if (checkErr(result)) return errText(result);
+    return text(result);
+  }
+);
+server.tool(
+  "diff_json",
+  "Compare two JSON strings and return a structured diff showing added, removed, and changed keys.",
+  {
+    left: z.string().describe("Original JSON"),
+    right: z.string().describe("New/modified JSON")
+  },
+  async ({ left, right }) => {
+    const result = diffJson(left, right);
+    if (checkErr(result)) return errText(result);
+    return text(toText(result));
+  }
+);
+server.tool(
+  "json_to_csv",
+  "Convert a JSON array of objects to CSV format.",
+  { input: z.string().describe("JSON array of objects") },
+  async ({ input }) => {
+    const result = jsonToCsv(input);
+    if (checkErr(result)) return errText(result);
+    return text(result);
+  }
+);
+server.tool(
+  "csv_to_json",
+  "Convert CSV text to a JSON array of objects.",
+  {
+    input: z.string().describe("CSV text"),
+    delimiter: z.string().default(",").describe("Field delimiter (default comma)")
+  },
+  async ({ input, delimiter }) => {
+    const result = csvToJson(input, { delimiter });
+    if (checkErr(result)) return errText(result);
+    return text(toText(result));
+  }
+);
+server.tool(
+  "jsonpath",
+  "Evaluate a JSONPath expression against a JSON string and return matching values.",
+  {
+    input: z.string().describe("JSON string"),
+    path: z.string().describe("JSONPath expression e.g. $.store.book[*].author")
+  },
+  async ({ input, path }) => {
+    const result = evaluateJsonPath(input, path);
+    if (!result.valid) return text(`Error: ${result.error ?? "Invalid JSONPath"}`);
+    return text(JSON.stringify(result.results, null, 2));
+  }
+);
+server.tool(
+  "validate_json",
+  "Validate a JSON string against a JSON Schema (Draft-7). Returns pass/fail with error details.",
+  {
+    data: z.string().describe("JSON data to validate"),
+    schema: z.string().describe("JSON Schema string")
+  },
+  async ({ data, schema }) => {
+    let parsedSchema;
+    try {
+      parsedSchema = JSON.parse(schema);
+    } catch {
+      return errText("Invalid schema JSON");
+    }
+    const result = validateJsonString(data, parsedSchema);
+    if (checkErr(result)) return errText(result);
+    return text(toText(result));
+  }
+);
+server.tool(
+  "yaml_to_json",
+  "Convert a YAML string to JSON.",
+  { input: z.string().describe("YAML string") },
+  async ({ input }) => {
+    const result = yamlToJson(input);
+    if (checkErr(result)) return errText(result);
+    return text(result);
+  }
+);
+server.tool(
+  "json_to_yaml",
+  "Convert a JSON string to YAML.",
+  { input: z.string().describe("JSON string") },
+  async ({ input }) => {
+    const result = jsonToYaml(input);
+    if (checkErr(result)) return errText(result);
+    return text(result);
+  }
+);
+server.tool(
+  "json_to_typescript",
+  "Generate TypeScript interfaces from a JSON object.",
+  {
+    input: z.string().describe("JSON string"),
+    name: z.string().default("Root").describe("Root interface name")
+  },
+  async ({ input, name }) => {
+    const result = jsonToTypescript(input, name);
+    if (checkErr(result)) return errText(result);
+    return text(result);
+  }
+);
+server.tool(
+  "json_to_go",
+  "Generate Go struct definitions from a JSON object.",
+  {
+    input: z.string().describe("JSON string"),
+    name: z.string().default("Root").describe("Root struct name")
+  },
+  async ({ input, name }) => {
+    const result = jsonToGo(input, name);
+    if (checkErr(result)) return errText(result);
+    return text(result);
+  }
+);
+server.tool(
+  "json_to_python",
+  "Generate Python TypedDict, dataclass, or Pydantic models from a JSON object.",
+  {
+    input: z.string().describe("JSON string"),
+    style: z.enum(["typeddict", "dataclass", "pydantic"]).default("pydantic").describe("Output style")
+  },
+  async ({ input, style }) => {
+    const result = jsonToPython(input, style);
+    if (checkErr(result)) return errText(result);
+    return text(result);
+  }
+);
+server.tool(
+  "json_to_zod",
+  "Generate a Zod schema from a JSON object.",
+  { input: z.string().describe("JSON string") },
+  async ({ input }) => {
+    const result = jsonToZod(input);
+    if (checkErr(result)) return errText(result);
+    return text(result);
+  }
+);
+server.tool(
+  "base64_encode",
+  "Encode a string to Base64.",
+  { input: z.string().describe("String to encode") },
+  async ({ input }) => {
+    const result = encodeBase64(input);
+    return text(result.output);
+  }
+);
+server.tool(
+  "base64_decode",
+  "Decode a Base64 string.",
+  { input: z.string().describe("Base64 string to decode") },
+  async ({ input }) => {
+    const result = decodeBase64(input);
+    if (!result.ok) return text(`Error: invalid Base64`);
+    return text(result.output);
+  }
+);
+server.tool(
+  "url_encode",
+  "Percent-encode a URL or URL component.",
+  {
+    input: z.string().describe("String to encode"),
+    mode: z.enum(["component", "full", "form"]).default("component").describe("Encoding mode")
+  },
+  async ({ input, mode }) => {
+    const result = encodeUrl(input, mode);
+    return text(result.output);
+  }
+);
+server.tool(
+  "url_decode",
+  "Decode a percent-encoded URL or URL component.",
+  { input: z.string().describe("Encoded string to decode") },
+  async ({ input }) => {
+    const result = decodeUrl(input);
+    return text(result.output);
+  }
+);
+server.tool(
+  "html_entities_encode",
+  "Encode special characters as HTML entities (e.g. < \u2192 &lt;).",
+  { input: z.string().describe("HTML string to encode") },
+  async ({ input }) => text(encodeHtmlEntities(input))
+);
+server.tool(
+  "html_entities_decode",
+  "Decode HTML entities back to plain text (e.g. &lt; \u2192 <).",
+  { input: z.string().describe("String with HTML entities to decode") },
+  async ({ input }) => text(decodeHtmlEntities(input))
+);
+server.tool(
+  "base32_encode",
+  "Encode a string to Base32.",
+  {
+    input: z.string().describe("String to encode"),
+    alphabet: z.enum(["standard", "extendedHex", "crockford", "zbase32"]).default("standard")
+  },
+  async ({ input, alphabet }) => text(base32Encode(input, alphabet))
+);
+server.tool(
+  "base32_decode",
+  "Decode a Base32 string.",
+  {
+    input: z.string().describe("Base32 string to decode"),
+    alphabet: z.enum(["standard", "extendedHex", "crockford", "zbase32"]).default("standard")
+  },
+  async ({ input, alphabet }) => {
+    const result = base32Decode(input, alphabet);
+    if (checkErr(result)) return errText(result);
+    return text(result);
+  }
+);
+server.tool(
+  "hash",
+  "Hash a string using MD5, SHA-1, SHA-256, SHA-384, or SHA-512.",
+  {
+    input: z.string().describe("String to hash"),
+    algorithm: z.enum(["MD5", "SHA-1", "SHA-256", "SHA-384", "SHA-512"]).default("SHA-256")
+  },
+  async ({ input, algorithm }) => {
+    const result = await hashOne(algorithm, input);
+    return text(result);
+  }
+);
+server.tool(
+  "hash_all",
+  "Hash a string with all algorithms (MD5, SHA-1, SHA-256, SHA-384, SHA-512) at once.",
+  { input: z.string().describe("String to hash") },
+  async ({ input }) => {
+    const results = await hashAll(input);
+    const lines = results.map((r) => `${r.algorithm.padEnd(8)}: ${r.hex}`).join("\n");
+    return text(lines);
+  }
+);
+server.tool(
+  "bcrypt_hash",
+  "Hash a password using bcrypt.",
+  {
+    password: z.string().describe("Password to hash"),
+    rounds: z.number().int().min(8).max(14).default(10).describe("Salt rounds (8\u201314, default 10)")
+  },
+  async ({ password, rounds }) => {
+    const hash = await hashPassword(password, rounds);
+    return text(hash);
+  }
+);
+server.tool(
+  "bcrypt_verify",
+  "Verify a password against a bcrypt hash.",
+  {
+    password: z.string().describe("Plain-text password"),
+    hash: z.string().describe("bcrypt hash to verify against")
+  },
+  async ({ password, hash }) => {
+    const valid = await verifyPassword(password, hash);
+    return text(valid ? "Valid \u2014 password matches hash." : "Invalid \u2014 password does not match hash.");
+  }
+);
+server.tool(
+  "generate_uuid",
+  "Generate one or more UUIDs (v4 random or v7 time-ordered).",
+  {
+    version: z.enum(["v4", "v7"]).default("v4").describe("UUID version"),
+    count: z.number().int().min(1).max(100).default(1).describe("How many to generate")
+  },
+  async ({ version, count }) => {
+    const ver = version === "v4" ? "v4" : "v7";
+    if (count === 1) {
+      const result = generateUuid(ver);
+      return text(result.value);
+    }
+    const uuids = [];
+    for (let i = 0; i < count; i++) uuids.push(generateUuid(ver).value);
+    return text(uuids.join("\n"));
+  }
+);
+server.tool(
+  "generate_ulid",
+  "Generate a ULID (Universally Unique Lexicographically Sortable Identifier).",
+  { count: z.number().int().min(1).max(100).default(1) },
+  async ({ count }) => {
+    const ids = [];
+    for (let i = 0; i < count; i++) ids.push(generateUlid());
+    return text(ids.join("\n"));
+  }
+);
+server.tool(
+  "generate_password",
+  "Generate a cryptographically secure random password.",
+  {
+    length: z.number().int().min(8).max(128).default(16).describe("Password length"),
+    uppercase: z.boolean().default(true),
+    lowercase: z.boolean().default(true),
+    numbers: z.boolean().default(true),
+    symbols: z.boolean().default(true)
+  },
+  async ({ length, uppercase, lowercase, numbers, symbols }) => {
+    const result = generatePassword({ length, uppercase, lowercase, numbers, symbols });
+    return text(result);
+  }
+);
+server.tool(
+  "convert_case",
+  "Convert a string to a different case format: camelCase, snake_case, kebab-case, PascalCase, SCREAMING_SNAKE, Title Case, etc.",
+  {
+    input: z.string().describe("String to convert"),
+    format: z.enum([
+      "camelCase",
+      "PascalCase",
+      "snake_case",
+      "kebab-case",
+      "SCREAMING_SNAKE",
+      "Title Case",
+      "lowercase",
+      "UPPERCASE",
+      "dot.case",
+      "path/case"
+    ]).describe("Target case format")
+  },
+  async ({ input, format }) => text(convertCase(input, format))
+);
+server.tool(
+  "slugify",
+  "Convert text to a URL-friendly slug.",
+  {
+    input: z.string().describe("Text to slugify"),
+    separator: z.enum(["-", "_"]).default("-")
+  },
+  async ({ input, separator }) => text(slugify(input, separator))
+);
+server.tool(
+  "word_count",
+  "Count words, characters, sentences, and estimate reading time for a block of text.",
+  { input: z.string().describe("Text to analyze") },
+  async ({ input }) => {
+    const result = countWords(input);
+    return text(
+      `Words:      ${result.words}
+Characters: ${result.chars} (${result.charsNoSpaces} without spaces)
+Lines:      ${result.lines}
+Sentences:  ${result.sentences}
+Reading:    ~${result.readingTimeSec}s (~${Math.ceil(result.readingTimeSec / 60)} min)`
+    );
+  }
+);
+server.tool(
+  "escape_string",
+  "Escape special characters in a string for use in JSON, JavaScript, HTML, URL, or CSV.",
+  {
+    input: z.string().describe("String to escape"),
+    mode: z.enum(["json", "javascript", "html", "url", "csv"]).describe("Escape target format")
+  },
+  async ({ input, mode }) => text(escapeString(input, mode))
+);
+server.tool(
+  "unescape_string",
+  "Unescape special characters in a JSON, JavaScript, HTML, URL-encoded, or CSV string.",
+  {
+    input: z.string().describe("String to unescape"),
+    mode: z.enum(["json", "javascript", "html", "url", "csv"]).describe("Format to unescape from")
+  },
+  async ({ input, mode }) => text(unescapeString(input, mode))
+);
+server.tool(
+  "lorem_ipsum",
+  "Generate Lorem Ipsum placeholder text.",
+  {
+    unit: z.enum(["words", "sentences", "paragraphs"]).default("sentences"),
+    count: z.number().int().min(1).max(50).default(3)
+  },
+  async ({ unit, count }) => text(loremGenerate(unit, count))
+);
+server.tool(
+  "unix_timestamp",
+  "Convert a Unix timestamp (seconds or milliseconds) to a human-readable date.",
+  { timestamp: z.number().describe("Unix timestamp in seconds or milliseconds") },
+  async ({ timestamp }) => {
+    const result = fromUnix(timestamp);
+    return text(
+      `UTC:   ${result.utc}
+ISO:   ${result.iso}
+Local: ${result.local}
+Unix:  ${result.unix} (${result.ms ? "ms" : "s"})`
+    );
+  }
+);
+server.tool(
+  "parse_cron",
+  "Parse a cron expression and return a human-readable description.",
+  { expression: z.string().describe('Cron expression e.g. "0 9 * * MON-FRI"') },
+  async ({ expression }) => {
+    const result = parseCron(normalizeCron(expression));
+    if (!result.valid) return text(`Invalid cron: ${result.error}`);
+    return text(result.summary ?? "Valid cron expression");
+  }
+);
+server.tool(
+  "cron_next_runs",
+  "Show the next N scheduled run times for a cron expression.",
+  {
+    expression: z.string().describe("Cron expression"),
+    count: z.number().int().min(1).max(20).default(5)
+  },
+  async ({ expression, count }) => {
+    const result = getNextRuns(normalizeCron(expression), count);
+    if (checkErr(result)) return errText(result);
+    const runs = result;
+    return text(runs.map((d, i) => `${i + 1}. ${d.toISOString()}`).join("\n"));
+  }
+);
+server.tool(
+  "date_diff",
+  "Calculate the difference between two dates.",
+  {
+    from: z.string().describe("Start date (ISO 8601 or natural language)"),
+    to: z.string().describe("End date (ISO 8601 or natural language)")
+  },
+  async ({ from, to }) => {
+    const result = diffDates(from, to);
+    if (checkErr(result)) return errText(result);
+    const r = result;
+    return text(
+      `${r.years}y ${r.months}mo ${r.days}d ${r.hours}h
+Total days: ${r.totalDays}`
+    );
+  }
+);
+server.tool(
+  "convert_timezone",
+  "Convert a date/time from one timezone to another.",
+  {
+    datetime: z.string().describe("Date-time string (ISO 8601)"),
+    from_tz: z.string().describe('Source IANA timezone e.g. "UTC"'),
+    to_tz: z.string().describe('Target IANA timezone e.g. "America/New_York"')
+  },
+  async ({ datetime, from_tz, to_tz }) => {
+    const result = convertTime(datetime, from_tz, to_tz);
+    if (checkErr(result)) return errText(result);
+    const r = result;
+    return text(r.result ?? toText(result));
+  }
+);
+server.tool(
+  "convert_bytes",
+  "Convert a byte value between B, KB, MB, GB, TB, KiB, MiB, GiB, TiB.",
+  {
+    value: z.number().describe("Numeric value to convert"),
+    from: z.enum(["B", "KB", "MB", "GB", "TB", "PB", "KiB", "MiB", "GiB", "TiB"]).describe("Source unit")
+  },
+  async ({ value, from }) => {
+    const result = convertBytes(value, from);
+    const lines = Object.entries(result).map(([unit, r]) => `${unit.padEnd(5)}: ${r.formatted}`).join("\n");
+    return text(lines);
+  }
+);
+server.tool(
+  "px_to_units",
+  "Convert a px value to rem, em, pt, and vw units.",
+  {
+    px: z.number().describe("Pixel value to convert"),
+    base_font_size: z.number().default(16).describe("Base font size in px (default 16)")
+  },
+  async ({ px, base_font_size }) => {
+    const result = pxToAll(px, base_font_size);
+    const lines = Object.entries(result).map(([unit, val]) => `${unit.padEnd(6)}: ${val}`).join("\n");
+    return text(lines);
+  }
+);
+server.tool(
+  "decode_jwt",
+  "Decode a JWT token and display header, payload, and expiry info. Does not verify signature.",
+  { token: z.string().describe("JWT token (3 dot-separated base64 segments)") },
+  async ({ token }) => {
+    const result = decodeJwt(token);
+    if (!result.ok) return text(`Error: ${result.error}`);
+    const lines = [];
+    lines.push("\u2500\u2500 Header \u2500\u2500");
+    lines.push(JSON.stringify(result.header, null, 2));
+    lines.push("\u2500\u2500 Payload \u2500\u2500");
+    lines.push(JSON.stringify(result.payload, null, 2));
+    if (result.expiresAt) {
+      const expired = result.expiresAt < /* @__PURE__ */ new Date();
+      lines.push(`\u2500\u2500 Expiry \u2500\u2500
+${result.expiresAt.toISOString()} (${expired ? "EXPIRED" : "valid"})`);
+    }
+    lines.push(`Algorithm: ${result.algorithm}`);
+    return text(lines.join("\n"));
+  }
+);
+server.tool(
+  "build_curl",
+  "Build a cURL command from URL, method, headers, and body.",
+  {
+    url: z.string().url().describe("Request URL"),
+    method: z.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]).default("GET"),
+    headers: z.record(z.string()).optional().describe("Key/value headers object"),
+    body: z.string().optional().describe("Request body string")
+  },
+  async ({ url, method, headers, body }) => {
+    const result = buildCurl({ url, method, headers: headers ? Object.entries(headers).map(([k, v]) => ({ key: k, value: v })) : [], body: body ?? "", bodyType: body ? "raw" : "none", auth: { type: "none" } });
+    return text(result);
+  }
+);
+server.tool(
+  "curl_to_code",
+  "Convert a cURL command to code: fetch, axios, python-requests, go-http, php-curl, or ruby-net-http.",
+  {
+    curl: z.string().describe("Full cURL command string"),
+    language: z.enum(["fetch", "axios", "python-requests", "go-http", "php-curl", "ruby-net-http"]).describe("Target language/library")
+  },
+  async ({ curl, language }) => {
+    const parsed = parseCurlCommand(curl);
+    if (checkErr(parsed)) return errText(parsed);
+    const result = convertToCode(parsed, language);
+    if (!result) return text("Error: could not convert cURL to code");
+    return text(result);
+  }
+);
+server.tool(
+  "convert_color",
+  "Parse a color (HEX, RGB, HSL, HSV, or named CSS color) and return all format conversions.",
+  { input: z.string().describe('Color value e.g. "#ff6b35", "rgb(255,107,53)", "hsl(18,100%,60%)"') },
+  async ({ input }) => {
+    const result = parseColor(input);
+    if (!result.valid) return text(`Error: cannot parse color "${input}"`);
+    const c = result;
+    return text(
+      `HEX:  ${c.hex}
+RGB:  rgb(${c.rgb.r}, ${c.rgb.g}, ${c.rgb.b})
+HSL:  hsl(${c.hsl.h}, ${c.hsl.s}%, ${c.hsl.l}%)
+HSV:  hsv(${c.hsv.h}, ${c.hsv.s}%, ${c.hsv.v}%)`
+    );
+  }
+);
+server.tool(
+  "format_sql",
+  "Format a SQL query with proper indentation and keyword uppercasing.",
+  {
+    input: z.string().describe("SQL query to format"),
+    uppercase: z.boolean().default(true).describe("Uppercase SQL keywords")
+  },
+  async ({ input, uppercase }) => {
+    const result = formatSql(input, { uppercase });
+    return text(result);
+  }
+);
+server.tool(
+  "format_html",
+  "Format and indent HTML markup.",
+  {
+    input: z.string().describe("HTML string to format"),
+    indent: z.number().int().min(1).max(8).default(2)
+  },
+  async ({ input, indent }) => {
+    const result = formatHtml(input, indent);
+    if (checkErr(result)) return errText(result);
+    return text(result.output ?? toText(result));
+  }
+);
+server.tool(
+  "test_regex",
+  "Test a regular expression against an input string and return all matches with capture groups.",
+  {
+    pattern: z.string().describe("Regex pattern (without slashes)"),
+    flags: z.string().default("g").describe('Regex flags: g, i, m, s, u (default "g")'),
+    input: z.string().describe("String to test the pattern against")
+  },
+  async ({ pattern, flags, input }) => {
+    const result = testRegex(pattern, flags.split(""), input);
+    if (checkErr(result)) return errText(result);
+    const r = result;
+    if (r.matchCount === 0) return text("No matches found.");
+    const lines = [`${r.matchCount} match${r.matchCount > 1 ? "es" : ""}:`];
+    r.matches.forEach((m, i) => {
+      lines.push(`  ${i + 1}. "${m.fullMatch}" at index ${m.index}${m.groups.length ? ` (groups: ${m.groups.join(", ")})` : ""}`);
+    });
+    return text(lines.join("\n"));
+  }
+);
+server.tool(
+  "validate_yaml",
+  "Validate YAML syntax and return stats or error details.",
+  { input: z.string().describe("YAML string to validate") },
+  async ({ input }) => {
+    const result = validateYaml(input);
+    if (!result.valid) return text(`Invalid YAML`);
+    return text(`Valid YAML
+Documents: ${result.documentCount}
+Keys: ${result.keyCount}`);
+  }
+);
+server.tool(
+  "toml_to_json",
+  "Convert a TOML string to JSON.",
+  { input: z.string().describe("TOML string") },
+  async ({ input }) => {
+    const result = tomlToJson(input);
+    if (checkErr(result)) return errText(result);
+    return text(result);
+  }
+);
+server.tool(
+  "xml_to_json",
+  "Convert an XML document to JSON.",
+  { input: z.string().describe("XML string") },
+  async ({ input }) => {
+    const result = xmlToJson(input);
+    if (checkErr(result)) return errText(result);
+    return text(result);
+  }
+);
+var transport = new StdioServerTransport();
+await server.connect(transport);

package/package.json

@@ -0,0 +1,50 @@
+{
+  "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.",
+  "author": "Utilix <hello@utilix.tech>",
+  "license": "MIT",
+  "homepage": "https://utilix.tech/docs",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "developer-tools",
+    "utilities",
+    "claude",
+    "cursor",
+    "copilot",
+    "json",
+    "encoding",
+    "hashing",
+    "utilix"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "bin": {
+    "utilix-mcp": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "smithery.yaml",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "@utilix-tech/sdk": "^0.1.4",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.4.0"
+  }
+}

package/smithery.yaml

@@ -0,0 +1,63 @@
+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.
+homepage: https://utilix.tech
+license: MIT
+
+startCommand:
+  type: stdio
+  command: npx
+  args:
+    - "@utilix-tech/mcp"
+
+tools:
+  - format_json
+  - minify_json
+  - diff_json
+  - json_to_csv
+  - csv_to_json
+  - jsonpath
+  - validate_json
+  - yaml_to_json
+  - json_to_yaml
+  - json_to_typescript
+  - json_to_go
+  - json_to_python
+  - json_to_zod
+  - base64_encode
+  - base64_decode
+  - url_encode
+  - url_decode
+  - html_entities_encode
+  - html_entities_decode
+  - base32_encode
+  - base32_decode
+  - hash
+  - hash_all
+  - bcrypt_hash
+  - bcrypt_verify
+  - generate_uuid
+  - generate_ulid
+  - generate_password
+  - convert_case
+  - slugify
+  - word_count
+  - escape_string
+  - unescape_string
+  - lorem_ipsum
+  - unix_timestamp
+  - parse_cron
+  - cron_next_runs
+  - date_diff
+  - convert_timezone
+  - convert_bytes
+  - px_to_units
+  - decode_jwt
+  - build_curl
+  - curl_to_code
+  - convert_color
+  - format_sql
+  - format_html
+  - test_regex
+  - validate_yaml
+  - toml_to_json
+  - xml_to_json