openzca 0.1.32 → 0.1.34

package/dist/cli.js

@@ -706,30 +706,108 @@ function asThreadType(groupFlag) {
   return groupFlag ? ThreadType.Group : ThreadType.User;
 }
 function parseTextStyles(input) {
-  const styles = [];
+  const allStyles = [];
+  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];
+    const headingMatch = line.match(/^(#{1,6})\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 });
+      processedLines.push(headingMatch[2]);
+      continue;
+    }
+    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];
+    }
+    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);
+  }
+  const inlineInput = processedLines.join("\n");
+  const colorMap = {
+    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(colorMap).join("|");
   const markers = [
-    { pattern: /\*\*\*(.+?)\*\*\*/g, style: TextStyle.Bold },
+    // 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: input, styles: [] }];
-  for (const { pattern, style } of markers) {
+  let segments = [{ text: inlineInput, styles: [] }];
+  for (const marker of markers) {
     const next = [];
     for (const seg of segments) {
       let lastIndex = 0;
-      const regex = new RegExp(pattern.source, pattern.flags);
+      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 combined = [...seg.styles, style];
-        if (pattern.source.startsWith("\\*\\*\\*")) {
-          combined.push(TextStyle.Italic);
+        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: m[1], styles: combined });
+        next.push({ text: innerText, styles: combined });
         lastIndex = regex.lastIndex;
       }
       if (lastIndex < seg.text.length) {
@@ -745,10 +823,47 @@ function parseTextStyles(input) {
     const start = plainText.length;
     plainText += seg.text;
     for (const st of seg.styles) {
-      styles.push({ start, len: seg.text.length, st });
+      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++) {
+    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 });
+        }
+      }
     }
+    offset += lineLen + 1;
   }
-  return { text: plainText, styles };
+  return { text: plainText, styles: allStyles };
 }
 function parseBooleanFromEnv(name, fallback) {
   const raw = process.env[name]?.trim();
@@ -2933,7 +3048,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 (supports **bold** *italic* __underline__ ~~strikethrough~~)").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* __underline__ ~~strike~~ {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.32",
+  "version": "0.1.34",
   "description": "Open-source zca-compatible CLI to integrate Zalo with OpenClaw",
   "type": "module",
   "bin": {