@utilix-tech/mcp 0.10.0 → 0.12.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.12.0
+- Added IBAN Validator / Formatter (`validate_iban`) and Loan / Mortgage Calculator (`calculate_loan`).
+- (npm publish for this version was retried after fixing a CI pin: `npm install -g npm@latest` started pulling npm 12, which requires Node >=22 and broke on this job's pinned Node 20 — now pinned to the npm 11 line.)
+
+## 0.11.0
+- Added robots.txt Validator (`validate_robots_txt`) and Credit Card Number Validator (`validate_card_number`).
+
 ## 0.10.0
 - Added Sitemap.xml Validator (`validate_sitemap`).
 

package/README.md

@@ -1,6 +1,6 @@
 # @utilix-tech/mcp
 
-MCP server exposing 107 developer utility tools to Claude, Cursor, VS Code Copilot, and any [Model Context Protocol](https://modelcontextprotocol.io) compatible AI assistant.
+MCP server exposing 111 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.
 
@@ -145,13 +145,16 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `date_diff` | Calculate the difference between two dates |
 | `convert_timezone` | Convert a date/time between timezones |
 
-### Units (2 tools)
+### Units (5 tools)
 | Tool | Description |
 |------|-------------|
 | `convert_bytes` | Convert between B, KB, MB, GB, TB, KiB, MiB, GiB, TiB |
 | `px_to_units` | Convert pixels to rem, em, pt, and vw |
+| `validate_card_number` | Validate a credit card number via the Luhn checksum and detect its network |
+| `validate_iban` | Validate an IBAN via the mod-97 checksum and format it into grouped blocks |
+| `calculate_loan` | Compute a loan's monthly payment, total interest, and amortization schedule |
 
-### API / Network (7 tools)
+### API / Network (8 tools)
 | Tool | Description |
 |------|-------------|
 | `decode_jwt` | Decode a JWT: header, payload, and expiry |
@@ -161,6 +164,7 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `cors_headers` | Generate CORS response headers for a configuration |
 | `parse_har` | Parse a DevTools .har network export into requests and summary stats |
 | `validate_sitemap` | Validate a sitemap.xml or sitemap index against the sitemaps.org protocol |
+| `validate_robots_txt` | Validate a robots.txt file: User-agent groups, rules, and directive syntax |
 
 ### Color (4 tools)
 | Tool | Description |

package/dist/index.js

@@ -1579,6 +1579,353 @@ server.tool(
     return text(JSON.stringify(result, null, 2));
   }
 );
+var _KNOWN_ROBOTS_DIRECTIVES = /* @__PURE__ */ new Set(["user-agent", "disallow", "allow", "sitemap", "crawl-delay", "host"]);
+function _validateRobotsTxt(text2) {
+  if (!text2 || !text2.trim()) return { error: "Input is empty" };
+  const lines = text2.split("\n");
+  const issues = [];
+  const groups = [];
+  const sitemaps = [];
+  let currentGroup = null;
+  for (let i = 0; i < lines.length; i++) {
+    const rawLine = lines[i];
+    const lineNum = i + 1;
+    const commentIdx = rawLine.indexOf("#");
+    const line = (commentIdx >= 0 ? rawLine.slice(0, commentIdx) : rawLine).trim();
+    if (!line) continue;
+    const colonIdx = line.indexOf(":");
+    if (colonIdx === -1) {
+      issues.push({ severity: "error", line: lineNum, message: `Malformed line (missing ':'): "${line}"` });
+      continue;
+    }
+    const directive = line.slice(0, colonIdx).trim().toLowerCase();
+    const value = line.slice(colonIdx + 1).trim();
+    if (!_KNOWN_ROBOTS_DIRECTIVES.has(directive)) {
+      issues.push({ severity: "warning", line: lineNum, message: `Unknown directive "${directive}"` });
+      continue;
+    }
+    if (directive === "sitemap") {
+      if (!/^https?:\/\//i.test(value)) {
+        issues.push({ severity: "error", line: lineNum, message: `Sitemap URL "${value}" must be absolute (start with http:// or https://)` });
+      }
+      sitemaps.push(value);
+      continue;
+    }
+    if (directive === "user-agent") {
+      if (!value) {
+        issues.push({ severity: "error", line: lineNum, message: "User-agent directive is missing a value" });
+      }
+      if (currentGroup && currentGroup.rules.length === 0 && currentGroup.crawlDelay === void 0) {
+        currentGroup.userAgents.push(value);
+      } else {
+        currentGroup = { userAgents: [value], rules: [], line: lineNum };
+        groups.push(currentGroup);
+      }
+      continue;
+    }
+    if (!currentGroup) {
+      issues.push({ severity: "error", line: lineNum, message: `"${directive}" directive found before any User-agent line` });
+      continue;
+    }
+    if (directive === "disallow" || directive === "allow") {
+      if (value !== "" && !value.startsWith("/") && !value.startsWith("*")) {
+        issues.push({ severity: "warning", line: lineNum, message: `${directive === "disallow" ? "Disallow" : "Allow"} value "${value}" should start with "/" (or be empty)` });
+      }
+      if (currentGroup.rules.some((r) => r.type === directive && r.value === value)) {
+        issues.push({ severity: "warning", line: lineNum, message: `Duplicate ${directive} rule for "${value}" in this group` });
+      }
+      currentGroup.rules.push({ type: directive, value, line: lineNum });
+    } else if (directive === "crawl-delay") {
+      const n = Number(value);
+      if (Number.isNaN(n) || n < 0) {
+        issues.push({ severity: "error", line: lineNum, message: `Crawl-delay "${value}" must be a non-negative number` });
+      } else {
+        currentGroup.crawlDelay = n;
+      }
+    }
+  }
+  if (groups.length === 0) {
+    issues.push({ severity: "error", line: 1, message: "No User-agent groups found" });
+  }
+  const seenUA = /* @__PURE__ */ new Map();
+  for (const g of groups) {
+    for (const ua of g.userAgents) {
+      const key = ua.toLowerCase();
+      const firstLine = seenUA.get(key);
+      if (firstLine !== void 0) {
+        issues.push({ severity: "warning", line: g.line, message: `Duplicate User-agent "${ua}" (first seen on line ${firstLine})` });
+      } else {
+        seenUA.set(key, g.line);
+      }
+    }
+  }
+  const valid = !issues.some((i) => i.severity === "error");
+  return { groups, sitemaps, issues, valid };
+}
+server.tool(
+  "validate_robots_txt",
+  "Validate a robots.txt file: parse it into User-agent groups and flag structural mistakes \u2014 directives before any User-agent, unknown directives, non-absolute Sitemap URLs, malformed Crawl-delay values, missing leading slashes, and duplicate rules.",
+  { text: z.string().describe("The robots.txt file contents") },
+  async ({ text: robotsTxt }) => {
+    const result = _validateRobotsTxt(robotsTxt);
+    if ("error" in result) return errText(result);
+    return text(JSON.stringify(result, null, 2));
+  }
+);
+var _CARD_NETWORK_RULES = [
+  { name: "American Express", lengths: [15], test: (d) => /^3[47]/.test(d) },
+  { name: "Diners Club", lengths: [14], test: (d) => /^3(?:0[0-5]|[68])/.test(d) },
+  {
+    name: "Discover",
+    lengths: [16, 19],
+    test: (d) => /^(?:6011|65|64[4-9])/.test(d) || /^622(?:12[6-9]|1[3-9]\d|[2-8]\d{2}|9[01]\d|92[0-5])/.test(d)
+  },
+  { name: "JCB", lengths: [16], test: (d) => /^35(?:2[89]|[3-8]\d)/.test(d) },
+  {
+    name: "Mastercard",
+    lengths: [16],
+    test: (d) => {
+      const two = parseInt(d.slice(0, 2), 10);
+      const four = parseInt(d.slice(0, 4), 10);
+      return two >= 51 && two <= 55 || four >= 2221 && four <= 2720;
+    }
+  },
+  { name: "Maestro", lengths: [12, 13, 14, 15, 16, 17, 18, 19], test: (d) => /^(?:50|5[6-8]|6304|6390|67)/.test(d) },
+  { name: "UnionPay", lengths: [16, 17, 18, 19], test: (d) => /^62/.test(d) },
+  { name: "Visa", lengths: [13, 16, 19], test: (d) => /^4/.test(d) }
+];
+function _luhnCheck(digits) {
+  let sum = 0;
+  let shouldDouble = false;
+  for (let i = digits.length - 1; i >= 0; i--) {
+    let d = parseInt(digits[i], 10);
+    if (shouldDouble) {
+      d *= 2;
+      if (d > 9) d -= 9;
+    }
+    sum += d;
+    shouldDouble = !shouldDouble;
+  }
+  return sum % 10 === 0;
+}
+function _detectCardNetwork(digits) {
+  for (const rule of _CARD_NETWORK_RULES) {
+    if (rule.lengths.includes(digits.length) && rule.test(digits)) return rule.name;
+  }
+  return null;
+}
+function _formatCardNumber(digits, network) {
+  if (network === "American Express") {
+    return `${digits.slice(0, 4)} ${digits.slice(4, 10)} ${digits.slice(10)}`.trim();
+  }
+  return digits.match(/.{1,4}/g)?.join(" ") ?? digits;
+}
+function _validateCardNumber(input) {
+  if (!input || !input.trim()) return { error: "Input is empty" };
+  const digits = input.replace(/[\s-]/g, "");
+  if (!/^\d+$/.test(digits)) return { error: "Card number must contain only digits, spaces, or hyphens" };
+  if (digits.length < 12 || digits.length > 19) {
+    return { error: `Card number length (${digits.length}) is outside the valid range of 12-19 digits` };
+  }
+  const valid = _luhnCheck(digits);
+  const network = _detectCardNetwork(digits);
+  const formatted = _formatCardNumber(digits, network);
+  return { valid, network, length: digits.length, formatted };
+}
+server.tool(
+  "validate_card_number",
+  "Validate a credit card number via the Luhn checksum and detect its network (Visa, Mastercard, American Express, Discover, Diners Club, JCB, Maestro, UnionPay) from its prefix and length. No card data is stored or transmitted.",
+  { number: z.string().describe("The card number, digits with optional spaces or hyphens") },
+  async ({ number }) => {
+    const result = _validateCardNumber(number);
+    if ("error" in result) return errText(result);
+    return text(JSON.stringify(result, null, 2));
+  }
+);
+var _IBAN_COUNTRY_LENGTHS = {
+  AD: 24,
+  AE: 23,
+  AL: 28,
+  AT: 20,
+  AZ: 28,
+  BA: 20,
+  BE: 16,
+  BG: 22,
+  BH: 22,
+  BR: 29,
+  BY: 28,
+  CH: 21,
+  CR: 22,
+  CY: 28,
+  CZ: 24,
+  DE: 22,
+  DK: 18,
+  DO: 28,
+  EE: 20,
+  EG: 29,
+  ES: 24,
+  FI: 18,
+  FO: 18,
+  FR: 27,
+  GB: 22,
+  GE: 22,
+  GI: 23,
+  GL: 18,
+  GR: 27,
+  GT: 28,
+  HR: 21,
+  HU: 28,
+  IE: 22,
+  IL: 23,
+  IQ: 23,
+  IS: 26,
+  IT: 27,
+  JO: 30,
+  KW: 30,
+  KZ: 20,
+  LB: 28,
+  LC: 32,
+  LI: 21,
+  LT: 20,
+  LU: 20,
+  LV: 21,
+  LY: 25,
+  MC: 27,
+  MD: 24,
+  ME: 22,
+  MK: 19,
+  MR: 27,
+  MT: 31,
+  MU: 30,
+  NL: 18,
+  NO: 15,
+  PK: 24,
+  PL: 28,
+  PS: 29,
+  PT: 25,
+  QA: 29,
+  RO: 24,
+  RS: 22,
+  SA: 24,
+  SC: 31,
+  SE: 24,
+  SI: 19,
+  SK: 24,
+  SM: 27,
+  ST: 25,
+  SV: 28,
+  TL: 23,
+  TN: 24,
+  TR: 26,
+  UA: 29,
+  VA: 22,
+  VG: 24,
+  XK: 20
+};
+function _ibanMod97(numeric) {
+  let remainder = 0;
+  for (let i = 0; i < numeric.length; i += 7) {
+    remainder = parseInt(String(remainder) + numeric.substr(i, 7), 10) % 97;
+  }
+  return remainder;
+}
+function _formatIban(cleaned) {
+  return cleaned.match(/.{1,4}/g)?.join(" ") ?? cleaned;
+}
+function _validateIban(input) {
+  if (!input || !input.trim()) return { error: "Input is empty" };
+  const cleaned = input.replace(/\s/g, "").toUpperCase();
+  if (!/^[A-Z0-9]+$/.test(cleaned)) return { error: "IBAN must contain only letters and digits" };
+  if (cleaned.length < 4 || cleaned.length > 34) {
+    return { error: `IBAN length (${cleaned.length}) is outside the valid range of 4-34 characters` };
+  }
+  if (!/^[A-Z]{2}\d{2}/.test(cleaned)) {
+    return { error: "IBAN must start with a 2-letter country code followed by 2 check digits" };
+  }
+  const countryCode = cleaned.slice(0, 2);
+  const checkDigits = cleaned.slice(2, 4);
+  const bban = cleaned.slice(4);
+  const rearranged = cleaned.slice(4) + cleaned.slice(0, 4);
+  const numeric = rearranged.split("").map((ch) => /[A-Z]/.test(ch) ? String(ch.charCodeAt(0) - 55) : ch).join("");
+  const checksumValid = _ibanMod97(numeric) === 1;
+  const expectedLength = _IBAN_COUNTRY_LENGTHS[countryCode] ?? null;
+  const lengthValid = expectedLength === null ? null : cleaned.length === expectedLength;
+  const valid = checksumValid && lengthValid !== false;
+  return {
+    valid,
+    formatted: _formatIban(cleaned),
+    countryCode,
+    checkDigits,
+    bban,
+    length: cleaned.length,
+    expectedLength,
+    checksumValid,
+    lengthValid
+  };
+}
+server.tool(
+  "validate_iban",
+  "Validate an IBAN via the mod-97 checksum defined by ISO 13616 and format it into the standard human-readable grouped form. Cross-checks the total length against the country's registered fixed length where known.",
+  { iban: z.string().describe("The IBAN, with or without spaces") },
+  async ({ iban }) => {
+    const result = _validateIban(iban);
+    if ("error" in result) return errText(result);
+    return text(JSON.stringify(result, null, 2));
+  }
+);
+function _roundMoneyMcp(n) {
+  return Math.round(n * 100) / 100;
+}
+function _calculateLoan(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);
+  }
+  const schedule = [];
+  let balance = _roundMoneyMcp(principal);
+  let totalPayment = 0;
+  for (let month = 1; month <= termMonths; month++) {
+    const interest = monthlyRate === 0 ? 0 : _roundMoneyMcp(balance * monthlyRate);
+    let principalPortion = _roundMoneyMcp(monthlyPayment) - interest;
+    if (month === termMonths || principalPortion > balance) principalPortion = balance;
+    const payment = _roundMoneyMcp(principalPortion + interest);
+    balance = _roundMoneyMcp(balance - principalPortion);
+    totalPayment += payment;
+    schedule.push({ month, payment, principal: _roundMoneyMcp(principalPortion), interest, balance: Math.max(balance, 0) });
+  }
+  return {
+    monthlyPayment: _roundMoneyMcp(monthlyPayment),
+    totalPayment: _roundMoneyMcp(totalPayment),
+    totalInterest: _roundMoneyMcp(totalPayment - principal),
+    termMonths,
+    schedule
+  };
+}
+server.tool(
+  "calculate_loan",
+  "Compute the fixed monthly payment, total interest, and full month-by-month amortization schedule for a loan or mortgage from principal, annual interest rate (as a percent), and term in months.",
+  {
+    principal: z.number().describe("Loan principal amount"),
+    annualRatePercent: z.number().describe("Annual interest rate as a percent, e.g. 6.5"),
+    termMonths: z.number().int().describe("Loan term in months")
+  },
+  async ({ principal, annualRatePercent, termMonths }) => {
+    const result = _calculateLoan(principal, annualRatePercent, termMonths);
+    if ("error" in result) return errText(result);
+    return text(JSON.stringify(result, null, 2));
+  }
+);
 server.tool(
   "format_ndjson",
   "Validate newline-delimited JSON (NDJSON/JSON Lines), report per-line errors, and pretty-print each valid line.",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@utilix-tech/mcp",
-  "version": "0.10.0",
-  "description": "MCP server exposing 107 Utilix developer tools to Claude, Cursor, VS Code Copilot, and any MCP-compatible AI assistant.",
+  "version": "0.12.0",
+  "description": "MCP server exposing 111 Utilix developer tools to Claude, Cursor, VS Code Copilot, and any MCP-compatible AI assistant.",
   "author": "Utilix <hello@utilix.tech>",
   "license": "MIT",
   "homepage": "https://utilix.tech/mcp",