@utilix-tech/mcp 0.85.0 → 0.86.0

package/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 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.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 266 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,6 +315,7 @@ 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)
 | Tool | Description |

package/dist/index.js

@@ -13677,5 +13677,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.86.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",