@utilix-tech/mcp 0.60.0 → 0.62.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.62.0
+- Add `build_priority_header`, `parse_priority_header` tools: build an HTTP Priority request/response-header value from an urgency (0-7) and/or an incremental flag per RFC 9218, or parse an existing one into the same shape.
+- Add `lookup_close_code`, `list_close_codes` tools: look up what a WebSocket close code means per RFC 6455 and the IANA reserved ranges, or list every well-known code.
+
+## 0.61.0
+- Add `calculate_extra_payment_payoff` tool: 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.
+
 ## 0.60.0
 - Add `build_retry_after_header`, `parse_retry_after_header` tools: build an HTTP Retry-After response header from a delay in seconds or a target date, or parse an existing one, per RFC 9110.
 - Add `calculate_freelancer_rate` tool: solve for the minimum hourly rate a freelancer must charge to hit a target annual income, given billable hours, weeks worked, overhead, and a profit margin.

package/README.md

@@ -1,6 +1,6 @@
 # @utilix-tech/mcp
 
-MCP server exposing 211 developer utility tools to Claude, Cursor, VS Code Copilot, and any [Model Context Protocol](https://modelcontextprotocol.io) compatible AI assistant.
+MCP server exposing 216 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 (36 tools)
+### Units (37 tools)
 | Tool | Description |
 |------|-------------|
 | `convert_bytes` | Convert between B, KB, MB, GB, TB, KiB, MiB, GiB, TiB |
@@ -201,8 +201,9 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `calculate_debt_to_income_ratio` | Compute the debt-to-income ratio (total monthly debt payments / gross monthly income) from one or more monthly debts, plus a qualitative tier matching common mortgage-lending guidance |
 | `calculate_blended_loan_rate` | Compute the single weighted-average interest rate across a list of loan balances, weighted by each loan's share of the combined balance, plus combined monthly and annual interest accrual |
 | `calculate_freelancer_rate` | Solve for the minimum hourly rate a freelancer must charge to hit a target annual income, given billable hours, weeks worked, overhead, and a profit margin |
+| `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 |
 
-### API / Network (33 tools)
+### API / Network (37 tools)
 | Tool | Description |
 |------|-------------|
 | `decode_jwt` | Decode a JWT: header, payload, and expiry |
@@ -240,6 +241,10 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `parse_prefer_header` | Parse an existing Prefer header value into its list of preferences, values, and parameters |
 | `build_retry_after_header` | Build a Retry-After response header from a delay in seconds or a target date, per RFC 9110 |
 | `parse_retry_after_header` | Parse an existing Retry-After header value into the same shape |
+| `build_priority_header` | Build an HTTP Priority request/response-header value from an urgency (0-7) and/or an incremental flag, per RFC 9218 |
+| `parse_priority_header` | Parse an existing Priority header value into its urgency and incremental fields, with spec defaults applied |
+| `lookup_close_code` | Look up what a WebSocket close code means, per RFC 6455 and the IANA reserved ranges |
+| `list_close_codes` | List every well-known WebSocket close code (1000-1015) |
 
 ### Color (4 tools)
 | Tool | Description |

package/dist/index.js

@@ -2091,6 +2091,55 @@ server.tool(
     return text(JSON.stringify(result, null, 2));
   }
 );
+function _calculateExtraPaymentPayoff(principal, annualRatePercent, termMonths, extraMonthlyPayment) {
+  const baseline = _calculateLoan(principal, annualRatePercent, termMonths);
+  if ("error" in baseline) return baseline;
+  if (!Number.isFinite(extraMonthlyPayment) || extraMonthlyPayment < 0) {
+    return { error: "Extra monthly payment must be zero or a positive number" };
+  }
+  const monthlyRate = annualRatePercent / 100 / 12;
+  const payment = _roundMoneyMcp(baseline.monthlyPayment) + _roundMoneyMcp(extraMonthlyPayment);
+  let balance = _roundMoneyMcp(principal);
+  let totalInterestPaid = 0;
+  let payoffMonths = termMonths;
+  for (let month = 1; month <= termMonths; month++) {
+    const interest = monthlyRate === 0 ? 0 : _roundMoneyMcp(balance * monthlyRate);
+    let principalPortion = payment - interest;
+    if (principalPortion > balance) principalPortion = balance;
+    totalInterestPaid += interest;
+    balance = _roundMoneyMcp(balance - principalPortion);
+    if (balance <= 0) {
+      payoffMonths = month;
+      break;
+    }
+  }
+  const baselineTotalInterest = baseline.totalInterest;
+  return {
+    monthlyPayment: _roundMoneyMcp(baseline.monthlyPayment),
+    extraMonthlyPayment: _roundMoneyMcp(extraMonthlyPayment),
+    baselinePayoffMonths: termMonths,
+    baselineTotalInterest,
+    newPayoffMonths: payoffMonths,
+    newTotalInterest: _roundMoneyMcp(totalInterestPaid),
+    monthsSaved: termMonths - payoffMonths,
+    interestSaved: _roundMoneyMcp(baselineTotalInterest - totalInterestPaid)
+  };
+}
+server.tool(
+  "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 on top of the standard amortized payment.",
+  {
+    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("Original loan term in months"),
+    extraMonthlyPayment: z.number().describe("Fixed extra amount added to every monthly payment")
+  },
+  async ({ principal, annualRatePercent, termMonths, extraMonthlyPayment }) => {
+    const result = _calculateExtraPaymentPayoff(principal, annualRatePercent, termMonths, extraMonthlyPayment);
+    if ("error" in result) return errText(result);
+    return text(JSON.stringify(result, null, 2));
+  }
+);
 var _BARCODE_FORMAT_BY_LENGTH = { 8: "EAN-8", 12: "UPC-A", 13: "EAN-13" };
 function _computeBarcodeCheckDigit(dataDigits) {
   let sum = 0;
@@ -9800,5 +9849,124 @@ server.tool(
     return text(JSON.stringify(result, null, 2));
   }
 );
+function _isValidUrgencyMcp(n) {
+  return typeof n === "number" && Number.isInteger(n) && n >= 0 && n <= 7;
+}
+function _buildPriorityHeaderMcp(input) {
+  const { urgency, incremental } = input;
+  if (urgency === void 0 && incremental === void 0) {
+    return { error: "Provide at least one of urgency or incremental" };
+  }
+  if (urgency !== void 0 && !_isValidUrgencyMcp(urgency)) {
+    return { error: "urgency must be an integer between 0 and 7" };
+  }
+  const parts = [];
+  if (urgency !== void 0) parts.push(`u=${urgency}`);
+  if (incremental === true) parts.push("i");
+  else if (incremental === false) parts.push("i=?0");
+  const headerValue = parts.join(", ");
+  return { header: `Priority: ${headerValue}`, headerValue, urgency: urgency ?? 3, incremental: incremental ?? false };
+}
+function _parsePriorityHeaderMcp(raw) {
+  if (!raw || raw.trim() === "") return { error: "Input is empty" };
+  const withoutLabel = raw.trim().replace(/^priority:\s*/i, "");
+  const parts = withoutLabel.split(",").map((p) => p.trim()).filter((p) => p.length > 0);
+  if (parts.length === 0) return { error: "Input is empty" };
+  let urgency = 3;
+  let incremental = false;
+  for (const part of parts) {
+    const eq = part.indexOf("=");
+    const key = (eq === -1 ? part : part.slice(0, eq)).trim();
+    const rawValue = eq === -1 ? void 0 : part.slice(eq + 1).trim();
+    if (key === "u") {
+      if (rawValue === void 0 || !/^\d+$/.test(rawValue)) return { error: `Invalid urgency value in "${part}"` };
+      const n = Number(rawValue);
+      if (n < 0 || n > 7) return { error: `urgency must be between 0 and 7, got ${n}` };
+      urgency = n;
+    } else if (key === "i") {
+      if (rawValue === void 0 || rawValue === "?1") incremental = true;
+      else if (rawValue === "?0") incremental = false;
+      else return { error: `Invalid incremental value in "${part}"` };
+    }
+  }
+  const headerValue = incremental ? `u=${urgency}, i` : `u=${urgency}, i=?0`;
+  return { header: `Priority: ${headerValue}`, headerValue, urgency, incremental };
+}
+server.tool(
+  "build_priority_header",
+  "Build a Priority request/response-header value from an urgency (0-7, default 3) and/or an incremental flag, per RFC 9218. At least one of the two must be given.",
+  {
+    urgency: z.number().int().min(0).max(7).optional().describe("Urgency from 0 (highest) to 7 (lowest), default 3"),
+    incremental: z.boolean().optional().describe("Whether the response can be processed incrementally as it arrives, default false")
+  },
+  async ({ urgency, incremental }) => {
+    const result = _buildPriorityHeaderMcp({ urgency, incremental });
+    if ("error" in result) return errText(result);
+    return text(JSON.stringify(result, null, 2));
+  }
+);
+server.tool(
+  "parse_priority_header",
+  'Parse an existing Priority header value (with or without a leading "Priority:" label) into its urgency and incremental fields, per RFC 9218. Missing fields fall back to their spec default (u=3, i=false).',
+  {
+    header: z.string().min(1).describe("The Priority header value to parse")
+  },
+  async ({ header }) => {
+    const result = _parsePriorityHeaderMcp(header);
+    if ("error" in result) return errText(result);
+    return text(JSON.stringify(result, null, 2));
+  }
+);
+var _WELL_KNOWN_CLOSE_CODES_MCP = {
+  1e3: { name: "Normal Closure", description: "The connection successfully completed the purpose for which it was created.", sentOnWire: true },
+  1001: { name: "Going Away", description: "An endpoint is going away, such as a server shutting down or a browser navigating away from the page.", sentOnWire: true },
+  1002: { name: "Protocol Error", description: "An endpoint is terminating the connection due to a protocol error.", sentOnWire: true },
+  1003: { name: "Unsupported Data", description: "An endpoint received a data type it cannot accept, such as a binary-only endpoint receiving a text message.", sentOnWire: true },
+  1004: { name: "Reserved", description: "Reserved. A meaning might be defined in the future.", sentOnWire: true },
+  1005: { name: "No Status Received", description: "A reserved value used internally by libraries to indicate no status code was actually present in the close frame. Must not be sent on the wire.", sentOnWire: false },
+  1006: { name: "Abnormal Closure", description: "A reserved value used internally by libraries to indicate the connection closed without a close frame, e.g. the TCP connection dropped. Must not be sent on the wire.", sentOnWire: false },
+  1007: { name: "Invalid frame payload data", description: "An endpoint is terminating the connection because it received data inconsistent with the message type, such as non-UTF-8 data in a text message.", sentOnWire: true },
+  1008: { name: "Policy Violation", description: "A generic status code used when no other code fits and the endpoint does not want to reveal further details, or a message violated its policy.", sentOnWire: true },
+  1009: { name: "Message Too Big", description: "An endpoint is terminating the connection because it received a message too large to process.", sentOnWire: true },
+  1010: { name: "Mandatory Extension", description: "A client is terminating the connection because the server did not negotiate one or more extensions the client required.", sentOnWire: true },
+  1011: { name: "Internal Error", description: "A server is terminating the connection because it encountered an unexpected condition that prevented it from fulfilling the request.", sentOnWire: true },
+  1012: { name: "Service Restart", description: "The server is terminating the connection because it is restarting.", sentOnWire: true },
+  1013: { name: "Try Again Later", description: "The server is terminating the connection due to a temporary condition, such as being overloaded, and the client should reconnect later.", sentOnWire: true },
+  1014: { name: "Bad Gateway", description: "The server, acting as a gateway or proxy, received an invalid response from an upstream server it connected to while processing the request.", sentOnWire: true },
+  1015: { name: "TLS Handshake", description: "A reserved value used internally by libraries to indicate the TLS handshake failed. Must not be sent on the wire.", sentOnWire: false }
+};
+function _lookupCloseCodeMcp(code) {
+  if (!Number.isInteger(code) || code < 0 || code > 65535) {
+    return { error: "code must be an integer between 0 and 65535" };
+  }
+  const known = _WELL_KNOWN_CLOSE_CODES_MCP[code];
+  if (known) return { code, name: known.name, description: known.description, range: "standard", sentOnWire: known.sentOnWire };
+  if (code < 1e3) return { error: `${code} is not a valid WebSocket close code; codes below 1000 are not permitted on the wire` };
+  if (code <= 2999) return { code, name: "Unassigned", description: "Reserved for future use by the WebSocket protocol specification. No meaning is defined yet.", range: "reserved-future", sentOnWire: true };
+  if (code <= 3999) return { code, name: "Library/Framework Use", description: "Reserved for use by libraries, frameworks, and applications. Codes in this range are meant to be registered directly with IANA in the WebSocket Close Code Number Registry.", range: "library-framework", sentOnWire: true };
+  if (code <= 4999) return { code, name: "Private Use", description: "Reserved for private use between a specific client and server implementation. These codes cannot be registered with IANA.", range: "private-use", sentOnWire: true };
+  return { error: `${code} is outside the defined close code ranges (0-4999); codes 5000 and above have no assigned meaning` };
+}
+server.tool(
+  "lookup_close_code",
+  "Look up what a WebSocket close code means, per the RFC 6455 close code definitions and the IANA WebSocket Close Code Number Registry reserved ranges.",
+  {
+    code: z.number().int().min(0).max(65535).describe("The WebSocket close code to look up")
+  },
+  async ({ code }) => {
+    const result = _lookupCloseCodeMcp(code);
+    if ("error" in result) return errText(result);
+    return text(JSON.stringify(result, null, 2));
+  }
+);
+server.tool(
+  "list_close_codes",
+  "List every well-known WebSocket close code (1000-1015) defined directly by RFC 6455, in ascending order.",
+  {},
+  async () => {
+    const codes = Object.entries(_WELL_KNOWN_CLOSE_CODES_MCP).map(([code, info]) => ({ code: Number(code), name: info.name, description: info.description, range: "standard", sentOnWire: info.sentOnWire })).sort((a, b) => a.code - b.code);
+    return text(JSON.stringify({ codes }, null, 2));
+  }
+);
 var transport = new StdioServerTransport();
 await server.connect(transport);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@utilix-tech/mcp",
-  "version": "0.60.0",
+  "version": "0.62.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",