@utilix-tech/mcp 0.84.0 → 0.86.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.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.
+
 ## 0.84.0
 - Add `find_cron_overlaps` tool: walk minute-by-minute over a window of days and flag every minute where two or more cron schedules fire at once, listing which expressions collided.
 - Add `lint_dockerfile` tool: lint a Dockerfile for an unpinned or `:latest` base image, a final stage missing WORKDIR or USER, and ADD used on a plain local file where COPY would do.

package/README.md

@@ -1,6 +1,6 @@
 # @utilix-tech/mcp
 
-MCP server exposing 262 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.
 
@@ -134,7 +134,7 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `generate_random_data` | Generate random mock data: names, emails, UUIDs, IPs, etc. |
 | `generate_csp_nonce` | Generate a cryptographically random CSP nonce with ready-to-paste header directive and script/style tag snippets |
 
-### Text (16 tools)
+### Text (17 tools)
 | Tool | Description |
 |------|-------------|
 | `convert_case` | Convert text case: camelCase, snake_case, PascalCase, etc. |
@@ -155,6 +155,7 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `analyze_sentence_lengths` | Split text into sentences and report a histogram of sentence lengths, plus mean, median, standard deviation, and a consistency label |
 | `lookup_emoji` | Search a curated table of ~280 common emoji by name, keyword, or GitHub-style shortcode, or look one up exactly by shortcode, character, or category |
 | `analyze_keyword_density` | Count keyword/phrase frequency and density (occurrences per 100 words) across a block of text, with single-word or 2/3-word phrase modes |
+| `check_dash_usage` | 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 |
 
 ### Time (6 tools)
 | Tool | Description |
@@ -167,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 (46 tools)
+### Units (48 tools)
 | Tool | Description |
 |------|-------------|
 | `convert_bytes` | Convert between B, KB, MB, GB, TB, KiB, MiB, GiB, TiB |
@@ -216,6 +217,8 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `calculate_loan_prepayment_penalty` | Compute the dollar penalty cost of paying a loan off early, given its remaining payoff balance and a prepayment penalty structure: either a flat percent of the payoff balance, or a fixed number of months of interest at the loan's annual rate |
 | `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 |
@@ -283,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 |
@@ -312,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

@@ -13533,5 +13533,324 @@ server.tool(
     return text(JSON.stringify(result, null, 2));
   }
 );
+var _CC_MIN_PAYMENT_MAX_MONTHS_MCP = 1200;
+function _calculateCreditCardMinimumPaymentMcp(balance, aprPercent, minPaymentPercent, minPaymentFloor) {
+  if (!Number.isFinite(balance) || balance <= 0) {
+    return { error: "balance must be a finite number greater than zero" };
+  }
+  if (!Number.isFinite(aprPercent) || aprPercent < 0) {
+    return { error: "aprPercent must be a finite, non-negative number" };
+  }
+  if (!Number.isFinite(minPaymentPercent) || minPaymentPercent <= 0) {
+    return { error: "minPaymentPercent must be a finite number greater than zero" };
+  }
+  if (!Number.isFinite(minPaymentFloor) || minPaymentFloor < 0) {
+    return { error: "minPaymentFloor must be a finite, non-negative number" };
+  }
+  const round2 = (n) => Math.round(n * 100) / 100;
+  const monthlyRate = aprPercent / 100 / 12;
+  let bal = balance;
+  let totalInterestPaid = 0;
+  let totalPaid = 0;
+  let firstMonthPayment = 0;
+  let finalMonthPayment = 0;
+  let month = 0;
+  while (bal > 5e-3 && month < _CC_MIN_PAYMENT_MAX_MONTHS_MCP) {
+    month++;
+    const interest = bal * monthlyRate;
+    bal += interest;
+    totalInterestPaid += interest;
+    let payment = Math.max(bal * (minPaymentPercent / 100), minPaymentFloor);
+    if (payment > bal) payment = bal;
+    bal -= payment;
+    totalPaid += payment;
+    finalMonthPayment = round2(payment);
+    if (month === 1) firstMonthPayment = round2(payment);
+  }
+  if (bal > 5e-3) {
+    return { error: `balance cannot be paid off within ${_CC_MIN_PAYMENT_MAX_MONTHS_MCP} months at this minimum-payment formula; increase minPaymentPercent or minPaymentFloor` };
+  }
+  return {
+    monthsToPayoff: month,
+    yearsToPayoff: round2(month / 12),
+    totalInterestPaid: round2(totalInterestPaid),
+    totalPaid: round2(totalPaid),
+    firstMonthPayment,
+    finalMonthPayment
+  };
+}
+server.tool(
+  "calculate_credit_card_minimum_payment",
+  `Simulate paying only the minimum payment on a revolving credit card balance every month, where the minimum payment is whichever is larger of a percent of the current balance or a fixed dollar floor. Reports months and years to payoff, total interest, total paid, and the first vs. final month's payment amount, so the "minimum payment trap" becomes visible.`,
+  {
+    balance: z.number().positive().describe("Current revolving balance owed"),
+    aprPercent: z.number().min(0).describe("Annual percentage rate, as a percent"),
+    minPaymentPercent: z.number().positive().describe("Minimum payment as a percent of the current balance, as a percent"),
+    minPaymentFloor: z.number().min(0).optional().describe("Fixed dollar floor for the minimum payment, default 0")
+  },
+  async ({ balance, aprPercent, minPaymentPercent, minPaymentFloor }) => {
+    const result = _calculateCreditCardMinimumPaymentMcp(balance, aprPercent, minPaymentPercent, minPaymentFloor ?? 0);
+    if ("error" in result) return errText(result);
+    return text(JSON.stringify(result, null, 2));
+  }
+);
+function _dashContextSnippetMcp(input, index, matchLen) {
+  const start = Math.max(0, index - 20);
+  const end = Math.min(input.length, index + matchLen + 20);
+  const body = input.slice(start, end).replace(/\s+/g, " ").trim();
+  return (start > 0 ? "\u2026" : "") + body + (end < input.length ? "\u2026" : "");
+}
+function _checkDashUsageMcp(input) {
+  const issues = [];
+  const enDashCount = (input.match(/–/g) ?? []).length;
+  const hyphenCount = (input.match(/-/g) ?? []).length;
+  const doubleHyphenMatches = [...input.matchAll(/-{2,}/g)];
+  for (const m of doubleHyphenMatches) {
+    const index = m.index ?? 0;
+    issues.push({
+      type: "double-hyphen",
+      index,
+      context: _dashContextSnippetMcp(input, index, m[0].length),
+      message: `Found ${m[0].length} consecutive hyphens ("${m[0]}"); likely meant to be an em dash (\u2014) or en dash (\u2013).`
+    });
+  }
+  const spacedHyphenMatches = [...input.matchAll(/(?<=\S) - (?=\S)/g)];
+  for (const m of spacedHyphenMatches) {
+    const index = m.index ?? 0;
+    issues.push({
+      type: "spaced-hyphen",
+      index,
+      context: _dashContextSnippetMcp(input, index, m[0].length),
+      message: "A hyphen surrounded by spaces usually signals an intended em dash (\u2014), not a hyphenated compound word."
+    });
+  }
+  const emDashOccurrences = [...input.matchAll(/—/g)];
+  let spacedEm = 0;
+  let unspacedEm = 0;
+  for (const m of emDashOccurrences) {
+    const idx = m.index ?? 0;
+    const before = input[idx - 1];
+    const after = input[idx + 1];
+    if (before === " " && after === " ") spacedEm++;
+    else if (before !== " " && after !== " ") unspacedEm++;
+  }
+  let dominantEmDashStyle = "none";
+  let emDashSpacingConsistent = true;
+  if (emDashOccurrences.length > 0) {
+    dominantEmDashStyle = spacedEm >= unspacedEm ? "spaced" : "unspaced";
+    emDashSpacingConsistent = spacedEm === 0 || unspacedEm === 0;
+    if (!emDashSpacingConsistent) {
+      for (const m of emDashOccurrences) {
+        const idx = m.index ?? 0;
+        const before = input[idx - 1];
+        const after = input[idx + 1];
+        const isSpaced = before === " " && after === " ";
+        const matchesDominant = dominantEmDashStyle === "spaced" ? isSpaced : !isSpaced;
+        if (!matchesDominant) {
+          issues.push({
+            type: "inconsistent-em-dash-spacing",
+            index: idx,
+            context: _dashContextSnippetMcp(input, idx, 1),
+            message: `This em dash is ${isSpaced ? "spaced" : "unspaced"}, but the document mostly uses ${dominantEmDashStyle} em dashes.`
+          });
+        }
+      }
+    }
+  }
+  issues.sort((a, b) => a.index - b.index);
+  return {
+    emDashCount: emDashOccurrences.length,
+    enDashCount,
+    hyphenCount,
+    doubleHyphenCount: doubleHyphenMatches.length,
+    spacedHyphenCount: spacedHyphenMatches.length,
+    emDashSpacingConsistent,
+    dominantEmDashStyle,
+    issues
+  };
+}
+server.tool(
+  "check_dash_usage",
+  'Scan text for likely dash misuse: a hyphen surrounded by spaces where an em dash is probably intended ("word - word"), a double hyphen ("--") left unconverted, and inconsistent spacing around em dashes across the same document (mixing "word \u2014 word" and "word\u2014word"). Pure regex heuristic, not a grammar parser.',
+  { text: z.string().describe("The text to scan for dash usage issues") },
+  async ({ text: input }) => {
+    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.84.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",