@utilix-tech/mcp 0.7.0 → 0.8.0

package/README.md

@@ -1,6 +1,6 @@
 # @utilix-tech/mcp
 
-MCP server exposing 102 developer utility tools to Claude, Cursor, VS Code Copilot, and any [Model Context Protocol](https://modelcontextprotocol.io) compatible AI assistant.
+MCP server exposing 104 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. Requires Node.js 18 or later.
 
@@ -121,7 +121,7 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `generate_qr` | Generate a QR code as an SVG string |
 | `generate_random_data` | Generate random mock data: names, emails, UUIDs, IPs, etc. |
 
-### Text (10 tools)
+### Text (11 tools)
 | Tool | Description |
 |------|-------------|
 | `convert_case` | Convert text case: camelCase, snake_case, PascalCase, etc. |
@@ -134,6 +134,7 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `html_to_markdown` | Convert HTML to Markdown |
 | `line_operations` | Sort, deduplicate, reverse, shuffle, trim, or number lines |
 | `detect_passive_voice` | Flag sentences written in passive voice, e.g. "was written", "were approved by the team" |
+| `score_readability` | Score text with Flesch Reading Ease, Flesch-Kincaid Grade Level, and Gunning Fog Index |
 
 ### Time (5 tools)
 | Tool | Description |
@@ -241,6 +242,11 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 |------|-------------|
 | `read_pdf_metadata` | Read title, author, dates, page count, and encryption flag from a PDF's trailer/Info dictionary: no PDF rendering library required |
 
+### Audio (1 tool)
+| Tool | Description |
+|------|-------------|
+| `read_wav_info` | Read sample rate, channel count, bit depth, and duration from a WAV file's RIFF/fmt/data chunk headers: no audio library required |
+
 ## Requirements
 
 - Node.js 18+

package/dist/index.js

@@ -1876,5 +1876,136 @@ server.tool("parse_jwks", "Parse a JSON Web Key Set (or a single bare JWK) and s
   if ("error" in result) return errText(result);
   return text(JSON.stringify(result, null, 2));
 });
+var _WAV_AUDIO_FORMAT_LABELS = { 1: "PCM", 3: "IEEE float", 6: "A-law", 7: "mu-law", 65534: "Extensible" };
+function _readWavAscii4(bytes, offset) {
+  return String.fromCharCode(bytes[offset], bytes[offset + 1], bytes[offset + 2], bytes[offset + 3]);
+}
+function _readWavInfo(bytes) {
+  if (bytes.length < 12) return { error: "File is too small to be a valid WAV file" };
+  if (_readWavAscii4(bytes, 0) !== "RIFF") return { error: 'Not a RIFF file (missing "RIFF" header)' };
+  if (_readWavAscii4(bytes, 8) !== "WAVE") return { error: 'Not a WAVE file (missing "WAVE" format marker)' };
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const fileSize = view.getUint32(4, true) + 8;
+  let offset = 12;
+  let fmt = null;
+  let dataSize = null;
+  while (offset + 8 <= bytes.length) {
+    const chunkId = _readWavAscii4(bytes, offset);
+    const chunkSize = view.getUint32(offset + 4, true);
+    const dataOffset = offset + 8;
+    if (chunkId === "fmt ") {
+      if (dataOffset + 16 > bytes.length) return { error: 'Truncated "fmt " chunk' };
+      fmt = {
+        audioFormat: view.getUint16(dataOffset, true),
+        channels: view.getUint16(dataOffset + 2, true),
+        sampleRate: view.getUint32(dataOffset + 4, true),
+        byteRate: view.getUint32(dataOffset + 8, true),
+        blockAlign: view.getUint16(dataOffset + 12, true),
+        bitsPerSample: view.getUint16(dataOffset + 14, true)
+      };
+    } else if (chunkId === "data") {
+      dataSize = Math.min(chunkSize, bytes.length - dataOffset);
+    }
+    offset = dataOffset + chunkSize + chunkSize % 2;
+    if (fmt && dataSize !== null) break;
+  }
+  if (!fmt) return { error: 'No "fmt " chunk found in this WAV file' };
+  if (dataSize === null) return { error: 'No "data" chunk found in this WAV file' };
+  if (fmt.byteRate <= 0) return { error: 'Invalid byte rate in "fmt " chunk' };
+  const durationSeconds = Math.round(dataSize / fmt.byteRate * 1e3) / 1e3;
+  return {
+    audioFormat: fmt.audioFormat,
+    audioFormatLabel: _WAV_AUDIO_FORMAT_LABELS[fmt.audioFormat] ?? `Unknown (0x${fmt.audioFormat.toString(16)})`,
+    channels: fmt.channels,
+    sampleRate: fmt.sampleRate,
+    byteRate: fmt.byteRate,
+    blockAlign: fmt.blockAlign,
+    bitsPerSample: fmt.bitsPerSample,
+    dataSize,
+    durationSeconds,
+    fileSize
+  };
+}
+server.tool("read_wav_info", "Read sample rate, channel count, bit depth, and duration directly from a WAV file's RIFF/fmt/data chunk headers. No audio library required.", { wav_base64: z.string().describe("Base64-encoded WAV file bytes, optionally prefixed with a data: URL scheme") }, async ({ wav_base64 }) => {
+  const bytes = new Uint8Array(Buffer.from(wav_base64.replace(/^data:.*;base64,/, ""), "base64"));
+  const result = _readWavInfo(bytes);
+  if ("error" in result) return errText(result);
+  return text(JSON.stringify(result, null, 2));
+});
+function _readabilitySplitIntoSentences(text2) {
+  const matches = text2.match(/[^.!?]+[.!?]*/g);
+  if (!matches) return [];
+  return matches.map((s) => s.trim()).filter((s) => s.length > 0);
+}
+function _countReadabilitySyllables(word) {
+  const w = word.toLowerCase().replace(/[^a-z]/g, "");
+  if (w.length === 0) return 0;
+  if (w.length <= 3) return 1;
+  let count = 0;
+  let prevWasVowel = false;
+  for (const ch of w) {
+    const isVowel = "aeiouy".includes(ch);
+    if (isVowel && !prevWasVowel) count++;
+    prevWasVowel = isVowel;
+  }
+  if (w.endsWith("e") && !w.endsWith("le") && count > 1) count--;
+  if (w.endsWith("le") && w.length > 2 && !"aeiouy".includes(w[w.length - 3])) count++;
+  return Math.max(count, 1);
+}
+function _readabilityGradeLabel(fleschReadingEase) {
+  if (fleschReadingEase >= 90) return "Very easy (5th grade)";
+  if (fleschReadingEase >= 80) return "Easy (6th grade)";
+  if (fleschReadingEase >= 70) return "Fairly easy (7th grade)";
+  if (fleschReadingEase >= 60) return "Standard (8th-9th grade)";
+  if (fleschReadingEase >= 50) return "Fairly difficult (10th-12th grade)";
+  if (fleschReadingEase >= 30) return "Difficult (college)";
+  return "Very difficult (college graduate)";
+}
+function _round1Readability(n) {
+  return Math.round(n * 10) / 10;
+}
+function _scoreReadability(input) {
+  const sentences = _readabilitySplitIntoSentences(input);
+  const words = input.match(/[a-zA-Z']+/g) ?? [];
+  const sentenceCount = Math.max(sentences.length, 1);
+  const wordCount = words.length;
+  const syllableCounts = words.map(_countReadabilitySyllables);
+  const syllableCount = syllableCounts.reduce((a, b) => a + b, 0);
+  const complexWordCount = syllableCounts.filter((c) => c >= 3).length;
+  if (wordCount === 0) {
+    return {
+      wordCount: 0,
+      sentenceCount: 0,
+      syllableCount: 0,
+      complexWordCount: 0,
+      avgWordsPerSentence: 0,
+      avgSyllablesPerWord: 0,
+      fleschReadingEase: 0,
+      fleschKincaidGrade: 0,
+      gunningFog: 0,
+      readingLevel: "No text to score"
+    };
+  }
+  const avgWordsPerSentence = wordCount / sentenceCount;
+  const avgSyllablesPerWord = syllableCount / wordCount;
+  const fleschReadingEase = _round1Readability(206.835 - 1.015 * avgWordsPerSentence - 84.6 * avgSyllablesPerWord);
+  const fleschKincaidGrade = _round1Readability(0.39 * avgWordsPerSentence + 11.8 * avgSyllablesPerWord - 15.59);
+  const gunningFog = _round1Readability(0.4 * (avgWordsPerSentence + 100 * (complexWordCount / wordCount)));
+  return {
+    wordCount,
+    sentenceCount: sentences.length,
+    syllableCount,
+    complexWordCount,
+    avgWordsPerSentence: _round1Readability(avgWordsPerSentence),
+    avgSyllablesPerWord: _round1Readability(avgSyllablesPerWord),
+    fleschReadingEase,
+    fleschKincaidGrade,
+    gunningFog,
+    readingLevel: _readabilityGradeLabel(fleschReadingEase)
+  };
+}
+server.tool("score_readability", "Score text with Flesch Reading Ease, Flesch-Kincaid Grade Level, and Gunning Fog Index, using a heuristic syllable counter.", { text: z.string() }, async ({ text: input }) => {
+  return { content: [{ type: "text", text: JSON.stringify(_scoreReadability(input), null, 2) }] };
+});
 var transport = new StdioServerTransport();
 await server.connect(transport);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@utilix-tech/mcp",
-  "version": "0.7.0",
-  "description": "MCP server exposing 102 Utilix developer tools to Claude, Cursor, VS Code Copilot, and any MCP-compatible AI assistant.",
+  "version": "0.8.0",
+  "description": "MCP server exposing 104 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/mcp",