@utilix-tech/mcp 0.40.0 → 0.41.0

package/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 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.41.0
+- Add `calculate_cash_breakdown`, `calculate_change` tools: break a cash amount down into the minimum count of bills/coins from a set of denominations (largest first), or compute change owed for a payment/tender pair and its breakdown.
+- Add `generate_etag` tool: compute a content-hash ETag (MD5/SHA-1/SHA-256) for a response header, with an optional weak-validator (W/) prefix.
+
 ## 0.40.0
 - Add `generate_sri_hash` tool: compute SHA-256/384/512 Subresource Integrity hashes for a script or stylesheet's content, formatted as the `<algorithm>-<base64>` string an HTML `integrity` attribute expects.
 - Add `analyze_email_headers` tool: parse a raw email header block into structured From/To/Subject fields, the Received hop chain in order, and SPF/DKIM/DMARC results from an Authentication-Results header.

package/README.md

@@ -1,6 +1,6 @@
 # @utilix-tech/mcp
 
-MCP server exposing 165 developer utility tools to Claude, Cursor, VS Code Copilot, and any [Model Context Protocol](https://modelcontextprotocol.io) compatible AI assistant.
+MCP server exposing 168 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.
 
@@ -110,7 +110,7 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `base62_encode` | Encode text as Base62 (alphanumeric, URL-safe) |
 | `base62_decode` | Decode a Base62 string back to text |
 
-### Hashing (5 tools)
+### Hashing (6 tools)
 | Tool | Description |
 |------|-------------|
 | `hash` | Hash a string with MD5, SHA-1, SHA-256, SHA-384, or SHA-512 |
@@ -118,6 +118,7 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `bcrypt_hash` | Hash a password using bcrypt |
 | `bcrypt_verify` | Verify a password against a bcrypt hash |
 | `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)
 | Tool | Description |
@@ -158,7 +159,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 (24 tools)
+### Units (26 tools)
 | Tool | Description |
 |------|-------------|
 | `convert_bytes` | Convert between B, KB, MB, GB, TB, KiB, MiB, GiB, TiB |
@@ -185,6 +186,8 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `calculate_savings_goal` | Solve for months to reach a savings goal at a fixed monthly contribution, or the monthly contribution required to hit a goal by a target month count |
 | `calculate_roi` | Compute return on investment percent from an initial and final value, plus the annualized (CAGR) return given an optional holding period in years |
 | `compare_unit_prices` | Compare two or more package options by price and quantity to find the true cost per unit, flag the cheapest, and report how much more expensive each other option is |
+| `calculate_cash_breakdown` | Break a cash amount down into the minimum count of bills/coins from a set of denominations, largest first |
+| `calculate_change` | Compute change owed for a payment/tender pair and break it down into the minimum count of bills/coins |
 
 ### API / Network (16 tools)
 | Tool | Description |

package/dist/index.js

@@ -6830,5 +6830,106 @@ server.tool(
     return text(JSON.stringify(result, null, 2));
   }
 );
+var _USD_DENOMINATIONS_MCP = [100, 50, 20, 10, 5, 1, 0.25, 0.1, 0.05, 0.01];
+function _cashToCentsMcp(n) {
+  return Math.round(n * 100);
+}
+function _calculateCashBreakdownMcp(amount, denominations) {
+  if (!Number.isFinite(amount) || amount < 0) return { error: "Amount must be zero or a positive number" };
+  if (denominations.length === 0) return { error: "At least one denomination is required" };
+  for (const d of denominations) {
+    if (!Number.isFinite(d) || d <= 0) return { error: "Each denomination must be a positive number" };
+  }
+  const round2 = (n) => Math.round(n * 100) / 100;
+  const sorted = Array.from(new Set(denominations)).sort((a, b) => b - a);
+  let remainingCents = _cashToCentsMcp(amount);
+  const breakdown = [];
+  let totalCount = 0;
+  for (const d of sorted) {
+    const dCents = _cashToCentsMcp(d);
+    const count = Math.floor(remainingCents / dCents);
+    if (count > 0) {
+      breakdown.push({ denomination: d, count, subtotal: round2(count * d) });
+      remainingCents -= count * dCents;
+      totalCount += count;
+    }
+  }
+  return {
+    amount: round2(amount),
+    denominations: sorted,
+    breakdown,
+    totalCount,
+    remainder: round2(remainingCents / 100)
+  };
+}
+server.tool(
+  "calculate_cash_breakdown",
+  "Break a cash amount down into the minimum count of bills/coins from a set of denominations, using the standard greedy largest-first approach (optimal for canonical currency denomination sets like USD, EUR, and GBP). Any amount that can't be represented exactly with the given denominations is reported as a remainder rather than rounded away.",
+  {
+    amount: z.number().describe("The cash amount to break down"),
+    denominations: z.array(z.number()).min(1).optional().describe("Available bill/coin denominations, largest to smallest (defaults to US denominations: 100, 50, 20, 10, 5, 1, 0.25, 0.1, 0.05, 0.01)")
+  },
+  async ({ amount, denominations }) => {
+    const result = _calculateCashBreakdownMcp(amount, denominations && denominations.length > 0 ? denominations : _USD_DENOMINATIONS_MCP);
+    if ("error" in result) return errText(result);
+    return text(JSON.stringify(result, null, 2));
+  }
+);
+server.tool(
+  "calculate_change",
+  "Compute the change owed for a payment/tender pair (amount tendered minus amount due) and break that change down into the minimum count of bills/coins from the given denominations.",
+  {
+    amountDue: z.number().describe("The amount owed"),
+    amountTendered: z.number().describe("The amount paid, must be greater than or equal to amountDue"),
+    denominations: z.array(z.number()).min(1).optional().describe("Available bill/coin denominations, largest to smallest (defaults to US denominations: 100, 50, 20, 10, 5, 1, 0.25, 0.1, 0.05, 0.01)")
+  },
+  async ({ amountDue, amountTendered, denominations }) => {
+    if (!Number.isFinite(amountDue) || amountDue < 0) return errText({ error: "Amount due must be zero or a positive number" });
+    if (!Number.isFinite(amountTendered) || amountTendered < 0) return errText({ error: "Amount tendered must be zero or a positive number" });
+    if (_cashToCentsMcp(amountTendered) < _cashToCentsMcp(amountDue)) {
+      return errText({ error: "Amount tendered must be greater than or equal to the amount due" });
+    }
+    const round2 = (n) => Math.round(n * 100) / 100;
+    const denoms = denominations && denominations.length > 0 ? denominations : _USD_DENOMINATIONS_MCP;
+    const changeDue = round2(amountTendered - amountDue);
+    const breakdown = _calculateCashBreakdownMcp(changeDue, denoms);
+    if ("error" in breakdown) return errText(breakdown);
+    return text(JSON.stringify({
+      amountDue: round2(amountDue),
+      amountTendered: round2(amountTendered),
+      changeDue,
+      denominations: breakdown.denominations,
+      breakdown: breakdown.breakdown,
+      totalCount: breakdown.totalCount,
+      remainder: breakdown.remainder
+    }, null, 2));
+  }
+);
+var _ETAG_ALGORITHMS_MCP = ["MD5", "SHA-1", "SHA-256"];
+var _ETAG_NODE_ALG_MAP_MCP = { "MD5": "md5", "SHA-1": "sha1", "SHA-256": "sha256" };
+function _generateEtagMcp(content, algorithm, weak) {
+  if (content.length === 0) return { error: "Content is required" };
+  if (!_ETAG_ALGORITHMS_MCP.includes(algorithm)) {
+    return { error: `Unknown algorithm: ${algorithm}. Must be one of ${_ETAG_ALGORITHMS_MCP.join(", ")}` };
+  }
+  const hash = createHash(_ETAG_NODE_ALG_MAP_MCP[algorithm]).update(content, "utf8").digest("hex");
+  const quoted = `"${hash}"`;
+  const etag = weak ? `W/${quoted}` : quoted;
+  return { algorithm, weak, hash, etag, headerName: "ETag", snippet: `ETag: ${etag}` };
+}
+server.tool(
+  "generate_etag",
+  "Compute a content-hash ETag for the given content: digest it with MD5, SHA-1, or SHA-256, hex-encode it, and quote it into the exact string an ETag response header expects, with an optional weak-validator (W/) prefix. Hashes whatever content you give it; does not replicate any specific web server's own size/modification-time-based ETag algorithm.",
+  {
+    content: z.string().min(1).describe("The content to hash into an ETag"),
+    algorithm: z.enum(_ETAG_ALGORITHMS_MCP).default("SHA-1").describe("Hash algorithm to use"),
+    weak: z.boolean().default(false).describe("Whether to produce a weak validator (W/ prefix)")
+  },
+  async ({ content, algorithm, weak }) => {
+    const result = _generateEtagMcp(content, algorithm, weak);
+    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,7 +1,7 @@
 {
   "name": "@utilix-tech/mcp",
-  "version": "0.40.0",
-  "description": "MCP server exposing 152 Utilix developer tools to Claude, Cursor, VS Code Copilot, and any MCP-compatible AI assistant.",
+  "version": "0.41.0",
+  "description": "MCP server exposing 168 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",