@ai-matrx/content-ir 0.22.7 → 0.23.0

package/dist/index.cjs

@@ -1,5 +1,6 @@
 'use strict';
 
+var textCase = require('@ai-matrx/kit/text-case');
 var Ajv = require('ajv');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -2127,313 +2128,8 @@ function stripKindDeep(value) {
   }
   return value;
 }
-
-// text-case.ts
-var DEFAULT_WORD_REPLACEMENTS = {
-  // Acronyms & initialisms
-  "api": "API",
-  "apis": "APIs",
-  "ui": "UI",
-  "ux": "UX",
-  "id": "ID",
-  "ids": "IDs",
-  "qr": "QR",
-  "ssr": "SSR",
-  "csr": "CSR",
-  "ssg": "SSG",
-  "isr": "ISR",
-  "spa": "SPA",
-  "pwa": "PWA",
-  "sdk": "SDK",
-  "sdks": "SDKs",
-  "cli": "CLI",
-  "tty": "TTY",
-  "repl": "REPL",
-  "ci": "CI",
-  "cd": "CD",
-  "cpu": "CPU",
-  "cpus": "CPUs",
-  "gpu": "GPU",
-  "gpus": "GPUs",
-  "ram": "RAM",
-  "rom": "ROM",
-  "ssd": "SSD",
-  "ssds": "SSDs",
-  "hdd": "HDD",
-  "hdds": "HDDs",
-  "kpi": "KPI",
-  "kpis": "KPIs",
-  "sla": "SLA",
-  "slas": "SLAs",
-  "slo": "SLO",
-  "slos": "SLOs",
-  "sli": "SLI",
-  "slis": "SLIs",
-  "dom": "DOM",
-  // Web, formats, protocols
-  "url": "URL",
-  "urls": "URLs",
-  "uri": "URI",
-  "uris": "URIs",
-  "http": "HTTP",
-  "https": "HTTPS",
-  "html": "HTML",
-  "css": "CSS",
-  "json": "JSON",
-  "yaml": "YAML",
-  "yml": "YML",
-  "toml": "TOML",
-  "csv": "CSV",
-  "pdf": "PDF",
-  "tsv": "TSV",
-  "jpg": "JPG",
-  "jpeg": "JPEG",
-  "png": "PNG",
-  "gif": "GIF",
-  "webp": "WebP",
-  "heic": "HEIC",
-  "heif": "HEIF",
-  "bmp": "BMP",
-  "tiff": "TIFF",
-  "ico": "ICO",
-  "xml": "XML",
-  "sql": "SQL",
-  "db": "DB",
-  "dbs": "DBs",
-  "nosql": "NoSQL",
-  "graphql": "GraphQL",
-  "grpc": "gRPC",
-  "rest": "REST",
-  "restful": "RESTful",
-  "websocket": "WebSocket",
-  "websockets": "WebSockets",
-  "webrtc": "WebRTC",
-  // Networking
-  "ip": "IP",
-  "ipv4": "IPv4",
-  "ipv6": "IPv6",
-  "dns": "DNS",
-  "dhcp": "DHCP",
-  "nat": "NAT",
-  "tcp": "TCP",
-  "udp": "UDP",
-  "icmp": "ICMP",
-  "ttl": "TTL",
-  "lan": "LAN",
-  "wan": "WAN",
-  "vlan": "VLAN",
-  "cdn": "CDN",
-  "ftp": "FTP",
-  "ssh": "SSH",
-  "tls": "TLS",
-  "ssl": "SSL",
-  // Security & crypto
-  "jwt": "JWT",
-  "jws": "JWS",
-  "jwe": "JWE",
-  "hmac": "HMAC",
-  "rsa": "RSA",
-  "ecdsa": "ECDSA",
-  "aes": "AES",
-  "pbkdf2": "PBKDF2",
-  "argon2": "Argon2",
-  "scrypt": "scrypt",
-  "totp": "TOTP",
-  "hotp": "HOTP",
-  "mfa": "MFA",
-  "2fa": "2FA",
-  "csrf": "CSRF",
-  "xss": "XSS",
-  "ssrf": "SSRF",
-  "rce": "RCE",
-  "dos": "DoS",
-  "ddos": "DDoS",
-  "mitm": "MITM",
-  "csp": "CSP",
-  "cors": "CORS",
-  "pii": "PII",
-  "phi": "PHI",
-  "gdpr": "GDPR",
-  "ccpa": "CCPA",
-  "hipaa": "HIPAA",
-  "rfc": "RFC",
-  // Platforms, langs, tools (single-token)
-  "javascript": "JavaScript",
-  "typescript": "TypeScript",
-  "jsx": "JSX",
-  "tsx": "TSX",
-  "node": "Node",
-  // (used when tokenized alone)
-  "deno": "Deno",
-  "bun": "Bun",
-  "react": "React",
-  "nextjs": "Next.js",
-  // if your tokenizer drops dots, keep this
-  "nodejs": "Node.js",
-  "postgresql": "PostgreSQL",
-  "postgres": "Postgres",
-  "mysql": "MySQL",
-  "sqlite": "SQLite",
-  "redis": "Redis",
-  "supabase": "Supabase",
-  "docker": "Docker",
-  "kubernetes": "Kubernetes",
-  "k8s": "Kubernetes",
-  "helm": "Helm",
-  "npm": "npm",
-  "pnpm": "pnpm",
-  "yarn": "Yarn",
-  "eslint": "ESLint",
-  "prettier": "Prettier",
-  "vite": "Vite",
-  "webpack": "Webpack",
-  "babel": "Babel",
-  // OS & vendors
-  "macos": "macOS",
-  "ios": "iOS",
-  "ipados": "iPadOS",
-  "watchos": "watchOS",
-  "tvos": "tvOS",
-  "windows": "Windows",
-  "linux": "Linux",
-  "ubuntu": "Ubuntu",
-  "github": "GitHub",
-  "gitlab": "GitLab",
-  "bitbucket": "Bitbucket",
-  // Data & analytics
-  "etl": "ETL",
-  "elt": "ELT",
-  "olap": "OLAP",
-  "oltp": "OLTP",
-  "bi": "BI",
-  // Time & locales
-  "utc": "UTC",
-  "gmt": "GMT",
-  "pst": "PST",
-  "pdt": "PDT",
-  "pt": "PT",
-  // Common “small words” to keep lowercase (unless first/last word)
-  "or": "or",
-  "and": "and",
-  "the": "the",
-  "of": "of",
-  "in": "in",
-  "to": "to",
-  "with": "with",
-  "as": "as",
-  "by": "by",
-  "for": "for",
-  "on": "on",
-  "at": "at",
-  "up": "up",
-  "a": "a",
-  "an": "an",
-  "is": "is",
-  "are": "are",
-  "was": "was",
-  "were": "were",
-  "be": "be",
-  "but": "but",
-  "nor": "nor",
-  "so": "so",
-  "yet": "yet",
-  "per": "per",
-  "via": "via",
-  // Latin abbreviations (tokenized as words in some pipelines)
-  "eg": "e.g.",
-  "ie": "i.e.",
-  "etc": "etc.",
-  "aka": "aka",
-  "vs": "vs.",
-  "v": "v.",
-  // Client abbreviations
-  "CIC": "CIC",
-  "AGR": "AGR",
-  "AGER": "AGER",
-  "DD": "DD",
-  "TS": "TS",
-  "TM": "TM",
-  "arman": "Arman"
-};
-var DEFAULT_OPTIONS = {
-  textCase: "title",
-  wordReplacements: DEFAULT_WORD_REPLACEMENTS,
-  trim: true
-};
-function formatText(text, options = {}) {
-  const opts = { ...DEFAULT_OPTIONS, ...options };
-  if (!text) return "";
-  let normalized = text.replace(/_/g, " ").replace(/-/g, " ").replace(/([a-z])([A-Z])/g, "$1 $2").replace(/\s+/g, " ");
-  if (opts.trim) {
-    normalized = normalized.trim();
-  }
-  let caseTransformed = normalized;
-  switch (opts.textCase) {
-    case "title":
-      caseTransformed = normalized.replace(
-        /\w\S*/g,
-        (word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()
-      );
-      break;
-    case "sentence":
-      if (normalized.length > 0) {
-        caseTransformed = normalized.charAt(0).toUpperCase() + normalized.slice(1).toLowerCase();
-      }
-      break;
-    case "lower":
-      caseTransformed = normalized.toLowerCase();
-      break;
-    case "upper":
-      caseTransformed = normalized.toUpperCase();
-      break;
-  }
-  let result = caseTransformed;
-  if (opts.wordReplacements) {
-    Object.entries(opts.wordReplacements).forEach(([key, value]) => {
-      const regex = new RegExp(`\\b${key}\\b`, "gi");
-      result = result.replace(regex, value);
-    });
-  }
-  return result;
-}
-var IDENTIFIER_ACRONYMS = [
-  "ID",
-  "URL",
-  "PDF",
-  "HTML",
-  "JSON",
-  "API",
-  "AI",
-  "UI",
-  "CSV",
-  "SMS",
-  "SEO",
-  "LLM",
-  "MCP",
-  "UUID",
-  "ISO"
-];
-var IDENTIFIER_ACRONYM_SET = new Set(IDENTIFIER_ACRONYMS.map((a) => a.toLowerCase()));
-function humanizeIdentifier(identifier) {
-  const text = (identifier ?? "").trim();
-  if (text === "") return "";
-  if (!text.includes("_") && /\s/.test(text)) {
-    return /^\p{Ll}/u.test(text) ? text.charAt(0).toUpperCase() + text.slice(1) : text;
-  }
-  return text.replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)(?![A-Z]s(?![a-z]))([A-Z][a-z])/g, "$1 $2").split(/[_\-.\s]+/).filter((part) => part.length > 0).map(identifierWord).join(" ");
-}
-function identifierWord(part) {
-  const lower = part.toLowerCase();
-  if (IDENTIFIER_ACRONYM_SET.has(lower)) return part.toUpperCase();
-  if (lower.length > 1 && lower.endsWith("s") && IDENTIFIER_ACRONYM_SET.has(lower.slice(0, -1))) {
-    return `${lower.slice(0, -1).toUpperCase()}s`;
-  }
-  return part.charAt(0).toUpperCase() + part.slice(1).toLowerCase();
-}
-
-// core/schema-structure.ts
 function formatBlockLabel(key) {
-  return formatText(key, { textCase: "title" });
+  return textCase.formatText(key, { textCase: "title" });
 }
 function schemaStructureDepth(schema, allSchemas, visiting = /* @__PURE__ */ new Set()) {
   if (visiting.has(schema.kind)) return 0;
@@ -5123,10 +4819,8 @@ function tryDecodeDirectiveContent(content, onError) {
   }
   return tryDecodeDirective(parsed, onError);
 }
-
-// directives/display.ts
 function titleCaseToken(token) {
-  return humanizeIdentifier(token) || token;
+  return textCase.humanizeIdentifier(token) || token;
 }
 var ACTION_BY_CLASS = {
   reference: "Reference",
@@ -8125,6 +7819,198 @@ function resolveReferenceLinks(fragment, defs) {
   return resolved.replace(new RegExp(`${PLACEHOLDER}(\\d+)${PLACEHOLDER}`, "g"), (_m, i) => spans[Number(i)] ?? "");
 }
 
+// source/delimiter-guard.ts
+var ZWSP = "\u200B";
+var ESCAPED_DOLLARS = `${ZWSP}$${ZWSP}$`;
+var ESCAPED_BRACKET = `${ZWSP}[`;
+function protectedRanges(text) {
+  return findCodeRanges(text).map((r) => [r.start, r.end]);
+}
+function isProtected(index, ranges) {
+  return ranges.some(([start, end]) => index >= start && index < end);
+}
+function preview(text, max = 160) {
+  const flat = text.replace(/\s+/g, " ").trim();
+  return flat.length > max ? `${flat.slice(0, max)}\u2026` : flat;
+}
+function guardMathDelimiters(text) {
+  if (!text.includes("$$")) return { text, violations: [] };
+  const ranges = protectedRanges(text);
+  const tokens = [];
+  for (let i = 0; i < text.length - 1; i++) {
+    if (text[i] !== "$" || text[i + 1] !== "$") continue;
+    if (!isProtected(i, ranges)) tokens.push(i);
+    i++;
+  }
+  if (tokens.length === 0) return { text, violations: [] };
+  const violations = [];
+  const escapeAt = [];
+  let j = 0;
+  while (j < tokens.length) {
+    const open = tokens[j];
+    const close = tokens[j + 1];
+    if (close === void 0) {
+      violations.push({
+        reason: "unpaired",
+        index: open,
+        spanLength: 0,
+        // An unpaired `$$` is inert to remark-math (nothing closes it), so it
+        // is reported but NOT escaped — it already renders as literal text.
+        preview: preview(text.slice(open, open + 120))
+      });
+      break;
+    }
+    const inner = text.slice(open + 2, close);
+    if (isMathPlaceholder(inner)) {
+      escapeAt.push(open, close);
+      violations.push({ reason: "prose-span", index: open, spanLength: inner.length, preview: preview(inner) });
+      j += 2;
+      continue;
+    }
+    if (looksLikeDisplayMath(inner, opensFlowBlock(text, open))) {
+      j += 2;
+      continue;
+    }
+    escapeAt.push(open);
+    violations.push({
+      reason: "prose-span",
+      index: open,
+      spanLength: inner.length,
+      preview: preview(inner)
+    });
+    j += 1;
+  }
+  let guarded = text;
+  for (const index of [...escapeAt].sort((a, b) => b - a)) {
+    guarded = `${guarded.slice(0, index)}${ESCAPED_DOLLARS}${guarded.slice(index + 2)}`;
+  }
+  return { text: guarded, violations };
+}
+var MAX_LINK_LABEL = 200;
+var LABEL_BLOCK_STRUCTURE = /\n[ \t]*\n|(?:^|\n)[ \t]*[-*+][ \t]+|#{2,6}[ \t]/;
+function guardRunawayLinks(text) {
+  if (!text.includes("[")) return { text, violations: [] };
+  const ranges = protectedRanges(text);
+  const violations = [];
+  const escapeAt = [];
+  const linkRe = /\[((?:[^[\]\\]|\\.)*)\]\(([^\s)]*)/g;
+  let m;
+  while ((m = linkRe.exec(text)) !== null) {
+    const open = m.index;
+    if (isProtected(open, ranges)) continue;
+    const label = m[1] ?? "";
+    const runaway = label.length > MAX_LINK_LABEL || LABEL_BLOCK_STRUCTURE.test(label);
+    if (!runaway) continue;
+    escapeAt.push(open);
+    violations.push({
+      reason: "runaway-link",
+      index: open,
+      spanLength: label.length,
+      preview: preview(label)
+    });
+  }
+  let guarded = text;
+  for (const index of [...escapeAt].sort((a, b) => b - a)) {
+    guarded = `${guarded.slice(0, index)}${ESCAPED_BRACKET}${guarded.slice(index + 1)}`;
+  }
+  return { text: guarded, violations };
+}
+function guardMarkdownDelimiters(text) {
+  const math = guardMathDelimiters(text);
+  const links = guardRunawayLinks(math.text);
+  return {
+    text: links.text,
+    violations: [...math.violations, ...links.violations]
+  };
+}
+function reportDelimiterViolations(violations, context) {
+  if (violations.length === 0) return;
+  try {
+    const worst = violations.find((v) => v.reason !== "unpaired") ?? violations[0];
+    if (!worst) return;
+    const message = worst.reason === "prose-span" ? `Malformed math delimiters: a stray "$$" would have turned ${worst.spanLength} chars of prose into a math span (KaTeX would render it as red error text). Escaped it.` : worst.reason === "runaway-link" ? `Runaway markdown link: an unclosed "[" would have turned ${worst.spanLength} chars into one link label. Escaped it.` : `Malformed math delimiters: an unpaired "$$" reached the renderer.`;
+    console.warn(`[markdown-delimiter-guard] ${message}`, {
+      renderPath: context.renderPath,
+      violations
+    });
+    context.capture?.({
+      source: "markdown-delimiters",
+      message,
+      relation: `markdown:${context.renderPath}`,
+      details: worst.preview,
+      conversationId: context.conversationId,
+      callSite: "guardMarkdownDelimiters",
+      raw: { messageId: context.messageId, violations }
+    });
+  } catch {
+  }
+}
+
+// source/thinking.ts
+function codeRanges2(text, live) {
+  const ranges = findCodeRanges(text).map((r) => [r.start, r.end]);
+  if (live) {
+    const pending = pendingCodeSpanStart(text);
+    if (pending >= 0 && !inCode(ranges, pending)) ranges.push([pending, text.length]);
+  }
+  return ranges.sort((x, y) => x[0] - y[0]);
+}
+function inCode(ranges, index) {
+  return ranges.some(([a, b]) => index >= a && index < b);
+}
+function collapseGaps(text) {
+  const ranges = codeRanges2(text, false);
+  let out = "";
+  let at = 0;
+  for (const [a, b] of ranges) {
+    out += text.slice(at, a).replace(/\n{3,}/g, "\n\n") + text.slice(a, b);
+    at = b;
+  }
+  return out + text.slice(at).replace(/\n{3,}/g, "\n\n");
+}
+var OPEN_TAG = /<(thinking|reasoning)\b[^>]*>/gi;
+function removeClosedBlocks(input, live) {
+  let text = input;
+  for (; ; ) {
+    const ranges = codeRanges2(text, live);
+    OPEN_TAG.lastIndex = 0;
+    let opener = null;
+    for (let m = OPEN_TAG.exec(text); m; m = OPEN_TAG.exec(text)) {
+      if (!inCode(ranges, m.index)) {
+        opener = m;
+        break;
+      }
+    }
+    if (!opener) return { text, openAt: -1 };
+    const closeTag = new RegExp(`</${opener[1]}\\s*>`, "gi");
+    closeTag.lastIndex = opener.index + opener[0].length;
+    let closer = null;
+    for (let m = closeTag.exec(text); m; m = closeTag.exec(text)) {
+      if (!inCode(ranges, m.index)) {
+        closer = m;
+        break;
+      }
+    }
+    if (!closer) return { text, openAt: opener.index };
+    text = text.slice(0, opener.index) + text.slice(closer.index + closer[0].length);
+  }
+}
+function stripThinking(input) {
+  if (!input) return "";
+  return collapseGaps(removeClosedBlocks(input, false).text).trim();
+}
+function hasThinkingTags(input) {
+  if (!input) return false;
+  return removeClosedBlocks(input, false).text !== input;
+}
+function stripThinkingStreaming(input) {
+  if (!input) return { visible: "", isThinking: false };
+  const { text, openAt } = removeClosedBlocks(input, true);
+  const isThinking = openAt !== -1;
+  const kept = isThinking ? text.slice(0, openAt) : text;
+  return { visible: collapseGaps(kept).replace(/^\s+/, ""), isThinking };
+}
+
 // source/code-range-edits.ts
 function unwrapCodeSpans(text) {
   if (!text.includes("`")) return text;
@@ -8630,6 +8516,10 @@ exports.findWholeTableStart = findWholeTableStart;
 exports.fingerprintText = fingerprintText;
 exports.formatBlockLabel = formatBlockLabel;
 exports.getParseSession = getParseSession;
+exports.guardMarkdownDelimiters = guardMarkdownDelimiters;
+exports.guardMathDelimiters = guardMathDelimiters;
+exports.guardRunawayLinks = guardRunawayLinks;
+exports.hasThinkingTags = hasThinkingTags;
 exports.hasUnclosedBacktickRun = hasUnclosedBacktickRun;
 exports.indexOutsideInlineCode = indexOutsideInlineCode;
 exports.initialXmlBalance = initialXmlBalance;
@@ -8709,6 +8599,7 @@ exports.rehydrateNodeOutcome = rehydrateNodeOutcome;
 exports.rehydrateRunResult = rehydrateRunResult;
 exports.removeCodeSpans = removeCodeSpans;
 exports.replaceFences = replaceFences;
+exports.reportDelimiterViolations = reportDelimiterViolations;
 exports.resetLegacyShellUses = resetLegacyShellUses;
 exports.resolveReferenceLinks = resolveReferenceLinks;
 exports.resolvesInContent = resolvesInContent;
@@ -8735,6 +8626,8 @@ exports.startsPipelessTable = startsPipelessTable;
 exports.storageToKindSchema = storageToKindSchema;
 exports.stripControlKeys = stripControlKeys;
 exports.stripKindDeep = stripKindDeep;
+exports.stripThinking = stripThinking;
+exports.stripThinkingStreaming = stripThinkingStreaming;
 exports.tableContainerIndent = tableContainerIndent;
 exports.tableStartsAt = tableStartsAt;
 exports.titleCaseToken = titleCaseToken;