@utilix-tech/mcp 0.89.0 → 0.91.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.91.0
+- Add `find_yaml_duplicate_keys` tool: report every mapping key that collides with an earlier key in the same YAML mapping scope, with the line and column of each repeated occurrence.
+- Add `detect_negative_amortization` tool: check whether a proposed loan payment covers the interest accruing each period and, if not, project the shortfall and the resulting balance growth, optionally flagging the month a balance cap is crossed.
+
+## 0.90.0
+- Add `intersect_semver_ranges` tool: determine whether two semver ranges overlap and, if so, the intersecting range, supporting the same caret/tilde/comparison-operator/exact-version syntax as the semver tool.
+- Add `check_markdown_internal_links` tool: scan a Markdown document's ATX headings, compute GitHub-style anchor slugs, and flag `[text](#slug)` links that point at a heading that doesn't exist.
+
 ## 0.89.0
 - Add `check_acronym_expansion` tool: scan text for acronyms and flag any used before being expanded on first mention, recognizing both the "full term (ACRONYM)" and "ACRONYM (full term)" conventions, with acronyms never expanded anywhere reported separately.
 

package/README.md

@@ -1,6 +1,6 @@
 # @utilix-tech/mcp
 
-MCP server exposing 270 developer utility tools to Claude, Cursor, VS Code Copilot, and any [Model Context Protocol](https://modelcontextprotocol.io) compatible AI assistant.
+MCP server exposing 274 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.
 
@@ -169,7 +169,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 (48 tools)
+### Units (51 tools)
 | Tool | Description |
 |------|-------------|
 | `convert_bytes` | Convert between B, KB, MB, GB, TB, KiB, MiB, GiB, TiB |
@@ -220,7 +220,9 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `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 |
 | `calculate_credit_card_minimum_payment` | Simulate paying only the minimum payment on a revolving credit card balance, where the minimum is the larger of a percent of the balance or a fixed dollar floor, and report months/years to payoff, total interest, and total paid |
+| `detect_negative_amortization` | Given a loan's balance, annual rate, and a proposed monthly payment, check whether that payment covers the interest accruing each period; if not, report the shortfall and project how the balance grows instead of shrinking |
 | `calculate_sales_commission` | Compute a sales commission from either a flat percent rate applied to the whole sale amount, or a tiered (marginal) rate structure where each tier applies only to the slice of sales within it, plus an optional base salary added to the total payout |
+| `intersect_semver_ranges` | Determine whether two semver ranges overlap and, if so, the intersecting range, supporting the same caret/tilde/comparison-operator/exact-version syntax as the semver tool |
 
 ### API / Network (51 tools)
 | Tool | Description |
@@ -320,11 +322,12 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `extract_markdown_link_references` | Extract every reference-style Markdown link ([text][ref], [text][], ![alt][ref]) and match it against its [ref]: url definition, flagging unresolved references and unused definitions |
 | `build_character_class` | Assemble a [...] regex character class from named building blocks (lowercase, uppercase, digits, whitespace), custom ranges, and literal custom characters, with optional negation |
 
-### Data (18 tools)
+### Data (20 tools)
 | Tool | Description |
 |------|-------------|
 | `validate_yaml` | Validate YAML syntax |
 | `resolve_yaml_anchors` | Expand YAML anchors, aliases, and merge keys inline, and list which anchors were referenced vs. left unused |
+| `find_yaml_duplicate_keys` | Parse a YAML document and report every mapping key that collides with an earlier key in the same mapping scope, with the line and column of each repeated occurrence |
 | `toml_to_json` | Convert TOML to JSON |
 | `xml_to_json` | Convert XML to JSON |
 | `parse_csv` | Parse a CSV string and return the data as JSON |
@@ -341,6 +344,7 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `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 |
 | `align_markdown_tables` | Reformat every GitHub-Flavored-Markdown pipe table in a document so each column's pipes line up visually, preserving left/center/right alignment markers |
 | `validate_markdown_heading_hierarchy` | Scan a Markdown document's ATX headings and flag heading-structure issues: skipped levels, multiple H1s, empty headings, duplicate headings, and a document that doesn't start at H1 |
+| `check_markdown_internal_links` | Scan a Markdown document's ATX headings, compute the GitHub-style anchor slug for each, and check every [text](#slug) internal link against them, flagging links that point at a heading that doesn't exist |
 
 ### CSS (2 tools)
 | Tool | Description |

package/dist/index.js

@@ -803,6 +803,62 @@ server.tool(
     return text(JSON.stringify(result, null, 2));
   }
 );
+function _matchYamlKeyMcp(lineText) {
+  const dashMatch = /^(\s*)((?:-\s+)*)/.exec(lineText);
+  const basePrefix = (dashMatch?.[1].length ?? 0) + (dashMatch?.[2].length ?? 0);
+  const rest = lineText.slice(basePrefix);
+  const quoted = /^(["'])((?:\\.|(?!\1).)*)\1(\s*:(?:\s|$))/.exec(rest);
+  if (quoted) {
+    return { key: quoted[2], prefixLength: basePrefix, matchLength: quoted[1].length * 2 + quoted[2].length, quote: quoted[1] };
+  }
+  const plain = /^([^\s:#][^:]*?)(\s*:(?:\s|$))/.exec(rest);
+  if (plain) {
+    return { key: plain[1], prefixLength: basePrefix, matchLength: plain[1].length, quote: null };
+  }
+  return null;
+}
+function _maskYamlKeyMcp(lineText, match, n) {
+  const suffix = `__dup${n}__`;
+  const before = lineText.slice(0, match.prefixLength);
+  const keyPart = lineText.slice(match.prefixLength, match.prefixLength + match.matchLength);
+  const after = lineText.slice(match.prefixLength + match.matchLength);
+  if (match.quote) {
+    return `${before}${keyPart.slice(0, -1)}${suffix}${match.quote}${after}`;
+  }
+  return `${before}${keyPart}${suffix}${after}`;
+}
+function _findYamlDuplicateKeys(yamlText) {
+  if (!yamlText || !yamlText.trim()) return { error: "Input is empty" };
+  const lines = yamlText.split("\n");
+  const duplicates = [];
+  for (let pass = 0; pass < 500; pass++) {
+    try {
+      yaml.load(lines.join("\n"));
+      return { duplicateCount: duplicates.length, duplicates };
+    } catch (e) {
+      const err = e;
+      const reason = err.reason ?? err.message;
+      if (!/duplicated mapping key/i.test(reason)) return { error: reason };
+      const lineIdx = err.mark?.line;
+      if (lineIdx == null || lineIdx < 0 || lineIdx >= lines.length) return { error: reason };
+      const match = _matchYamlKeyMcp(lines[lineIdx]);
+      if (!match) return { error: reason };
+      duplicates.push({ key: match.key, line: lineIdx + 1, column: match.prefixLength + 1 });
+      lines[lineIdx] = _maskYamlKeyMcp(lines[lineIdx], match, duplicates.length);
+    }
+  }
+  return { error: "Too many duplicate keys to fully enumerate" };
+}
+server.tool(
+  "find_yaml_duplicate_keys",
+  "Parse a YAML document and report every mapping key that collides with an earlier key in the same mapping scope, with the line and column of each repeated occurrence.",
+  { yaml: z.string().describe("The YAML document to check") },
+  async ({ yaml: yamlText }) => {
+    const result = _findYamlDuplicateKeys(yamlText);
+    if ("error" in result) return errText(result);
+    return text(JSON.stringify(result, null, 2));
+  }
+);
 server.tool(
   "toml_to_json",
   "Convert a TOML string to JSON.",
@@ -12370,6 +12426,73 @@ server.tool(
     return text(JSON.stringify(result, null, 2));
   }
 );
+var _NEGATIVE_AMORTIZATION_MAX_PROJECTION_MONTHS_MCP = 600;
+function _detectNegativeAmortizationMcp(principal, annualRatePercent, monthlyPayment, projectionMonths, capPercent) {
+  if (!Number.isFinite(principal) || principal <= 0) {
+    return { error: "principal must be a positive number" };
+  }
+  if (!Number.isFinite(annualRatePercent) || annualRatePercent < 0) {
+    return { error: "annualRatePercent must be zero or a positive number" };
+  }
+  if (!Number.isFinite(monthlyPayment) || monthlyPayment < 0) {
+    return { error: "monthlyPayment must be zero or a positive number" };
+  }
+  if (projectionMonths !== void 0 && (!Number.isInteger(projectionMonths) || projectionMonths <= 0)) {
+    return { error: "projectionMonths must be a positive whole number" };
+  }
+  if (capPercent !== void 0 && (!Number.isFinite(capPercent) || capPercent <= 0)) {
+    return { error: "capPercent must be a positive number" };
+  }
+  const monthlyRate = annualRatePercent / 100 / 12;
+  const monthlyInterest = principal * monthlyRate;
+  const shortfall = Math.max(0, _roundMoneyPrepaymentPenaltyMcp(monthlyInterest - monthlyPayment));
+  const isNegativeAmortizing = monthlyPayment < monthlyInterest;
+  const months = Math.min(projectionMonths ?? 12, _NEGATIVE_AMORTIZATION_MAX_PROJECTION_MONTHS_MCP);
+  const capBalance = capPercent != null ? principal * (capPercent / 100) : null;
+  const projection = [];
+  let balance = principal;
+  let capCrossedMonth = null;
+  for (let month = 1; month <= months; month++) {
+    const interest = balance * monthlyRate;
+    const endingBalance = balance + interest - monthlyPayment;
+    projection.push({
+      month,
+      startingBalance: _roundMoneyPrepaymentPenaltyMcp(balance),
+      interest: _roundMoneyPrepaymentPenaltyMcp(interest),
+      payment: _roundMoneyPrepaymentPenaltyMcp(monthlyPayment),
+      endingBalance: _roundMoneyPrepaymentPenaltyMcp(Math.max(endingBalance, 0))
+    });
+    if (capBalance != null && capCrossedMonth == null && endingBalance >= capBalance) {
+      capCrossedMonth = month;
+    }
+    balance = endingBalance;
+    if (balance <= 0) break;
+  }
+  return {
+    monthlyInterest: _roundMoneyPrepaymentPenaltyMcp(monthlyInterest),
+    isNegativeAmortizing,
+    shortfall,
+    breakEvenPayment: _roundMoneyPrepaymentPenaltyMcp(monthlyInterest),
+    projection,
+    capCrossedMonth
+  };
+}
+server.tool(
+  "detect_negative_amortization",
+  "Given a loan's balance, annual rate, and a proposed monthly payment, check whether that payment covers the interest accruing each period. If not, report the shortfall and project how the balance grows instead of shrinking.",
+  {
+    principal: z.number().describe("The loan's current balance"),
+    annualRatePercent: z.number().describe("The loan's annual interest rate as a percent"),
+    monthlyPayment: z.number().describe("The proposed monthly payment"),
+    projectionMonths: z.number().optional().describe("How many months to project the balance (default 12, max 600)"),
+    capPercent: z.number().optional().describe("Optional balance cap as a percent of the original principal (e.g. 110 for a 110% cap)")
+  },
+  async ({ principal, annualRatePercent, monthlyPayment, projectionMonths, capPercent }) => {
+    const result = _detectNegativeAmortizationMcp(principal, annualRatePercent, monthlyPayment, projectionMonths, capPercent);
+    if ("error" in result) return errText(result);
+    return text(JSON.stringify(result, null, 2));
+  }
+);
 var _ARIA_GLOBAL_ATTRS_MCP = /* @__PURE__ */ new Set([
   "aria-atomic",
   "aria-busy",
@@ -14189,5 +14312,253 @@ server.tool(
     return text(JSON.stringify(result, null, 2));
   }
 );
+var _SEMVER_RANGE_RE_MCP = /^v?(\d+)\.(\d+)\.(\d+)(?:-([a-zA-Z0-9._-]+?))?(?:\+([a-zA-Z0-9._-]+))?$/;
+function _parseSemverRangeMcp(version) {
+  const m = version.trim().match(_SEMVER_RANGE_RE_MCP);
+  if (!m) return { error: `Invalid semver: '${version}'` };
+  const result = { major: parseInt(m[1], 10), minor: parseInt(m[2], 10), patch: parseInt(m[3], 10) };
+  if (m[4] !== void 0) result.prerelease = m[4];
+  if (m[5] !== void 0) result.build = m[5];
+  return result;
+}
+function _compareSemverPrereleaseMcp(a, b) {
+  if (a === void 0 && b === void 0) return 0;
+  if (a === void 0) return 1;
+  if (b === void 0) return -1;
+  const aParts = a.split(".");
+  const bParts = b.split(".");
+  const len = Math.max(aParts.length, bParts.length);
+  for (let i = 0; i < len; i++) {
+    const ap = aParts[i];
+    const bp = bParts[i];
+    if (ap === void 0) return -1;
+    if (bp === void 0) return 1;
+    const aNum = parseInt(ap, 10);
+    const bNum = parseInt(bp, 10);
+    const aIsNum = !isNaN(aNum) && String(aNum) === ap;
+    const bIsNum = !isNaN(bNum) && String(bNum) === bp;
+    if (aIsNum && bIsNum) {
+      if (aNum < bNum) return -1;
+      if (aNum > bNum) return 1;
+    } else if (aIsNum) {
+      return -1;
+    } else if (bIsNum) {
+      return 1;
+    } else {
+      if (ap < bp) return -1;
+      if (ap > bp) return 1;
+    }
+  }
+  return 0;
+}
+function _compareSemverRangeVersionsMcp(a, b) {
+  if (a.major !== b.major) return a.major < b.major ? -1 : 1;
+  if (a.minor !== b.minor) return a.minor < b.minor ? -1 : 1;
+  if (a.patch !== b.patch) return a.patch < b.patch ? -1 : 1;
+  return _compareSemverPrereleaseMcp(a.prerelease, b.prerelease);
+}
+function _tightenSemverLowerMcp(a, b) {
+  if (a.value === null) return b;
+  if (b.value === null) return a;
+  const cmp = _compareSemverRangeVersionsMcp(a.value, b.value);
+  if (cmp > 0) return a;
+  if (cmp < 0) return b;
+  return { value: a.value, inclusive: a.inclusive && b.inclusive };
+}
+function _tightenSemverUpperMcp(a, b) {
+  if (a.value === null) return b;
+  if (b.value === null) return a;
+  const cmp = _compareSemverRangeVersionsMcp(a.value, b.value);
+  if (cmp < 0) return a;
+  if (cmp > 0) return b;
+  return { value: a.value, inclusive: a.inclusive && b.inclusive };
+}
+function _isValidSemverIntervalMcp(lower, upper) {
+  if (lower.value === null || upper.value === null) return true;
+  const cmp = _compareSemverRangeVersionsMcp(lower.value, upper.value);
+  if (cmp < 0) return true;
+  if (cmp > 0) return false;
+  return lower.inclusive && upper.inclusive;
+}
+function _formatSemverRangeVersionMcp(v) {
+  let s = `${v.major}.${v.minor}.${v.patch}`;
+  if (v.prerelease) s += `-${v.prerelease}`;
+  if (v.build) s += `+${v.build}`;
+  return s;
+}
+function _semverIntervalToRangeStringMcp(interval) {
+  const { lower, upper } = interval;
+  if (lower.value === null && upper.value === null) return "*";
+  if (lower.value !== null && upper.value !== null) {
+    const cmp = _compareSemverRangeVersionsMcp(lower.value, upper.value);
+    if (cmp === 0 && lower.inclusive && upper.inclusive) return _formatSemverRangeVersionMcp(lower.value);
+  }
+  const parts = [];
+  if (lower.value !== null) parts.push(`${lower.inclusive ? ">=" : ">"}${_formatSemverRangeVersionMcp(lower.value)}`);
+  if (upper.value !== null) parts.push(`${upper.inclusive ? "<=" : "<"}${_formatSemverRangeVersionMcp(upper.value)}`);
+  return parts.length ? parts.join(" ") : "*";
+}
+function _parseSemverSingleConstraintMcp(range) {
+  if (range === "*" || range === "") return { lower: { value: null, inclusive: true }, upper: { value: null, inclusive: true } };
+  const caretMatch = range.match(/^\^v?(\d+)\.(\d+)\.(\d+)(?:-([a-zA-Z0-9._-]+))?$/);
+  if (caretMatch) {
+    const major = parseInt(caretMatch[1], 10);
+    const minor = parseInt(caretMatch[2], 10);
+    const patch = parseInt(caretMatch[3], 10);
+    const pre = caretMatch[4];
+    const lowerVal = { major, minor, patch, prerelease: pre };
+    let upperVal;
+    if (major !== 0) upperVal = { major: major + 1, minor: 0, patch: 0 };
+    else if (minor !== 0) upperVal = { major: 0, minor: minor + 1, patch: 0 };
+    else upperVal = { major: 0, minor: 0, patch: patch + 1 };
+    return { lower: { value: lowerVal, inclusive: true }, upper: { value: upperVal, inclusive: false } };
+  }
+  const tildeMatch = range.match(/^~v?(\d+)\.(\d+)\.(\d+)(?:-([a-zA-Z0-9._-]+))?$/);
+  if (tildeMatch) {
+    const major = parseInt(tildeMatch[1], 10);
+    const minor = parseInt(tildeMatch[2], 10);
+    const patch = parseInt(tildeMatch[3], 10);
+    const pre = tildeMatch[4];
+    const lowerVal = { major, minor, patch, prerelease: pre };
+    const upperVal = { major, minor: minor + 1, patch: 0 };
+    return { lower: { value: lowerVal, inclusive: true }, upper: { value: upperVal, inclusive: false } };
+  }
+  const opMatch = range.match(/^(>=|<=|>|<|=)v?(.+)$/);
+  if (opMatch) {
+    const op = opMatch[1];
+    const parsed = _parseSemverRangeMcp(opMatch[2]);
+    if ("error" in parsed) return parsed;
+    if (op === ">=") return { lower: { value: parsed, inclusive: true }, upper: { value: null, inclusive: true } };
+    if (op === "<=") return { lower: { value: null, inclusive: true }, upper: { value: parsed, inclusive: true } };
+    if (op === ">") return { lower: { value: parsed, inclusive: false }, upper: { value: null, inclusive: true } };
+    if (op === "<") return { lower: { value: null, inclusive: true }, upper: { value: parsed, inclusive: false } };
+    return { lower: { value: parsed, inclusive: true }, upper: { value: parsed, inclusive: true } };
+  }
+  const plain = _parseSemverRangeMcp(range);
+  if (!("error" in plain)) return { lower: { value: plain, inclusive: true }, upper: { value: plain, inclusive: true } };
+  return { error: `Unsupported range: '${range}'` };
+}
+function _semverRangeToIntervalsMcp(range) {
+  const trimmed = range.trim();
+  if (trimmed === "") return [{ lower: { value: null, inclusive: true }, upper: { value: null, inclusive: true } }];
+  const orParts = trimmed.split("||").map((s) => s.trim());
+  const intervals = [];
+  for (const orPart of orParts) {
+    const andTokens = orPart.split(/\s+/).filter(Boolean);
+    let combined = { lower: { value: null, inclusive: true }, upper: { value: null, inclusive: true } };
+    for (const token of andTokens) {
+      const parsed = _parseSemverSingleConstraintMcp(token);
+      if ("error" in parsed) return parsed;
+      combined = { lower: _tightenSemverLowerMcp(combined.lower, parsed.lower), upper: _tightenSemverUpperMcp(combined.upper, parsed.upper) };
+    }
+    intervals.push(combined);
+  }
+  return intervals;
+}
+function _intersectSemverRangesMcp(rangeA, rangeB) {
+  const intervalsA = _semverRangeToIntervalsMcp(rangeA);
+  if (!Array.isArray(intervalsA)) return intervalsA;
+  const intervalsB = _semverRangeToIntervalsMcp(rangeB);
+  if (!Array.isArray(intervalsB)) return intervalsB;
+  const results = [];
+  for (const a of intervalsA) {
+    for (const b of intervalsB) {
+      const lower = _tightenSemverLowerMcp(a.lower, b.lower);
+      const upper = _tightenSemverUpperMcp(a.upper, b.upper);
+      if (_isValidSemverIntervalMcp(lower, upper)) results.push({ lower, upper });
+    }
+  }
+  if (results.length === 0) return { overlaps: false, intersection: null };
+  const formatted = Array.from(new Set(results.map(_semverIntervalToRangeStringMcp)));
+  return { overlaps: true, intersection: formatted.join(" || ") };
+}
+server.tool(
+  "intersect_semver_ranges",
+  "Determine whether two semver ranges overlap and, if so, the intersecting range. Supports the same caret/tilde/comparison-operator/exact-version syntax (combined with || or space-separated AND) as the semver tool.",
+  {
+    rangeA: z.string().describe('The first semver range, e.g. "^1.2.0"'),
+    rangeB: z.string().describe('The second semver range, e.g. ">=1.5.0 <2.0.0"')
+  },
+  async ({ rangeA, rangeB }) => {
+    const result = _intersectSemverRangesMcp(rangeA, rangeB);
+    if ("error" in result) return errText(result);
+    return text(JSON.stringify(result, null, 2));
+  }
+);
+function _stripInlineMarkdownForLinksMcp(text2) {
+  return text2.replace(/(\*\*\*|___)(.+?)\1/g, "$2").replace(/(\*\*|__)(.+?)\1/g, "$2").replace(/(\*|_)(.+?)\1/g, "$2").replace(/`([^`]+)`/g, "$1").replace(/!\[([^\]]*)\]\([^)]*\)/g, "$1").replace(/\[([^\]]+)\]\([^)]*\)/g, "$1").trim();
+}
+function _slugifyHeadingForLinksMcp(text2, seen) {
+  let slug = text2.toLowerCase().trim().replace(/[^\p{L}\p{N}\s_-]/gu, "").replace(/\s/g, "-");
+  const count = seen.get(slug) ?? 0;
+  seen.set(slug, count + 1);
+  if (count > 0) slug = `${slug}-${count}`;
+  return slug;
+}
+var _ANCHOR_LINK_RE_MCP = /\[([^\]]*)\]\(#([^)\s]+)\)/g;
+function _checkMarkdownInternalLinksMcp(markdown) {
+  const lines = markdown.replace(/\r\n/g, "\n").split("\n");
+  const headings = [];
+  const seen = /* @__PURE__ */ new Map();
+  let inFence = false;
+  let fenceMarker = "";
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const fenceMatch = line.match(/^\s*(```+|~~~+)/);
+    if (fenceMatch) {
+      if (!inFence) {
+        inFence = true;
+        fenceMarker = fenceMatch[1][0];
+      } else if (fenceMatch[1][0] === fenceMarker) {
+        inFence = false;
+      }
+      continue;
+    }
+    if (inFence) continue;
+    const headingMatch = line.match(/^(#{1,6})\s+(.+?)\s*#*\s*$/);
+    if (!headingMatch) continue;
+    const level = headingMatch[1].length;
+    const text2 = _stripInlineMarkdownForLinksMcp(headingMatch[2]);
+    if (text2 === "") continue;
+    const slug = _slugifyHeadingForLinksMcp(text2, seen);
+    headings.push({ level, text: text2, slug, line: i + 1 });
+  }
+  const validSlugs = new Set(headings.map((h) => h.slug));
+  const links = [];
+  inFence = false;
+  fenceMarker = "";
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const fenceMatch = line.match(/^\s*(```+|~~~+)/);
+    if (fenceMatch) {
+      if (!inFence) {
+        inFence = true;
+        fenceMarker = fenceMatch[1][0];
+      } else if (fenceMatch[1][0] === fenceMarker) {
+        inFence = false;
+      }
+      continue;
+    }
+    if (inFence) continue;
+    const re = new RegExp(_ANCHOR_LINK_RE_MCP);
+    let m;
+    while ((m = re.exec(line)) !== null) {
+      const target = m[2];
+      links.push({ text: m[1], target, line: i + 1, valid: validSlugs.has(target) });
+    }
+  }
+  return { headings, links, brokenLinks: links.filter((l) => !l.valid) };
+}
+server.tool(
+  "check_markdown_internal_links",
+  "Scan a Markdown document's ATX headings, compute the GitHub-style anchor slug for each, and check every [text](#slug) internal link against them, flagging links that point at a heading that doesn't exist (or was renamed).",
+  {
+    markdown: z.string().describe("The Markdown document to scan")
+  },
+  async ({ markdown }) => {
+    const result = _checkMarkdownInternalLinksMcp(markdown);
+    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.89.0",
-  "description": "MCP server exposing 270 Utilix developer tools to Claude, Cursor, VS Code Copilot, and any MCP-compatible AI assistant.",
+  "version": "0.91.0",
+  "description": "MCP server exposing 272 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",