openzca 0.1.33 → 0.1.35

package/dist/cli.js

@@ -707,40 +707,92 @@ function asThreadType(groupFlag) {
 }
 function parseTextStyles(input) {
   const allStyles = [];
-  const lines = input.split("\n");
+  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++) {
-    const line = lines[i];
-    const headingMatch = line.match(/^(#{1,3})\s(.*)$/);
+    let line = lines[i];
+    if (codeLineIndices.has(i)) {
+      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 });
-      if (level === 3) lineStyles.push({ lineIndex: i, style: TextStyle.Small });
+      else if (level === 3 || level === 4) lineStyles.push({ lineIndex: i, style: TextStyle.Small });
       processedLines.push(headingMatch[2]);
       continue;
     }
-    const olMatch = line.match(/^(\d+)\.\s(.*)$/);
+    const bqMatch = line.match(/^(>+)\s?(.*)$/);
+    if (bqMatch) {
+      lineStyles.push({ lineIndex: i, style: TextStyle.Indent, indentSize: bqMatch[1].length });
+      line = bqMatch[2];
+    }
+    const indentContentMatch = line.match(/^(\s+)(.*)$/);
+    let indentLevel = 0;
+    let content = line;
+    if (indentContentMatch) {
+      indentLevel = Math.max(1, Math.floor(indentContentMatch[1].length / 2));
+      content = indentContentMatch[2];
+    }
+    if (/^[-*+]\s\[[ xX]\]\s/.test(content)) {
+      processedLines.push(line);
+      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 = line.match(/^-\s(.*)$/);
+    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;
     }
-    const indentMatch = line.match(/^(>+)\s?(.*)$/);
-    if (indentMatch) {
-      lineStyles.push({ lineIndex: i, style: TextStyle.Indent, indentSize: indentMatch[1].length });
-      processedLines.push(indentMatch[2]);
-      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 = {
     red: TextStyle.Red,
@@ -748,16 +800,22 @@ function parseTextStyles(input) {
     yellow: TextStyle.Yellow,
     green: TextStyle.Green,
     small: TextStyle.Small,
-    big: TextStyle.Big
+    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)
     { pattern: /\*\*(.+?)\*\*/g, style: TextStyle.Bold },
+    { pattern: /__(.+?)__/g, style: TextStyle.Bold },
+    // * and _ = italic (standard markdown)
     { pattern: /\*(.+?)\*/g, style: TextStyle.Italic },
-    { pattern: /__(.+?)__/g, style: TextStyle.Underline },
+    { pattern: /_(.+?)_/g, style: TextStyle.Italic },
+    // ~~ = strikethrough
     { pattern: /~~(.+?)~~/g, style: TextStyle.StrikeThrough }
   ];
   let segments = [{ text: inlineInput, styles: [] }];
@@ -797,6 +855,28 @@ function parseTextStyles(input) {
       allStyles.push({ start, len: seg.text.length, st });
     }
   }
+  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;
+      }
+      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++) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openzca",
-  "version": "0.1.33",
+  "version": "0.1.35",
   "description": "Open-source zca-compatible CLI to integrate Zalo with OpenClaw",
   "type": "module",
   "bin": {