@alexnodeland/claude-telegram 0.3.0 → 0.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alexnodeland/claude-telegram",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Claude Code Channel plugin + standalone orchestrator bridging Telegram to Claude Code sessions",
   "module": "src/index.ts",
   "main": "src/index.ts",

package/src/html.ts

@@ -23,3 +23,125 @@ export const fmt = {
   link: (text: string, url: string) => `<a href="${escapeHtml(url)}">${escapeHtml(text)}</a>`,
   strikethrough: (text: string) => `<s>${escapeHtml(text)}</s>`,
 };
+
+/**
+ * Convert Markdown (Claude's output format) to Telegram-compatible HTML.
+ *
+ * Handles: fenced code blocks, inline code, bold, italic, strikethrough,
+ * links, and headers. Content is HTML-escaped before conversion so the
+ * resulting string is safe to send with parse_mode: "HTML".
+ */
+export function markdownToTelegramHtml(md: string): string {
+  const PLACEHOLDER_PREFIX = "\u2060CBLK";
+  const PLACEHOLDER_SUFFIX = "CBLK\u2060";
+
+  // 1. Extract fenced code blocks and tables into placeholders
+  const codeBlocks: string[] = [];
+  let withPlaceholders = md.replace(/```(\w*)\n([\s\S]*?)```/g, (_match, lang: string, code: string) => {
+    const escaped = escapeHtml(code.replace(/\n$/, ""));
+    const html = lang
+      ? `<pre><code class="language-${escapeHtml(lang)}">${escaped}</code></pre>`
+      : `<pre>${escaped}</pre>`;
+    codeBlocks.push(html);
+    return `${PLACEHOLDER_PREFIX}${codeBlocks.length - 1}${PLACEHOLDER_SUFFIX}`;
+  });
+
+  // 1b. Extract Markdown tables into <pre> placeholders
+  withPlaceholders = withPlaceholders.replace(/(?:^|\n)(\|.+\|(?:\r?\n\|.+\|)*)/g, (_match, tableBlock: string) => {
+    const html = convertMarkdownTable(tableBlock);
+    codeBlocks.push(html);
+    return `\n${PLACEHOLDER_PREFIX}${codeBlocks.length - 1}${PLACEHOLDER_SUFFIX}`;
+  });
+
+  // 2. Process non-code-block text
+  const placeholderRe = new RegExp(`(${PLACEHOLDER_PREFIX}\\d+${PLACEHOLDER_SUFFIX})`, "g");
+  const matchRe = new RegExp(`^${PLACEHOLDER_PREFIX}(\\d+)${PLACEHOLDER_SUFFIX}$`);
+
+  const processed = withPlaceholders
+    .split(placeholderRe)
+    .map((segment) => {
+      const cbMatch = segment.match(matchRe);
+      if (cbMatch) return codeBlocks[Number(cbMatch[1])];
+      return convertInlineFormatting(segment);
+    })
+    .join("");
+
+  return processed;
+}
+
+/** Convert inline Markdown formatting in a text segment (no fenced code blocks). */
+function convertInlineFormatting(text: string): string {
+  const parts = text.split(/(`[^`]+`)/g);
+
+  return parts
+    .map((part) => {
+      if (part.startsWith("`") && part.endsWith("`")) {
+        return `<code>${escapeHtml(part.slice(1, -1))}</code>`;
+      }
+
+      let s = escapeHtml(part);
+
+      // Headers → bold
+      s = s.replace(/^(#{1,6})\s+(.+)$/gm, (_m, _hashes: string, content: string) => `<b>${content}</b>`);
+
+      // Bold: **text** or __text__
+      s = s.replace(/\*\*(.+?)\*\*/g, "<b>$1</b>");
+      s = s.replace(/__(.+?)__/g, "<b>$1</b>");
+
+      // Italic: *text* or _text_
+      s = s.replace(/(?<!\w)\*(?!\s)(.+?)(?<!\s)\*(?!\w)/g, "<i>$1</i>");
+      s = s.replace(/(?<!\w)_(?!\s)(.+?)(?<!\s)_(?!\w)/g, "<i>$1</i>");
+
+      // Strikethrough: ~~text~~
+      s = s.replace(/~~(.+?)~~/g, "<s>$1</s>");
+
+      // Links: [text](url)
+      s = s.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2">$1</a>');
+
+      // Bullet lists: leading "- " or "* " → "• "
+      s = s.replace(/^[\t ]*[-*]\s+/gm, "• ");
+
+      return s;
+    })
+    .join("");
+}
+
+/** Convert a Markdown table to an aligned monospace <pre> block. */
+function convertMarkdownTable(tableText: string): string {
+  const rows = tableText.split(/\r?\n/).filter((r) => r.includes("|"));
+
+  // Parse cells from each row
+  const parsed = rows.map((row) =>
+    row
+      .replace(/^\|/, "")
+      .replace(/\|$/, "")
+      .split("|")
+      .map((c) => c.trim()),
+  );
+
+  // Filter out separator rows (--- or :---: etc.)
+  const dataRows = parsed.filter((cells) => !cells.every((c) => /^[:\-\s]+$/.test(c)));
+  if (dataRows.length === 0) return `<pre>${escapeHtml(tableText)}</pre>`;
+
+  // Calculate max width per column
+  const colCount = Math.max(...dataRows.map((r) => r.length));
+  const widths: number[] = Array.from({ length: colCount }, () => 0);
+  for (const row of dataRows) {
+    for (let i = 0; i < colCount; i++) {
+      widths[i] = Math.max(widths[i] ?? 0, (row[i] ?? "").length);
+    }
+  }
+
+  // Build aligned rows
+  const lines = dataRows.map((row, rowIdx) => {
+    const padded = widths.map((w, i) => (row[i] ?? "").padEnd(w)).join("  ");
+    // Add a separator line after the header
+    if (rowIdx === 0 && dataRows.length > 1) {
+      const sep = widths.map((w) => "─".repeat(w)).join("──");
+      return `${padded}\n${sep}`;
+    }
+    return padded;
+  });
+
+  return `<pre>${escapeHtml(lines.join("\n"))}</pre>`;
+}

package/src/streaming.ts

@@ -1,4 +1,4 @@
-import { escapeHtml, fmt } from "./html.js";
+import { escapeHtml, fmt, markdownToTelegramHtml } from "./html.js";
 import type { TelegramClient } from "./telegram.js";
 
 const MAX_TG_LENGTH = 4096;
@@ -33,7 +33,7 @@ export class StreamingRenderer {
     const trimmed = text.trim();
     if (!trimmed) return;
     this.lastToolMessageId = null; // new text block clears tool context
-    await sendLongMessage(this.tg, this.chatId, escapeHtml(trimmed));
+    await sendLongMessage(this.tg, this.chatId, markdownToTelegramHtml(trimmed));
   }
 
   async showToolCall(toolName: string, input: unknown): Promise<void> {