@utilix-tech/mcp 0.56.0 → 0.58.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.58.0
+- Add `apply_json_merge_patch` tool: apply an RFC 7396 JSON Merge Patch document to a target JSON document, with null-valued patch keys removing the matching target key.
+- Add `generate_csp_nonce` tool: generate a cryptographically random, base64-encoded Content-Security-Policy nonce with ready-to-paste header directive and script/style tag snippets.
+
+## 0.57.0
+- Add `build_accept_language`, `parse_accept_language` tools: build an Accept-Language request-header value from locale/quality pairs sorted by descending preference, or parse an existing one into its ranked entries.
+- Add `calculate_blended_loan_rate` tool: compute the single weighted-average interest rate across a list of loan balances, plus combined monthly and annual interest accrual.
+
 ## 0.56.0
 - Add `calculate_debt_to_income_ratio` tool: 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.
 - Add `infer_csv_column_types` tool: parse CSV/TSV data and infer each column's data type (integer, float, boolean, ISO 8601 date, or string), flagging nullable columns and empty-cell counts.

package/README.md

@@ -1,6 +1,6 @@
 # @utilix-tech/mcp
 
-MCP server exposing 200 developer utility tools to Claude, Cursor, VS Code Copilot, and any [Model Context Protocol](https://modelcontextprotocol.io) compatible AI assistant.
+MCP server exposing 205 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.
 
@@ -75,7 +75,7 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 
 ## Tools
 
-### JSON (15 tools)
+### JSON (16 tools)
 | Tool | Description |
 |------|-------------|
 | `format_json` | Pretty-print and validate a JSON string |
@@ -85,6 +85,7 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `csv_to_json` | Convert CSV text to a JSON array |
 | `jsonpath` | Evaluate a JSONPath expression |
 | `resolve_json_pointer` | Resolve an RFC 6901 JSON Pointer against a JSON document |
+| `apply_json_merge_patch` | Apply an RFC 7396 JSON Merge Patch document to a target JSON document |
 | `validate_json` | Validate JSON against a JSON Schema |
 | `yaml_to_json` | Convert YAML to JSON |
 | `json_to_yaml` | Convert JSON to YAML |
@@ -120,7 +121,7 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `generate_sri_hash` | Compute a Subresource Integrity hash (SHA-256/384/512) for a script or stylesheet's content, formatted for an HTML `integrity` attribute |
 | `generate_etag` | Compute a content-hash ETag (MD5/SHA-1/SHA-256) for a response header, with an optional weak-validator prefix |
 
-### Generators (6 tools)
+### Generators (7 tools)
 | Tool | Description |
 |------|-------------|
 | `generate_uuid` | Generate UUID v4 or v7 |
@@ -129,6 +130,7 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `estimate_password_entropy` | Estimate a password's entropy in bits, strength label, and crack-time estimates |
 | `generate_qr` | Generate a QR code as an SVG string |
 | `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)
 | Tool | Description |
@@ -160,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 (34 tools)
+### Units (35 tools)
 | Tool | Description |
 |------|-------------|
 | `convert_bytes` | Convert between B, KB, MB, GB, TB, KiB, MiB, GiB, TiB |
@@ -197,8 +199,9 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `calculate_gpa` | Compute a weighted GPA from a list of courses, each with a letter grade and credit hours, using the standard 4.0-capped scale |
 | `calculate_credit_utilization` | Compute per-account and overall credit utilization (balance / limit) from one or more credit accounts, plus a qualitative tier matching common credit-scoring guidance |
 | `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 |
 
-### API / Network (29 tools)
+### API / Network (31 tools)
 | Tool | Description |
 |------|-------------|
 | `decode_jwt` | Decode a JWT: header, payload, and expiry |
@@ -230,6 +233,8 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `build_content_disposition` | Build a Content-Disposition response header for a file download or inline display, with an RFC 5987 filename* parameter for non-ASCII filenames |
 | `parse_content_disposition` | Parse a Content-Disposition header value into its disposition type, decoded filename, and raw parameters |
 | `build_x_content_type_options_header` | Build the fixed X-Content-Type-Options: nosniff header, validate a pasted value, or assess MIME-sniffing risk for a given Content-Type |
+| `build_accept_language` | Build an Accept-Language request-header value from locale/quality pairs, sorted by descending preference |
+| `parse_accept_language` | Parse an existing Accept-Language header value into its ranked locale/quality pairs |
 
 ### Color (4 tools)
 | Tool | Description |

package/dist/index.js

@@ -4,7 +4,7 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
-import { createHash } from "crypto";
+import { createHash, randomBytes } from "crypto";
 import * as yaml from "js-yaml";
 import {
   parseJson,
@@ -4655,6 +4655,45 @@ server.tool(
     return text(JSON.stringify(result, null, 2));
   }
 );
+function _isMergePatchObjectMcp(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function _mergeJsonPatchMcp(target, patch) {
+  if (!_isMergePatchObjectMcp(patch)) return patch;
+  const result = _isMergePatchObjectMcp(target) ? { ...target } : {};
+  for (const key of Object.keys(patch)) {
+    const value = patch[key];
+    if (value === null) {
+      delete result[key];
+    } else {
+      result[key] = _mergeJsonPatchMcp(result[key], value);
+    }
+  }
+  return result;
+}
+server.tool(
+  "apply_json_merge_patch",
+  "Apply an RFC 7396 JSON Merge Patch document to a target JSON document and return the merged result. A null-valued key in the patch removes that key from the target; a patch that is not itself a JSON object replaces the target wholesale, which is how arrays are replaced rather than merged element by element.",
+  {
+    target: z.string().describe("The target JSON document, as a JSON string"),
+    patch: z.string().describe("The RFC 7396 JSON Merge Patch document, as a JSON string")
+  },
+  async ({ target, patch }) => {
+    let targetParsed;
+    try {
+      targetParsed = JSON.parse(target);
+    } catch {
+      return errText({ error: "Target is not valid JSON" });
+    }
+    let patchParsed;
+    try {
+      patchParsed = JSON.parse(patch);
+    } catch {
+      return errText({ error: "Patch is not valid JSON" });
+    }
+    return text(JSON.stringify({ result: _mergeJsonPatchMcp(targetParsed, patchParsed) }, null, 2));
+  }
+);
 function _convertAprApyMcp(rate, compoundsPerYear, direction) {
   if (!Number.isFinite(rate) || rate < 0) return { error: "Rate must be zero or a positive number" };
   if (!Number.isInteger(compoundsPerYear) || compoundsPerYear <= 0) return { error: "Compounding frequency must be a positive whole number of periods per year" };
@@ -9327,5 +9366,158 @@ server.tool(
     }, null, 2));
   }
 );
+function _formatAcceptLanguageQualityMcp(q) {
+  let s = q.toFixed(3);
+  s = s.replace(/0+$/, "");
+  s = s.replace(/\.$/, "");
+  return s;
+}
+function _formatAcceptLanguageEntriesMcp(entries) {
+  return entries.map((e) => e.quality === 1 ? e.locale : `${e.locale};q=${_formatAcceptLanguageQualityMcp(e.quality)}`).join(", ");
+}
+function _sortAcceptLanguageEntriesMcp(entries) {
+  return entries.map((e, i) => ({ e, i })).sort((a, b) => b.e.quality - a.e.quality || a.i - b.i).map((x) => x.e);
+}
+function _buildAcceptLanguageMcp(locales) {
+  if (!Array.isArray(locales) || locales.length === 0) return { error: "At least one locale is required" };
+  const entries = [];
+  for (let i = 0; i < locales.length; i++) {
+    const { locale, quality } = locales[i];
+    if (typeof locale !== "string" || locale.trim() === "") return { error: `locale ${i + 1}: locale is required` };
+    const q = quality === void 0 ? 1 : quality;
+    if (typeof q !== "number" || !Number.isFinite(q) || q < 0 || q > 1) {
+      return { error: `locale ${i + 1}: quality must be between 0 and 1` };
+    }
+    entries.push({ locale: locale.trim(), quality: Math.round(q * 1e3) / 1e3 });
+  }
+  const sorted = _sortAcceptLanguageEntriesMcp(entries);
+  const headerValue = _formatAcceptLanguageEntriesMcp(sorted);
+  return { header: `Accept-Language: ${headerValue}`, headerValue, entries: sorted };
+}
+function _parseAcceptLanguageMcp(raw) {
+  if (!raw || raw.trim() === "") return { error: "Input is empty" };
+  const withoutLabel = raw.trim().replace(/^accept-language:\s*/i, "");
+  const parts = withoutLabel.split(",").map((p) => p.trim()).filter((p) => p.length > 0);
+  if (parts.length === 0) return { error: "Input is empty" };
+  const entries = [];
+  for (const part of parts) {
+    const [localeRaw, ...paramsRaw] = part.split(";").map((s) => s.trim());
+    if (!localeRaw) return { error: `Invalid entry: "${part}"` };
+    let quality = 1;
+    for (const param of paramsRaw) {
+      const m = /^q=([\d.]+)$/i.exec(param);
+      if (!m) return { error: `Invalid parameter in "${part}"` };
+      quality = Number(m[1]);
+      if (!Number.isFinite(quality) || quality < 0 || quality > 1) {
+        return { error: `q value must be between 0 and 1 in "${part}"` };
+      }
+    }
+    entries.push({ locale: localeRaw, quality: Math.round(quality * 1e3) / 1e3 });
+  }
+  const sorted = _sortAcceptLanguageEntriesMcp(entries);
+  const headerValue = _formatAcceptLanguageEntriesMcp(sorted);
+  return { header: `Accept-Language: ${headerValue}`, headerValue, entries: sorted };
+}
+server.tool(
+  "build_accept_language",
+  'Build an Accept-Language request-header value from a list of locale/quality pairs, sorting by descending quality (ties keep their original order) and omitting ";q=1" for the default weight, per RFC 9110 section 12.5.4.',
+  {
+    locales: z.array(z.object({
+      locale: z.string().describe('A language range, e.g. "en-US" or "*"'),
+      quality: z.number().min(0).max(1).optional().describe("Preference weight from 0 to 1 (default 1)")
+    })).min(1).describe("Locale/quality pairs to build the header from")
+  },
+  async ({ locales }) => {
+    const result = _buildAcceptLanguageMcp(locales);
+    if ("error" in result) return errText(result);
+    return text(JSON.stringify(result, null, 2));
+  }
+);
+server.tool(
+  "parse_accept_language",
+  'Parse an existing Accept-Language header value (with or without a leading "Accept-Language:" label) into its ranked locale/quality pairs, sorted by descending quality per RFC 9110 section 12.5.4 (a missing ";q=" defaults to 1).',
+  {
+    header: z.string().min(1).describe("The Accept-Language header value to parse")
+  },
+  async ({ header }) => {
+    const result = _parseAcceptLanguageMcp(header);
+    if ("error" in result) return errText(result);
+    return text(JSON.stringify(result, null, 2));
+  }
+);
+function _calculateBlendedLoanRateMcp(loans) {
+  if (!Array.isArray(loans) || loans.length === 0) {
+    return { error: "loans must be a non-empty array" };
+  }
+  const round2 = (n) => Math.round(n * 100) / 100;
+  const round4 = (n) => Math.round(n * 1e4) / 1e4;
+  let totalBalance = 0;
+  for (let i = 0; i < loans.length; i++) {
+    const loan = loans[i];
+    if (typeof loan.balance !== "number" || !Number.isFinite(loan.balance) || loan.balance <= 0) {
+      return { error: `loan ${i + 1}: balance must be a finite number greater than zero` };
+    }
+    if (typeof loan.ratePercent !== "number" || !Number.isFinite(loan.ratePercent) || loan.ratePercent < 0) {
+      return { error: `loan ${i + 1}: ratePercent must be a finite, non-negative number` };
+    }
+    totalBalance += loan.balance;
+  }
+  let totalMonthlyInterest = 0;
+  let weightedRateSum = 0;
+  const results = loans.map((loan, i) => {
+    const monthlyInterest = round2(loan.balance * loan.ratePercent / 100 / 12);
+    totalMonthlyInterest += monthlyInterest;
+    weightedRateSum += loan.balance * loan.ratePercent;
+    return {
+      label: loan.label?.trim() || `Loan ${i + 1}`,
+      balance: loan.balance,
+      ratePercent: loan.ratePercent,
+      monthlyInterest,
+      shareOfTotalPercent: round2(loan.balance / totalBalance * 100)
+    };
+  });
+  return {
+    loans: results,
+    totalBalance: round2(totalBalance),
+    weightedAverageRatePercent: round4(weightedRateSum / totalBalance),
+    totalMonthlyInterest: round2(totalMonthlyInterest),
+    totalAnnualInterest: round2(totalMonthlyInterest * 12)
+  };
+}
+server.tool(
+  "calculate_blended_loan_rate",
+  "Compute the single weighted-average interest rate across a list of loan balances (e.g. multiple credit cards or student loans being weighed for consolidation), weighting each loan's rate by its share of the combined balance, plus the combined monthly and annual interest accrual.",
+  {
+    loans: z.array(z.object({
+      label: z.string().optional().describe("Optional loan label"),
+      balance: z.number().positive().describe("Outstanding balance for this loan"),
+      ratePercent: z.number().min(0).describe("Annual interest rate for this loan, as a percent")
+    })).min(1).describe("A non-empty list of loan balances and rates")
+  },
+  async ({ loans }) => {
+    const result = _calculateBlendedLoanRateMcp(loans);
+    if ("error" in result) return errText(result);
+    return text(JSON.stringify(result, null, 2));
+  }
+);
+server.tool(
+  "generate_csp_nonce",
+  'Generate a cryptographically random, base64-encoded nonce for a Content-Security-Policy script-src or style-src directive, along with ready-to-paste header directive and <script>/<style nonce="..."> tag snippets. Generates a fresh, unique value on every call.',
+  {
+    byteLength: z.number().int().min(8).max(64).optional().describe("Number of random bytes to encode (default 16 = 128 bits, the CSP spec's recommended minimum)")
+  },
+  async ({ byteLength }) => {
+    const length = byteLength ?? 16;
+    const nonce = randomBytes(length).toString("base64");
+    return text(JSON.stringify({
+      nonce,
+      byteLength: length,
+      scriptSrcDirective: `script-src 'nonce-${nonce}'`,
+      styleSrcDirective: `style-src 'nonce-${nonce}'`,
+      scriptTag: `<script nonce="${nonce}">`,
+      styleTag: `<style nonce="${nonce}">`
+    }, null, 2));
+  }
+);
 var transport = new StdioServerTransport();
 await server.connect(transport);

package/package.json

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