@utilix-tech/mcp 0.71.0 → 0.73.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.73.0
+- Add `calculate_mortgage_points` tool: compare a loan with no discount points against the same loan at a reduced rate bought with points, and compute the monthly savings and break-even month.
+- Add `calculate_cookie_size_budget` tool: parse a Cookie header's name=value pairs and compute each cookie's and the total header's byte size against RFC 6265's per-cookie limit and a configurable budget.
+
+## 0.72.0
+- Add `validate_vin` tool: validate a 17-character VIN via the ISO 3779 / NHTSA weighted mod-11 check digit and split it into its WMI, VDS, and VIS sections.
+- Add `validate_isin` tool: validate a 12-character ISIN via its Luhn-style mod-10 check digit and break it into its country code and security identifier.
+
 ## 0.71.0
 - Add `read_midi_info` tool: parse a Standard MIDI File's header and every track chunk to report format, tick division, initial tempo, time signature, and per-track event/note-on counts, plus total duration in seconds accounting for tempo changes.
 

package/README.md

@@ -1,6 +1,6 @@
 # @utilix-tech/mcp
 
-MCP server exposing 237 developer utility tools to Claude, Cursor, VS Code Copilot, and any [Model Context Protocol](https://modelcontextprotocol.io) compatible AI assistant.
+MCP server exposing 241 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.
 
@@ -162,7 +162,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 (39 tools)
+### Units (43 tools)
 | Tool | Description |
 |------|-------------|
 | `convert_bytes` | Convert between B, KB, MB, GB, TB, KiB, MiB, GiB, TiB |
@@ -205,8 +205,11 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `calculate_extra_payment_payoff` | Compute how much faster a fixed-rate loan pays off, and how much interest is saved, when a fixed extra amount is added to every monthly payment |
 | `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 |
+| `validate_vin` | Validate a 17-character VIN via the ISO 3779 / NHTSA weighted mod-11 check digit and split it into its WMI, VDS, and VIS sections |
+| `validate_isin` | Validate a 12-character ISIN via its Luhn-style mod-10 check digit and break it into its country code and security identifier |
+| `calculate_mortgage_points` | Compare a loan with no discount points against the same loan at a reduced rate bought with points, and compute the monthly savings and the break-even month where cumulative savings recoup the points cost |
 
-### API / Network (48 tools)
+### API / Network (49 tools)
 | Tool | Description |
 |------|-------------|
 | `decode_jwt` | Decode a JWT: header, payload, and expiry |
@@ -259,6 +262,7 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `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 |
+| `calculate_cookie_size_budget` | Parse a Cookie header's name=value pairs and compute each cookie's and the total header's byte size against RFC 6265's 4096-byte per-cookie guarantee and a configurable budget |
 
 ### Color (4 tools)
 | Tool | Description |

package/dist/index.js

@@ -11397,5 +11397,231 @@ server.tool(
     return text(JSON.stringify(result, null, 2));
   }
 );
+var _VIN_TRANSLITERATION_MCP = {
+  A: 1,
+  B: 2,
+  C: 3,
+  D: 4,
+  E: 5,
+  F: 6,
+  G: 7,
+  H: 8,
+  J: 1,
+  K: 2,
+  L: 3,
+  M: 4,
+  N: 5,
+  P: 7,
+  R: 9,
+  S: 2,
+  T: 3,
+  U: 4,
+  V: 5,
+  W: 6,
+  X: 7,
+  Y: 8,
+  Z: 9
+};
+var _VIN_WEIGHTS_MCP = [8, 7, 6, 5, 4, 3, 2, 10, 0, 9, 8, 7, 6, 5, 4, 3, 2];
+function _validateVin(input) {
+  if (!input || !input.trim()) return { error: "Input is empty" };
+  const cleaned = input.replace(/\s/g, "").toUpperCase();
+  if (cleaned.length !== 17) return { error: `VIN length (${cleaned.length}) must be exactly 17 characters` };
+  if (!/^[A-HJ-NPR-Z0-9]{17}$/.test(cleaned)) {
+    return { error: "VIN must contain only letters and digits, excluding I, O, and Q" };
+  }
+  let sum = 0;
+  for (let i = 0; i < 17; i++) {
+    const ch = cleaned[i];
+    const value = /[0-9]/.test(ch) ? Number(ch) : _VIN_TRANSLITERATION_MCP[ch];
+    sum += value * _VIN_WEIGHTS_MCP[i];
+  }
+  const remainder = sum % 11;
+  const expectedCheckDigit = remainder === 10 ? "X" : String(remainder);
+  const checkDigit = cleaned[8];
+  return {
+    valid: checkDigit === expectedCheckDigit,
+    vin: cleaned,
+    checkDigit,
+    expectedCheckDigit,
+    wmi: cleaned.slice(0, 3),
+    vds: cleaned.slice(3, 9),
+    vis: cleaned.slice(9, 17)
+  };
+}
+server.tool(
+  "validate_vin",
+  "Validate a 17-character VIN via the ISO 3779 / NHTSA weighted mod-11 check digit at position 9, and split it into its World Manufacturer Identifier (WMI), Vehicle Descriptor Section (VDS), and Vehicle Identifier Section (VIS). Does not decode make, model, or model year.",
+  { vin: z.string().describe("The 17-character VIN, with or without spaces") },
+  async ({ vin }) => {
+    const result = _validateVin(vin);
+    if ("error" in result) return errText(result);
+    return text(JSON.stringify(result, null, 2));
+  }
+);
+function _isinLuhnCheckDigitMcp(payloadDigits) {
+  let sum = 0;
+  let shouldDouble = true;
+  for (let i = payloadDigits.length - 1; i >= 0; i--) {
+    let d = parseInt(payloadDigits[i], 10);
+    if (shouldDouble) {
+      d *= 2;
+      if (d > 9) d -= 9;
+    }
+    sum += d;
+    shouldDouble = !shouldDouble;
+  }
+  return (10 - sum % 10) % 10;
+}
+function _validateIsin(input) {
+  if (!input || !input.trim()) return { error: "Input is empty" };
+  const cleaned = input.replace(/\s/g, "").toUpperCase();
+  if (cleaned.length !== 12) return { error: `ISIN length (${cleaned.length}) must be exactly 12 characters` };
+  if (!/^[A-Z]{2}[A-Z0-9]{9}\d$/.test(cleaned)) {
+    return { error: "ISIN must be a 2-letter country code, 9 alphanumeric characters, then 1 numeric check digit" };
+  }
+  const countryCode = cleaned.slice(0, 2);
+  const securityIdentifier = cleaned.slice(2, 11);
+  const checkDigit = Number(cleaned[11]);
+  const payload = cleaned.slice(0, 11).split("").map((ch) => /[A-Z]/.test(ch) ? String(ch.charCodeAt(0) - 55) : ch).join("");
+  const expectedCheckDigit = _isinLuhnCheckDigitMcp(payload);
+  return {
+    valid: checkDigit === expectedCheckDigit,
+    isin: cleaned,
+    countryCode,
+    securityIdentifier,
+    checkDigit,
+    expectedCheckDigit,
+    formatted: `${countryCode} ${securityIdentifier} ${checkDigit}`
+  };
+}
+server.tool(
+  "validate_isin",
+  "Validate a 12-character ISIN (ISO 6166) via its Luhn-style mod-10 check digit. The 2-letter country code and 9-character alphanumeric security identifier are transliterated (A=10 ... Z=35) into a numeric string before the Luhn algorithm is applied, the same way credit card numbers are checksummed.",
+  { isin: z.string().describe("The 12-character ISIN, with or without spaces") },
+  async ({ isin }) => {
+    const result = _validateIsin(isin);
+    if ("error" in result) return errText(result);
+    return text(JSON.stringify(result, null, 2));
+  }
+);
+function _roundMoneyMortgagePointsMcp(n) {
+  return Math.round(n * 100) / 100;
+}
+function _calculateLoanForPointsMcp(principal, annualRatePercent, termMonths) {
+  if (!Number.isFinite(principal) || principal <= 0) return { error: "Principal must be a positive number" };
+  if (!Number.isFinite(annualRatePercent) || annualRatePercent < 0) {
+    return { error: "Annual interest rate must be zero or a positive number" };
+  }
+  if (!Number.isInteger(termMonths) || termMonths <= 0) {
+    return { error: "Term must be a positive whole number of months" };
+  }
+  const monthlyRate = annualRatePercent / 100 / 12;
+  let monthlyPayment;
+  if (monthlyRate === 0) {
+    monthlyPayment = principal / termMonths;
+  } else {
+    const factor = Math.pow(1 + monthlyRate, termMonths);
+    monthlyPayment = principal * monthlyRate * factor / (factor - 1);
+  }
+  let balance = _roundMoneyMortgagePointsMcp(principal);
+  let totalPayment = 0;
+  for (let month = 1; month <= termMonths; month++) {
+    const interest = monthlyRate === 0 ? 0 : _roundMoneyMortgagePointsMcp(balance * monthlyRate);
+    let principalPortion = _roundMoneyMortgagePointsMcp(monthlyPayment) - interest;
+    if (month === termMonths || principalPortion > balance) principalPortion = balance;
+    const payment = _roundMoneyMortgagePointsMcp(principalPortion + interest);
+    balance = _roundMoneyMortgagePointsMcp(balance - principalPortion);
+    totalPayment += payment;
+  }
+  return { monthlyPayment: _roundMoneyMortgagePointsMcp(monthlyPayment), totalInterest: _roundMoneyMortgagePointsMcp(totalPayment - principal) };
+}
+function _calculateMortgagePointsMcp(loanAmount, baseRatePercent, termMonths, pointsCostPercent, rateReductionPercent) {
+  if (!Number.isFinite(pointsCostPercent) || pointsCostPercent < 0) {
+    return { error: "Points cost must be zero or a positive percent of the loan amount" };
+  }
+  if (!Number.isFinite(rateReductionPercent) || rateReductionPercent < 0) {
+    return { error: "Rate reduction must be zero or a positive number" };
+  }
+  if (rateReductionPercent > baseRatePercent) {
+    return { error: "Rate reduction cannot exceed the base interest rate" };
+  }
+  const withoutPoints = _calculateLoanForPointsMcp(loanAmount, baseRatePercent, termMonths);
+  if ("error" in withoutPoints) return withoutPoints;
+  const withPoints = _calculateLoanForPointsMcp(loanAmount, baseRatePercent - rateReductionPercent, termMonths);
+  if ("error" in withPoints) return withPoints;
+  const pointsCost = _roundMoneyMortgagePointsMcp(loanAmount * (pointsCostPercent / 100));
+  const monthlySavings = _roundMoneyMortgagePointsMcp(withoutPoints.monthlyPayment - withPoints.monthlyPayment);
+  const breakEvenMonths = monthlySavings > 0 ? Math.ceil(pointsCost / monthlySavings) : null;
+  return {
+    pointsCost,
+    monthlyPaymentWithoutPoints: withoutPoints.monthlyPayment,
+    monthlyPaymentWithPoints: withPoints.monthlyPayment,
+    monthlySavings,
+    breakEvenMonths,
+    totalInterestWithoutPoints: withoutPoints.totalInterest,
+    totalInterestWithPoints: withPoints.totalInterest,
+    totalInterestSavings: _roundMoneyMortgagePointsMcp(withoutPoints.totalInterest - withPoints.totalInterest)
+  };
+}
+server.tool(
+  "calculate_mortgage_points",
+  "Compare a loan with no discount points against the same loan at a reduced rate bought with points costing a percentage of the loan amount, and compute the monthly savings and the break-even month where cumulative savings recoup the points cost.",
+  {
+    loanAmount: z.number().describe("The loan principal"),
+    baseRatePercent: z.number().describe("The loan's annual interest rate with no points, as a percent, e.g. 6.5"),
+    termMonths: z.number().int().describe("The loan term in months"),
+    pointsCostPercent: z.number().describe("Cost of the discount points, as a percent of the loan amount, e.g. 1 for one point"),
+    rateReductionPercent: z.number().describe("How many percentage points the rate drops when the points are bought, e.g. 0.25")
+  },
+  async ({ loanAmount, baseRatePercent, termMonths, pointsCostPercent, rateReductionPercent }) => {
+    const result = _calculateMortgagePointsMcp(loanAmount, baseRatePercent, termMonths, pointsCostPercent, rateReductionPercent);
+    if ("error" in result) return errText(result);
+    return text(JSON.stringify(result, null, 2));
+  }
+);
+var _PER_COOKIE_BYTE_LIMIT_MCP = 4096;
+var _DEFAULT_COOKIE_BUDGET_BYTES_MCP = 4096;
+function _calculateCookieSizeBudgetMcp(cookieHeader, budgetBytes = _DEFAULT_COOKIE_BUDGET_BYTES_MCP) {
+  if (typeof cookieHeader !== "string" || !cookieHeader.trim()) {
+    return { error: "A Cookie header value is required" };
+  }
+  if (!Number.isFinite(budgetBytes) || budgetBytes <= 0) {
+    return { error: "Budget must be a positive number of bytes" };
+  }
+  const parts = cookieHeader.split(";").map((p) => p.trim()).filter(Boolean);
+  if (parts.length === 0) return { error: "A Cookie header value is required" };
+  const cookies = [];
+  for (const part of parts) {
+    const eq = part.indexOf("=");
+    if (eq === -1) return { error: `Malformed cookie pair "${part}" is missing '='` };
+    const name = part.slice(0, eq).trim();
+    const value = part.slice(eq + 1).trim();
+    if (!name) return { error: "Cookie name cannot be empty" };
+    const bytes = Buffer.byteLength(`${name}=${value}`, "utf8");
+    cookies.push({ name, value, bytes, exceedsPerCookieLimit: bytes > _PER_COOKIE_BYTE_LIMIT_MCP });
+  }
+  const totalBytes = cookies.reduce((sum, c) => sum + c.bytes, 0) + Math.max(cookies.length - 1, 0) * 2;
+  return {
+    cookies,
+    cookieCount: cookies.length,
+    totalBytes,
+    budgetBytes,
+    exceedsBudget: totalBytes > budgetBytes
+  };
+}
+server.tool(
+  "calculate_cookie_size_budget",
+  "Parse a Cookie request header's name=value pairs and compute each cookie's serialized byte size and the total header size, flagging any cookie over RFC 6265's 4096-byte per-cookie guarantee and the total against a configurable budget (4096 bytes by default).",
+  {
+    cookieHeader: z.string().describe('The Cookie header value to parse, e.g. "session=abc123; theme=dark"'),
+    budgetBytes: z.number().optional().describe("Total byte budget to check against; defaults to 4096")
+  },
+  async ({ cookieHeader, budgetBytes }) => {
+    const result = _calculateCookieSizeBudgetMcp(cookieHeader, budgetBytes ?? _DEFAULT_COOKIE_BUDGET_BYTES_MCP);
+    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.71.0",
+  "version": "0.73.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",