openzca 0.1.34 → 0.1.36

package/dist/cli.js

@@ -707,6 +707,23 @@ function asThreadType(groupFlag) {
 }
 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;
@@ -718,27 +735,45 @@ function parseTextStyles(input) {
   const processedLines = [];
   for (let i = 0; i < lines.length; i++) {
     let line = lines[i];
-    const headingMatch = line.match(/^(#{1,6})\s(.*)$/);
+    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) 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 bqMatch = line.match(/^(>+)\s?(.*)$/);
     if (bqMatch) {
-      lineStyles.push({ lineIndex: i, style: TextStyle.Indent, indentSize: bqMatch[1].length });
+      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.max(1, Math.floor(indentContentMatch[1].length / 2));
+      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) {
@@ -764,6 +799,15 @@ function parseTextStyles(input) {
     }
     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,
@@ -780,12 +824,12 @@ function parseTextStyles(input) {
     { pattern: new RegExp(`\\{(${tagNames})\\}(.+?)\\{/\\1\\}`, "g"), style: null },
     // *** = bold + italic
     { pattern: /\*\*\*(.+?)\*\*\*/g, style: TextStyle.Bold, extraStyles: [TextStyle.Italic] },
-    // ** and __ = bold (standard markdown)
+    // ** and __ = bold (standard markdown; __ requires word boundaries)
     { pattern: /\*\*(.+?)\*\*/g, style: TextStyle.Bold },
-    { pattern: /__(.+?)__/g, style: TextStyle.Bold },
-    // * and _ = italic (standard markdown)
+    { pattern: /(?<!\w)__(.+?)__(?!\w)/g, style: TextStyle.Bold },
+    // * and _ = italic (_ requires word boundaries to avoid snake_case)
     { pattern: /\*(.+?)\*/g, style: TextStyle.Italic },
-    { pattern: /_(.+?)_/g, style: TextStyle.Italic },
+    { pattern: /(?<!\w)_(.+?)_(?!\w)/g, style: TextStyle.Italic },
     // ~~ = strikethrough
     { pattern: /~~(.+?)~~/g, style: TextStyle.StrikeThrough }
   ];
@@ -826,6 +870,23 @@ function parseTextStyles(input) {
       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--;
+    }
+  }
   if (escapeMap.length > 0) {
     const escRegex = /\x01(\d+)\x02/g;
     const shifts = [];

package/package.json

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