openzca 0.1.36 → 0.1.37

package/dist/cli.js

@@ -18,6 +18,7 @@ import {
   TextStyle,
   ThreadType
 } from "zca-js";
+import { marked } from "marked";
 
 // src/lib/store.ts
 import fs from "fs/promises";
@@ -706,110 +707,7 @@ function asThreadType(groupFlag) {
   return groupFlag ? ThreadType.Group : ThreadType.User;
 }
 function parseTextStyles(input) {
-  const allStyles = [];
-  const codeLineIndices = /* @__PURE__ */ new Set();
-  {
-    const rawLines = input.split("\n");
-    const kept = [];
-    let inCode = false;
-    for (const rawLine of rawLines) {
-      if (/^```/.test(rawLine)) {
-        inCode = !inCode;
-        continue;
-      }
-      if (inCode) {
-        codeLineIndices.add(kept.length);
-      }
-      kept.push(rawLine);
-    }
-    input = kept.join("\n");
-  }
-  const escapeMap = [];
-  const escaped = input.replace(/\\([*_~#\\{}>+\-])/g, (_match, ch) => {
-    const idx = escapeMap.length;
-    escapeMap.push(ch);
-    return `
${idx}`;
-  });
-  const lines = escaped.split("\n");
-  const lineStyles = [];
-  const processedLines = [];
-  for (let i = 0; i < lines.length; i++) {
-    let line = lines[i];
-    if (codeLineIndices.has(i)) {
-      const codeIndentMatch = line.match(/^(\s+)(.*)$/);
-      if (codeIndentMatch) {
-        const codeIndent = Math.min(5, Math.max(1, Math.floor(codeIndentMatch[1].length / 2)));
-        lineStyles.push({ lineIndex: i, style: TextStyle.Indent, indentSize: codeIndent });
-        processedLines.push(codeIndentMatch[2]);
-      } else {
-        processedLines.push(line);
-      }
-      continue;
-    }
-    const headingMatch = line.match(/^(#{1,4})\s(.*)$/);
-    if (headingMatch) {
-      const level = headingMatch[1].length;
-      lineStyles.push({ lineIndex: i, style: TextStyle.Bold });
-      if (level === 1) lineStyles.push({ lineIndex: i, style: TextStyle.Big });
-      else if (level === 3 || level === 4) lineStyles.push({ lineIndex: i, style: TextStyle.Small });
-      processedLines.push(headingMatch[2]);
-      continue;
-    }
-    const bqMatch = line.match(/^(>+)\s?(.*)$/);
-    if (bqMatch) {
-      lineStyles.push({ lineIndex: i, style: TextStyle.Indent, indentSize: Math.min(5, bqMatch[1].length) });
-      line = bqMatch[2];
-    }
-    const indentContentMatch = line.match(/^(\s+)(.*)$/);
-    let indentLevel = 0;
-    let content = line;
-    if (indentContentMatch) {
-      indentLevel = Math.min(5, Math.max(1, Math.floor(indentContentMatch[1].length / 2)));
-      content = indentContentMatch[2];
-    }
-    if (/^[-*+]\s\[[ xX]\]\s/.test(content)) {
-      if (indentLevel > 0) {
-        lineStyles.push({ lineIndex: i, style: TextStyle.Indent, indentSize: indentLevel });
-      }
-      processedLines.push(content);
-      continue;
-    }
-    const olMatch = content.match(/^(\d+)\.\s(.*)$/);
-    if (olMatch) {
-      if (indentLevel > 0) {
-        lineStyles.push({ lineIndex: i, style: TextStyle.Indent, indentSize: indentLevel });
-      }
-      lineStyles.push({ lineIndex: i, style: TextStyle.OrderedList });
-      processedLines.push(olMatch[2]);
-      continue;
-    }
-    const ulMatch = content.match(/^[-*+]\s(.*)$/);
-    if (ulMatch) {
-      if (indentLevel > 0) {
-        lineStyles.push({ lineIndex: i, style: TextStyle.Indent, indentSize: indentLevel });
-      }
-      lineStyles.push({ lineIndex: i, style: TextStyle.UnorderedList });
-      processedLines.push(ulMatch[1]);
-      continue;
-    }
-    if (indentLevel > 0) {
-      lineStyles.push({ lineIndex: i, style: TextStyle.Indent, indentSize: indentLevel });
-      processedLines.push(content);
-      continue;
-    }
-    processedLines.push(line);
-  }
-  for (const ci of codeLineIndices) {
-    if (ci < processedLines.length) {
-      processedLines[ci] = processedLines[ci].replace(/[*_~{}]/g, (ch) => {
-        const idx = escapeMap.length;
-        escapeMap.push(ch);
-        return `
${idx}`;
-      });
-    }
-  }
-  const inlineInput = processedLines.join("\n");
-  const colorMap = {
+  const tagColorMap = {
     red: TextStyle.Red,
     orange: TextStyle.Orange,
     yellow: TextStyle.Yellow,
@@ -818,113 +716,272 @@ function parseTextStyles(input) {
     big: TextStyle.Big,
     underline: TextStyle.Underline
   };
-  const tagNames = Object.keys(colorMap).join("|");
-  const markers = [
-    // Tags first so inner markdown markers are preserved for subsequent passes
-    { pattern: new RegExp(`\\{(${tagNames})\\}(.+?)\\{/\\1\\}`, "g"), style: null },
-    // *** = bold + italic
-    { pattern: /\*\*\*(.+?)\*\*\*/g, style: TextStyle.Bold, extraStyles: [TextStyle.Italic] },
-    // ** and __ = bold (standard markdown; __ requires word boundaries)
-    { pattern: /\*\*(.+?)\*\*/g, style: TextStyle.Bold },
-    { pattern: /(?<!\w)__(.+?)__(?!\w)/g, style: TextStyle.Bold },
-    // * and _ = italic (_ requires word boundaries to avoid snake_case)
-    { pattern: /\*(.+?)\*/g, style: TextStyle.Italic },
-    { pattern: /(?<!\w)_(.+?)_(?!\w)/g, style: TextStyle.Italic },
-    // ~~ = strikethrough
-    { pattern: /~~(.+?)~~/g, style: TextStyle.StrikeThrough }
-  ];
-  let segments = [{ text: inlineInput, styles: [] }];
-  for (const marker of markers) {
-    const next = [];
-    for (const seg of segments) {
-      let lastIndex = 0;
-      const regex = new RegExp(marker.pattern.source, marker.pattern.flags);
-      let m;
-      while ((m = regex.exec(seg.text)) !== null) {
-        if (m.index > lastIndex) {
-          next.push({ text: seg.text.slice(lastIndex, m.index), styles: [...seg.styles] });
-        }
-        const isTagPattern = marker.style === null;
-        const innerText = isTagPattern ? m[2] : m[1];
-        const resolvedStyle = isTagPattern ? colorMap[m[1]] : marker.style;
-        const combined = [...seg.styles, resolvedStyle];
-        if (marker.extraStyles) {
-          combined.push(...marker.extraStyles);
-        }
-        next.push({ text: innerText, styles: combined });
-        lastIndex = regex.lastIndex;
-      }
-      if (lastIndex < seg.text.length) {
-        next.push({ text: seg.text.slice(lastIndex), styles: [...seg.styles] });
-      } else if (lastIndex === 0) {
-        next.push(seg);
+  const tagNames = Object.keys(tagColorMap).join("|");
+  const tagRegex = new RegExp(`\\{(${tagNames})\\}([\\s\\S]+?)\\{/\\1\\}`, "g");
+  const tagSlots = [];
+  const maskedInput = input.replace(tagRegex, (_m, tagName, inner) => {
+    const idx = tagSlots.length;
+    const placeholder = `
TAG${idx}`;
+    tagSlots.push({ placeholder, tagName, innerMd: inner });
+    return placeholder;
+  });
+  const tokens = marked.lexer(maskedInput);
+  const styles = [];
+  let text = "";
+  function emitLineStyles(lineStart, lineLen, lineStyles) {
+    if (lineLen <= 0) return;
+    for (const ls of lineStyles) {
+      if (ls.style === TextStyle.Indent) {
+        styles.push({ start: lineStart, len: lineLen, st: ls.style, indentSize: ls.indentSize });
+      } else {
+        styles.push({ start: lineStart, len: lineLen, st: ls.style });
       }
     }
-    segments = next;
-  }
-  let plainText = "";
-  for (const seg of segments) {
-    const start = plainText.length;
-    plainText += seg.text;
-    for (const st of seg.styles) {
-      allStyles.push({ start, len: seg.text.length, st });
-    }
   }
-  const orphanRegex = /\*([^*\n]+?)\*/g;
-  const orphanMatches = [...plainText.matchAll(orphanRegex)];
-  for (let oi = orphanMatches.length - 1; oi >= 0; oi--) {
-    const om = orphanMatches[oi];
-    const openPos = om.index;
-    const content = om[1];
-    const closePos = openPos + content.length + 1;
-    allStyles.push({ start: openPos + 1, len: content.length, st: TextStyle.Italic });
-    plainText = plainText.slice(0, closePos) + plainText.slice(closePos + 1);
-    plainText = plainText.slice(0, openPos) + plainText.slice(openPos + 1);
-    for (const s of allStyles) {
-      if (s.start > closePos) s.start--;
-      else if (s.start + s.len > closePos) s.len--;
-      if (s.start > openPos) s.start--;
-      else if (s.start + s.len > openPos) s.len--;
+  function walkInline(tokens2, inheritedStyles) {
+    for (const tok of tokens2) {
+      switch (tok.type) {
+        case "text": {
+          const t = tok;
+          if (t.tokens && t.tokens.length > 0) {
+            walkInline(t.tokens, inheritedStyles);
+          } else {
+            const start = text.length;
+            text += t.text;
+            const len = t.text.length;
+            if (len > 0) {
+              for (const st of inheritedStyles) {
+                styles.push({ start, len, st });
+              }
+            }
+          }
+          break;
+        }
+        case "strong": {
+          const t = tok;
+          walkInline(t.tokens, [...inheritedStyles, TextStyle.Bold]);
+          break;
+        }
+        case "em": {
+          const t = tok;
+          walkInline(t.tokens, [...inheritedStyles, TextStyle.Italic]);
+          break;
+        }
+        case "del": {
+          const t = tok;
+          walkInline(t.tokens, [...inheritedStyles, TextStyle.StrikeThrough]);
+          break;
+        }
+        case "codespan": {
+          const t = tok;
+          const start = text.length;
+          text += t.text;
+          const len = t.text.length;
+          if (len > 0) {
+            for (const st of inheritedStyles) {
+              styles.push({ start, len, st });
+            }
+          }
+          break;
+        }
+        case "escape": {
+          const t = tok;
+          const start = text.length;
+          text += t.text;
+          if (t.text.length > 0) {
+            for (const st of inheritedStyles) {
+              styles.push({ start, len: t.text.length, st });
+            }
+          }
+          break;
+        }
+        case "link": {
+          const t = tok;
+          walkInline(t.tokens, inheritedStyles);
+          break;
+        }
+        case "image": {
+          const t = tok;
+          const start = text.length;
+          text += t.text;
+          if (t.text.length > 0) {
+            for (const st of inheritedStyles) {
+              styles.push({ start, len: t.text.length, st });
+            }
+          }
+          break;
+        }
+        case "br": {
+          text += "\n";
+          break;
+        }
+        case "checkbox": {
+          const t = tok;
+          text += t.checked ? "[x] " : "[ ] ";
+          break;
+        }
+        default: {
+          const t = tok;
+          if (t.tokens && t.tokens.length > 0) {
+            walkInline(t.tokens, inheritedStyles);
+          } else if (t.text != null) {
+            const start = text.length;
+            text += t.text;
+            if (t.text.length > 0) {
+              for (const st of inheritedStyles) {
+                styles.push({ start, len: t.text.length, st });
+              }
+            }
+          }
+          break;
+        }
+      }
     }
   }
-  if (escapeMap.length > 0) {
-    const escRegex = /\x01(\d+)\x02/g;
-    const shifts = [];
-    let cumDelta = 0;
-    for (const m of plainText.matchAll(escRegex)) {
-      const idx = parseInt(m[1], 10);
-      cumDelta += m[0].length - escapeMap[idx].length;
-      shifts.push({ pos: m.index + m[0].length, delta: cumDelta });
-    }
-    for (const s of allStyles) {
-      let startDelta = 0;
-      let endDelta = 0;
-      const end = s.start + s.len;
-      for (const sh of shifts) {
-        if (sh.pos <= s.start) startDelta = sh.delta;
-        if (sh.pos <= end) endDelta = sh.delta;
+  function walkBlock(tokens2, blockLineStyles, depth) {
+    for (let ti = 0; ti < tokens2.length; ti++) {
+      const tok = tokens2[ti];
+      switch (tok.type) {
+        case "heading": {
+          const t = tok;
+          const headingStyles = [{ style: TextStyle.Bold }];
+          if (t.depth === 1) headingStyles.push({ style: TextStyle.Big });
+          else if (t.depth === 3 || t.depth === 4) headingStyles.push({ style: TextStyle.Small });
+          if (t.depth <= 4) {
+            const lineStart = text.length;
+            walkInline(t.tokens, []);
+            const lineLen = text.length - lineStart;
+            emitLineStyles(lineStart, lineLen, [...blockLineStyles, ...headingStyles]);
+            text += "\n";
+          } else {
+            const lineStart = text.length;
+            text += "#".repeat(t.depth) + " ";
+            walkInline(t.tokens, []);
+            const lineLen = text.length - lineStart;
+            emitLineStyles(lineStart, lineLen, blockLineStyles);
+            text += "\n";
+          }
+          break;
+        }
+        case "paragraph": {
+          const t = tok;
+          const lineStart = text.length;
+          walkInline(t.tokens, []);
+          const lineLen = text.length - lineStart;
+          emitLineStyles(lineStart, lineLen, blockLineStyles);
+          text += "\n";
+          break;
+        }
+        case "code": {
+          const t = tok;
+          text += t.text;
+          text += "\n";
+          break;
+        }
+        case "blockquote": {
+          const t = tok;
+          const bqDepth = depth + 1;
+          walkBlock(t.tokens, [...blockLineStyles, { style: TextStyle.Indent, indentSize: Math.min(5, bqDepth) }], bqDepth);
+          break;
+        }
+        case "list": {
+          const t = tok;
+          const listStyle = t.ordered ? TextStyle.OrderedList : TextStyle.UnorderedList;
+          for (const item of t.items) {
+            if (item.task) {
+              const lineStart = text.length;
+              text += item.checked ? "[x] " : "[ ] ";
+              const nonCheckboxTokens = item.tokens.filter((t2) => t2.type !== "checkbox");
+              walkInline(nonCheckboxTokens, []);
+              const lineLen = text.length - lineStart;
+              emitLineStyles(lineStart, lineLen, blockLineStyles);
+              text += "\n";
+            } else {
+              const hasSubList = item.tokens.some((t2) => t2.type === "list");
+              if (hasSubList) {
+                const inlineTokens = item.tokens.filter((t2) => t2.type !== "list");
+                const subLists = item.tokens.filter((t2) => t2.type === "list");
+                if (inlineTokens.length > 0) {
+                  const lineStart = text.length;
+                  walkInline(inlineTokens, []);
+                  const lineLen = text.length - lineStart;
+                  emitLineStyles(lineStart, lineLen, [...blockLineStyles, { style: listStyle }]);
+                  text += "\n";
+                }
+                const subIndent = Math.min(5, depth + 1);
+                walkBlock(subLists, [...blockLineStyles, { style: TextStyle.Indent, indentSize: subIndent }], depth + 1);
+              } else {
+                const lineStart = text.length;
+                walkInline(item.tokens, []);
+                const lineLen = text.length - lineStart;
+                emitLineStyles(lineStart, lineLen, [...blockLineStyles, { style: listStyle }]);
+                text += "\n";
+              }
+            }
+          }
+          break;
+        }
+        case "hr": {
+          text += "---\n";
+          break;
+        }
+        case "html": {
+          const t = tok;
+          text += t.text;
+          break;
+        }
+        case "text": {
+          const t = tok;
+          const lineStart = text.length;
+          if (t.tokens && t.tokens.length > 0) {
+            walkInline(t.tokens, []);
+          } else {
+            text += t.text;
+          }
+          const lineLen = text.length - lineStart;
+          emitLineStyles(lineStart, lineLen, blockLineStyles);
+          text += "\n";
+          break;
+        }
+        case "space": {
+          break;
+        }
+        default: {
+          const t = tok;
+          if (t.raw) text += t.raw;
+          break;
+        }
       }
-      s.start -= startDelta;
-      s.len -= endDelta - startDelta;
     }
-    plainText = plainText.replace(escRegex, (_m, idxStr) => escapeMap[parseInt(idxStr, 10)]);
   }
-  const finalLines = plainText.split("\n");
-  let offset = 0;
-  for (let i = 0; i < finalLines.length; i++) {
-    const lineLen = finalLines[i].length;
-    for (const ls of lineStyles) {
-      if (ls.lineIndex === i && lineLen > 0) {
-        if (ls.style === TextStyle.Indent) {
-          allStyles.push({ start: offset, len: lineLen, st: TextStyle.Indent, indentSize: ls.indentSize });
-        } else {
-          allStyles.push({ start: offset, len: lineLen, st: ls.style });
-        }
+  walkBlock(tokens, [], 0);
+  if (text.endsWith("\n")) {
+    text = text.slice(0, -1);
+  }
+  for (const slot of tagSlots) {
+    const phIdx = text.indexOf(slot.placeholder);
+    if (phIdx === -1) continue;
+    const inner = parseTextStyles(slot.innerMd);
+    const replacement = inner.text;
+    const phLen = slot.placeholder.length;
+    text = text.slice(0, phIdx) + replacement + text.slice(phIdx + phLen);
+    const delta = replacement.length - phLen;
+    for (const s of styles) {
+      if (s.start >= phIdx + phLen) {
+        s.start += delta;
+      } else if (s.start + s.len > phIdx) {
+        s.len += delta;
       }
     }
-    offset += lineLen + 1;
+    const tagStyle = tagColorMap[slot.tagName];
+    if (tagStyle) {
+      styles.push({ start: phIdx, len: replacement.length, st: tagStyle });
+    }
+    for (const is of inner.styles) {
+      styles.push({ start: phIdx + is.start, len: is.len, st: is.st, ..."indentSize" in is ? { indentSize: is.indentSize } : {} });
+    }
   }
-  return { text: plainText, styles: allStyles };
+  return { text, styles };
 }
 function parseBooleanFromEnv(name, fallback) {
   const raw = process.env[name]?.trim();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openzca",
-  "version": "0.1.36",
+  "version": "0.1.37",
   "description": "Open-source zca-compatible CLI to integrate Zalo with OpenClaw",
   "type": "module",
   "bin": {
@@ -44,6 +44,7 @@
     "@types/qrcode-terminal": "^0.12.2",
     "commander": "^14.0.3",
     "image-size": "^2.0.2",
+    "marked": "^17.0.4",
     "qrcode-terminal": "^0.12.0",
     "zca-js": "^2.0.4"
   },