openzca 0.1.36 → 0.1.38

package/dist/cli.js

@@ -15,7 +15,6 @@ import {
   Gender,
   Reactions,
   ReviewPendingMemberRequestStatus,
-  TextStyle,
   ThreadType
 } from "zca-js";
 
@@ -579,6 +578,273 @@ 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 codeLineIndices = extractCodeBlockLines(input);
+  input = stripCodeFences(input);
+  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 = [];
+  for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
+    let line = lines[lineIndex];
+    if (codeLineIndices.has(lineIndex)) {
+      processedLines.push(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) {
+      lineStyles.push({
+        lineIndex,
+        style: TextStyle.Indent,
+        indentSize: 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];
+    }
+    if (/^[-*+]\s\[[ xX]\]\s/.test(content)) {
+      if (indentLevel > 0) {
+        lineStyles.push({ lineIndex, style: TextStyle.Indent, indentSize: indentLevel });
+      }
+      processedLines.push(content);
+      continue;
+    }
+    const orderedListMatch = content.match(/^(\d+)\.\s(.*)$/);
+    if (orderedListMatch) {
+      if (indentLevel > 0) {
+        lineStyles.push({ lineIndex, style: TextStyle.Indent, indentSize: indentLevel });
+      }
+      lineStyles.push({ lineIndex, style: TextStyle.OrderedList });
+      processedLines.push(orderedListMatch[2]);
+      continue;
+    }
+    const unorderedListMatch = content.match(/^[-*+]\s(.*)$/);
+    if (unorderedListMatch) {
+      if (indentLevel > 0) {
+        lineStyles.push({ lineIndex, style: TextStyle.Indent, indentSize: indentLevel });
+      }
+      lineStyles.push({ lineIndex, style: TextStyle.UnorderedList });
+      processedLines.push(unorderedListMatch[1]);
+      continue;
+    }
+    if (indentLevel > 0) {
+      lineStyles.push({ lineIndex, style: TextStyle.Indent, indentSize: indentLevel });
+      processedLines.push(content);
+      continue;
+    }
+    processedLines.push(line);
+  }
+  for (const codeLineIndex of codeLineIndices) {
+    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 extractCodeBlockLines(input) {
+  const codeLineIndices = /* @__PURE__ */ new Set();
+  const rawLines = input.split("\n");
+  let lineIndex = 0;
+  let inCodeBlock = false;
+  for (const rawLine of rawLines) {
+    if (/^```/.test(rawLine)) {
+      inCodeBlock = !inCodeBlock;
+      continue;
+    }
+    if (inCodeBlock) {
+      codeLineIndices.add(lineIndex);
+    }
+    lineIndex += 1;
+  }
+  return codeLineIndices;
+}
+function stripCodeFences(input) {
+  const keptLines = [];
+  let inCodeBlock = false;
+  for (const rawLine of input.split("\n")) {
+    if (/^```/.test(rawLine)) {
+      inCodeBlock = !inCodeBlock;
+      continue;
+    }
+    keptLines.push(rawLine);
+  }
+  return keptLines.join("\n");
+}
+function clampIndent(spaceCount) {
+  return Math.min(5, Math.max(1, Math.floor(spaceCount / 2)));
+}
+
 // src/cli.ts
 var require2 = createRequire(import.meta.url);
 var { version: PKG_VERSION } = require2("../package.json");
@@ -705,227 +971,6 @@ function output(value, asJson = false) {
 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 = {
-    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 = [
-    // 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);
-      }
-    }
-    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--;
-    }
-  }
-  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: allStyles };
-}
 function parseBooleanFromEnv(name, fallback) {
   const raw = process.env[name]?.trim();
   if (!raw) return fallback;
@@ -3109,7 +3154,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.36",
+  "version": "0.1.38",
   "description": "Open-source zca-compatible CLI to integrate Zalo with OpenClaw",
   "type": "module",
   "bin": {