@grinev/opencode-telegram-bot 0.15.0 → 0.16.0

package/dist/i18n/es.js

@@ -345,4 +345,19 @@ export const es = {
     "stt.not_configured": "🎤 El reconocimiento de voz no está configurado.\n\nConfigura STT_API_URL y STT_API_KEY en .env para habilitarlo.",
     "stt.error": "🔴 No se pudo reconocer el audio: {error}",
     "stt.empty_result": "🎤 No se detectó voz en el mensaje de audio.",
+    "cmd.description.open": "Añadir proyecto navegando directorios",
+    "open.back": "⬆️ Subir",
+    "open.roots": "📋 Volver a raíces",
+    "open.prev_page": "⬅️ Anterior",
+    "open.next_page": "Siguiente ➡️",
+    "open.select_current": "✅ Seleccionar esta carpeta",
+    "open.select_root": "📂 Selecciona un directorio raíz para explorar:",
+    "open.access_denied": "⛔ Acceso denegado: la ruta está fuera de los directorios permitidos",
+    "open.scan_error": "🔴 No se puede explorar el directorio: {error}",
+    "open.open_error": "🔴 No se pudo abrir el explorador de directorios.",
+    "open.selected": "✅ Proyecto añadido: {project}\n\n📋 Usa /sessions o /new para empezar a trabajar.",
+    "open.select_error": "🔴 No se pudo añadir el proyecto.",
+    "open.no_subfolders": "📭 Sin subcarpetas",
+    "open.subfolder_count": "{count} subcarpeta",
+    "open.subfolders_count": "{count} subcarpetas",
 };

package/dist/i18n/fr.js

@@ -345,4 +345,19 @@ export const fr = {
     "stt.not_configured": "🎤 La reconnaissance vocale n'est pas configurée.\n\nDéfinissez STT_API_URL et STT_API_KEY dans .env pour l'activer.",
     "stt.error": "🔴 Impossible de reconnaître l'audio : {error}",
     "stt.empty_result": "🎤 Aucune parole détectée dans le message audio.",
+    "cmd.description.open": "Ajouter un projet en parcourant les dossiers",
+    "open.back": "⬆️ Remonter",
+    "open.roots": "📋 Retour aux racines",
+    "open.prev_page": "⬅️ Précédent",
+    "open.next_page": "Suivant ➡️",
+    "open.select_current": "✅ Sélectionner ce dossier",
+    "open.select_root": "📂 Sélectionnez un répertoire racine à parcourir :",
+    "open.access_denied": "⛔ Accès refusé : le chemin est en dehors des répertoires autorisés",
+    "open.scan_error": "🔴 Impossible de parcourir le répertoire : {error}",
+    "open.open_error": "🔴 Impossible d'ouvrir l'explorateur de répertoires.",
+    "open.selected": "✅ Projet ajouté : {project}\n\n📋 Utilisez /sessions ou /new pour commencer.",
+    "open.select_error": "🔴 Impossible d'ajouter le projet.",
+    "open.no_subfolders": "📭 Aucun sous-dossier",
+    "open.subfolder_count": "{count} sous-dossier",
+    "open.subfolders_count": "{count} sous-dossiers",
 };

package/dist/i18n/ru.js

@@ -345,4 +345,19 @@ export const ru = {
     "stt.not_configured": "🎤 Распознавание голоса не настроено.\n\nУстановите STT_API_URL и STT_API_KEY в .env для включения.",
     "stt.error": "🔴 Не удалось распознать аудио: {error}",
     "stt.empty_result": "🎤 В аудиосообщении не обнаружена речь.",
+    "cmd.description.open": "Добавить проект через обзор папок",
+    "open.back": "⬆️ Наверх",
+    "open.roots": "📋 К списку корней",
+    "open.prev_page": "⬅️ Назад",
+    "open.next_page": "Далее ➡️",
+    "open.select_current": "✅ Выбрать эту папку",
+    "open.select_root": "📂 Выберите корневой каталог для просмотра:",
+    "open.access_denied": "⛔ Доступ запрещён: путь за пределами разрешённых каталогов",
+    "open.scan_error": "🔴 Не удалось открыть каталог: {error}",
+    "open.open_error": "🔴 Не удалось открыть обозреватель каталогов.",
+    "open.selected": "✅ Проект добавлен: {project}\n\n📋 Используйте /sessions или /new для начала работы.",
+    "open.select_error": "🔴 Не удалось добавить проект.",
+    "open.no_subfolders": "📭 Нет подпапок",
+    "open.subfolder_count": "{count} подпапка",
+    "open.subfolders_count": "{count} подпапок",
 };

package/dist/i18n/zh.js

@@ -345,4 +345,19 @@ export const zh = {
     "stt.not_configured": "🎤 语音识别尚未配置。\n\n在 .env 中设置 STT_API_URL 和 STT_API_KEY 以启用。",
     "stt.error": "🔴 识别音频失败：{error}",
     "stt.empty_result": "🎤 音频消息中未检测到语音。",
+    "cmd.description.open": "通过浏览目录添加项目",
+    "open.back": "⬆️ 上级",
+    "open.roots": "📋 返回根目录",
+    "open.prev_page": "⬅️ 上一页",
+    "open.next_page": "下一页 ➡️",
+    "open.select_current": "✅ 选择此文件夹",
+    "open.select_root": "📂 选择要浏览的根目录：",
+    "open.access_denied": "⛔ 访问被拒绝：路径超出允许的目录范围",
+    "open.scan_error": "🔴 无法浏览目录：{error}",
+    "open.open_error": "🔴 无法打开目录浏览器。",
+    "open.selected": "✅ 项目已添加：{project}\n\n📋 使用 /sessions 或 /new 开始工作。",
+    "open.select_error": "🔴 添加项目失败。",
+    "open.no_subfolders": "📭 无子文件夹",
+    "open.subfolder_count": "{count} 个子文件夹",
+    "open.subfolders_count": "{count} 个子文件夹",
 };

package/dist/index.js

@@ -12,6 +12,8 @@ async function main() {
         return;
     }
     setRuntimeMode(modeResult.mode);
+    const { initializeLogger } = await import("./utils/logger.js");
+    await initializeLogger();
     const { startBotApp } = await import("./app/start-bot-app.js");
     await startBotApp();
 }

package/dist/project/manager.js

@@ -80,7 +80,8 @@ export async function getProjectById(id) {
 }
 export async function getProjectByWorktree(worktree) {
     const projects = await getProjects();
-    const project = projects.find((p) => p.worktree === worktree);
+    const key = worktreeKey(worktree);
+    const project = projects.find((p) => worktreeKey(p.worktree) === key);
     if (!project) {
         throw new Error(`Project with worktree ${worktree} not found`);
     }

package/dist/summary/aggregator.js

@@ -43,6 +43,7 @@ class SummaryAggregator {
     onSessionCompactedCallback = null;
     onSessionErrorCallback = null;
     onSessionRetryCallback = null;
+    onSessionIdleCallback = null;
     onPermissionCallback = null;
     onSessionDiffCallback = null;
     onFileChangeCallback = null;
@@ -105,6 +106,9 @@ class SummaryAggregator {
     setOnSessionRetry(callback) {
         this.onSessionRetryCallback = callback;
     }
+    setOnSessionIdle(callback) {
+        this.onSessionIdleCallback = callback;
+    }
     setOnPermission(callback) {
         this.onPermissionCallback = callback;
     }
@@ -643,7 +647,13 @@ class SummaryAggregator {
                     this.onCostCallback(assistantInfo.cost);
                 }
                 if (this.onCompleteCallback && finalText.length > 0) {
-                    this.onCompleteCallback(this.currentSessionId, messageID, finalText);
+                    this.onCompleteCallback(this.currentSessionId, messageID, finalText, {
+                        agent: assistantMessage.agent,
+                        providerID: assistantMessage.providerID,
+                        modelID: assistantMessage.modelID,
+                        createdAt: time?.created,
+                        completedAt: time?.completed,
+                    });
                 }
                 this.textMessageStates.delete(messageID);
                 this.messages.delete(messageID);
@@ -1038,6 +1048,12 @@ class SummaryAggregator {
         logger.info(`[Aggregator] Session became idle: ${sessionID}`);
         // Stop typing indicator when session goes idle
         this.stopTypingIndicator();
+        if (this.onSessionIdleCallback) {
+            const callback = this.onSessionIdleCallback;
+            setImmediate(() => {
+                callback(sessionID);
+            });
+        }
     }
     handleSessionCompacted(event) {
         const properties = event.properties;

package/dist/summary/formatter.js

@@ -4,6 +4,7 @@ import { config } from "../config.js";
 import { logger } from "../utils/logger.js";
 import { t } from "../i18n/index.js";
 import { getCurrentProject } from "../settings/manager.js";
+import { normalizeMarkdownForTelegramRendering } from "../telegram/render/markdown-normalizer.js";
 const TELEGRAM_MESSAGE_LIMIT = 4096;
 const MARKDOWN_V2_RESERVED_CHARS = /([_\*\[\]\(\)~`>#+\-=|{}.!\\])/g;
 function truncateWithEllipsis(text, maxLength) {
@@ -59,87 +60,6 @@ function splitText(text, maxLength, options) {
     }
     return parts;
 }
-function isCodeFenceLine(line) {
-    return line.trimStart().startsWith("```");
-}
-function isHorizontalRuleLine(line) {
-    const normalized = line.trim();
-    if (!normalized) {
-        return false;
-    }
-    return /^([-*_])(?:\s*\1){2,}$/.test(normalized);
-}
-function isHeadingLine(line) {
-    return /^\s{0,3}#{1,6}\s+\S/.test(line);
-}
-function normalizeHeadingLine(line) {
-    const match = line.match(/^\s{0,3}#{1,6}\s+(.+?)\s*$/);
-    if (!match) {
-        return line;
-    }
-    return `**${match[1]}**`;
-}
-function normalizeChecklistLine(line) {
-    const match = line.match(/^(\s*)(?:[-+*]|\d+\.)\s+\[( |x|X)\]\s+(.*)$/);
-    if (!match) {
-        return null;
-    }
-    const marker = match[2].toLowerCase() === "x" ? "✅" : "🔲";
-    return `${match[1]}${marker} ${match[3]}`;
-}
-function preprocessMarkdownForTelegram(text) {
-    const lines = text.split("\n");
-    const output = [];
-    let inCodeFence = false;
-    let inQuote = false;
-    for (let index = 0; index < lines.length; index++) {
-        const line = lines[index];
-        if (isCodeFenceLine(line)) {
-            inCodeFence = !inCodeFence;
-            inQuote = false;
-            output.push(line);
-            continue;
-        }
-        if (inCodeFence) {
-            output.push(line);
-            continue;
-        }
-        if (!line.trim()) {
-            inQuote = false;
-            output.push(line);
-            continue;
-        }
-        if (isHeadingLine(line)) {
-            output.push(normalizeHeadingLine(line));
-            inQuote = false;
-            continue;
-        }
-        if (isHorizontalRuleLine(line)) {
-            output.push("──────────");
-            inQuote = false;
-            continue;
-        }
-        const trimmedLeft = line.trimStart();
-        if (trimmedLeft.startsWith(">")) {
-            inQuote = true;
-            const quoteContent = trimmedLeft.replace(/^>\s?/, "");
-            const normalizedChecklistInQuote = normalizeChecklistLine(quoteContent);
-            output.push(normalizedChecklistInQuote ? `> ${normalizedChecklistInQuote.trimStart()}` : trimmedLeft);
-            continue;
-        }
-        const normalizedChecklist = normalizeChecklistLine(line);
-        if (normalizedChecklist) {
-            output.push(inQuote ? `> ${normalizedChecklist.trimStart()}` : normalizedChecklist);
-            continue;
-        }
-        if (inQuote) {
-            output.push(`> ${trimmedLeft}`);
-            continue;
-        }
-        output.push(line);
-    }
-    return output.join("\n");
-}
 export function normalizePathForDisplay(filePath) {
     const normalizedPath = filePath.replace(/\\/g, "/");
     const project = getCurrentProject();
@@ -164,18 +84,12 @@ export function normalizePathForDisplay(filePath) {
 export function formatSummary(text) {
     return formatSummaryWithMode(text, config.bot.messageFormatMode);
 }
-export function getAssistantParseMode() {
-    if (config.bot.messageFormatMode === "markdown") {
-        return "MarkdownV2";
-    }
-    return undefined;
-}
 export function escapePlainTextForTelegramMarkdownV2(text) {
     return text.replace(MARKDOWN_V2_RESERVED_CHARS, "\\$1");
 }
 function formatMarkdownForTelegram(text) {
     try {
-        const preprocessed = preprocessMarkdownForTelegram(text);
+        const preprocessed = normalizeMarkdownForTelegramRendering(text);
         return escapeMarkdownV2PipesOutsideCode(convert(preprocessed, "keep"));
     }
     catch (error) {

package/dist/telegram/render/block-fallback.js

@@ -0,0 +1,28 @@
+import { logger } from "../../utils/logger.js";
+import * as blockRenderer from "./block-renderer.js";
+const BLOCK_RENDER_ORDER = ["full", "simplified", "line-by-line", "plain"];
+export function renderTelegramBlockWithFallback(block) {
+    let lastError;
+    const failures = [];
+    for (const mode of BLOCK_RENDER_ORDER) {
+        try {
+            const renderedBlock = blockRenderer.renderTelegramBlock(block, mode);
+            if (failures.length > 0) {
+                logger.debug("[TelegramRender] Block fallback applied", {
+                    blockType: block.type,
+                    selectedMode: renderedBlock.mode,
+                    failures,
+                });
+            }
+            return renderedBlock;
+        }
+        catch (error) {
+            lastError = error;
+            failures.push({
+                mode,
+                reason: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    throw lastError instanceof Error ? lastError : new Error("Failed to render Telegram block");
+}

package/dist/telegram/render/block-parser.js

@@ -0,0 +1,295 @@
+import { toString } from "mdast-util-to-string";
+import { unified } from "unified";
+import remarkGfm from "remark-gfm";
+import remarkParse from "remark-parse";
+import { normalizeMarkdownForTelegramBlockParsing } from "./markdown-normalizer.js";
+const markdownProcessor = unified().use(remarkParse).use(remarkGfm);
+function pushTextNode(nodes, text) {
+    if (!text) {
+        return;
+    }
+    const previous = nodes.at(-1);
+    if (previous?.type === "text") {
+        previous.text += text;
+        return;
+    }
+    nodes.push({ type: "text", text });
+}
+function appendInlineNodes(target, additions) {
+    for (const node of additions) {
+        if (node.type === "text") {
+            pushTextNode(target, node.text);
+            continue;
+        }
+        target.push(node);
+    }
+}
+function prefixLines(text, prefix) {
+    return text
+        .split("\n")
+        .map((line) => `${prefix}${line}`)
+        .join("\n");
+}
+function createPlainBlock(text) {
+    const normalized = text.trim();
+    if (!normalized) {
+        return [];
+    }
+    return [{ type: "plain", text: normalized }];
+}
+function extractInlinePlainText(nodes) {
+    let result = "";
+    for (const node of nodes) {
+        switch (node.type) {
+            case "text":
+                result += node.value;
+                break;
+            case "strong":
+            case "emphasis":
+            case "delete":
+            case "link":
+                result += extractInlinePlainText(node.children);
+                break;
+            case "inlineCode":
+                result += node.value;
+                break;
+            case "break":
+                result += "\n";
+                break;
+            case "image":
+                result += node.alt ?? "";
+                break;
+            case "imageReference":
+                result += node.alt ?? "";
+                break;
+            case "linkReference":
+                result += extractInlinePlainText(node.children);
+                break;
+            case "html":
+                result += node.value;
+                break;
+            case "footnoteReference":
+                result += `[^${node.identifier}]`;
+                break;
+            default:
+                result += toString(node);
+                break;
+        }
+    }
+    return result;
+}
+function extractTableCellPlainText(cell) {
+    return extractInlinePlainText(cell.children);
+}
+function extractListItemPlainText(item, index, ordered) {
+    const prefix = item.checked === true ? "✅ " : item.checked === false ? "🔲 " : "";
+    const marker = ordered ? `${index + 1}. ` : "- ";
+    const body = item.children.map(extractBlockPlainText).filter(Boolean).join("\n");
+    return `${marker}${prefix}${body}`.trimEnd();
+}
+function extractBlockPlainText(node) {
+    switch (node.type) {
+        case "paragraph":
+        case "heading":
+            return extractInlinePlainText(node.children);
+        case "blockquote":
+            return node.children
+                .map(extractBlockPlainText)
+                .filter(Boolean)
+                .map((text) => prefixLines(text, "> "))
+                .join("\n");
+        case "list":
+            return node.children
+                .map((item, index) => extractListItemPlainText(item, index, Boolean(node.ordered)))
+                .filter(Boolean)
+                .join("\n");
+        case "listItem":
+            return node.children.map(extractBlockPlainText).filter(Boolean).join("\n");
+        case "code":
+            return node.value;
+        case "table":
+            return node.children
+                .map((row) => row.children.map(extractTableCellPlainText).join(" | "))
+                .join("\n");
+        case "thematicBreak":
+            return "──────────";
+        case "html":
+            return node.value;
+        default:
+            return toString(node);
+    }
+}
+function parseInlineNodes(nodes) {
+    const result = [];
+    for (const node of nodes) {
+        switch (node.type) {
+            case "text":
+                pushTextNode(result, node.value);
+                break;
+            case "strong": {
+                const children = parseInlineNodes(node.children);
+                if (!children) {
+                    return null;
+                }
+                result.push({ type: "bold", children });
+                break;
+            }
+            case "emphasis": {
+                const children = parseInlineNodes(node.children);
+                if (!children) {
+                    return null;
+                }
+                result.push({ type: "italic", children });
+                break;
+            }
+            case "delete": {
+                const children = parseInlineNodes(node.children);
+                if (!children) {
+                    return null;
+                }
+                result.push({ type: "strike", children });
+                break;
+            }
+            case "inlineCode":
+                result.push({ type: "code", text: node.value });
+                break;
+            case "link": {
+                const children = parseInlineNodes(node.children);
+                if (!children) {
+                    return null;
+                }
+                result.push({ type: "link", text: children, url: node.url });
+                break;
+            }
+            case "break":
+                pushTextNode(result, "\n");
+                break;
+            default:
+                return null;
+        }
+    }
+    return result;
+}
+function parseParagraphBlock(node) {
+    const inlines = parseInlineNodes(node.children);
+    if (!inlines) {
+        return createPlainBlock(extractBlockPlainText(node));
+    }
+    return [{ type: "paragraph", inlines }];
+}
+function parseHeadingBlock(node) {
+    const inlines = parseInlineNodes(node.children);
+    if (!inlines) {
+        return createPlainBlock(extractBlockPlainText(node));
+    }
+    return [
+        {
+            type: "heading",
+            level: Math.min(6, Math.max(1, Math.floor(node.depth))),
+            inlines,
+        },
+    ];
+}
+function parseBlockquoteBlock(node) {
+    const lines = [];
+    for (const child of node.children) {
+        if (child.type !== "paragraph" && child.type !== "heading") {
+            return createPlainBlock(extractBlockPlainText(node));
+        }
+        const inlines = parseInlineNodes(child.children);
+        if (!inlines) {
+            return createPlainBlock(extractBlockPlainText(node));
+        }
+        lines.push(inlines);
+    }
+    if (lines.length === 0) {
+        return [];
+    }
+    return [{ type: "blockquote", lines }];
+}
+function parseListItemInlines(item) {
+    const result = [];
+    const taskPrefix = item.checked === true ? "✅ " : item.checked === false ? "🔲 " : "";
+    if (taskPrefix) {
+        pushTextNode(result, taskPrefix);
+    }
+    for (let index = 0; index < item.children.length; index++) {
+        const child = item.children[index];
+        if (child.type !== "paragraph") {
+            return null;
+        }
+        const inlines = parseInlineNodes(child.children);
+        if (!inlines) {
+            return null;
+        }
+        if (index > 0) {
+            pushTextNode(result, "\n");
+        }
+        appendInlineNodes(result, inlines);
+    }
+    return result;
+}
+function parseListBlock(node) {
+    const items = [];
+    for (const item of node.children) {
+        const parsedItem = parseListItemInlines(item);
+        if (!parsedItem) {
+            return createPlainBlock(extractBlockPlainText(node));
+        }
+        items.push(parsedItem);
+    }
+    if (items.length === 0) {
+        return [];
+    }
+    return [{ type: "list", ordered: Boolean(node.ordered), items }];
+}
+function parseCodeBlock(node) {
+    return [{ type: "code", language: node.lang ?? undefined, text: node.value }];
+}
+function parseTableBlock(node) {
+    const rows = node.children.map((row) => row.children.map(extractTableCellPlainText));
+    if (rows.length === 0) {
+        return [];
+    }
+    return [{ type: "table", rows }];
+}
+function parseRootContent(node) {
+    switch (node.type) {
+        case "paragraph":
+            return parseParagraphBlock(node);
+        case "heading":
+            return parseHeadingBlock(node);
+        case "blockquote":
+            return parseBlockquoteBlock(node);
+        case "list":
+            return parseListBlock(node);
+        case "code":
+            return parseCodeBlock(node);
+        case "table":
+            return parseTableBlock(node);
+        case "thematicBreak":
+            return [{ type: "rule" }];
+        default:
+            return createPlainBlock(extractBlockPlainText(node));
+    }
+}
+function mergeAdjacentBlocks(blocks) {
+    const merged = [];
+    for (const block of blocks) {
+        const previous = merged.at(-1);
+        if (previous?.type === "blockquote" && block.type === "blockquote") {
+            previous.lines.push(...block.lines);
+            continue;
+        }
+        merged.push(block);
+    }
+    return merged;
+}
+export function parseTelegramBlocks(markdown) {
+    const normalized = normalizeMarkdownForTelegramBlockParsing(markdown).trim();
+    if (!normalized) {
+        return [];
+    }
+    const tree = markdownProcessor.parse(normalized);
+    return mergeAdjacentBlocks(tree.children.flatMap(parseRootContent));
+}