@utilix-tech/mcp 0.67.0 → 0.69.0

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 Full release notes for all Utilix surfaces (browser tools, REST API, SDKs, MCP server) live at [utilix.tech/changelog](https://utilix.tech/changelog). This file tracks just this package.
 
+## 0.69.0
+- Add `parse_commit_trailers` tool: parse a commit message's trailer block (Co-authored-by, Signed-off-by, Fixes, Reviewed-by, etc.) per git's RFC 822-style trailer convention, returning each trailer's key and value plus the body with the trailer block removed.
+- Add `extract_markdown_footnotes` tool: extract every Markdown-Extra-style footnote reference and definition from a document, flagging references with no matching definition and definitions that are never referenced.
+
+## 0.68.0
+- Add `build_robots_meta_tag`, `parse_robots_meta_tag` tools: build a `<meta name="robots" content="...">` tag from the same directive vocabulary as X-Robots-Tag, optionally scoped to a crawler via the name attribute, or parse an existing tag into the same shape.
+- Add `extract_svg_sprite_symbols` tool: parse an SVG sprite sheet's `<symbol>` definitions and list each one's id, viewBox, width, and height, alongside a ready-to-paste `<use href="#id"></use>` usage snippet.
+
 ## 0.67.0
 - Add `analyze_regex_groups` tool: parse a regex pattern's capture groups (numbered and named) and backreferences, flagging any backreference pointing at a group that doesn't exist or hasn't finished being defined yet at that point in the pattern.
 

package/README.md

@@ -1,6 +1,6 @@
 # @utilix-tech/mcp
 
-MCP server exposing 228 developer utility tools to Claude, Cursor, VS Code Copilot, and any [Model Context Protocol](https://modelcontextprotocol.io) compatible AI assistant.
+MCP server exposing 233 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.
 
@@ -205,7 +205,7 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `plan_debt_payoff` | Simulate paying off a list of debts under both the snowball (smallest balance first) and avalanche (highest rate first) strategies given a fixed extra monthly payment, and compare months to payoff and total interest |
 | `calculate_loan_refinance` | Compare a current loan's remaining payments against a new refinanced loan on the same outstanding balance, and compute the monthly savings and the break-even month where cumulative savings recoup the closing costs |
 
-### API / Network (44 tools)
+### API / Network (48 tools)
 | Tool | Description |
 |------|-------------|
 | `decode_jwt` | Decode a JWT: header, payload, and expiry |
@@ -254,6 +254,8 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `parse_x_robots_tag` | Parse an existing X-Robots-Tag header value into the same shape |
 | `lookup_websocket_opcode` | Look up what a WebSocket frame opcode means, per RFC 6455's 4-bit opcode space |
 | `list_websocket_opcodes` | List every WebSocket frame opcode (0x0-0xF) |
+| `build_robots_meta_tag` | Build a `<meta name="robots" content="...">` tag from directives (noindex, nofollow, max-snippet, etc.), the same vocabulary as X-Robots-Tag, optionally scoped to a crawler via the name attribute |
+| `parse_robots_meta_tag` | Parse an existing robots meta tag (or bare content value) into the same shape |
 
 ### Color (4 tools)
 | Tool | Description |
@@ -263,7 +265,7 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `color_palette` | Generate a color palette from a base color |
 | `color_shades` | Generate shades or tints from a base color |
 
-### Code (16 tools)
+### Code (20 tools)
 | Tool | Description |
 |------|-------------|
 | `format_sql` | Format a SQL query with proper indentation |
@@ -283,6 +285,9 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `validate_tsconfig` | Validate a tsconfig.json file (JSONC-aware): unknown keys, unknown compilerOptions, and type mismatches |
 | `validate_package_exports` | Validate a package.json "exports" field: dual-package (ESM/CJS) misconfigurations like a missing default fallback or a require/import pointing at the wrong extension |
 | `audit_dependency_ranges` | Classify each package.json dependency's version range type and flag wildcard ranges, the "latest" tag, git/URL/file/link dependencies, and packages listed with conflicting or redundant ranges across sections |
+| `extract_svg_sprite_symbols` | Parse an SVG sprite sheet's `<symbol>` definitions and list each one's id, viewBox, width, and height, alongside a ready-to-paste `<use href="#id"></use>` usage snippet |
+| `parse_commit_trailers` | Parse a commit message's trailer block (Co-authored-by, Signed-off-by, Fixes, Reviewed-by, etc.) per git's RFC 822-style trailer convention, returning each trailer's key/value plus the body with the trailer block removed |
+| `extract_markdown_footnotes` | Extract every Markdown-Extra-style footnote reference and definition from a document, flagging references with no matching definition and definitions that are never referenced |
 
 ### Data (16 tools)
 | Tool | Description |

package/dist/index.js

@@ -10868,5 +10868,257 @@ server.tool(
     return text(JSON.stringify(result, null, 2));
   }
 );
+function _buildRobotsMetaTagMcp(options) {
+  const built = _buildXRobotsTagMcp({
+    flags: options?.flags,
+    maxSnippet: options?.maxSnippet,
+    maxImagePreview: options?.maxImagePreview,
+    maxVideoPreview: options?.maxVideoPreview,
+    unavailableAfter: options?.unavailableAfter
+  });
+  if ("error" in built) return built;
+  const name = (typeof options?.name === "string" ? options.name.trim() : "") || "robots";
+  return {
+    content: built.header,
+    name,
+    tag: `<meta name="${name}" content="${built.header}">`,
+    directives: built.directives,
+    notes: built.notes,
+    warnings: built.warnings
+  };
+}
+var _ROBOTS_META_TAG_REGEX_MCP = /<meta\b[^>]*>/i;
+var _ROBOTS_META_NAME_ATTR_REGEX_MCP = /\bname\s*=\s*["']([^"']*)["']/i;
+var _ROBOTS_META_CONTENT_ATTR_REGEX_MCP = /\bcontent\s*=\s*["']([^"']*)["']/i;
+function _parseRobotsMetaTagMcp(raw) {
+  if (!raw || raw.trim() === "") return { error: "Input is empty" };
+  const trimmed = raw.trim();
+  let name = "robots";
+  let content = trimmed;
+  const tagMatch = trimmed.match(_ROBOTS_META_TAG_REGEX_MCP);
+  if (tagMatch) {
+    const nameMatch = tagMatch[0].match(_ROBOTS_META_NAME_ATTR_REGEX_MCP);
+    const contentMatch = tagMatch[0].match(_ROBOTS_META_CONTENT_ATTR_REGEX_MCP);
+    if (!contentMatch) return { error: "Meta tag is missing a content attribute" };
+    if (nameMatch) name = nameMatch[1].trim() || "robots";
+    content = contentMatch[1];
+  }
+  const tokens = content.split(",").map((t) => t.trim()).filter((t) => t !== "");
+  if (tokens.length === 0) return { error: "No directives found" };
+  const flags = [];
+  let maxSnippet;
+  let maxImagePreview;
+  let maxVideoPreview;
+  let unavailableAfter;
+  for (const token of tokens) {
+    const eq = token.indexOf(":");
+    const directiveName = (eq === -1 ? token : token.slice(0, eq)).trim().toLowerCase();
+    const value = eq === -1 ? "" : token.slice(eq + 1).trim();
+    if (eq === -1) {
+      if (!_isXRobotsTagFlagMcp(directiveName)) return { error: `Unrecognized directive "${token}"` };
+      flags.push(directiveName);
+      continue;
+    }
+    if (directiveName === "max-snippet") {
+      const n = Number(value);
+      if (value === "" || !Number.isInteger(n) || n < -1) return { error: `max-snippet value "${value}" is not a valid integer >= -1` };
+      maxSnippet = n;
+    } else if (directiveName === "max-image-preview") {
+      if (!["none", "standard", "large"].includes(value)) return { error: `max-image-preview value "${value}" must be one of "none", "standard", "large"` };
+      maxImagePreview = value;
+    } else if (directiveName === "max-video-preview") {
+      const n = Number(value);
+      if (value === "" || !Number.isInteger(n) || n < -1) return { error: `max-video-preview value "${value}" is not a valid integer >= -1` };
+      maxVideoPreview = n;
+    } else if (directiveName === "unavailable_after") {
+      if (value === "" || Number.isNaN(Date.parse(value))) return { error: `unavailable_after value "${value}" is not a valid, parseable date` };
+      unavailableAfter = value;
+    } else {
+      return { error: `Unrecognized directive "${token}"` };
+    }
+  }
+  return _buildRobotsMetaTagMcp({ flags, maxSnippet, maxImagePreview, maxVideoPreview, unavailableAfter, name });
+}
+server.tool(
+  "build_robots_meta_tag",
+  'Build a <meta name="robots" content="..."> tag from flag directives (noindex, nofollow, noarchive, nosnippet, notranslate, noimageindex, none, all, indexifembedded) plus optional max-snippet, max-image-preview, max-video-preview, and unavailable_after value directives, the exact same directive vocabulary as the X-Robots-Tag header. Scope the tag to a single crawler with name (e.g. "googlebot") instead of the default "robots".',
+  {
+    flags: z.array(z.enum(["noindex", "nofollow", "noarchive", "nosnippet", "notranslate", "noimageindex", "none", "all", "indexifembedded"])).optional().describe("Flag directives to include"),
+    maxSnippet: z.number().int().min(-1).optional().describe("Max text snippet length in characters; 0 shows no snippet, -1 means no limit"),
+    maxImagePreview: z.enum(["none", "standard", "large"]).optional().describe("Max image preview size shown in search results"),
+    maxVideoPreview: z.number().int().min(-1).optional().describe("Max video preview length in seconds; 0 shows no preview, -1 means no limit"),
+    unavailableAfter: z.string().optional().describe("Stop showing this page in search results after this date/time"),
+    name: z.string().optional().describe('Optional crawler name to scope the tag to via its name attribute, e.g. "googlebot" (default "robots")')
+  },
+  async ({ flags, maxSnippet, maxImagePreview, maxVideoPreview, unavailableAfter, name }) => {
+    const result = _buildRobotsMetaTagMcp({ flags, maxSnippet, maxImagePreview, maxVideoPreview, unavailableAfter, name });
+    if ("error" in result) return errText(result);
+    return text(JSON.stringify(result, null, 2));
+  }
+);
+server.tool(
+  "parse_robots_meta_tag",
+  'Parse an existing <meta name="..." content="..."> robots tag (or a bare content attribute value on its own) into the same shape build_robots_meta_tag returns.',
+  {
+    tag: z.string().min(1).describe("The meta tag (or bare content value) to parse")
+  },
+  async ({ tag }) => {
+    const result = _parseRobotsMetaTagMcp(tag);
+    if ("error" in result) return errText(result);
+    return text(JSON.stringify(result, null, 2));
+  }
+);
+var _SVG_SYMBOL_TAG_REGEX_MCP = /<symbol\b([^>]*)>/gi;
+function _extractSvgAttrMcp(attrs, name) {
+  const match = attrs.match(new RegExp(`\\s${name}\\s*=\\s*["']([^"']*)["']`, "i"));
+  return match ? match[1] : null;
+}
+function _extractSvgSpriteSymbolsMcp(svg) {
+  const trimmed = svg.trim();
+  if (!trimmed) return { error: "Empty input" };
+  const symbols = [];
+  let skippedCount = 0;
+  for (const match of trimmed.matchAll(_SVG_SYMBOL_TAG_REGEX_MCP)) {
+    const attrs = match[1];
+    const id = _extractSvgAttrMcp(attrs, "id");
+    if (!id) {
+      skippedCount++;
+      continue;
+    }
+    symbols.push({
+      id,
+      viewBox: _extractSvgAttrMcp(attrs, "viewBox"),
+      width: _extractSvgAttrMcp(attrs, "width"),
+      height: _extractSvgAttrMcp(attrs, "height"),
+      usageSnippet: `<svg><use href="#${id}"></use></svg>`
+    });
+  }
+  if (symbols.length === 0 && skippedCount === 0) {
+    return { error: "No <symbol> elements found" };
+  }
+  return { symbolCount: symbols.length, symbols, skippedCount };
+}
+server.tool(
+  "extract_svg_sprite_symbols",
+  `Parse an SVG sprite sheet's <symbol> definitions and list each one's id, viewBox, width, and height, alongside a ready-to-paste <use href="#id"></use> usage snippet. A symbol with no id is skipped (counted in skippedCount) since it can't be referenced by a <use> element at all.`,
+  {
+    svg: z.string().min(1).describe("The SVG sprite sheet markup")
+  },
+  async ({ svg }) => {
+    const result = _extractSvgSpriteSymbolsMcp(svg);
+    if ("error" in result) return errText(result);
+    return text(JSON.stringify(result, null, 2));
+  }
+);
+var _TRAILER_LINE_REGEX_MCP = /^([A-Za-z][A-Za-z0-9-]*): (.+)$/;
+var _TRAILER_CONTINUATION_REGEX_MCP = /^[ \t]+\S/;
+function _parseCommitTrailersMcp(message) {
+  const lines = message.replace(/\r\n/g, "\n").split("\n");
+  while (lines.length > 0 && lines[lines.length - 1].trim() === "") lines.pop();
+  if (lines.length === 0) return { error: "Empty input" };
+  let start = 0;
+  for (let i = lines.length - 1; i >= 0; i--) {
+    if (lines[i].trim() === "") {
+      start = i + 1;
+      break;
+    }
+  }
+  const paragraph = lines.slice(start);
+  const trailers = [];
+  let valid = true;
+  for (const line of paragraph) {
+    const m = line.match(_TRAILER_LINE_REGEX_MCP);
+    if (m) {
+      trailers.push({ key: m[1], value: m[2].trim() });
+    } else if (_TRAILER_CONTINUATION_REGEX_MCP.test(line) && trailers.length > 0) {
+      trailers[trailers.length - 1].value += " " + line.trim();
+    } else {
+      valid = false;
+      break;
+    }
+  }
+  if (!valid || trailers.length === 0) {
+    return { trailers: [], body: lines.join("\n").trim(), hasTrailers: false };
+  }
+  const body = lines.slice(0, start).join("\n").trim();
+  return { trailers, body, hasTrailers: true };
+}
+server.tool(
+  "parse_commit_trailers",
+  `Parse a commit message's trailer block (Co-authored-by, Signed-off-by, Fixes, Reviewed-by, etc.) per git's RFC 822-style trailer convention (git-interpret-trailers): the last paragraph of the message, where every line is either a "Key: value" pair or an indented continuation of the previous trailer's value. Returns the trailers plus the message body with the trailer block removed.`,
+  {
+    message: z.string().min(1).describe("The full commit message")
+  },
+  async ({ message }) => {
+    const result = _parseCommitTrailersMcp(message);
+    return text(JSON.stringify(result, null, 2));
+  }
+);
+var _FOOTNOTE_DEFINITION_LINE_REGEX_MCP = /^\[\^([^\]]+)\]:\s?(.*)$/;
+var _FOOTNOTE_CONTINUATION_REGEX_MCP = /^(?: {4}|\t)/;
+var _FOOTNOTE_REFERENCE_REGEX_MCP = /\[\^([^\]]+)\]/g;
+function _extractMarkdownFootnotesMcp(markdown) {
+  const trimmed = markdown.trim();
+  if (!trimmed) return { error: "Empty input" };
+  if (!trimmed.includes("[^")) return { error: "No footnote references or definitions found" };
+  const lines = markdown.replace(/\r\n/g, "\n").split("\n");
+  const definitions = [];
+  const definedLabels = /* @__PURE__ */ new Set();
+  const consumed = new Array(lines.length).fill(false);
+  let i = 0;
+  while (i < lines.length) {
+    const match = lines[i].match(_FOOTNOTE_DEFINITION_LINE_REGEX_MCP);
+    if (!match) {
+      i++;
+      continue;
+    }
+    const label = match[1];
+    const textLines = [match[2]];
+    consumed[i] = true;
+    let j = i + 1;
+    while (j < lines.length && (_FOOTNOTE_CONTINUATION_REGEX_MCP.test(lines[j]) || lines[j].trim() === "" && j + 1 < lines.length && _FOOTNOTE_CONTINUATION_REGEX_MCP.test(lines[j + 1]))) {
+      textLines.push(lines[j].trim() === "" ? "" : lines[j].replace(_FOOTNOTE_CONTINUATION_REGEX_MCP, ""));
+      consumed[j] = true;
+      j++;
+    }
+    if (!definedLabels.has(label)) {
+      definedLabels.add(label);
+      definitions.push({ label, text: textLines.join("\n").trim() });
+    }
+    i = j;
+  }
+  const referenceScanText = lines.filter((_, idx) => !consumed[idx]).join("\n");
+  const refOrder = [];
+  const refCounts = /* @__PURE__ */ new Map();
+  for (const m of referenceScanText.matchAll(_FOOTNOTE_REFERENCE_REGEX_MCP)) {
+    const label = m[1];
+    if (!refCounts.has(label)) {
+      refCounts.set(label, 0);
+      refOrder.push(label);
+    }
+    refCounts.set(label, (refCounts.get(label) ?? 0) + 1);
+  }
+  const references = refOrder.map((label) => ({ label, count: refCounts.get(label) ?? 0 }));
+  const referencedSet = new Set(refOrder);
+  const unresolvedReferences = refOrder.filter((label) => !definedLabels.has(label));
+  const unusedDefinitions = definitions.filter((d) => !referencedSet.has(d.label)).map((d) => d.label);
+  const referenceCount = refOrder.reduce((sum, label) => sum + (refCounts.get(label) ?? 0), 0);
+  if (definitions.length === 0 && references.length === 0) {
+    return { error: "No footnote references or definitions found" };
+  }
+  return { definitionCount: definitions.length, referenceCount, definitions, references, unresolvedReferences, unusedDefinitions };
+}
+server.tool(
+  "extract_markdown_footnotes",
+  "Extract every Markdown-Extra-style footnote reference ([^label]) and definition ([^label]: text, with 4-space/tab-indented continuation lines) from a document, then flag references with no matching definition and definitions that are never referenced.",
+  {
+    markdown: z.string().min(1).describe("The Markdown document text")
+  },
+  async ({ markdown }) => {
+    const result = _extractMarkdownFootnotesMcp(markdown);
+    if ("error" in result) return errText(result);
+    return text(JSON.stringify(result, null, 2));
+  }
+);
 var transport = new StdioServerTransport();
 await server.connect(transport);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@utilix-tech/mcp",
-  "version": "0.67.0",
+  "version": "0.69.0",
   "description": "MCP server exposing 198 Utilix developer tools to Claude, Cursor, VS Code Copilot, and any MCP-compatible AI assistant.",
   "author": "Utilix <hello@utilix.tech>",
   "license": "MIT",