@utilix-tech/mcp 0.78.0 → 0.80.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.80.0
+- Add `diff_json_patch`, `apply_json_patch` tools: diff two JSON documents into an RFC 6902 JSON Patch operation list (add/remove/replace/move/copy/test), or apply a patch to a target document.
+- Add `parse_connection_string` tool: parse a database connection URI (postgres, mysql, mongodb, redis, amqp, and similar) into its scheme, credentials, hosts, database, and query parameters.
+
+## 0.79.0
+- Add `calculate_real_rate_of_return` tool: apply the Fisher equation to solve for whichever of the nominal rate, inflation rate, or inflation-adjusted real rate is missing, given exactly two of the three.
+- Add `calculate_retry_backoff_schedule` tool: compute the full sequence of delays an exponential-backoff retry policy would actually produce, optionally capped and with full/equal jitter ranges, plus the total best-case and worst-case wait across all retries.
+
 ## 0.78.0
 - Add `ndjson_to_csv` tool: convert newline-delimited JSON (one flat object per line) into CSV, inferring the header row from the union of keys across all lines.
 

package/README.md

@@ -1,6 +1,6 @@
 # @utilix-tech/mcp
 
-MCP server exposing 250 developer utility tools to Claude, Cursor, VS Code Copilot, and any [Model Context Protocol](https://modelcontextprotocol.io) compatible AI assistant.
+MCP server exposing 255 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 (16 tools)
+### JSON (18 tools)
 | Tool | Description |
 |------|-------------|
 | `format_json` | Pretty-print and validate a JSON string |
@@ -86,6 +86,8 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `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 |
+| `diff_json_patch` | Compare two JSON documents and generate an RFC 6902 JSON Patch operation list |
+| `apply_json_patch` | Apply a sequence of RFC 6902 JSON Patch operations (add, remove, replace, move, copy, test) to a target document |
 | `validate_json` | Validate JSON against a JSON Schema |
 | `yaml_to_json` | Convert YAML to JSON |
 | `json_to_yaml` | Convert JSON to YAML |
@@ -164,7 +166,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 (45 tools)
+### Units (46 tools)
 | Tool | Description |
 |------|-------------|
 | `convert_bytes` | Convert between B, KB, MB, GB, TB, KiB, MiB, GiB, TiB |
@@ -212,6 +214,7 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `calculate_mortgage_points` | Compare a loan with no discount points against the same loan at a reduced rate bought with points, and compute the monthly savings and the break-even month where cumulative savings recoup the points cost |
 | `calculate_loan_prepayment_penalty` | Compute the dollar penalty cost of paying a loan off early, given its remaining payoff balance and a prepayment penalty structure: either a flat percent of the payoff balance, or a fixed number of months of interest at the loan's annual rate |
 | `estimate_data_transfer_time` | Estimate the theoretical time to transfer a file of a given size over a connection of a given speed, or (given a target time instead) the bandwidth required to hit it |
+| `calculate_real_rate_of_return` | Apply the Fisher equation to solve for whichever of the nominal rate, inflation rate, or inflation-adjusted real rate is missing, given exactly two of the three |
 
 ### API / Network (51 tools)
 | Tool | Description |
@@ -278,7 +281,7 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `color_palette` | Generate a color palette from a base color |
 | `color_shades` | Generate shades or tints from a base color |
 
-### Code (21 tools)
+### Code (22 tools)
 | Tool | Description |
 |------|-------------|
 | `format_sql` | Format a SQL query with proper indentation |
@@ -302,6 +305,7 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `parse_commit_trailers` | Parse a commit message's trailer block (Co-authored-by, Signed-off-by, Fixes, Reviewed-by, etc.) per git's RFC 822-style trailer convention, returning each trailer's key/value plus the body with the trailer block removed |
 | `extract_markdown_footnotes` | Extract every Markdown-Extra-style footnote reference and definition from a document, flagging references with no matching definition and definitions that are never referenced |
 | `validate_aria` | Parse an HTML snippet and check every role and aria-* attribute against a curated table of WAI-ARIA 1.2 roles: unknown role names, an aria-* attribute not permitted on the given role, and a widget role missing its required aria-* state |
+| `parse_connection_string` | Parse a database connection URI (postgres, mysql, mongodb, redis, amqp, and similar) into its scheme, credentials, hosts, database, and query parameters |
 
 ### Data (16 tools)
 | Tool | Description |
@@ -337,7 +341,7 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `unicode_inspect` | Inspect Unicode code points of a string |
 | `optimize_svg` | Optimize and minify an SVG string |
 
-### AI / Agent (28 tools)
+### AI / Agent (29 tools)
 | Tool | Description |
 |------|-------------|
 | `estimate_tokens` | Estimate token count and cost for an LLM prompt |
@@ -368,6 +372,7 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `vector_similarity` | Cosine similarity, dot product, and Euclidean / Manhattan distance between two numeric vectors |
 | `format_few_shot_examples` | Format input/output example pairs into a numbered, XML-tagged, or delimiter-separated few-shot prompt template |
 | `lint_tool_schema` | Lint an OpenAI, Anthropic, or MCP tool/function-calling definition for missing descriptions, invalid names, empty enums, and required/properties mismatches |
+| `calculate_retry_backoff_schedule` | Compute the full sequence of delays an exponential-backoff retry policy would actually produce, given a base delay, multiplier, and max retry count, optionally capped at a max delay and with full/equal jitter ranges |
 
 ### Image (4 tools)
 | Tool | Description |

package/dist/index.js

@@ -1243,6 +1243,64 @@ server.tool("vector_similarity", "Compute cosine similarity, dot product, Euclid
   if ("error" in result) return errText(result);
   return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
 });
+function _calculateRetryBackoffSchedule(input) {
+  const { baseDelayMs, multiplier, maxRetries, maxDelayMs, jitter = "none" } = input;
+  if (!Number.isFinite(baseDelayMs) || baseDelayMs <= 0) {
+    return { error: "baseDelayMs must be a finite number greater than zero" };
+  }
+  if (!Number.isFinite(multiplier) || multiplier < 1) {
+    return { error: "multiplier must be a finite number of at least 1" };
+  }
+  if (!Number.isInteger(maxRetries) || maxRetries < 1 || maxRetries > 50) {
+    return { error: "maxRetries must be a whole number between 1 and 50" };
+  }
+  if (maxDelayMs !== void 0 && (!Number.isFinite(maxDelayMs) || maxDelayMs <= 0)) {
+    return { error: "maxDelayMs must be a finite number greater than zero when provided" };
+  }
+  if (jitter !== "none" && jitter !== "full" && jitter !== "equal") {
+    return { error: "jitter must be one of 'none', 'full', or 'equal'" };
+  }
+  const round0 = (n) => Math.round(n);
+  const attempts = [];
+  let totalBestCaseMs = 0;
+  let totalWorstCaseMs = 0;
+  for (let i = 1; i <= maxRetries; i++) {
+    let nominal = baseDelayMs * Math.pow(multiplier, i - 1);
+    if (maxDelayMs !== void 0) nominal = Math.min(nominal, maxDelayMs);
+    let minDelay;
+    let maxDelay;
+    if (jitter === "full") {
+      minDelay = 0;
+      maxDelay = nominal;
+    } else if (jitter === "equal") {
+      minDelay = nominal / 2;
+      maxDelay = nominal;
+    } else {
+      minDelay = nominal;
+      maxDelay = nominal;
+    }
+    attempts.push({ attempt: i, nominalDelayMs: round0(nominal), minDelayMs: round0(minDelay), maxDelayMs: round0(maxDelay) });
+    totalBestCaseMs += minDelay;
+    totalWorstCaseMs += maxDelay;
+  }
+  return { attempts, jitter, totalBestCaseMs: round0(totalBestCaseMs), totalWorstCaseMs: round0(totalWorstCaseMs) };
+}
+server.tool(
+  "calculate_retry_backoff_schedule",
+  "Compute the full sequence of delays an exponential-backoff retry policy would actually produce, given a base delay, multiplier, and max retry count, optionally capped at a max delay and with full/equal jitter ranges, plus the total best-case and worst-case wait across all retries. Distinct from build_retry_after_header, which builds a single HTTP Retry-After response header.",
+  {
+    baseDelayMs: z.number().describe("Delay before the first retry, in milliseconds"),
+    multiplier: z.number().describe("Factor the delay is multiplied by after each attempt"),
+    maxRetries: z.number().int().describe("Number of retry attempts to compute (1-50)"),
+    maxDelayMs: z.number().optional().describe("Optional cap applied to every computed delay"),
+    jitter: z.enum(["none", "full", "equal"]).default("none").describe('"full" randomizes uniformly between 0 and the nominal delay; "equal" randomizes between half the nominal delay and the full value')
+  },
+  async ({ baseDelayMs, multiplier, maxRetries, maxDelayMs, jitter }) => {
+    const result = _calculateRetryBackoffSchedule({ baseDelayMs, multiplier, maxRetries, maxDelayMs, jitter });
+    if ("error" in result) return errText(result);
+    return text(JSON.stringify(result, null, 2));
+  }
+);
 server.tool("summarize_for_llm", "Extractive summarization: pick key sentences to fit a token budget.", { text: z.string(), max_tokens: z.number().int().min(10).default(200), strategy: z.enum(["extractive", "first", "last"]).default("extractive") }, async ({ text: text2, max_tokens, strategy }) => {
   return { content: [{ type: "text", text: JSON.stringify(summarizeForLlm(text2, max_tokens, strategy), null, 2) }] };
 });
@@ -2259,6 +2317,64 @@ server.tool(
     return text(JSON.stringify(result, null, 2));
   }
 );
+var _REAL_RATE_FIELDS_MCP = ["nominalRatePercent", "inflationRatePercent", "realRatePercent"];
+function _calculateRealRateOfReturn(input) {
+  const provided = (v) => typeof v === "number" && Number.isFinite(v);
+  const given = _REAL_RATE_FIELDS_MCP.filter((f) => provided(input[f]));
+  if (given.length !== 2) {
+    return { error: `Provide exactly two of nominalRatePercent, inflationRatePercent, realRatePercent (got ${given.length})` };
+  }
+  for (const f of given) {
+    const v = input[f];
+    if (v <= -100) return { error: `${f} must be greater than -100` };
+  }
+  const has = (f) => given.includes(f);
+  const nominal0 = input.nominalRatePercent;
+  const inflation0 = input.inflationRatePercent;
+  const real0 = input.realRatePercent;
+  let nominalRatePercent;
+  let inflationRatePercent;
+  let realRatePercent;
+  let solvedFor;
+  if (has("nominalRatePercent") && has("inflationRatePercent")) {
+    nominalRatePercent = nominal0;
+    inflationRatePercent = inflation0;
+    realRatePercent = ((1 + nominal0 / 100) / (1 + inflation0 / 100) - 1) * 100;
+    solvedFor = "realRatePercent";
+  } else if (has("realRatePercent") && has("inflationRatePercent")) {
+    realRatePercent = real0;
+    inflationRatePercent = inflation0;
+    nominalRatePercent = ((1 + real0 / 100) * (1 + inflation0 / 100) - 1) * 100;
+    solvedFor = "nominalRatePercent";
+  } else {
+    nominalRatePercent = nominal0;
+    realRatePercent = real0;
+    inflationRatePercent = ((1 + nominal0 / 100) / (1 + real0 / 100) - 1) * 100;
+    solvedFor = "inflationRatePercent";
+  }
+  const round4 = (n) => Math.round(n * 1e4) / 1e4;
+  return {
+    nominalRatePercent: round4(nominalRatePercent),
+    inflationRatePercent: round4(inflationRatePercent),
+    realRatePercent: round4(realRatePercent),
+    given,
+    solvedFor
+  };
+}
+server.tool(
+  "calculate_real_rate_of_return",
+  "Apply the Fisher equation, (1 + nominal) = (1 + real) * (1 + inflation), to solve for whichever of the nominal rate, inflation rate, or inflation-adjusted real rate is missing, given exactly two of the three (all as percents).",
+  {
+    nominalRatePercent: z.number().optional().describe("Nominal (stated) annual rate as a percent"),
+    inflationRatePercent: z.number().optional().describe("Annual inflation rate as a percent"),
+    realRatePercent: z.number().optional().describe("Inflation-adjusted real rate as a percent")
+  },
+  async ({ nominalRatePercent, inflationRatePercent, realRatePercent }) => {
+    const result = _calculateRealRateOfReturn({ nominalRatePercent, inflationRatePercent, realRatePercent });
+    if ("error" in result) return errText(result);
+    return text(JSON.stringify(result, null, 2));
+  }
+);
 function _computeIsbn10CheckDigitMcp(dataDigits) {
   let sum = 0;
   for (let i = 0; i < 9; i++) sum += dataDigits[i] * (10 - i);
@@ -12330,5 +12446,303 @@ server.tool(
     return text(JSON.stringify(result, null, 2));
   }
 );
+function _escapeJsonPointerTokenMcp(token) {
+  return token.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+function _unescapeJsonPointerTokenMcp(token) {
+  return token.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+function _parseJsonPointerTokensMcp(pointer) {
+  if (pointer === "") return [];
+  if (!pointer.startsWith("/")) throw new Error(`Invalid JSON Pointer "${pointer}": must start with "/"`);
+  return pointer.slice(1).split("/").map(_unescapeJsonPointerTokenMcp);
+}
+function _isJsonPatchObjectMcp(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function _jsonPatchDeepEqualMcp(a, b) {
+  if (a === b) return true;
+  if (typeof a !== typeof b) return false;
+  if (Array.isArray(a) || Array.isArray(b)) {
+    if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
+    return a.every((v, i) => _jsonPatchDeepEqualMcp(v, b[i]));
+  }
+  if (_isJsonPatchObjectMcp(a) && _isJsonPatchObjectMcp(b)) {
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    if (aKeys.length !== bKeys.length) return false;
+    return aKeys.every((k) => k in b && _jsonPatchDeepEqualMcp(a[k], b[k]));
+  }
+  return false;
+}
+function _jsonPatchGetByTokensMcp(doc, tokens) {
+  let current = doc;
+  for (const token of tokens) {
+    if (Array.isArray(current)) {
+      const index = token === "-" ? current.length - 1 : parseInt(token, 10);
+      if (!Number.isInteger(index) || index < 0 || index >= current.length) return { found: false, value: void 0 };
+      current = current[index];
+    } else if (_isJsonPatchObjectMcp(current)) {
+      if (!(token in current)) return { found: false, value: void 0 };
+      current = current[token];
+    } else {
+      return { found: false, value: void 0 };
+    }
+  }
+  return { found: true, value: current };
+}
+function _diffJsonPatchMcp(a, b) {
+  const ops = [];
+  _diffJsonPatchValueMcp(a, b, "", ops);
+  return ops;
+}
+function _diffJsonPatchValueMcp(a, b, path, ops) {
+  if (_jsonPatchDeepEqualMcp(a, b)) return;
+  if (_isJsonPatchObjectMcp(a) && _isJsonPatchObjectMcp(b)) {
+    for (const key of Object.keys(a)) {
+      if (!(key in b)) ops.push({ op: "remove", path: `${path}/${_escapeJsonPointerTokenMcp(key)}` });
+    }
+    for (const key of Object.keys(b)) {
+      const childPath = `${path}/${_escapeJsonPointerTokenMcp(key)}`;
+      if (!(key in a)) {
+        ops.push({ op: "add", path: childPath, value: b[key] });
+      } else {
+        _diffJsonPatchValueMcp(a[key], b[key], childPath, ops);
+      }
+    }
+    return;
+  }
+  if (Array.isArray(a) && Array.isArray(b)) {
+    const minLen = Math.min(a.length, b.length);
+    for (let i = 0; i < minLen; i++) _diffJsonPatchValueMcp(a[i], b[i], `${path}/${i}`, ops);
+    if (b.length > a.length) {
+      for (let i = a.length; i < b.length; i++) ops.push({ op: "add", path: `${path}/${i}`, value: b[i] });
+    } else if (a.length > b.length) {
+      for (let i = a.length - 1; i >= b.length; i--) ops.push({ op: "remove", path: `${path}/${i}` });
+    }
+    return;
+  }
+  ops.push({ op: "replace", path, value: b });
+}
+function _applyJsonPatchMcp(target, operations) {
+  let doc = JSON.parse(JSON.stringify(target ?? null));
+  const applyOne = (op, index) => {
+    if (op.path === void 0 || op.op === void 0) return `Operation ${index}: missing "op" or "path"`;
+    let tokens;
+    try {
+      tokens = _parseJsonPointerTokensMcp(op.path);
+    } catch (e) {
+      return `Operation ${index}: ${e.message}`;
+    }
+    const setAt = (tgtTokens, value) => {
+      if (tgtTokens.length === 0) {
+        doc = value;
+        return null;
+      }
+      const parentTokens = tgtTokens.slice(0, -1);
+      const lastToken = tgtTokens[tgtTokens.length - 1];
+      const { found, value: parent } = _jsonPatchGetByTokensMcp(doc, parentTokens);
+      if (!found) return `Operation ${index}: path "${op.path}" has no parent`;
+      if (Array.isArray(parent)) {
+        const idx = lastToken === "-" ? parent.length : parseInt(lastToken, 10);
+        if (!Number.isInteger(idx) || idx < 0 || idx > parent.length) return `Operation ${index}: array index "${lastToken}" out of bounds`;
+        parent.splice(idx, 0, value);
+      } else if (_isJsonPatchObjectMcp(parent)) {
+        parent[lastToken] = value;
+      } else {
+        return `Operation ${index}: cannot add into a non-object, non-array value at "${op.path}"`;
+      }
+      return null;
+    };
+    const replaceAt = (tgtTokens, value) => {
+      if (tgtTokens.length === 0) {
+        doc = value;
+        return null;
+      }
+      const parentTokens = tgtTokens.slice(0, -1);
+      const lastToken = tgtTokens[tgtTokens.length - 1];
+      const { found, value: parent } = _jsonPatchGetByTokensMcp(doc, parentTokens);
+      if (!found) return `Operation ${index}: path "${op.path}" has no parent`;
+      if (Array.isArray(parent)) {
+        const idx = lastToken === "-" ? parent.length - 1 : parseInt(lastToken, 10);
+        if (!Number.isInteger(idx) || idx < 0 || idx >= parent.length) return `Operation ${index}: array index "${lastToken}" out of bounds`;
+        parent[idx] = value;
+      } else if (_isJsonPatchObjectMcp(parent)) {
+        if (!(lastToken in parent)) return `Operation ${index}: path "${op.path}" does not exist`;
+        parent[lastToken] = value;
+      } else {
+        return `Operation ${index}: cannot replace into a non-object, non-array value at "${op.path}"`;
+      }
+      return null;
+    };
+    const removeAt = (tgtTokens) => {
+      if (tgtTokens.length === 0) return { error: `Operation ${index}: cannot remove the whole document (path "")` };
+      const parentTokens = tgtTokens.slice(0, -1);
+      const lastToken = tgtTokens[tgtTokens.length - 1];
+      const { found, value: parent } = _jsonPatchGetByTokensMcp(doc, parentTokens);
+      if (!found) return { error: `Operation ${index}: path "${op.path}" has no parent` };
+      if (Array.isArray(parent)) {
+        const idx = lastToken === "-" ? parent.length - 1 : parseInt(lastToken, 10);
+        if (!Number.isInteger(idx) || idx < 0 || idx >= parent.length) return { error: `Operation ${index}: array index "${lastToken}" out of bounds` };
+        const [removed] = parent.splice(idx, 1);
+        return { error: null, removed };
+      }
+      if (_isJsonPatchObjectMcp(parent)) {
+        if (!(lastToken in parent)) return { error: `Operation ${index}: path "${op.path}" does not exist` };
+        const removed = parent[lastToken];
+        delete parent[lastToken];
+        return { error: null, removed };
+      }
+      return { error: `Operation ${index}: cannot remove from a non-object, non-array value at "${op.path}"` };
+    };
+    switch (op.op) {
+      case "add":
+        return setAt(tokens, op.value);
+      case "replace":
+        return replaceAt(tokens, op.value);
+      case "remove":
+        return removeAt(tokens).error;
+      case "test": {
+        const { found, value } = _jsonPatchGetByTokensMcp(doc, tokens);
+        if (!found) return `Operation ${index}: path "${op.path}" does not exist`;
+        if (!_jsonPatchDeepEqualMcp(value, op.value)) return `Operation ${index}: test failed at "${op.path}"`;
+        return null;
+      }
+      case "move": {
+        if (!op.from) return `Operation ${index}: "move" requires "from"`;
+        let fromTokens;
+        try {
+          fromTokens = _parseJsonPointerTokensMcp(op.from);
+        } catch (e) {
+          return `Operation ${index}: ${e.message}`;
+        }
+        const removal = removeAt(fromTokens);
+        if (removal.error) return removal.error;
+        return setAt(tokens, removal.removed);
+      }
+      case "copy": {
+        if (!op.from) return `Operation ${index}: "copy" requires "from"`;
+        let fromTokens;
+        try {
+          fromTokens = _parseJsonPointerTokensMcp(op.from);
+        } catch (e) {
+          return `Operation ${index}: ${e.message}`;
+        }
+        const { found, value } = _jsonPatchGetByTokensMcp(doc, fromTokens);
+        if (!found) return `Operation ${index}: "from" path "${op.from}" does not exist`;
+        return setAt(tokens, JSON.parse(JSON.stringify(value)));
+      }
+      default:
+        return `Operation ${index}: unknown op "${op.op}"`;
+    }
+  };
+  for (let i = 0; i < operations.length; i++) {
+    const err = applyOne(operations[i], i);
+    if (err) return { error: err };
+  }
+  return { result: doc };
+}
+server.tool(
+  "diff_json_patch",
+  "Compare two JSON documents and generate an RFC 6902 JSON Patch (a list of add/remove/replace operations) that transforms the first into the second. Object keys produce add/remove/replace; arrays are compared position by position (not a minimal edit-distance diff, so a reordering is not detected as a move).",
+  {
+    a: z.string().describe("The source JSON document, as a JSON string"),
+    b: z.string().describe("The target JSON document, as a JSON string")
+  },
+  async ({ a, b }) => {
+    let aParsed;
+    try {
+      aParsed = JSON.parse(a);
+    } catch {
+      return errText({ error: "First document is not valid JSON" });
+    }
+    let bParsed;
+    try {
+      bParsed = JSON.parse(b);
+    } catch {
+      return errText({ error: "Second document is not valid JSON" });
+    }
+    return text(JSON.stringify({ patch: _diffJsonPatchMcp(aParsed, bParsed) }, null, 2));
+  }
+);
+server.tool(
+  "apply_json_patch",
+  "Apply a sequence of RFC 6902 JSON Patch operations (add, remove, replace, move, copy, test) to a target JSON document and return the result, or an error naming the first operation that failed and why.",
+  {
+    target: z.string().describe("The document to patch, as a JSON string"),
+    patch: z.string().describe("The RFC 6902 JSON Patch operation array, as a JSON string")
+  },
+  async ({ target, patch }) => {
+    let targetParsed;
+    try {
+      targetParsed = JSON.parse(target);
+    } catch {
+      return errText({ error: "Target is not valid JSON" });
+    }
+    let operations;
+    try {
+      operations = JSON.parse(patch);
+    } catch {
+      return errText({ error: "Patch is not valid JSON" });
+    }
+    if (!Array.isArray(operations)) return errText({ error: "Patch must be a JSON array of RFC 6902 operations" });
+    const result = _applyJsonPatchMcp(targetParsed, operations);
+    if ("error" in result) return errText(result);
+    return text(JSON.stringify(result, null, 2));
+  }
+);
+var _CONNECTION_STRING_RE_MCP = /^([a-zA-Z][a-zA-Z0-9+.-]*):\/\/(?:([^@/?#]*)@)?([^/?#]*)(?:\/([^?#]*))?(?:\?([^#]*))?$/;
+function _parseConnectionHostMcp(segment) {
+  const ipv6Match = segment.match(/^\[([^\]]+)\](?::(\d+))?$/);
+  if (ipv6Match) return { host: ipv6Match[1], port: ipv6Match[2] ? parseInt(ipv6Match[2], 10) : null };
+  const lastColon = segment.lastIndexOf(":");
+  if (lastColon === -1) return { host: segment, port: null };
+  const portPart = segment.slice(lastColon + 1);
+  if (!/^\d+$/.test(portPart)) return { host: segment, port: null };
+  return { host: segment.slice(0, lastColon), port: parseInt(portPart, 10) };
+}
+function _parseConnectionStringMcp(input) {
+  if (!input || !input.trim()) return { error: "Connection string is empty" };
+  const trimmed = input.trim();
+  const match = trimmed.match(_CONNECTION_STRING_RE_MCP);
+  if (!match) return { error: "Not a valid scheme://[user[:password]@]host[,host2][/database][?params] connection string" };
+  const [, scheme, userinfo, hostPart, databasePart, queryPart] = match;
+  let user = null;
+  let password = null;
+  if (userinfo) {
+    const sepIndex = userinfo.indexOf(":");
+    if (sepIndex === -1) {
+      user = decodeURIComponent(userinfo);
+    } else {
+      user = decodeURIComponent(userinfo.slice(0, sepIndex));
+      password = decodeURIComponent(userinfo.slice(sepIndex + 1));
+    }
+  }
+  const hosts = hostPart ? hostPart.split(",").filter(Boolean).map(_parseConnectionHostMcp) : [];
+  const database = databasePart ? decodeURIComponent(databasePart) : null;
+  const params = {};
+  if (queryPart) {
+    for (const pair of queryPart.split("&")) {
+      if (!pair) continue;
+      const eqIndex = pair.indexOf("=");
+      const key = eqIndex === -1 ? pair : pair.slice(0, eqIndex);
+      const value = eqIndex === -1 ? "" : pair.slice(eqIndex + 1);
+      params[decodeURIComponent(key)] = decodeURIComponent(value);
+    }
+  }
+  return { scheme, user, password, hosts, database, params };
+}
+server.tool(
+  "parse_connection_string",
+  "Parse a database connection URI (postgres://, mysql://, mongodb://, mongodb+srv://, redis://, amqp://, and similar generic scheme:// connection strings) into its scheme, credentials, one or more hosts (mongodb-style comma-separated host lists included), database/path, and query parameters. Pure offline parse: never connects, resolves DNS, or validates the driver/scheme combination.",
+  {
+    connectionString: z.string().describe("The database connection string to parse")
+  },
+  async ({ connectionString }) => {
+    const result = _parseConnectionStringMcp(connectionString);
+    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.78.0",
+  "version": "0.80.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",