@utilix-tech/mcp 0.85.0 → 0.87.0

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 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.87.0
+- Add `validate_markdown_heading_hierarchy` tool: scan a Markdown document's ATX headings and flag heading-structure issues: skipped levels, multiple H1s, empty headings, duplicate headings at the same level, and a document that doesn't start at H1.
+
+## 0.86.0
+- Add `calculate_sales_commission` tool: compute a flat or tiered (marginal) sales commission from a sale amount, where tiered mode applies each rate only to the slice of sales within that tier, plus an optional base salary added to the total payout.
+- Add `build_character_class` tool: assemble a `[...]` regex character class from named building blocks (lowercase, uppercase, digits, whitespace), custom ranges, and literal custom characters, with optional negation.
+
 ## 0.85.0
 - Add `calculate_credit_card_minimum_payment` tool: simulate paying only the minimum payment on a revolving credit card balance, where the minimum is the larger of a percent of the balance or a fixed dollar floor, and report months/years to payoff, total interest, and total paid.
 - Add `check_dash_usage` tool: scan text for likely dash misuse: a hyphen surrounded by spaces, an unconverted double hyphen, and inconsistent spacing around em dashes across the same document.

package/README.md

@@ -1,6 +1,6 @@
 # @utilix-tech/mcp
 
-MCP server exposing 264 developer utility tools to Claude, Cursor, VS Code Copilot, and any [Model Context Protocol](https://modelcontextprotocol.io) compatible AI assistant.
+MCP server exposing 267 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.
 
@@ -168,7 +168,7 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `convert_timezone` | Convert a date/time between timezones |
 | `convert_iso8601_duration` | Parse an ISO 8601 duration into components and total seconds, or format seconds into a duration string |
 
-### Units (47 tools)
+### Units (48 tools)
 | Tool | Description |
 |------|-------------|
 | `convert_bytes` | Convert between B, KB, MB, GB, TB, KiB, MiB, GiB, TiB |
@@ -218,6 +218,7 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `estimate_data_transfer_time` | Estimate the theoretical time to transfer a file of a given size over a connection of a given speed, or (given a target time instead) the bandwidth required to hit it |
 | `calculate_real_rate_of_return` | Apply the Fisher equation to solve for whichever of the nominal rate, inflation rate, or inflation-adjusted real rate is missing, given exactly two of the three |
 | `calculate_credit_card_minimum_payment` | Simulate paying only the minimum payment on a revolving credit card balance, where the minimum is the larger of a percent of the balance or a fixed dollar floor, and report months/years to payoff, total interest, and total paid |
+| `calculate_sales_commission` | Compute a sales commission from either a flat percent rate applied to the whole sale amount, or a tiered (marginal) rate structure where each tier applies only to the slice of sales within it, plus an optional base salary added to the total payout |
 
 ### API / Network (51 tools)
 | Tool | Description |
@@ -285,7 +286,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 (25 tools)
+### Code (27 tools)
 | Tool | Description |
 |------|-------------|
 | `format_sql` | Format a SQL query with proper indentation |
@@ -314,8 +315,9 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `validate_fence_language_tags` | Scan a Markdown document's fenced code blocks and flag a missing, unknown, or inconsistently-cased language tag against a curated list of common syntax-highlighter identifiers |
 | `count_sql_placeholders` | Count positional (`?`, `$1`) and named (`:name`, `@name`) parameter placeholders in a SQL query, flagging mixed styles and numbered-sequence gaps or duplicates |
 | `extract_markdown_link_references` | Extract every reference-style Markdown link ([text][ref], [text][], ![alt][ref]) and match it against its [ref]: url definition, flagging unresolved references and unused definitions |
+| `build_character_class` | Assemble a [...] regex character class from named building blocks (lowercase, uppercase, digits, whitespace), custom ranges, and literal custom characters, with optional negation |
 
-### Data (16 tools)
+### Data (18 tools)
 | Tool | Description |
 |------|-------------|
 | `validate_yaml` | Validate YAML syntax |
@@ -335,6 +337,7 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `analyze_caption_speed` | Parse an SRT or WebVTT file and report the words-per-minute reading speed of every cue, flagging ones that exceed common broadcast accessibility guidelines |
 | `infer_csv_column_types` | Parse CSV/TSV data and infer each column's data type (integer, float, boolean, ISO 8601 date, or string), flagging nullable columns and empty-cell counts |
 | `align_markdown_tables` | Reformat every GitHub-Flavored-Markdown pipe table in a document so each column's pipes line up visually, preserving left/center/right alignment markers |
+| `validate_markdown_heading_hierarchy` | Scan a Markdown document's ATX headings and flag heading-structure issues: skipped levels, multiple H1s, empty headings, duplicate headings, and a document that doesn't start at H1 |
 
 ### CSS (2 tools)
 | Tool | Description |

package/dist/index.js

@@ -6793,6 +6793,95 @@ server.tool(
     return text(JSON.stringify(result, null, 2));
   }
 );
+var _HEADING_HIERARCHY_RE_MCP = /^(#{1,6})(?!#)(?:[ \t]+(.*?))?[ \t]*#*[ \t]*$/;
+function _validateMarkdownHeadingHierarchyMcp(markdown) {
+  const lines = markdown.replace(/\r\n/g, "\n").split("\n");
+  const headings = [];
+  let inFence = false;
+  let fenceMarker = "";
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const fenceMatch = line.match(/^\s*(```+|~~~+)/);
+    if (fenceMatch) {
+      if (!inFence) {
+        inFence = true;
+        fenceMarker = fenceMatch[1][0];
+      } else if (fenceMatch[1][0] === fenceMarker) {
+        inFence = false;
+      }
+      continue;
+    }
+    if (inFence) continue;
+    const match = line.match(_HEADING_HIERARCHY_RE_MCP);
+    if (!match) continue;
+    const level = match[1].length;
+    const text2 = _stripInlineMarkdownMcp(match[2] ?? "");
+    headings.push({ line: i + 1, level, text: text2 });
+  }
+  const issues = [];
+  const seen = /* @__PURE__ */ new Map();
+  let h1Count = 0;
+  let firstH1Line = null;
+  let prevLevel = null;
+  headings.forEach((h, idx) => {
+    if (h.text === "") {
+      issues.push({ line: h.line, type: "empty-heading", message: `Heading at line ${h.line} has no text` });
+    }
+    if (idx === 0 && h.level !== 1) {
+      issues.push({
+        line: h.line,
+        type: "starts-below-h1",
+        message: `Document starts with an H${h.level} heading instead of H1`
+      });
+    }
+    if (h.level === 1) {
+      h1Count++;
+      if (h1Count === 1) {
+        firstH1Line = h.line;
+      } else {
+        issues.push({
+          line: h.line,
+          type: "multiple-h1",
+          message: `Multiple H1 headings found: another H1 at line ${h.line} (first was at line ${firstH1Line})`
+        });
+      }
+    }
+    if (prevLevel !== null && h.level > prevLevel + 1) {
+      const skipped = h.level - prevLevel > 2 ? `H${prevLevel + 1}-H${h.level - 1}` : `H${prevLevel + 1}`;
+      issues.push({
+        line: h.line,
+        type: "skipped-level",
+        message: `Heading level jumps from H${prevLevel} to H${h.level} at line ${h.line}, skipping ${skipped}`
+      });
+    }
+    prevLevel = h.level;
+    if (h.text !== "") {
+      const key = `${h.level}:${h.text.toLowerCase()}`;
+      const earlierLine = seen.get(key);
+      if (earlierLine !== void 0) {
+        issues.push({
+          line: h.line,
+          type: "duplicate-heading",
+          message: `Heading "${h.text}" at line ${h.line} duplicates an H${h.level} heading at line ${earlierLine}`
+        });
+      } else {
+        seen.set(key, h.line);
+      }
+    }
+  });
+  return { headings, issues, h1Count };
+}
+server.tool(
+  "validate_markdown_heading_hierarchy",
+  "Scan a Markdown document's ATX headings and flag heading-structure issues: a level that skips one or more levels going deeper, more than one H1, an empty heading, a duplicate heading at the same level, or a document that doesn't start at H1. Setext-style headings are not recognized, and headings inside fenced code blocks are ignored.",
+  {
+    markdown: z.string().describe("The Markdown document to scan")
+  },
+  async ({ markdown }) => {
+    const result = _validateMarkdownHeadingHierarchyMcp(markdown);
+    return text(JSON.stringify(result, null, 2));
+  }
+);
 var _COMMIT_DEFAULT_TYPES_MCP = ["build", "chore", "ci", "docs", "feat", "fix", "perf", "refactor", "revert", "style", "test"];
 var _COMMIT_HEADER_RE_MCP = /^([A-Za-z][A-Za-z0-9-]*)(\(([^()]*)\))?(!)?: (.+)$/;
 var _COMMIT_FOOTER_LINE_RE_MCP = /^([A-Za-z][A-Za-z0-9-]*|BREAKING CHANGE)(: ?| #)(.*)$/;
@@ -13677,5 +13766,180 @@ server.tool(
     return text(JSON.stringify(_checkDashUsageMcp(input), null, 2));
   }
 );
+var _CommissionTierSchema = z.object({
+  upTo: z.number().nullable().describe("Upper bound of this tier (exclusive). null means unbounded and is only valid on the last tier."),
+  ratePercent: z.number().min(0).describe("Commission rate as a percent applied to the slice of salesAmount within this tier")
+});
+function _calculateSalesCommissionMcp(salesAmount, flatRatePercent, tiers, baseSalary) {
+  if (!Number.isFinite(salesAmount) || salesAmount < 0) {
+    return { error: "salesAmount must be a finite, non-negative number" };
+  }
+  if (!Number.isFinite(baseSalary) || baseSalary < 0) {
+    return { error: "baseSalary must be a finite, non-negative number when provided" };
+  }
+  const hasFlat = flatRatePercent !== void 0;
+  const hasTiers = tiers !== void 0;
+  if (hasFlat === hasTiers) {
+    return { error: "Provide exactly one of flatRatePercent or tiers, not both and not neither" };
+  }
+  const round4 = (n) => Math.round(n * 1e4) / 1e4;
+  if (hasFlat) {
+    if (!Number.isFinite(flatRatePercent) || flatRatePercent < 0) {
+      return { error: "flatRatePercent must be a finite, non-negative number" };
+    }
+    const commission2 = salesAmount * flatRatePercent / 100;
+    return {
+      salesAmount: round4(salesAmount),
+      mode: "flat",
+      commission: round4(commission2),
+      baseSalary: round4(baseSalary),
+      totalPayout: round4(baseSalary + commission2)
+    };
+  }
+  const tierList = tiers;
+  if (tierList.length === 0) {
+    return { error: "tiers must contain at least one entry" };
+  }
+  let previousUpTo = 0;
+  for (let i = 0; i < tierList.length; i++) {
+    const tier = tierList[i];
+    const isLast = i === tierList.length - 1;
+    if (!Number.isFinite(tier.ratePercent) || tier.ratePercent < 0) {
+      return { error: `tiers[${i}].ratePercent must be a finite, non-negative number` };
+    }
+    if (tier.upTo === null) {
+      if (!isLast) {
+        return { error: `tiers[${i}].upTo may only be null on the last tier (an unbounded top tier)` };
+      }
+    } else {
+      if (!Number.isFinite(tier.upTo) || tier.upTo <= previousUpTo) {
+        return { error: `tiers[${i}].upTo must be a finite number greater than the previous tier's upTo (${previousUpTo})` };
+      }
+      previousUpTo = tier.upTo;
+    }
+  }
+  let lowerBound = 0;
+  let commission = 0;
+  const breakdown = [];
+  for (const tier of tierList) {
+    const upper = tier.upTo === null ? Infinity : tier.upTo;
+    const amountInRange = Math.min(Math.max(salesAmount - lowerBound, 0), upper - lowerBound);
+    const commissionForRange = amountInRange * tier.ratePercent / 100;
+    commission += commissionForRange;
+    breakdown.push({
+      rangeStart: round4(lowerBound),
+      rangeEnd: tier.upTo === null ? null : round4(tier.upTo),
+      ratePercent: tier.ratePercent,
+      amountInRange: round4(amountInRange),
+      commissionForRange: round4(commissionForRange)
+    });
+    lowerBound = upper;
+  }
+  return {
+    salesAmount: round4(salesAmount),
+    mode: "tiered",
+    commission: round4(commission),
+    baseSalary: round4(baseSalary),
+    totalPayout: round4(baseSalary + commission),
+    breakdown
+  };
+}
+server.tool(
+  "calculate_sales_commission",
+  "Compute a sales commission from either a flat percent rate applied to the whole sale amount, or a tiered (marginal) rate structure where each tier applies only to the slice of the sale amount within it, the same way progressive tax brackets work. An optional base salary is added to the commission to get a total payout. Pure arithmetic, no live data.",
+  {
+    salesAmount: z.number().min(0).describe("The total sale amount commission is computed on"),
+    flatRatePercent: z.number().min(0).optional().describe("A flat commission rate as a percent, applied to the whole salesAmount. Mutually exclusive with tiers."),
+    tiers: z.array(_CommissionTierSchema).optional().describe("Marginal commission tiers, sorted ascending by upTo. Mutually exclusive with flatRatePercent."),
+    baseSalary: z.number().min(0).optional().describe("Optional base salary added to the commission to get totalPayout, default 0")
+  },
+  async ({ salesAmount, flatRatePercent, tiers, baseSalary }) => {
+    const result = _calculateSalesCommissionMcp(salesAmount, flatRatePercent, tiers, baseSalary ?? 0);
+    if ("error" in result) return errText(result);
+    return text(JSON.stringify(result, null, 2));
+  }
+);
+var _CHAR_CLASS_SPECIAL_CHARS_MCP = /* @__PURE__ */ new Set(["]", "\\", "^", "-"]);
+function _escapeForCharClassMcp(ch) {
+  return _CHAR_CLASS_SPECIAL_CHARS_MCP.has(ch) ? `\\${ch}` : ch;
+}
+var _CHAR_CLASS_RANGE_RE_MCP = /^(.)-(.)$/u;
+function _buildCharacterClassMcp(lowercase, uppercase, digits, whitespace, customRanges, customChars, negate) {
+  const hasAny = lowercase || uppercase || digits || whitespace || customRanges.length > 0 || customChars.length > 0;
+  if (!hasAny) {
+    return { error: "At least one character set, custom range, or custom character must be specified" };
+  }
+  const parts = [];
+  const includes = [];
+  if (lowercase) {
+    parts.push("a-z");
+    includes.push("a-z: lowercase letters");
+  }
+  if (uppercase) {
+    parts.push("A-Z");
+    includes.push("A-Z: uppercase letters");
+  }
+  if (digits) {
+    parts.push("0-9");
+    includes.push("0-9: digits");
+  }
+  if (whitespace) {
+    parts.push("\\s");
+    includes.push("\\s: whitespace characters (space, tab, newline, etc.)");
+  }
+  for (let i = 0; i < customRanges.length; i++) {
+    const range = customRanges[i];
+    const match = _CHAR_CLASS_RANGE_RE_MCP.exec(range);
+    if (!match) {
+      return { error: `customRanges[${i}] ("${range}") must be exactly two characters joined by a hyphen, e.g. "f-k"` };
+    }
+    const [, start, end] = match;
+    if (start.codePointAt(0) > end.codePointAt(0)) {
+      return { error: `customRanges[${i}] ("${range}") has a start character that comes after its end character` };
+    }
+    parts.push(`${_escapeForCharClassMcp(start)}-${_escapeForCharClassMcp(end)}`);
+    includes.push(`${range}: custom range from '${start}' to '${end}' inclusive`);
+  }
+  if (customChars.length > 0) {
+    const seen = /* @__PURE__ */ new Set();
+    const unique = [];
+    for (const ch of customChars) {
+      if (!seen.has(ch)) {
+        seen.add(ch);
+        unique.push(ch);
+      }
+    }
+    parts.push(unique.map(_escapeForCharClassMcp).join(""));
+    includes.push(`custom characters: ${unique.join(", ")}`);
+  }
+  const pattern = `[${negate ? "^" : ""}${parts.join("")}]`;
+  return { pattern, negate, includes };
+}
+server.tool(
+  "build_character_class",
+  "Assemble a [...] regex character class from named building blocks (lowercase, uppercase, digits, whitespace), custom character ranges, and literal custom characters, with optional negation. Pure string assembly, it never runs the resulting pattern against any input.",
+  {
+    lowercase: z.boolean().optional().describe("Include a-z"),
+    uppercase: z.boolean().optional().describe("Include A-Z"),
+    digits: z.boolean().optional().describe("Include 0-9"),
+    whitespace: z.boolean().optional().describe("Include \\s (space, tab, newline, etc.)"),
+    customRanges: z.array(z.string()).optional().describe('Custom ranges like "f-k", each exactly two characters joined by a hyphen'),
+    customChars: z.string().optional().describe("Literal characters to include as-is; duplicates are ignored"),
+    negate: z.boolean().optional().describe("Wrap the class in [^...] to match any character NOT in the set")
+  },
+  async ({ lowercase, uppercase, digits, whitespace, customRanges, customChars, negate }) => {
+    const result = _buildCharacterClassMcp(
+      lowercase ?? false,
+      uppercase ?? false,
+      digits ?? false,
+      whitespace ?? false,
+      customRanges ?? [],
+      customChars ?? "",
+      negate ?? false
+    );
+    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.85.0",
+  "version": "0.87.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",