zardbot-telegram 1.0.0

package/dist/summary/formatter.js

@@ -0,0 +1,491 @@
+import * as path from "path";
+import { convert } from "telegram-markdown-v2";
+import { config } from "../config.js";
+import { logger } from "../utils/logger.js";
+import { t } from "../i18n/index.js";
+import { getCurrentProject } from "../settings/manager.js";
+const TELEGRAM_MESSAGE_LIMIT = 4096;
+const MARKDOWN_V2_RESERVED_CHARS = /([_\*\[\]\(\)~`>#+\-=|{}.!\\])/g;
+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) {
+        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;
+    }
+    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();
+    if (!project?.worktree) {
+        return normalizedPath;
+    }
+    const normalizedWorktree = project.worktree.replace(/\\/g, "/").replace(/\/+$/, "");
+    if (!normalizedWorktree) {
+        return normalizedPath;
+    }
+    const pathForCompare = process.platform === "win32" ? normalizedPath.toLowerCase() : normalizedPath;
+    const worktreeForCompare = process.platform === "win32" ? normalizedWorktree.toLowerCase() : normalizedWorktree;
+    if (pathForCompare === worktreeForCompare) {
+        return ".";
+    }
+    const worktreePrefix = `${worktreeForCompare}/`;
+    if (pathForCompare.startsWith(worktreePrefix)) {
+        return normalizedPath.slice(normalizedWorktree.length + 1);
+    }
+    return normalizedPath;
+}
+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);
+        return escapeMarkdownV2PipesOutsideCode(convert(preprocessed, "keep"));
+    }
+    catch (error) {
+        logger.warn("[Formatter] Failed to convert markdown summary, falling back to raw text", error);
+        return text;
+    }
+}
+function escapeMarkdownV2PipesOutsideCode(text) {
+    let result = "";
+    let index = 0;
+    let inInlineCode = false;
+    let inCodeFence = false;
+    while (index < text.length) {
+        if (text.startsWith("```", index)) {
+            result += "```";
+            index += 3;
+            inCodeFence = !inCodeFence;
+            continue;
+        }
+        const char = text[index];
+        if (!inCodeFence && char === "`") {
+            inInlineCode = !inInlineCode;
+            result += char;
+            index += 1;
+            continue;
+        }
+        if (!inCodeFence && !inInlineCode && char === "|" && text[index - 1] !== "\\") {
+            result += "\\|";
+            index += 1;
+            continue;
+        }
+        result += char;
+        index += 1;
+    }
+    return result;
+}
+export function formatSummaryWithMode(text, mode, maxLength = TELEGRAM_MESSAGE_LIMIT) {
+    if (!text || text.trim().length === 0) {
+        return [];
+    }
+    const normalizedMaxLength = Math.max(1, Math.floor(maxLength));
+    const rawTextLimit = mode === "raw" ? Math.max(1, normalizedMaxLength - "```\n\n```".length) : normalizedMaxLength;
+    const parts = splitText(text, rawTextLimit);
+    const formattedParts = [];
+    for (const part of parts) {
+        const trimmed = part.trim();
+        if (!trimmed) {
+            continue;
+        }
+        if (mode === "markdown") {
+            const converted = formatMarkdownForTelegram(trimmed);
+            const convertedParts = splitText(converted, normalizedMaxLength, {
+                avoidTrailingMarkdownEscape: true,
+            });
+            for (const convertedPart of convertedParts) {
+                const normalizedPart = convertedPart.trim();
+                if (normalizedPart) {
+                    formattedParts.push(normalizedPart);
+                }
+            }
+            continue;
+        }
+        if (parts.length > 1) {
+            formattedParts.push(`\`\`\`\n${trimmed}\n\`\`\``);
+        }
+        else {
+            formattedParts.push(trimmed);
+        }
+    }
+    return formattedParts;
+}
+function getToolDetails(tool, input) {
+    if (!input) {
+        return "";
+    }
+    // First, check fields specific to known tools
+    switch (tool) {
+        case "read":
+        case "edit":
+        case "write":
+        case "apply_patch":
+            const filePath = input.path || input.filePath;
+            if (typeof filePath === "string")
+                return normalizePathForDisplay(filePath);
+            break;
+        case "bash":
+            if (typeof input.command === "string")
+                return input.command;
+            break;
+        case "grep":
+        case "glob":
+            if (typeof input.pattern === "string")
+                return input.pattern;
+            break;
+    }
+    // Generic search for MCP and other tools
+    // Look for common fields: query, url, name, prompt
+    const commonFields = ["query", "url", "name", "prompt", "text"];
+    for (const field of commonFields) {
+        if (typeof input[field] === "string") {
+            return input[field];
+        }
+    }
+    // If nothing matched but string fields exist, take the first one (except description)
+    for (const [key, value] of Object.entries(input)) {
+        if (key !== "description" && typeof value === "string" && value.length > 0) {
+            return value;
+        }
+    }
+    return "";
+}
+function getToolIcon(tool) {
+    switch (tool) {
+        case "read":
+            return "📖";
+        case "write":
+            return "✍️";
+        case "edit":
+            return "✏️";
+        case "apply_patch":
+            return "🩹";
+        case "bash":
+            return "💻";
+        case "glob":
+            return "📁";
+        case "grep":
+            return "🔍";
+        case "task":
+            return "🤖";
+        case "question":
+            return "❓";
+        case "todoread":
+            return "📋";
+        case "todowrite":
+            return "📝";
+        case "webfetch":
+            return "🌐";
+        case "web-search_tavily_search":
+            return "🔎";
+        case "web-search_tavily_extract":
+            return "📄";
+        case "skill":
+            return "🎓";
+        default:
+            return "🛠️";
+    }
+}
+function formatTodos(todos) {
+    const MAX_TODOS = 20;
+    const statusToMarker = {
+        completed: "✅",
+        in_progress: "🔄",
+        pending: "🔲",
+    };
+    const formattedTodos = [];
+    for (let i = 0; i < Math.min(todos.length, MAX_TODOS); i++) {
+        const todo = todos[i];
+        const marker = statusToMarker[todo.status] ?? "🔲";
+        formattedTodos.push(`${marker} ${todo.content}`);
+    }
+    let result = formattedTodos.join("\n");
+    if (todos.length > MAX_TODOS) {
+        result += `\n${t("tool.todo.overflow", { count: todos.length - MAX_TODOS })}`;
+    }
+    return result;
+}
+function formatDiffLineInfo(filediff) {
+    const parts = [];
+    if (filediff.additions && filediff.additions > 0)
+        parts.push(`+${filediff.additions}`);
+    if (filediff.deletions && filediff.deletions > 0)
+        parts.push(`-${filediff.deletions}`);
+    return parts.length > 0 ? ` (${parts.join(" ")})` : "";
+}
+function countDiffChangesFromText(text) {
+    let additions = 0;
+    let deletions = 0;
+    for (const line of text.split("\n")) {
+        if (line.startsWith("+") && !line.startsWith("+++")) {
+            additions++;
+            continue;
+        }
+        if (line.startsWith("-") && !line.startsWith("---")) {
+            deletions++;
+        }
+    }
+    return { additions, deletions };
+}
+function extractFirstUpdatedFileFromTitle(title) {
+    for (const rawLine of title.split("\n")) {
+        const line = rawLine.trim();
+        if (line.length >= 3 && line[1] === " " && /[AMDURC]/.test(line[0])) {
+            return line.slice(2).trim();
+        }
+    }
+    return "";
+}
+export function formatToolInfo(toolInfo) {
+    const { tool, input, title } = toolInfo;
+    logger.debug(`[Formatter] formatToolInfo: tool=${tool}, hasMetadata=${!!toolInfo.metadata}, hasFilediff=${!!toolInfo.metadata?.filediff}`);
+    if (tool === "todowrite" && toolInfo.metadata?.todos) {
+        const todos = toolInfo.metadata.todos;
+        const toolIcon = getToolIcon(tool);
+        const todosList = formatTodos(todos);
+        return `${toolIcon} ${tool} (${todos.length})\n\n${todosList}`;
+    }
+    let details = title || getToolDetails(tool, input);
+    const toolIcon = getToolIcon(tool);
+    let description = "";
+    if (input && typeof input.description === "string") {
+        description = `${input.description}\n`;
+    }
+    if (tool === "bash" && input && typeof input.command === "string") {
+        details = input.command;
+    }
+    if (tool === "apply_patch") {
+        const filediff = toolInfo.metadata && "filediff" in toolInfo.metadata
+            ? toolInfo.metadata.filediff
+            : undefined;
+        if (filediff?.file) {
+            details = normalizePathForDisplay(filediff.file);
+        }
+        else if (title) {
+            const fileFromTitle = extractFirstUpdatedFileFromTitle(title);
+            if (fileFromTitle) {
+                details = normalizePathForDisplay(fileFromTitle);
+            }
+        }
+    }
+    const detailsStr = details ? ` ${details}` : "";
+    let lineInfo = "";
+    if (tool === "write" && input && "content" in input && typeof input.content === "string") {
+        const lines = countLines(input.content);
+        lineInfo = ` (+${lines})`;
+    }
+    if ((tool === "edit" || tool === "apply_patch") &&
+        toolInfo.metadata &&
+        "filediff" in toolInfo.metadata) {
+        const filediff = toolInfo.metadata.filediff;
+        logger.debug("[Formatter] Diff metadata:", JSON.stringify(toolInfo.metadata, null, 2));
+        lineInfo = formatDiffLineInfo(filediff);
+    }
+    if (tool === "apply_patch" && !lineInfo) {
+        const diffText = toolInfo.metadata && typeof toolInfo.metadata.diff === "string"
+            ? toolInfo.metadata.diff
+            : input && typeof input.patchText === "string"
+                ? input.patchText
+                : "";
+        if (diffText) {
+            lineInfo = formatDiffLineInfo(countDiffChangesFromText(diffText));
+        }
+    }
+    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;
+}
+function formatDiff(diff) {
+    const lines = diff.split("\n");
+    const formattedLines = [];
+    for (const line of lines) {
+        if (line.startsWith("@@")) {
+            continue;
+        }
+        if (line.startsWith("---") || line.startsWith("+++")) {
+            continue;
+        }
+        if (line.startsWith("Index:")) {
+            continue;
+        }
+        if (line.startsWith("===") && line.includes("=")) {
+            continue;
+        }
+        if (line.startsWith("\\ No newline")) {
+            continue;
+        }
+        if (line.startsWith(" ")) {
+            formattedLines.push(" " + line.slice(1));
+        }
+        else if (line.startsWith("+")) {
+            formattedLines.push("+ " + line.slice(1));
+        }
+        else if (line.startsWith("-")) {
+            formattedLines.push("- " + line.slice(1));
+        }
+        else {
+            formattedLines.push(line);
+        }
+    }
+    return formattedLines.join("\n");
+}
+export function prepareCodeFile(content, filePath, operation) {
+    const displayPath = normalizePathForDisplay(filePath);
+    let processedContent = content;
+    if (operation === "edit") {
+        processedContent = formatDiff(content);
+    }
+    const sizeKb = Buffer.byteLength(processedContent, "utf8") / 1024;
+    if (sizeKb > config.files.maxFileSizeKb) {
+        logger.debug(`[Formatter] File too large: ${displayPath} (${sizeKb.toFixed(2)} KB > ${config.files.maxFileSizeKb} KB)`);
+        return null;
+    }
+    const header = operation === "write"
+        ? t("tool.file_header.write", { path: displayPath })
+        : t("tool.file_header.edit", { path: displayPath });
+    const fullContent = header + processedContent;
+    const buffer = Buffer.from(fullContent, "utf8");
+    const basename = path.basename(filePath);
+    const filename = `${operation}_${basename}.txt`;
+    return { buffer, filename, caption: "" };
+}

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

@@ -0,0 +1,90 @@
+import { logger } from "../utils/logger.js";
+export class ToolMessageBatcher {
+    sendText;
+    sendFile;
+    sessionTasks = new Map();
+    generation = 0;
+    constructor(options) {
+        this.sendText = options.sendText;
+        this.sendFile = options.sendFile;
+    }
+    enqueue(sessionId, message) {
+        this.sendTextNow(sessionId, message, "enqueue");
+    }
+    sendTextNow(sessionId, message, reason) {
+        const normalizedMessage = message.trim();
+        if (!sessionId || normalizedMessage.length === 0) {
+            return;
+        }
+        const expectedGeneration = this.generation;
+        logger.debug(`[ToolBatcher] Sending text message: session=${sessionId}, reason=${reason}`);
+        void this.enqueueTask(sessionId, () => this.sendTextSafe(sessionId, normalizedMessage, reason, expectedGeneration));
+    }
+    enqueueUniqueByPrefix(sessionId, message, prefix) {
+        void prefix;
+        this.sendTextNow(sessionId, message, "enqueue_unique_by_prefix");
+    }
+    enqueueFile(sessionId, fileData) {
+        if (!sessionId) {
+            return;
+        }
+        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) {
+        void reason;
+        await (this.sessionTasks.get(sessionId) ?? Promise.resolve());
+    }
+    async flushAll(reason) {
+        void reason;
+        for (const task of this.sessionTasks.values()) {
+            await task;
+        }
+    }
+    clearSession(sessionId, reason) {
+        this.generation++;
+        logger.debug(`[ToolBatcher] Cleared session sends: session=${sessionId}, reason=${reason}`);
+    }
+    clearAll(reason) {
+        this.generation++;
+        logger.debug(`[ToolBatcher] Cleared all pending tool sends: reason=${reason}`);
+    }
+    enqueueTask(sessionId, task) {
+        const previousTask = this.sessionTasks.get(sessionId) ?? Promise.resolve();
+        const nextTask = previousTask
+            .catch(() => undefined)
+            .then(task)
+            .finally(() => {
+            if (this.sessionTasks.get(sessionId) === nextTask) {
+                this.sessionTasks.delete(sessionId);
+            }
+        });
+        this.sessionTasks.set(sessionId, nextTask);
+        return nextTask;
+    }
+    async sendTextSafe(sessionId, text, reason, expectedGeneration) {
+        if (this.generation !== expectedGeneration) {
+            logger.debug(`[ToolBatcher] Dropping stale tool text message: session=${sessionId}, reason=${reason}`);
+            return;
+        }
+        try {
+            await this.sendText(sessionId, text);
+        }
+        catch (err) {
+            logger.error(`[ToolBatcher] Failed to send tool text message: session=${sessionId}, reason=${reason}`, err);
+        }
+    }
+    async sendFileSafe(sessionId, fileData, reason, expectedGeneration) {
+        if (this.generation !== expectedGeneration) {
+            logger.debug(`[ToolBatcher] Dropping stale tool file message: session=${sessionId}, reason=${reason}`);
+            return;
+        }
+        try {
+            await this.sendFile(sessionId, fileData);
+        }
+        catch (err) {
+            logger.error(`[ToolBatcher] Failed to send tool file message: session=${sessionId}, reason=${reason}`, err);
+        }
+    }
+}