@grinev/opencode-telegram-bot 0.1.0-rc.1

package/dist/summary/aggregator.js

@@ -0,0 +1,427 @@
+import { prepareCodeFile } from "./formatter.js";
+import { logger } from "../utils/logger.js";
+import { getCurrentProject } from "../settings/manager.js";
+class SummaryAggregator {
+    currentSessionId = null;
+    currentMessageParts = new Map();
+    pendingParts = new Map();
+    messages = new Map();
+    messageCount = 0;
+    lastUpdated = 0;
+    onCompleteCallback = null;
+    onToolCallback = null;
+    onToolFileCallback = null;
+    onQuestionCallback = null;
+    onQuestionErrorCallback = null;
+    onThinkingCallback = null;
+    onTokensCallback = null;
+    onSessionCompactedCallback = null;
+    onPermissionCallback = null;
+    onSessionDiffCallback = null;
+    onFileChangeCallback = null;
+    processedToolStates = new Set();
+    bot = null;
+    chatId = null;
+    typingTimer = null;
+    partHashes = new Map();
+    setBotAndChatId(bot, chatId) {
+        this.bot = bot;
+        this.chatId = chatId;
+    }
+    setOnComplete(callback) {
+        this.onCompleteCallback = callback;
+    }
+    setOnTool(callback) {
+        this.onToolCallback = callback;
+    }
+    setOnToolFile(callback) {
+        this.onToolFileCallback = callback;
+    }
+    setOnQuestion(callback) {
+        this.onQuestionCallback = callback;
+    }
+    setOnQuestionError(callback) {
+        this.onQuestionErrorCallback = callback;
+    }
+    setOnThinking(callback) {
+        this.onThinkingCallback = callback;
+    }
+    setOnTokens(callback) {
+        this.onTokensCallback = callback;
+    }
+    setOnSessionCompacted(callback) {
+        this.onSessionCompactedCallback = callback;
+    }
+    setOnPermission(callback) {
+        this.onPermissionCallback = callback;
+    }
+    setOnSessionDiff(callback) {
+        this.onSessionDiffCallback = callback;
+    }
+    setOnFileChange(callback) {
+        this.onFileChangeCallback = callback;
+    }
+    startTypingIndicator() {
+        if (this.typingTimer) {
+            return;
+        }
+        const sendTyping = () => {
+            if (this.bot && this.chatId) {
+                this.bot.api.sendChatAction(this.chatId, "typing").catch((err) => {
+                    logger.error("Failed to send typing action:", err);
+                });
+            }
+        };
+        sendTyping();
+        this.typingTimer = setInterval(sendTyping, 4000);
+    }
+    stopTypingIndicator() {
+        if (this.typingTimer) {
+            clearInterval(this.typingTimer);
+            this.typingTimer = null;
+        }
+    }
+    processEvent(event) {
+        // Log all question-related events for debugging
+        if (event.type.startsWith("question.")) {
+            logger.info(`[Aggregator] Question event: ${event.type}`, JSON.stringify(event.properties, null, 2));
+        }
+        // Log all session-related events for debugging
+        if (event.type.startsWith("session.")) {
+            logger.debug(`[Aggregator] Session event: ${event.type}`, JSON.stringify(event.properties, null, 2));
+        }
+        switch (event.type) {
+            case "message.updated":
+                this.handleMessageUpdated(event);
+                break;
+            case "message.part.updated":
+                this.handleMessagePartUpdated(event);
+                break;
+            case "session.status":
+                this.handleSessionStatus(event);
+                break;
+            case "session.idle":
+                this.handleSessionIdle(event);
+                break;
+            case "session.compacted":
+                this.handleSessionCompacted(event);
+                break;
+            case "question.asked":
+                this.handleQuestionAsked(event);
+                break;
+            case "question.replied":
+                logger.info(`[Aggregator] Question replied: requestID=${event.properties.requestID}`);
+                break;
+            case "question.rejected":
+                logger.info(`[Aggregator] Question rejected: requestID=${event.properties.requestID}`);
+                break;
+            case "session.diff":
+                this.handleSessionDiff(event);
+                break;
+            case "permission.asked":
+                this.handlePermissionAsked(event);
+                break;
+            case "permission.replied":
+                logger.info(`[Aggregator] Permission replied: requestID=${event.properties.requestID}`);
+                break;
+            default:
+                logger.debug(`[Aggregator] Unhandled event type: ${event.type}`);
+                break;
+        }
+    }
+    setSession(sessionId) {
+        if (this.currentSessionId !== sessionId) {
+            this.clear();
+            this.currentSessionId = sessionId;
+        }
+    }
+    clear() {
+        this.stopTypingIndicator();
+        this.currentSessionId = null;
+        this.currentMessageParts.clear();
+        this.pendingParts.clear();
+        this.messages.clear();
+        this.partHashes.clear();
+        this.processedToolStates.clear();
+        this.messageCount = 0;
+        this.lastUpdated = 0;
+    }
+    handleMessageUpdated(event) {
+        const { info } = event.properties;
+        if (info.sessionID !== this.currentSessionId) {
+            return;
+        }
+        const messageID = info.id;
+        this.messages.set(messageID, { role: info.role });
+        if (info.role === "assistant") {
+            if (!this.currentMessageParts.has(messageID)) {
+                this.currentMessageParts.set(messageID, []);
+                this.messageCount++;
+                this.startTypingIndicator();
+                // Notify that agent started thinking
+                if (this.onThinkingCallback) {
+                    setImmediate(() => {
+                        this.onThinkingCallback();
+                    });
+                }
+            }
+            const pending = this.pendingParts.get(messageID) || [];
+            const current = this.currentMessageParts.get(messageID) || [];
+            this.currentMessageParts.set(messageID, [...current, ...pending]);
+            this.pendingParts.delete(messageID);
+            const assistantMessage = info;
+            const time = assistantMessage.time;
+            if (time?.completed) {
+                const parts = this.currentMessageParts.get(messageID) || [];
+                const lastPart = parts[parts.length - 1] || "";
+                logger.debug(`[Aggregator] Message part completed: messageId=${messageID}, textLength=${lastPart.length}, totalParts=${parts.length}, session=${this.currentSessionId}`);
+                // Extract and report tokens BEFORE onComplete so keyboard context is updated
+                const assistantInfo = info;
+                if (this.onTokensCallback && assistantInfo.tokens) {
+                    const tokens = {
+                        input: assistantInfo.tokens.input,
+                        output: assistantInfo.tokens.output,
+                        reasoning: assistantInfo.tokens.reasoning,
+                        cacheRead: assistantInfo.tokens.cache?.read || 0,
+                        cacheWrite: assistantInfo.tokens.cache?.write || 0,
+                    };
+                    logger.debug(`[Aggregator] Tokens: input=${tokens.input}, output=${tokens.output}, reasoning=${tokens.reasoning}`);
+                    // Call synchronously so keyboardManager is updated before onComplete sends the reply
+                    this.onTokensCallback(tokens);
+                }
+                if (this.onCompleteCallback && lastPart.length > 0) {
+                    this.onCompleteCallback(this.currentSessionId, lastPart);
+                }
+                this.currentMessageParts.delete(messageID);
+                this.messages.delete(messageID);
+                this.partHashes.delete(messageID);
+                logger.debug(`[Aggregator] Message completed cleanup: remaining messages=${this.currentMessageParts.size}`);
+                if (this.currentMessageParts.size === 0) {
+                    logger.debug("[Aggregator] No more active messages, stopping typing indicator");
+                    this.stopTypingIndicator();
+                }
+            }
+            this.lastUpdated = Date.now();
+        }
+    }
+    handleMessagePartUpdated(event) {
+        const { part } = event.properties;
+        if (part.sessionID !== this.currentSessionId) {
+            return;
+        }
+        const messageID = part.messageID;
+        const messageInfo = this.messages.get(messageID);
+        if (part.type === "text" && "text" in part && part.text) {
+            const partHash = this.hashString(part.text);
+            if (!this.partHashes.has(messageID)) {
+                this.partHashes.set(messageID, new Set());
+            }
+            const hashes = this.partHashes.get(messageID);
+            if (hashes.has(partHash)) {
+                return;
+            }
+            hashes.add(partHash);
+            if (messageInfo && messageInfo.role === "assistant") {
+                if (!this.currentMessageParts.has(messageID)) {
+                    this.currentMessageParts.set(messageID, []);
+                    this.startTypingIndicator();
+                }
+                const parts = this.currentMessageParts.get(messageID);
+                parts.push(part.text);
+            }
+            else {
+                if (!this.pendingParts.has(messageID)) {
+                    this.pendingParts.set(messageID, []);
+                }
+                const pending = this.pendingParts.get(messageID);
+                pending.push(part.text);
+            }
+        }
+        else if (part.type === "tool") {
+            const state = part.state;
+            const input = "input" in state ? state.input : undefined;
+            const title = "title" in state ? state.title : undefined;
+            logger.debug(`[Aggregator] Tool event: callID=${part.callID}, tool=${part.tool}, status=${"status" in state ? state.status : "unknown"}`);
+            if (part.tool === "question") {
+                logger.debug(`[Aggregator] Question tool part update:`, JSON.stringify(part, null, 2));
+                // Если question tool завершился с ошибкой, очищаем активный опрос
+                // чтобы агент мог пересоздать его с исправленными данными
+                if ("status" in state && state.status === "error") {
+                    logger.info(`[Aggregator] Question tool failed with error, clearing active poll. callID=${part.callID}`);
+                    if (this.onQuestionErrorCallback) {
+                        setImmediate(() => {
+                            this.onQuestionErrorCallback();
+                        });
+                    }
+                    return;
+                }
+                // NOTE: Questions are now handled via "question.asked" event, not via tool part updates.
+                // This ensures we have access to the requestID needed for question.reply().
+            }
+            if ("status" in state && state.status === "completed") {
+                logger.debug(`[Aggregator] Tool completed: callID=${part.callID}, tool=${part.tool}`, JSON.stringify(state, null, 2));
+                const notifiedKey = `notified-${part.callID}`;
+                if (!this.processedToolStates.has(notifiedKey)) {
+                    this.processedToolStates.add(notifiedKey);
+                    const toolData = {
+                        messageId: messageID,
+                        callId: part.callID,
+                        tool: part.tool,
+                        state: part.state,
+                        input,
+                        title,
+                        metadata: state.metadata,
+                    };
+                    logger.debug(`[Aggregator] Sending tool notification to Telegram: tool=${part.tool}, title=${title || "N/A"}`);
+                    if (this.onToolCallback) {
+                        this.onToolCallback(toolData);
+                    }
+                }
+            }
+            if ("status" in state && state.status === "completed") {
+                const fileKey = `file-${part.callID}`;
+                if (!this.processedToolStates.has(fileKey)) {
+                    this.processedToolStates.add(fileKey);
+                    if (part.tool === "write" && input && "content" in input && "filePath" in input) {
+                        const fileData = prepareCodeFile(input.content, input.filePath, "write");
+                        if (fileData && this.onToolFileCallback) {
+                            logger.debug(`[Aggregator] Sending write file: ${fileData.filename} (${fileData.buffer.length} bytes)`);
+                            this.onToolFileCallback(fileData);
+                        }
+                        // Notify about file change for pinned message
+                        if (this.onFileChangeCallback) {
+                            const lines = input.content.split("\n").length;
+                            this.onFileChangeCallback({
+                                file: input.filePath,
+                                additions: lines,
+                                deletions: 0,
+                            });
+                        }
+                    }
+                    else if (part.tool === "edit" &&
+                        state.metadata &&
+                        "diff" in state.metadata &&
+                        "filediff" in state.metadata) {
+                        const filediff = state.metadata.filediff;
+                        const filePath = filediff.file;
+                        const diff = state.metadata.diff;
+                        if (filePath && diff) {
+                            const fileData = prepareCodeFile(diff, filePath, "edit");
+                            if (fileData && this.onToolFileCallback) {
+                                logger.debug(`[Aggregator] Sending edit file: ${fileData.filename} (${fileData.buffer.length} bytes)`);
+                                this.onToolFileCallback(fileData);
+                            }
+                            // Notify about file change for pinned message
+                            if (this.onFileChangeCallback) {
+                                this.onFileChangeCallback({
+                                    file: filePath,
+                                    additions: filediff.additions || 0,
+                                    deletions: filediff.deletions || 0,
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        this.lastUpdated = Date.now();
+    }
+    hashString(str) {
+        let hash = 0;
+        for (let i = 0; i < str.length; i++) {
+            const char = str.charCodeAt(i);
+            hash = (hash << 5) - hash + char;
+            hash = hash & hash;
+        }
+        return hash.toString(36);
+    }
+    handleSessionStatus(event) {
+        const { sessionID } = event.properties;
+        if (sessionID !== this.currentSessionId) {
+            return;
+        }
+    }
+    handleSessionIdle(event) {
+        const { sessionID } = event.properties;
+        if (sessionID !== this.currentSessionId) {
+            return;
+        }
+        logger.info(`[Aggregator] Session became idle: ${sessionID}`);
+        // Stop typing indicator when session goes idle
+        this.stopTypingIndicator();
+    }
+    handleSessionCompacted(event) {
+        const properties = event.properties;
+        const { sessionID } = properties;
+        if (sessionID !== this.currentSessionId) {
+            return;
+        }
+        logger.info(`[Aggregator] Session compacted: ${sessionID}`);
+        // Reload context from history after compaction
+        if (this.onSessionCompactedCallback) {
+            setImmediate(() => {
+                const project = getCurrentProject();
+                if (project) {
+                    this.onSessionCompactedCallback(sessionID, project.worktree);
+                }
+            });
+        }
+    }
+    handleQuestionAsked(event) {
+        const { id, sessionID, questions } = event.properties;
+        if (sessionID !== this.currentSessionId) {
+            logger.debug(`[Aggregator] Ignoring question.asked for different session: ${sessionID} (current: ${this.currentSessionId})`);
+            return;
+        }
+        logger.info(`[Aggregator] Question asked: requestID=${id}, questions=${questions.length}`);
+        if (this.onQuestionCallback) {
+            const callback = this.onQuestionCallback;
+            setImmediate(async () => {
+                try {
+                    await callback(questions, id);
+                }
+                catch (err) {
+                    logger.error("[Aggregator] Error in question callback:", err);
+                }
+            });
+        }
+    }
+    handleSessionDiff(event) {
+        const properties = event.properties;
+        if (properties.sessionID !== this.currentSessionId) {
+            return;
+        }
+        logger.debug(`[Aggregator] Session diff: ${properties.diff.length} files changed`);
+        if (this.onSessionDiffCallback) {
+            const diffs = properties.diff.map((d) => ({
+                file: d.file,
+                additions: d.additions,
+                deletions: d.deletions,
+            }));
+            const callback = this.onSessionDiffCallback;
+            setImmediate(() => {
+                callback(properties.sessionID, diffs);
+            });
+        }
+    }
+    handlePermissionAsked(event) {
+        const request = event.properties;
+        if (request.sessionID !== this.currentSessionId) {
+            logger.debug(`[Aggregator] Ignoring permission.asked for different session: ${request.sessionID} (current: ${this.currentSessionId})`);
+            return;
+        }
+        logger.info(`[Aggregator] Permission asked: requestID=${request.id}, type=${request.permission}, patterns=${request.patterns.length}`);
+        if (this.onPermissionCallback) {
+            const callback = this.onPermissionCallback;
+            setImmediate(async () => {
+                try {
+                    await callback(request);
+                }
+                catch (err) {
+                    logger.error("[Aggregator] Error in permission callback:", err);
+                }
+            });
+        }
+    }
+}
+export const summaryAggregator = new SummaryAggregator();

package/dist/summary/formatter.js

@@ -0,0 +1,226 @@
+import * as path from "path";
+import { config } from "../config.js";
+import { logger } from "../utils/logger.js";
+const TELEGRAM_MESSAGE_LIMIT = 4096;
+function splitText(text, maxLength) {
+    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;
+        }
+        parts.push(text.slice(currentIndex, endIndex));
+        currentIndex = endIndex;
+    }
+    return parts;
+}
+export function formatSummary(text) {
+    if (!text || text.trim().length === 0) {
+        return [];
+    }
+    const parts = splitText(text, TELEGRAM_MESSAGE_LIMIT);
+    const formattedParts = [];
+    for (const part of parts) {
+        const trimmed = part.trim();
+        if (!trimmed) {
+            continue;
+        }
+        if (parts.length > 1) {
+            formattedParts.push(`\`\`\`\n${trimmed}\n\`\`\``);
+        }
+        else {
+            formattedParts.push(trimmed);
+        }
+    }
+    return formattedParts;
+}
+function getToolDetails(tool, input) {
+    if (!input) {
+        return "";
+    }
+    // Сначала проверяем специфичные для известных тулов поля
+    switch (tool) {
+        case "read":
+        case "edit":
+        case "write":
+            const path = input.path || input.filePath;
+            if (typeof path === "string")
+                return path;
+            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;
+    }
+    // Универсальный поиск для MCP и прочих инструментов
+    // Ищем типичные поля: query, url, name, prompt
+    const commonFields = ["query", "url", "name", "prompt", "text"];
+    for (const field of commonFields) {
+        if (typeof input[field] === "string") {
+            return input[field];
+        }
+    }
+    // Если ничего не нашли, но есть строковые поля, берем первое попавшееся (кроме 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 "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: "x",
+        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*(ещё ${todos.length - MAX_TODOS} задач)*`;
+    }
+    return result;
+}
+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${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;
+    }
+    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" && toolInfo.metadata && "filediff" in toolInfo.metadata) {
+        const filediff = toolInfo.metadata.filediff;
+        logger.debug("[Formatter] Edit metadata:", JSON.stringify(toolInfo.metadata, null, 2));
+        const parts = [];
+        if (filediff.additions && filediff.additions > 0)
+            parts.push(`+${filediff.additions}`);
+        if (filediff.deletions && filediff.deletions > 0)
+            parts.push(`-${filediff.deletions}`);
+        if (parts.length > 0) {
+            lineInfo = ` (${parts.join(" ")})`;
+        }
+    }
+    return `${toolIcon} ${description}${tool}${detailsStr}${lineInfo}`;
+}
+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) {
+    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: ${filePath} (${sizeKb.toFixed(2)} KB > ${config.files.maxFileSizeKb} KB)`);
+        return null;
+    }
+    const header = `${operation === "write" ? "Write" : "Edit"} File/Path: ${filePath}\n${"=".repeat(60)}\n\n`;
+    const fullContent = header + processedContent;
+    const buffer = Buffer.from(fullContent, "utf8");
+    const basename = path.basename(filePath);
+    const filename = `${operation}_${basename}.txt`;
+    return { buffer, filename, caption: "" };
+}