openzca 0.1.37 → 0.1.39

package/dist/cli.js

@@ -15,10 +15,8 @@ import {
   Gender,
   Reactions,
   ReviewPendingMemberRequestStatus,
-  TextStyle,
   ThreadType
 } from "zca-js";
-import { marked } from "marked";
 
 // src/lib/store.ts
 import fs from "fs/promises";
@@ -580,6 +578,255 @@ async function assertFilesExist(files) {
   }
 }
 
+// src/lib/text-styles.ts
+import { TextStyle } from "zca-js";
+var TAG_STYLE_MAP = {
+  red: TextStyle.Red,
+  orange: TextStyle.Orange,
+  yellow: TextStyle.Yellow,
+  green: TextStyle.Green,
+  small: TextStyle.Small,
+  big: TextStyle.Big,
+  underline: TextStyle.Underline
+};
+var INLINE_MARKERS = [
+  {
+    pattern: new RegExp(`\\{(${Object.keys(TAG_STYLE_MAP).join("|")})\\}(.+?)\\{/\\1\\}`, "g"),
+    style: null
+  },
+  { pattern: /\*\*\*(.+?)\*\*\*/g, style: TextStyle.Bold, extraStyles: [TextStyle.Italic] },
+  { pattern: /\*\*(.+?)\*\*/g, style: TextStyle.Bold },
+  { pattern: /(?<!\w)__(.+?)__(?!\w)/g, style: TextStyle.Bold },
+  { pattern: /\*(.+?)\*/g, style: TextStyle.Italic },
+  { pattern: /(?<!\w)_(.+?)_(?!\w)/g, style: TextStyle.Italic },
+  { pattern: /~~(.+?)~~/g, style: TextStyle.StrikeThrough }
+];
+function parseTextStyles(input) {
+  const allStyles = [];
+  const escapeMap = [];
+  const escapedInput = input.replace(/\\([*_~#\\{}>+\-])/g, (_match, ch) => {
+    const index = escapeMap.length;
+    escapeMap.push(ch);
+    return `
${index}`;
+  });
+  const lines = escapedInput.split("\n");
+  const lineStyles = [];
+  const processedLines = [];
+  const codeBlockLineIndices = /* @__PURE__ */ new Set();
+  let inCodeBlock = false;
+  for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
+    let line = lines[lineIndex];
+    let baseIndent = 0;
+    if (/^```/.test(line)) {
+      codeBlockLineIndices.add(lineIndex);
+      processedLines.push(line);
+      inCodeBlock = !inCodeBlock;
+      continue;
+    }
+    if (inCodeBlock) {
+      codeBlockLineIndices.add(lineIndex);
+      processedLines.push(normalizeCodeBlockLeadingWhitespace(line));
+      continue;
+    }
+    const headingMatch = line.match(/^(#{1,4})\s(.*)$/);
+    if (headingMatch) {
+      const depth = headingMatch[1].length;
+      lineStyles.push({ lineIndex, style: TextStyle.Bold });
+      if (depth === 1) {
+        lineStyles.push({ lineIndex, style: TextStyle.Big });
+      } else if (depth === 3 || depth === 4) {
+        lineStyles.push({ lineIndex, style: TextStyle.Small });
+      }
+      processedLines.push(headingMatch[2]);
+      continue;
+    }
+    const quoteMatch = line.match(/^(>+)\s?(.*)$/);
+    if (quoteMatch) {
+      baseIndent = Math.min(5, quoteMatch[1].length);
+      line = quoteMatch[2];
+    }
+    const indentMatch = line.match(/^(\s+)(.*)$/);
+    let indentLevel = 0;
+    let content = line;
+    if (indentMatch) {
+      indentLevel = clampIndent(indentMatch[1].length);
+      content = indentMatch[2];
+    }
+    const totalIndent = Math.min(5, baseIndent + indentLevel);
+    if (/^[-*+]\s\[[ xX]\]\s/.test(content)) {
+      if (totalIndent > 0) {
+        lineStyles.push({ lineIndex, style: TextStyle.Indent, indentSize: totalIndent });
+      }
+      processedLines.push(content);
+      continue;
+    }
+    const orderedListMatch = content.match(/^(\d+)\.\s(.*)$/);
+    if (orderedListMatch) {
+      if (totalIndent > 0) {
+        lineStyles.push({ lineIndex, style: TextStyle.Indent, indentSize: totalIndent });
+      }
+      lineStyles.push({ lineIndex, style: TextStyle.OrderedList });
+      processedLines.push(orderedListMatch[2]);
+      continue;
+    }
+    const unorderedListMatch = content.match(/^[-*+]\s(.*)$/);
+    if (unorderedListMatch) {
+      if (totalIndent > 0) {
+        lineStyles.push({ lineIndex, style: TextStyle.Indent, indentSize: totalIndent });
+      }
+      lineStyles.push({ lineIndex, style: TextStyle.UnorderedList });
+      processedLines.push(unorderedListMatch[1]);
+      continue;
+    }
+    if (totalIndent > 0) {
+      lineStyles.push({ lineIndex, style: TextStyle.Indent, indentSize: totalIndent });
+      processedLines.push(content);
+      continue;
+    }
+    processedLines.push(line);
+  }
+  for (const codeLineIndex of codeBlockLineIndices) {
+    if (codeLineIndex >= processedLines.length) {
+      continue;
+    }
+    processedLines[codeLineIndex] = processedLines[codeLineIndex].replace(/[*_~{}]/g, (ch) => {
+      const index = escapeMap.length;
+      escapeMap.push(ch);
+      return `
${index}`;
+    });
+  }
+  let segments = [{ text: processedLines.join("\n"), styles: [] }];
+  for (const marker of INLINE_MARKERS) {
+    const nextSegments = [];
+    for (const segment of segments) {
+      let lastIndex = 0;
+      const regex = new RegExp(marker.pattern.source, marker.pattern.flags);
+      let match;
+      while ((match = regex.exec(segment.text)) !== null) {
+        if (match.index > lastIndex) {
+          nextSegments.push({
+            text: segment.text.slice(lastIndex, match.index),
+            styles: [...segment.styles]
+          });
+        }
+        const isTagPattern = marker.style === null;
+        const innerText = isTagPattern ? match[2] : match[1];
+        const resolvedStyle = isTagPattern ? TAG_STYLE_MAP[match[1]] : marker.style;
+        const combinedStyles = [...segment.styles];
+        if (resolvedStyle) {
+          combinedStyles.push(resolvedStyle);
+        }
+        if (marker.extraStyles) {
+          combinedStyles.push(...marker.extraStyles);
+        }
+        nextSegments.push({
+          text: innerText,
+          styles: combinedStyles
+        });
+        lastIndex = regex.lastIndex;
+      }
+      if (lastIndex < segment.text.length) {
+        nextSegments.push({
+          text: segment.text.slice(lastIndex),
+          styles: [...segment.styles]
+        });
+      } else if (lastIndex === 0) {
+        nextSegments.push(segment);
+      }
+    }
+    segments = nextSegments;
+  }
+  let plainText = "";
+  for (const segment of segments) {
+    const start = plainText.length;
+    plainText += segment.text;
+    for (const style of segment.styles) {
+      allStyles.push({ start, len: segment.text.length, st: style });
+    }
+  }
+  const orphanMatches = [...plainText.matchAll(/\*([^*\n]+?)\*/g)];
+  for (let index = orphanMatches.length - 1; index >= 0; index -= 1) {
+    const match = orphanMatches[index];
+    const openPos = match.index ?? 0;
+    const content = match[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 style of allStyles) {
+      if (style.start > closePos) {
+        style.start -= 1;
+      } else if (style.start + style.len > closePos) {
+        style.len -= 1;
+      }
+      if (style.start > openPos) {
+        style.start -= 1;
+      } else if (style.start + style.len > openPos) {
+        style.len -= 1;
+      }
+    }
+  }
+  if (escapeMap.length > 0) {
+    const escapeRegex = /\x01(\d+)\x02/g;
+    const shifts = [];
+    let cumulativeDelta = 0;
+    for (const match of plainText.matchAll(escapeRegex)) {
+      const escapeIndex = Number.parseInt(match[1], 10);
+      cumulativeDelta += match[0].length - escapeMap[escapeIndex].length;
+      shifts.push({ pos: (match.index ?? 0) + match[0].length, delta: cumulativeDelta });
+    }
+    for (const style of allStyles) {
+      let startDelta = 0;
+      let endDelta = 0;
+      const end = style.start + style.len;
+      for (const shift of shifts) {
+        if (shift.pos <= style.start) {
+          startDelta = shift.delta;
+        }
+        if (shift.pos <= end) {
+          endDelta = shift.delta;
+        }
+      }
+      style.start -= startDelta;
+      style.len -= endDelta - startDelta;
+    }
+    plainText = plainText.replace(escapeRegex, (_match, index) => escapeMap[Number.parseInt(index, 10)]);
+  }
+  const finalLines = plainText.split("\n");
+  let offset = 0;
+  for (let lineIndex = 0; lineIndex < finalLines.length; lineIndex += 1) {
+    const lineLength = finalLines[lineIndex].length;
+    if (lineLength > 0) {
+      for (const lineStyle of lineStyles) {
+        if (lineStyle.lineIndex !== lineIndex) {
+          continue;
+        }
+        if (lineStyle.style === TextStyle.Indent) {
+          allStyles.push({
+            start: offset,
+            len: lineLength,
+            st: TextStyle.Indent,
+            indentSize: lineStyle.indentSize
+          });
+        } else {
+          allStyles.push({ start: offset, len: lineLength, st: lineStyle.style });
+        }
+      }
+    }
+    offset += lineLength + 1;
+  }
+  return { text: plainText, styles: allStyles };
+}
+function clampIndent(spaceCount) {
+  return Math.min(5, Math.max(1, Math.floor(spaceCount / 2)));
+}
+function normalizeCodeBlockLeadingWhitespace(line) {
+  return line.replace(
+    /^[ \t]+/,
+    (leadingWhitespace) => leadingWhitespace.replace(/\t/g, "\xA0\xA0\xA0\xA0").replace(/ /g, "\xA0")
+  );
+}
+
 // src/cli.ts
 var require2 = createRequire(import.meta.url);
 var { version: PKG_VERSION } = require2("../package.json");
@@ -706,283 +953,6 @@ function output(value, asJson = false) {
 function asThreadType(groupFlag) {
   return groupFlag ? ThreadType.Group : ThreadType.User;
 }
-function parseTextStyles(input) {
-  const tagColorMap = {
-    red: TextStyle.Red,
-    orange: TextStyle.Orange,
-    yellow: TextStyle.Yellow,
-    green: TextStyle.Green,
-    small: TextStyle.Small,
-    big: TextStyle.Big,
-    underline: TextStyle.Underline
-  };
-  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 });
-      }
-    }
-  }
-  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;
-        }
-      }
-    }
-  }
-  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;
-        }
-      }
-    }
-  }
-  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;
-      }
-    }
-    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, styles };
-}
 function parseBooleanFromEnv(name, fallback) {
   const raw = process.env[name]?.trim();
   if (!raw) return fallback;
@@ -3166,7 +3136,7 @@ auth.command("cache-clear").description("Clear local cache").action(
   })
 );
 var msg = program.command("msg").description("Messaging commands");
-msg.command("send <threadId> <message>").option("-g, --group", "Send to group").option("--raw", "Send raw text without parsing formatting markers").description("Send text message with formatting (**bold** *italic* __underline__ ~~strike~~ {red}color{/red} {big}size{/big} lists indents)").action(
+msg.command("send <threadId> <message>").option("-g, --group", "Send to group").option("--raw", "Send raw text without parsing formatting markers").description("Send text message with formatting (**bold** *italic* __bold__ ~~strike~~ {underline}text{/underline} {red}color{/red} {big}size{/big} lists indents)").action(
   wrapAction(async (threadId, message, opts, command) => {
     const { api } = await requireApi(command);
     if (opts.raw) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openzca",
-  "version": "0.1.37",
+  "version": "0.1.39",
   "description": "Open-source zca-compatible CLI to integrate Zalo with OpenClaw",
   "type": "module",
   "bin": {
@@ -44,7 +44,6 @@
     "@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"
   },