@grinev/opencode-telegram-bot 0.13.2 → 0.14.0

package/dist/summary/formatter.js

@@ -6,18 +6,44 @@ import { t } from "../i18n/index.js";
 import { getCurrentProject } from "../settings/manager.js";
 const TELEGRAM_MESSAGE_LIMIT = 4096;
 const MARKDOWN_V2_RESERVED_CHARS = /([_\*\[\]\(\)~`>#+\-=|{}.!\\])/g;
-function splitText(text, maxLength) {
+function endsWithOddTrailingBackslashes(text, start, end) {
+    let backslashCount = 0;
+    for (let index = end - 1; index >= start; index--) {
+        if (text[index] !== "\\") {
+            break;
+        }
+        backslashCount += 1;
+    }
+    return backslashCount % 2 === 1;
+}
+function resolveSplitEndIndex(text, currentIndex, maxLength, options) {
+    const hardLimit = Math.min(text.length, currentIndex + maxLength);
+    if (hardLimit >= text.length) {
+        return text.length;
+    }
+    let endIndex = hardLimit;
+    const breakPoint = text.lastIndexOf("\n", endIndex);
+    if (breakPoint > currentIndex) {
+        endIndex = breakPoint + 1;
+    }
+    if (!options?.avoidTrailingMarkdownEscape) {
+        return endIndex;
+    }
+    while (endIndex > currentIndex && endsWithOddTrailingBackslashes(text, currentIndex, endIndex)) {
+        endIndex -= 1;
+    }
+    return endIndex > currentIndex ? endIndex : hardLimit;
+}
+function splitText(text, maxLength, options) {
     const parts = [];
     let currentIndex = 0;
     while (currentIndex < text.length) {
-        let endIndex = currentIndex + maxLength;
-        if (endIndex >= text.length) {
-            parts.push(text.slice(currentIndex));
-            break;
-        }
-        const breakPoint = text.lastIndexOf("\n", endIndex);
-        if (breakPoint > currentIndex) {
-            endIndex = breakPoint + 1;
+        const endIndex = resolveSplitEndIndex(text, currentIndex, maxLength, options);
+        if (endIndex <= currentIndex) {
+            const fallbackEnd = Math.min(text.length, currentIndex + 1);
+            parts.push(text.slice(currentIndex, fallbackEnd));
+            currentIndex = fallbackEnd;
+            continue;
         }
         parts.push(text.slice(currentIndex, endIndex));
         currentIndex = endIndex;
@@ -192,7 +218,9 @@ export function formatSummaryWithMode(text, mode, maxLength = TELEGRAM_MESSAGE_L
         }
         if (mode === "markdown") {
             const converted = formatMarkdownForTelegram(trimmed);
-            const convertedParts = splitText(converted, normalizedMaxLength);
+            const convertedParts = splitText(converted, normalizedMaxLength, {
+                avoidTrailingMarkdownEscape: true,
+            });
             for (const convertedPart of convertedParts) {
                 const normalizedPart = convertedPart.trim();
                 if (normalizedPart) {
@@ -343,7 +371,7 @@ export function formatToolInfo(toolInfo) {
         const todos = toolInfo.metadata.todos;
         const toolIcon = getToolIcon(tool);
         const todosList = formatTodos(todos);
-        return `${toolIcon} ${tool} (${todos.length})\n${todosList}`;
+        return `${toolIcon} ${tool} (${todos.length})\n\n${todosList}`;
     }
     let details = title || getToolDetails(tool, input);
     const toolIcon = getToolIcon(tool);
@@ -393,6 +421,17 @@ export function formatToolInfo(toolInfo) {
     }
     return `${toolIcon} ${description}${tool}${detailsStr}${lineInfo}`;
 }
+export function formatCompactToolInfo(toolInfo, maxLength = 64, fallback = "-") {
+    const formatted = formatToolInfo(toolInfo);
+    const normalized = formatted?.replace(/\s*\n+\s*/g, " ").trim() ?? "";
+    if (!normalized) {
+        return fallback;
+    }
+    if (normalized.length <= maxLength) {
+        return normalized;
+    }
+    return `${normalized.slice(0, Math.max(0, maxLength - 3)).trimEnd()}...`;
+}
 function countLines(text) {
     return text.split("\n").length;
 }

package/dist/summary/subagent-formatter.js

@@ -0,0 +1,63 @@
+import { formatModelDisplayName } from "../pinned/format.js";
+import { t } from "../i18n/index.js";
+import { formatCompactToolInfo } from "./formatter.js";
+function formatToolStep(subagent) {
+    if (!subagent.currentTool) {
+        return "";
+    }
+    const toolInfo = {
+        sessionId: subagent.sessionId ?? subagent.parentSessionId,
+        messageId: subagent.cardId,
+        callId: subagent.cardId,
+        tool: subagent.currentTool,
+        state: {
+            status: "running",
+            input: subagent.currentToolInput ?? {},
+            title: subagent.currentToolTitle,
+            metadata: {},
+            time: { start: subagent.updatedAt },
+        },
+        input: subagent.currentToolInput,
+        title: subagent.currentToolTitle,
+        metadata: {},
+        hasFileAttachment: false,
+    };
+    const formatted = formatCompactToolInfo(toolInfo, 128, "").trim();
+    const firstSpaceIndex = formatted.indexOf(" ");
+    if (firstSpaceIndex >= 0 && formatted.slice(firstSpaceIndex + 1) === subagent.currentTool) {
+        return "";
+    }
+    return formatted;
+}
+function formatSubagentActivity(subagent) {
+    if (subagent.status === "completed") {
+        return `✅ ${t("subagent.completed")}`;
+    }
+    if (subagent.status === "error") {
+        const message = subagent.terminalMessage?.trim() || t("subagent.failed");
+        return `❌ ${message}`;
+    }
+    const toolStep = formatToolStep(subagent);
+    if (toolStep) {
+        return toolStep;
+    }
+    return `⚙️ ${t("subagent.working")}`;
+}
+async function formatSubagentCard(subagent) {
+    const modelName = formatModelDisplayName(subagent.providerID, subagent.modelID);
+    const lines = [
+        `🧩 ${t("subagent.line.task", { task: subagent.description })}`,
+        t("subagent.line.agent", { agent: subagent.agent }),
+        t("pinned.line.model", { model: modelName }),
+        "",
+        formatSubagentActivity(subagent),
+    ];
+    return lines.join("\n");
+}
+export async function renderSubagentCards(subagents) {
+    if (subagents.length === 0) {
+        return "";
+    }
+    const parts = await Promise.all(subagents.map((subagent) => formatSubagentCard(subagent)));
+    return parts.filter(Boolean).join("\n\n");
+}

package/dist/summary/tool-message-batcher.js

@@ -1,50 +1,15 @@
 import { logger } from "../utils/logger.js";
-const DEFAULT_INTERVAL_SECONDS = 5;
-const TELEGRAM_MESSAGE_MAX_LENGTH = 4096;
-function normalizeIntervalSeconds(value) {
-    if (!Number.isFinite(value)) {
-        return DEFAULT_INTERVAL_SECONDS;
-    }
-    const normalized = Math.floor(value);
-    if (normalized < 0) {
-        return DEFAULT_INTERVAL_SECONDS;
-    }
-    return normalized;
-}
 export class ToolMessageBatcher {
-    intervalSeconds;
     sendText;
     sendFile;
-    queues = new Map();
-    timers = new Map();
     sessionTasks = new Map();
     generation = 0;
     constructor(options) {
-        this.intervalSeconds = normalizeIntervalSeconds(options.intervalSeconds);
         this.sendText = options.sendText;
         this.sendFile = options.sendFile;
     }
-    setIntervalSeconds(nextIntervalSeconds) {
-        const normalized = normalizeIntervalSeconds(nextIntervalSeconds);
-        if (this.intervalSeconds === normalized) {
-            return;
-        }
-        this.intervalSeconds = normalized;
-        logger.info(`[ToolBatcher] Interval updated: ${normalized}s`);
-        if (normalized === 0) {
-            void this.flushAll("interval_updated");
-            return;
-        }
-        const sessionIds = Array.from(this.queues.keys());
-        for (const sessionId of sessionIds) {
-            this.restartTimer(sessionId);
-        }
-    }
-    getIntervalSeconds() {
-        return this.intervalSeconds;
-    }
     enqueue(sessionId, message) {
-        this.enqueueTextInternal(sessionId, message);
+        this.sendTextNow(sessionId, message, "enqueue");
     }
     sendTextNow(sessionId, message, reason) {
         const normalizedMessage = message.trim();
@@ -52,80 +17,38 @@ export class ToolMessageBatcher {
             return;
         }
         const expectedGeneration = this.generation;
-        logger.debug(`[ToolBatcher] Sending immediate text message outside queue: session=${sessionId}, reason=${reason}`);
+        logger.debug(`[ToolBatcher] Sending text message: session=${sessionId}, reason=${reason}`);
         void this.enqueueTask(sessionId, () => this.sendTextSafe(sessionId, normalizedMessage, reason, expectedGeneration));
     }
     enqueueUniqueByPrefix(sessionId, message, prefix) {
-        this.enqueueTextInternal(sessionId, message, prefix);
+        void prefix;
+        this.sendTextNow(sessionId, message, "enqueue_unique_by_prefix");
     }
     enqueueFile(sessionId, fileData) {
         if (!sessionId) {
             return;
         }
-        if (this.intervalSeconds === 0) {
-            const expectedGeneration = this.generation;
-            logger.debug(`[ToolBatcher] Sending immediate file message: session=${sessionId}`);
-            void this.enqueueTask(sessionId, () => this.sendFileSafe(sessionId, fileData, "immediate", expectedGeneration));
-            return;
-        }
-        const queue = this.queues.get(sessionId) ?? [];
-        queue.push({ kind: "file", fileData });
-        this.queues.set(sessionId, queue);
-        logger.debug(`[ToolBatcher] Queued file message: session=${sessionId}, queueSize=${queue.length}, interval=${this.intervalSeconds}s`);
-        this.ensureTimer(sessionId);
+        const expectedGeneration = this.generation;
+        logger.debug(`[ToolBatcher] Sending file message: session=${sessionId}`);
+        void this.enqueueTask(sessionId, () => this.sendFileSafe(sessionId, fileData, "enqueue_file", expectedGeneration));
     }
     async flushSession(sessionId, reason) {
-        await this.enqueueTask(sessionId, () => this.flushSessionInternal(sessionId, reason));
+        void reason;
+        await (this.sessionTasks.get(sessionId) ?? Promise.resolve());
     }
     async flushAll(reason) {
-        for (const sessionId of Array.from(this.timers.keys())) {
-            this.clearTimer(sessionId);
-        }
-        const sessionIds = Array.from(this.queues.keys());
-        for (const sessionId of sessionIds) {
-            await this.flushSession(sessionId, reason);
+        void reason;
+        for (const task of this.sessionTasks.values()) {
+            await task;
         }
     }
     clearSession(sessionId, reason) {
         this.generation++;
-        this.clearTimer(sessionId);
-        if (this.queues.delete(sessionId)) {
-            logger.debug(`[ToolBatcher] Cleared session queue: session=${sessionId}, reason=${reason}`);
-        }
+        logger.debug(`[ToolBatcher] Cleared session sends: session=${sessionId}, reason=${reason}`);
     }
     clearAll(reason) {
         this.generation++;
-        for (const timer of this.timers.values()) {
-            clearTimeout(timer);
-        }
-        const queuedSessions = this.queues.size;
-        this.timers.clear();
-        this.queues.clear();
-        if (queuedSessions > 0) {
-            logger.debug(`[ToolBatcher] Cleared all queued tool messages: sessions=${queuedSessions}, reason=${reason}`);
-        }
-    }
-    clearTimer(sessionId) {
-        const timer = this.timers.get(sessionId);
-        if (!timer) {
-            return;
-        }
-        clearTimeout(timer);
-        this.timers.delete(sessionId);
-    }
-    ensureTimer(sessionId) {
-        if (this.timers.has(sessionId)) {
-            return;
-        }
-        this.restartTimer(sessionId);
-    }
-    restartTimer(sessionId) {
-        this.clearTimer(sessionId);
-        const timer = setTimeout(() => {
-            this.timers.delete(sessionId);
-            void this.flushSession(sessionId, "interval_elapsed");
-        }, this.intervalSeconds * 1000);
-        this.timers.set(sessionId, timer);
+        logger.debug(`[ToolBatcher] Cleared all pending tool sends: reason=${reason}`);
     }
     enqueueTask(sessionId, task) {
         const previousTask = this.sessionTasks.get(sessionId) ?? Promise.resolve();
@@ -140,53 +63,6 @@ export class ToolMessageBatcher {
         this.sessionTasks.set(sessionId, nextTask);
         return nextTask;
     }
-    enqueueTextInternal(sessionId, message, uniquePrefix) {
-        const normalizedMessage = message.trim();
-        if (!sessionId || normalizedMessage.length === 0) {
-            return;
-        }
-        if (this.intervalSeconds === 0) {
-            const expectedGeneration = this.generation;
-            logger.debug(`[ToolBatcher] Sending immediate text message: session=${sessionId}`);
-            void this.enqueueTask(sessionId, () => this.sendTextSafe(sessionId, normalizedMessage, "immediate", expectedGeneration));
-            return;
-        }
-        const normalizedPrefix = uniquePrefix?.trim();
-        const queue = this.queues.get(sessionId) ?? [];
-        if (normalizedPrefix) {
-            const existingUniqueMessage = queue.find((item) => item.kind === "text" && item.text.startsWith(normalizedPrefix));
-            if (existingUniqueMessage) {
-                existingUniqueMessage.text = normalizedMessage;
-                this.queues.set(sessionId, queue);
-                logger.debug(`[ToolBatcher] Updated queued unique text message: session=${sessionId}, prefix=${normalizedPrefix}, interval=${this.intervalSeconds}s`);
-                this.ensureTimer(sessionId);
-                return;
-            }
-        }
-        queue.push({ kind: "text", text: normalizedMessage });
-        this.queues.set(sessionId, queue);
-        logger.debug(`[ToolBatcher] Queued text message: session=${sessionId}, queueSize=${queue.length}, interval=${this.intervalSeconds}s`);
-        this.ensureTimer(sessionId);
-    }
-    async flushSessionInternal(sessionId, reason) {
-        const expectedGeneration = this.generation;
-        this.clearTimer(sessionId);
-        const queuedItems = this.queues.get(sessionId);
-        if (!queuedItems || queuedItems.length === 0) {
-            return;
-        }
-        this.queues.delete(sessionId);
-        const flushItems = this.buildFlushItems(queuedItems);
-        logger.debug(`[ToolBatcher] Flushing ${queuedItems.length} queued items as ${flushItems.length} Telegram sends (session=${sessionId}, reason=${reason})`);
-        for (const item of flushItems) {
-            if (item.kind === "text") {
-                await this.sendTextSafe(sessionId, item.text, reason, expectedGeneration);
-            }
-            else {
-                await this.sendFileSafe(sessionId, item.fileData, reason, expectedGeneration);
-            }
-        }
-    }
     async sendTextSafe(sessionId, text, reason, expectedGeneration) {
         if (this.generation !== expectedGeneration) {
             logger.debug(`[ToolBatcher] Dropping stale tool text message: session=${sessionId}, reason=${reason}`);
@@ -211,75 +87,4 @@ export class ToolMessageBatcher {
             logger.error(`[ToolBatcher] Failed to send tool file message: session=${sessionId}, reason=${reason}`, err);
         }
     }
-    buildFlushItems(entries) {
-        const result = [];
-        const textBuffer = [];
-        const flushTextBuffer = () => {
-            if (textBuffer.length === 0) {
-                return;
-            }
-            const packedTextMessages = this.packMessages(textBuffer);
-            for (const text of packedTextMessages) {
-                result.push({ kind: "text", text });
-            }
-            textBuffer.length = 0;
-        };
-        for (const entry of entries) {
-            if (entry.kind === "text") {
-                textBuffer.push(entry.text);
-            }
-            else {
-                flushTextBuffer();
-                result.push({ kind: "file", fileData: entry.fileData });
-            }
-        }
-        flushTextBuffer();
-        return result;
-    }
-    packMessages(messages) {
-        const normalizedEntries = messages
-            .flatMap((message) => this.splitLongText(message, TELEGRAM_MESSAGE_MAX_LENGTH))
-            .filter((entry) => entry.length > 0);
-        if (normalizedEntries.length === 0) {
-            return [];
-        }
-        const result = [];
-        let current = "";
-        for (const entry of normalizedEntries) {
-            if (!current) {
-                current = entry;
-                continue;
-            }
-            const candidate = `${current}\n\n${entry}`;
-            if (candidate.length <= TELEGRAM_MESSAGE_MAX_LENGTH) {
-                current = candidate;
-                continue;
-            }
-            result.push(current);
-            current = entry;
-        }
-        if (current) {
-            result.push(current);
-        }
-        return result;
-    }
-    splitLongText(text, limit) {
-        if (text.length <= limit) {
-            return [text];
-        }
-        const chunks = [];
-        let remaining = text;
-        while (remaining.length > limit) {
-            let splitIndex = remaining.lastIndexOf("\n", limit);
-            if (splitIndex <= 0 || splitIndex < Math.floor(limit * 0.5)) {
-                splitIndex = limit;
-            }
-            chunks.push(remaining.slice(0, splitIndex));
-            remaining = remaining.slice(splitIndex).replace(/^\n+/, "");
-        }
-        if (remaining.length > 0) {
-            chunks.push(remaining);
-        }
-        return chunks;
-    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grinev/opencode-telegram-bot",
-  "version": "0.13.2",
+  "version": "0.14.0",
   "description": "Telegram bot client for OpenCode to run and monitor coding tasks from chat.",
   "type": "module",
   "main": "./dist/index.js",