@phuetz/code-buddy 1.6.0 → 1.6.1

package/dist/commands/handlers/channel-handlers.js

@@ -469,21 +469,44 @@ export async function registerAIMessageHandler(manager) {
                 catch (councilErr) {
                     lines.push(`❌ Council a échoué : ${councilErr instanceof Error ? councilErr.message : String(councilErr)}`);
                 }
-                // Telegram caps messages ~4096 chars; flush on line boundaries.
                 const full = lines.join('\n').trim() || '(aucune sortie)';
-                let buf = '';
-                const flush = async () => {
-                    if (buf) {
-                        await channel.send({ channelId: message.channel.id, content: buf });
+                // Render the aligned tables (📊 détail par IA + learned ranking) in a
+                // monospace code block so Telegram's proportional font doesn't break the
+                // padded columns; the prose (the winning answer) stays normal text.
+                let tableStart = full.indexOf('📊 Détail par IA');
+                if (tableStart < 0)
+                    tableStart = full.search(/Learned model ranking|No council history/);
+                const prose = tableStart >= 0 ? full.slice(0, tableStart).trim() : full;
+                const tables = tableStart >= 0 ? full.slice(tableStart).trim() : '';
+                // Telegram caps messages ~4096 chars; flush on line boundaries. Tables
+                // go in an HTML <pre> block (monospace) — HTML is the robust mode: inside
+                // <pre> only &, <, > need escaping (vs MarkdownV2's ~18 escapes / legacy
+                // Markdown's fragility). See Telegram Bot API "Formatting options".
+                const htmlEscape = (s) => s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+                const sendChunked = async (text, mono) => {
+                    if (!text)
+                        return;
+                    const limit = mono ? 3500 : 3800;
+                    let buf = '';
+                    const flush = async () => {
+                        if (!buf)
+                            return;
+                        await channel.send({
+                            channelId: message.channel.id,
+                            content: mono ? '<pre>' + htmlEscape(buf) + '</pre>' : buf,
+                            parseMode: mono ? 'html' : undefined,
+                        });
                         buf = '';
+                    };
+                    for (const ln of text.split('\n')) {
+                        if (buf.length + ln.length + 1 > limit)
+                            await flush();
+                        buf += (buf ? '\n' : '') + ln;
                     }
+                    await flush();
                 };
-                for (const ln of full.split('\n')) {
-                    if (buf.length + ln.length + 1 > 3800)
-                        await flush();
-                    buf += (buf ? '\n' : '') + ln;
-                }
-                await flush();
+                await sendChunked(prose, false);
+                await sendChunked(tables, true);
                 return;
             }
             // Remote tool-approval over Telegram. A daemon has no interactive terminal,
@@ -539,12 +562,37 @@ export async function registerAIMessageHandler(manager) {
             const entries = await agent.processUserMessage(message.content);
             const lastEntry = entries[entries.length - 1];
             const response = lastEntry ? String(lastEntry.content) : '';
-            // 6. Deliver reply (text)
-            await channel.send({
-                channelId: message.channel.id,
-                content: response,
-                replyTo: message.id,
-            });
+            // 6. Deliver the reply. On Telegram, render the agent's markdown to the
+            //    robust HTML subset (bold / code / tables / links) so it doesn't show
+            //    raw; if Telegram rejects the HTML (success:false) fall back to plain
+            //    text. Other channels keep native markdown (Discord/Slack render it).
+            if (channel.type === 'telegram' && response.trim()) {
+                const { renderTelegramHtml } = await import('../../rendering/telegram-html.js');
+                const chunks = renderTelegramHtml(response);
+                let ok = chunks.length > 0;
+                for (let i = 0; i < chunks.length; i++) {
+                    const res = await channel.send({
+                        channelId: message.channel.id,
+                        content: chunks[i],
+                        parseMode: 'html',
+                        replyTo: i === 0 ? message.id : undefined,
+                    });
+                    if (!res?.success) {
+                        ok = false;
+                        break;
+                    }
+                }
+                if (!ok) {
+                    await channel.send({ channelId: message.channel.id, content: response, replyTo: message.id });
+                }
+            }
+            else {
+                await channel.send({
+                    channelId: message.channel.id,
+                    content: response,
+                    replyTo: message.id,
+                });
+            }
             // 7. If the user SPOKE (voice note), answer by voice too — mirror the
             //    modality. Best-effort: the text reply already landed, so a TTS/upload
             //    failure (or a channel without voice support) is a no-op, never fatal.

package/dist/rendering/markdown-core.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Unified rendering — markdown core.
+ *
+ * Single source of truth for parsing markdown into a `marked` token AST. Every
+ * surface renderer (Telegram HTML, ANSI terminal, plain text) consumes these
+ * tokens so the SAME agent output renders consistently everywhere.
+ */
+import { type Token, type TokensList } from 'marked';
+/** Normalize then lex markdown into a `marked` token list. */
+export declare function parseMarkdown(md: string): TokensList;
+export type { Token, TokensList };
+/** HTML-escape the 3 characters that matter inside Telegram/HTML text + <pre>. */
+export declare function escapeHtml(s: string): string;

package/dist/rendering/markdown-core.js

@@ -0,0 +1,18 @@
+/**
+ * Unified rendering — markdown core.
+ *
+ * Single source of truth for parsing markdown into a `marked` token AST. Every
+ * surface renderer (Telegram HTML, ANSI terminal, plain text) consumes these
+ * tokens so the SAME agent output renders consistently everywhere.
+ */
+import { marked } from 'marked';
+/** Normalize then lex markdown into a `marked` token list. */
+export function parseMarkdown(md) {
+    const normalized = (md ?? '').replace(/\r\n/g, '\n');
+    return marked.lexer(normalized);
+}
+/** HTML-escape the 3 characters that matter inside Telegram/HTML text + <pre>. */
+export function escapeHtml(s) {
+    return s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+//# sourceMappingURL=markdown-core.js.map

package/dist/rendering/telegram-html.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Unified rendering — Telegram HTML.
+ *
+ * Renders a markdown string to Telegram's HTML subset (the robust parse mode:
+ * inside text/<pre> only & < > need escaping, vs MarkdownV2's ~18 specials).
+ * Output is ALWAYS valid HTML with balanced tags, split into ≤4096-char chunks
+ * so a long reply never gets rejected. Unsupported markdown (headings, tables,
+ * lists, hr) degrades to <b>/monospace/bullets rather than breaking.
+ *
+ * Supported Telegram tags: <b> <i> <u> <s> <code> <pre> <a href> <blockquote>.
+ */
+import { marked } from 'marked';
+/**
+ * Render markdown → array of Telegram-HTML message chunks (each ≤ maxLen,
+ * each independently valid). Never throws: on any parse error it falls back to
+ * escaped plain text.
+ */
+export declare function renderTelegramHtml(md: string, maxLen?: number): string[];
+/** Re-export so the lexer used here is the only `marked` entry point. */
+export { marked };

package/dist/rendering/telegram-html.js

@@ -0,0 +1,230 @@
+/**
+ * Unified rendering — Telegram HTML.
+ *
+ * Renders a markdown string to Telegram's HTML subset (the robust parse mode:
+ * inside text/<pre> only & < > need escaping, vs MarkdownV2's ~18 specials).
+ * Output is ALWAYS valid HTML with balanced tags, split into ≤4096-char chunks
+ * so a long reply never gets rejected. Unsupported markdown (headings, tables,
+ * lists, hr) degrades to <b>/monospace/bullets rather than breaking.
+ *
+ * Supported Telegram tags: <b> <i> <u> <s> <code> <pre> <a href> <blockquote>.
+ */
+import { marked } from 'marked';
+import { parseMarkdown, escapeHtml } from './markdown-core.js';
+const TG_MAX = 4096;
+// --- inline tokens → Telegram HTML ----------------------------------------
+function renderInline(tokens) {
+    if (!tokens)
+        return '';
+    let out = '';
+    for (const t of tokens) {
+        switch (t.type) {
+            case 'text': {
+                const tok = t;
+                out += tok.tokens ? renderInline(tok.tokens) : escapeHtml(tok.text);
+                break;
+            }
+            case 'escape':
+                out += escapeHtml(t.text);
+                break;
+            case 'strong':
+                out += `<b>${renderInline(t.tokens)}</b>`;
+                break;
+            case 'em':
+                out += `<i>${renderInline(t.tokens)}</i>`;
+                break;
+            case 'del':
+                out += `<s>${renderInline(t.tokens)}</s>`;
+                break;
+            case 'codespan':
+                out += `<code>${escapeHtml(t.text)}</code>`;
+                break;
+            case 'br':
+                out += '\n';
+                break;
+            case 'link': {
+                const lnk = t;
+                const inner = renderInline(lnk.tokens) || escapeHtml(lnk.text || '');
+                // Only emit a link for safe http(s) hrefs; otherwise keep just the text.
+                out += /^https?:\/\//i.test(lnk.href || '')
+                    ? `<a href="${escapeHtml(lnk.href)}">${inner}</a>`
+                    : inner;
+                break;
+            }
+            case 'image':
+                out += escapeHtml(t.text || t.href || '');
+                break;
+            case 'html':
+                // Raw inline HTML from the model is unsafe for Telegram → escape it literally.
+                out += escapeHtml(t.text);
+                break;
+            default: {
+                const any = t;
+                out += any.tokens ? renderInline(any.tokens) : escapeHtml(any.text ?? any.raw ?? '');
+            }
+        }
+    }
+    return out;
+}
+/** Inline tokens → plain text (no tags) — used inside <pre> table cells. */
+function inlineToPlain(tokens) {
+    if (!tokens)
+        return '';
+    let out = '';
+    for (const t of tokens) {
+        const any = t;
+        out += any.tokens ? inlineToPlain(any.tokens) : (any.text ?? '');
+    }
+    return out;
+}
+/** Mobile Telegram <pre> wraps past ~40 monospace chars, which destroys column
+ *  alignment — so only narrow tables get the aligned grid; wider ones become a
+ *  vertical "record" layout (bold row title + `Header : value` lines). */
+const TABLE_FIT_WIDTH = 40;
+/** A markdown table → a complete Telegram-HTML block (aligned <pre> if it fits
+ *  the mobile width, otherwise a responsive vertical layout). */
+function renderTableBlock(t) {
+    const headers = t.header.map((c) => inlineToPlain(c.tokens).trim());
+    const rows = t.rows.map((r) => r.map((c) => inlineToPlain(c.tokens).trim()));
+    const cols = headers.length;
+    const widths = [];
+    for (let i = 0; i < cols; i++) {
+        widths[i] = Math.max(headers[i]?.length ?? 0, ...rows.map((r) => (r[i] ?? '').length), 1);
+    }
+    const totalWidth = widths.reduce((a, b) => a + b, 0) + (cols - 1) * 2;
+    const hasNewline = [...headers, ...rows.flat()].some((c) => c.includes('\n'));
+    // Narrow + single-line → aligned monospace grid.
+    if (totalWidth <= TABLE_FIT_WIDTH && !hasNewline) {
+        const fmt = (cells) => cells.map((c, i) => (c ?? '').padEnd(widths[i])).join('  ').trimEnd();
+        const sep = widths.map((w) => '─'.repeat(w)).join('  ');
+        const text = [fmt(headers), sep, ...rows.map(fmt)].join('\n');
+        return `<pre>${escapeHtml(text)}</pre>`;
+    }
+    // Wide → vertical records: first column is the bold row title, the rest are
+    // `Header : value`. Reads cleanly at any screen width (no horizontal wrap).
+    return rows
+        .map((r) => {
+        const lines = [`<b>${escapeHtml(r[0] ?? '')}</b>`];
+        for (let i = 1; i < cols; i++) {
+            if (r[i])
+                lines.push(`${escapeHtml(headers[i] ?? '')} : ${escapeHtml(r[i])}`);
+        }
+        return lines.join('\n');
+    })
+        .join('\n\n');
+}
+// --- block tokens → array of balanced-HTML fragments -----------------------
+function renderBlocks(tokens) {
+    const blocks = [];
+    for (const t of tokens) {
+        switch (t.type) {
+            case 'space':
+                break;
+            case 'heading':
+                blocks.push(`<b>${renderInline(t.tokens)}</b>`);
+                break;
+            case 'paragraph':
+                blocks.push(renderInline(t.tokens));
+                break;
+            case 'text': {
+                const tok = t;
+                blocks.push(tok.tokens ? renderInline(tok.tokens) : escapeHtml(tok.text));
+                break;
+            }
+            case 'code':
+                blocks.push(`<pre>${escapeHtml(t.text)}</pre>`);
+                break;
+            case 'table':
+                blocks.push(renderTableBlock(t));
+                break;
+            case 'blockquote':
+                blocks.push(`<blockquote>${renderBlocks(t.tokens).join('\n')}</blockquote>`);
+                break;
+            case 'list': {
+                const list = t;
+                const lines = list.items.map((it, i) => {
+                    const marker = list.ordered ? `${(Number(list.start) || 1) + i}. ` : '• ';
+                    const body = renderBlocks(it.tokens).join('\n');
+                    return marker + body.replace(/\n/g, '\n' + ' '.repeat(marker.length));
+                });
+                blocks.push(lines.join('\n'));
+                break;
+            }
+            case 'hr':
+                blocks.push('──────────');
+                break;
+            case 'html':
+                blocks.push(escapeHtml(t.text));
+                break;
+            default: {
+                const any = t;
+                blocks.push(any.tokens ? renderInline(any.tokens) : escapeHtml(any.text ?? any.raw ?? ''));
+            }
+        }
+    }
+    return blocks.filter((b) => b.trim().length > 0);
+}
+/** Split one oversized block (a <pre> is re-fenced per chunk) at line/char bounds. */
+function splitBlock(block, maxLen) {
+    const isPre = block.startsWith('<pre>') && block.endsWith('</pre>');
+    const inner = isPre ? block.slice(5, -6) : block;
+    const wrap = (s) => (isPre ? `<pre>${s}</pre>` : s);
+    const budget = maxLen - (isPre ? 11 : 0);
+    const out = [];
+    let cur = '';
+    const flush = () => { if (cur) {
+        out.push(wrap(cur));
+        cur = '';
+    } };
+    for (const ln of inner.split('\n')) {
+        if (ln.length > budget) {
+            flush();
+            for (let i = 0; i < ln.length; i += budget)
+                out.push(wrap(ln.slice(i, i + budget)));
+            continue;
+        }
+        if (cur.length + ln.length + 1 > budget)
+            flush();
+        cur += (cur ? '\n' : '') + ln;
+    }
+    flush();
+    return out;
+}
+/**
+ * Render markdown → array of Telegram-HTML message chunks (each ≤ maxLen,
+ * each independently valid). Never throws: on any parse error it falls back to
+ * escaped plain text.
+ */
+export function renderTelegramHtml(md, maxLen = TG_MAX) {
+    let blocks;
+    try {
+        blocks = renderBlocks(parseMarkdown(md));
+    }
+    catch {
+        blocks = (md ?? '').split('\n\n').map((b) => escapeHtml(b)).filter((b) => b.trim());
+    }
+    if (blocks.length === 0)
+        return [];
+    const chunks = [];
+    let cur = '';
+    const flush = () => { if (cur) {
+        chunks.push(cur);
+        cur = '';
+    } };
+    for (const b of blocks) {
+        if (b.length > maxLen) {
+            flush();
+            for (const sub of splitBlock(b, maxLen))
+                chunks.push(sub);
+            continue;
+        }
+        if (cur.length + b.length + 2 > maxLen)
+            flush();
+        cur += (cur ? '\n\n' : '') + b;
+    }
+    flush();
+    return chunks;
+}
+/** Re-export so the lexer used here is the only `marked` entry point. */
+export { marked };
+//# sourceMappingURL=telegram-html.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phuetz/code-buddy",
-  "version": "1.6.0",
+  "version": "1.6.1",
   "description": "Open-source multi-provider AI coding agent for the terminal, desktop, and HTTP. 15 LLM providers (Grok, Claude, ChatGPT, Gemini, Ollama, LM Studio, …) with ~110 tools, a peer-to-peer fleet, opt-in self-improvement, multi-channel messaging, and a skills system.",
   "author": "Patrice Huetz <patrice.huetz@gmail.com>",
   "repository": {