@utilix-tech/mcp 0.2.0 → 0.3.1

package/README.md

@@ -1,6 +1,6 @@
 # @utilix-tech/mcp
 
-MCP server exposing 70 developer utility tools to Claude, Cursor, VS Code Copilot, and any [Model Context Protocol](https://modelcontextprotocol.io) compatible AI assistant.
+MCP server exposing 95 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.
 
@@ -52,6 +52,27 @@ Add to `.vscode/mcp.json`:
 }
 ```
 
+### Windsurf
+
+Add to `~/.codeium/windsurf/mcp_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "utilix": {
+      "command": "npx",
+      "args": ["-y", "@utilix-tech/mcp"]
+    }
+  }
+}
+```
+
+### Claude Code
+
+```bash
+claude mcp add utilix -- npx -y @utilix-tech/mcp
+```
+
 ## Tools
 
 ### JSON (13 tools)
@@ -176,6 +197,35 @@ Add to `.vscode/mcp.json`:
 | `unicode_inspect` | Inspect Unicode code points of a string |
 | `optimize_svg` | Optimize and minify an SVG string |
 
+### AI / Agent (25 tools)
+| Tool | Description |
+|------|-------------|
+| `estimate_tokens` | Estimate token count and cost for an LLM prompt |
+| `trim_to_tokens` | Trim text to fit a token budget |
+| `chunk_text` | Split text into overlapping chunks for RAG pipelines |
+| `rerank_chunks` | Rerank retrieved chunks by relevance to a query |
+| `score_relevance` | Score a chunk's relevance to a query |
+| `expand_query` | Expand a search query with synonyms/related terms |
+| `summarize_for_llm` | Summarize text to fit a target length or token budget |
+| `detect_pii` | Find emails, phones, SSNs, credit cards in text |
+| `detect_secrets` | Scan text for leaked API keys, tokens, passwords |
+| `detect_prompt_injection` | Score and flag adversarial/injection-style inputs |
+| `repair_json` | Fix malformed JSON with a list of applied fixes |
+| `sanitize_html` | Strip unsafe tags/attributes from HTML |
+| `flatten_json` | Flatten nested JSON into dot-notation keys |
+| `merge_json` | Deep or shallow merge two JSON objects |
+| `extract_json` | Extract JSON blocks embedded in free text |
+| `extract_urls` | Extract all URLs from text |
+| `extract_entities` | Extract named entities from text |
+| `extract_keywords` | Extract keywords from text |
+| `extract_tables` | Extract tabular data from text |
+| `deduplicate_lines` | Remove duplicate lines from text |
+| `validate_json_schema` | Validate JSON against a JSON Schema |
+| `compress_html` | Compress HTML for LLM context budgets |
+| `compress_markdown` | Compress Markdown for LLM context budgets |
+| `compress_json` | Compress JSON for LLM context budgets |
+| `diff_json_detailed` | Diff two parsed JSON values, returning every path with its op and unchanged paths |
+
 ## Requirements
 
 - Node.js 18+
@@ -183,5 +233,7 @@ Add to `.vscode/mcp.json`:
 ## Links
 
 - [Utilix web app](https://utilix.tech) — use these tools in the browser
+- [API Playground](https://utilix.tech/api) — try 10 endpoints live, no signup required
+- [REST API docs](https://utilix.tech/docs#rest-api) — 100+ endpoints at `api.utilix.tech/v1` (1,000 req/day free)
 - [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

@@ -74,6 +74,7 @@ import { formatSql, formatHtml, testRegex, minifyJs, formatGql, parseDockerImage
 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 as diffJsonDetailed, extractTables, extractEntities, compressHtml, compressMarkdown, compressJson, rerankChunks, scoreRelevance, expandQuery, summarizeForLlm } from "@utilix-tech/sdk/ai_agent";
 var CRON_DAY_MAP = {
   SUN: "0",
   MON: "1",
@@ -1027,5 +1028,120 @@ server.tool(
 (${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_detailed", "Diff two JSON objects (parsed values, not strings) \u2014 returns a flat list of every path with its op (added/removed/changed/unchanged), plus counts.", { a: z.unknown(), b: z.unknown() }, async ({ a, b }) => {
+  return { content: [{ type: "text", text: JSON.stringify(diffJsonDetailed(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.2.0",
-  "description": "MCP server exposing 70 Utilix developer tools to Claude, Cursor, VS Code Copilot, and any MCP-compatible AI assistant.",
+  "version": "0.3.1",
+  "description": "MCP server exposing 95 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",
@@ -32,7 +32,7 @@
     "README.md"
   ],
   "scripts": {
-    "build": "tsup",
+    "build": "tsup && chmod +x dist/index.js",
     "dev": "tsup --watch",
     "start": "node dist/index.js",
     "prepublishOnly": "npm run build"

package/smithery.yaml

@@ -1,7 +1,8 @@
 name: utilix
-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
+description: 70 developer utility tools for Claude, Cursor, VS Code, Windsurf, and any MCP-compatible AI assistant. Covers JSON, hashing, encoding, JWT, UUID, cron, color, SQL, regex, CSS, QR codes, and more. All tools run locally — no API key required.
+homepage: https://utilix.tech/mcp
 license: MIT
+repository: https://github.com/utilix-tech/utilix-mcp
 
 startCommand:
   type: stdio