@utilix-tech/mcp 0.55.0 → 0.57.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.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.
+
 ## 0.55.0
 - Add `validate_package_exports` tool: parse a package.json's exports field and flag common dual-package (ESM/CJS) misconfigurations, a types condition not listed first, a missing default fallback, mismatched require/import extensions, mixed subpath/condition keys, and pattern mismatches.
 - Add `build_x_content_type_options_header` tool: build the fixed X-Content-Type-Options: nosniff header, validate a pasted value, and assess MIME-sniffing risk for a given Content-Type.

package/README.md

@@ -1,6 +1,6 @@
 # @utilix-tech/mcp
 
-MCP server exposing 198 developer utility tools to Claude, Cursor, VS Code Copilot, and any [Model Context Protocol](https://modelcontextprotocol.io) compatible AI assistant.
+MCP server exposing 203 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.
 
@@ -160,7 +160,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 (33 tools)
+### Units (35 tools)
 | Tool | Description |
 |------|-------------|
 | `convert_bytes` | Convert between B, KB, MB, GB, TB, KiB, MiB, GiB, TiB |
@@ -196,8 +196,10 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `calculate_moving_averages` | Compute simple moving average (SMA) and exponential moving average (EMA) series from a list of numbers and a window size |
 | `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 |
@@ -229,6 +231,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 |
@@ -257,7 +261,7 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `validate_tsconfig` | Validate a tsconfig.json file (JSONC-aware): unknown keys, unknown compilerOptions, and type mismatches |
 | `validate_package_exports` | Validate a package.json "exports" field: dual-package (ESM/CJS) misconfigurations like a missing default fallback or a require/import pointing at the wrong extension |
 
-### Data (13 tools)
+### Data (14 tools)
 | Tool | Description |
 |------|-------------|
 | `validate_yaml` | Validate YAML syntax |
@@ -273,6 +277,7 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `find_csv_duplicate_rows` | Group CSV/TSV rows that share the same value across a chosen set of key columns, or the entire row |
 | `calculate_markdown_task_list_progress` | Parse a Markdown document's checkbox task list and report completion percentage overall and per section, grouped by the nearest preceding heading |
 | `analyze_caption_speed` | Parse an SRT or WebVTT file and report the words-per-minute reading speed of every cue, flagging ones that exceed common broadcast accessibility guidelines |
+| `infer_csv_column_types` | 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 |
 
 ### CSS (2 tools)
 | Tool | Description |

package/dist/index.js

@@ -7271,6 +7271,71 @@ server.tool(
     return text(JSON.stringify(result, null, 2));
   }
 );
+var _CSV_TYPE_ISO_DATE_RE_MCP = /^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})?)?$/;
+function _classifyCsvValueMcp(raw) {
+  const v = raw.trim();
+  if (v === "") return "empty";
+  if (/^(true|false)$/i.test(v)) return "boolean";
+  if (/^-?\d+$/.test(v)) return "integer";
+  if (/^-?\d+\.\d+$/.test(v)) return "float";
+  if (_CSV_TYPE_ISO_DATE_RE_MCP.test(v)) return "date";
+  return "string";
+}
+function _inferCsvColumnTypesMcp(input, delimiter, hasHeader) {
+  if (!input || input.trim() === "") return { error: "Input is empty" };
+  const delim = delimiter || ",";
+  const header = hasHeader !== false;
+  const lines = input.replace(/\r\n/g, "\n").split("\n").filter((l) => l.trim() !== "");
+  if (lines.length === 0) return { error: "No data found" };
+  const allRows = lines.map((l) => _parseCsvRowForSqlMcp(l, delim));
+  const headers = header ? allRows[0].map((h) => h.trim()) : allRows[0].map((_, idx) => `Column ${idx + 1}`);
+  const rows = header ? allRows.slice(1) : allRows;
+  const columns = headers.map((name, colIdx) => {
+    const seen = /* @__PURE__ */ new Set();
+    let sawString = false;
+    let nullCount = 0;
+    const sampleValues = [];
+    for (const row of rows) {
+      const raw = row[colIdx] ?? "";
+      const kind = _classifyCsvValueMcp(raw);
+      if (kind === "empty") {
+        nullCount++;
+        continue;
+      }
+      if (sampleValues.length < 3) sampleValues.push(raw);
+      if (kind === "string") sawString = true;
+      else seen.add(kind);
+    }
+    let inferredType;
+    if (sawString || seen.size === 0) inferredType = "string";
+    else if (seen.size === 1) inferredType = [...seen][0];
+    else if (seen.has("integer") && seen.has("float") && seen.size === 2) inferredType = "float";
+    else inferredType = "string";
+    return {
+      name,
+      inferredType,
+      nullable: nullCount > 0,
+      nullCount,
+      totalCount: rows.length,
+      sampleValues
+    };
+  });
+  return { columns, rowCount: rows.length };
+}
+server.tool(
+  "infer_csv_column_types",
+  "Parse CSV/TSV data and infer each column's data type (integer, float, boolean, ISO 8601 date, or string) by classifying every non-empty value and finding the tightest type that fits them all: all-integer values infer as integer, a mix of integers and decimals infers as float, and anything that doesn't fit a narrower type falls back to string. Empty cells mark a column nullable but don't affect its inferred type.",
+  {
+    csv: z.string().min(1).describe("CSV/TSV data to infer column types from"),
+    delimiter: z.string().optional().describe('Field delimiter (default ",")'),
+    hasHeader: z.boolean().default(true).describe("Whether the first row is a header")
+  },
+  async ({ csv, delimiter, hasHeader }) => {
+    const result = _inferCsvColumnTypesMcp(csv, delimiter, hasHeader);
+    if ("error" in result) return errText(result);
+    return text(JSON.stringify(result, null, 2));
+  }
+);
 var _VARY_HEADER_NOTES_MCP = {
   "accept-encoding": "Caches must store a separate response per compression scheme (gzip, br, etc.) the client accepts.",
   "accept-language": "Caches must store a separate response per requested language, which can fragment a shared cache badly if Accept-Language values are highly varied.",
@@ -8922,6 +8987,59 @@ server.tool(
     return text(JSON.stringify(result, null, 2));
   }
 );
+function _classifyDtiMcp(percent) {
+  if (percent < 36) return "healthy";
+  if (percent < 43) return "moderate";
+  if (percent < 50) return "high";
+  return "severe";
+}
+function _calculateDebtToIncomeRatioMcp(debts, grossMonthlyIncome) {
+  if (!Array.isArray(debts) || debts.length === 0) {
+    return { error: "debts must be a non-empty array" };
+  }
+  if (typeof grossMonthlyIncome !== "number" || !Number.isFinite(grossMonthlyIncome) || grossMonthlyIncome <= 0) {
+    return { error: "grossMonthlyIncome must be a finite number greater than zero" };
+  }
+  const round2 = (n) => Math.round(n * 100) / 100;
+  let totalMonthlyDebt = 0;
+  const results = [];
+  for (let i = 0; i < debts.length; i++) {
+    const debt = debts[i];
+    if (typeof debt.amount !== "number" || !Number.isFinite(debt.amount) || debt.amount < 0) {
+      return { error: `debt ${i + 1}: amount must be a finite, non-negative number` };
+    }
+    totalMonthlyDebt += debt.amount;
+    results.push({
+      label: debt.label?.trim() || `Debt ${i + 1}`,
+      amount: debt.amount,
+      percentOfIncome: round2(debt.amount / grossMonthlyIncome * 100)
+    });
+  }
+  const dtiPercent = round2(totalMonthlyDebt / grossMonthlyIncome * 100);
+  return {
+    debts: results,
+    totalMonthlyDebt: round2(totalMonthlyDebt),
+    grossMonthlyIncome,
+    dtiPercent,
+    tier: _classifyDtiMcp(dtiPercent)
+  };
+}
+server.tool(
+  "calculate_debt_to_income_ratio",
+  "Compute the debt-to-income ratio (total monthly debt payments / gross monthly income) from one or more monthly debt items, plus a qualitative tier matching common mortgage-lending guidance: under 36% is healthy, under 43% is moderate (43% is the back-end ratio ceiling many mortgage lenders use), under 50% is high, and 50%+ is severe. This is a back-end DTI (all monthly debt payments over gross income), not a front-end housing-only ratio.",
+  {
+    debts: z.array(z.object({
+      label: z.string().optional().describe("Optional debt label"),
+      amount: z.number().min(0).describe("Monthly payment amount for this debt")
+    })).min(1).describe("A non-empty list of monthly debt payments"),
+    grossMonthlyIncome: z.number().positive().describe("Gross (pre-tax) monthly income")
+  },
+  async ({ debts, grossMonthlyIncome }) => {
+    const result = _calculateDebtToIncomeRatioMcp(debts, grossMonthlyIncome);
+    if ("error" in result) return errText(result);
+    return text(JSON.stringify(result, null, 2));
+  }
+);
 var _CAPTION_TIMESTAMP_RE_MCP = /(\d+):(\d{1,2}):(\d{1,2})[.,](\d{1,3})|(\d{1,3}):(\d{1,2})[.,](\d{1,3})/;
 var _CAPTION_SKIP_BLOCK_KEYWORDS_MCP = ["NOTE", "STYLE", "REGION"];
 function _parseCaptionTimestampMcp(raw) {
@@ -9209,5 +9327,139 @@ 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));
+  }
+);
 var transport = new StdioServerTransport();
 await server.connect(transport);

package/package.json

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