opencode-telegram-group-topics-bot 0.11.2

package/dist/summary/aggregator.js

@@ -0,0 +1,625 @@
+import { normalizePathForDisplay, prepareCodeFile } from "./formatter.js";
+import { logger } from "../utils/logger.js";
+import { getSessionById } from "../session/manager.js";
+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 "";
+}
+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 extractEventSessionId(event) {
+    const eventWithProperties = event;
+    if (typeof eventWithProperties.properties?.info?.sessionID === "string") {
+        return eventWithProperties.properties.info.sessionID;
+    }
+    if (typeof eventWithProperties.properties?.part?.sessionID === "string") {
+        return eventWithProperties.properties.part.sessionID;
+    }
+    if (typeof eventWithProperties.properties?.request?.sessionID === "string") {
+        return eventWithProperties.properties.request.sessionID;
+    }
+    if (typeof eventWithProperties.properties?.session?.id === "string") {
+        return eventWithProperties.properties.session.id;
+    }
+    return null;
+}
+class SummaryAggregator {
+    trackedSessionIds = new Set();
+    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;
+    onTypingIndicatorCallback = null;
+    onTokensCallback = null;
+    onSessionCompactedCallback = null;
+    onSessionErrorCallback = null;
+    onSessionRetryCallback = null;
+    onPermissionCallback = null;
+    onSessionDiffCallback = null;
+    onFileChangeCallback = null;
+    onClearedCallback = null;
+    processedToolStates = new Set();
+    thinkingFiredForMessages = new Set();
+    typingTimer = null;
+    activeTypingSessions = new Set();
+    partHashes = new Map();
+    getMessageKey(sessionId, messageId) {
+        return `${sessionId}:${messageId}`;
+    }
+    isTrackedSession(sessionId) {
+        return this.trackedSessionIds.has(sessionId);
+    }
+    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;
+    }
+    setOnTypingIndicator(callback) {
+        this.onTypingIndicatorCallback = callback;
+    }
+    setOnTokens(callback) {
+        this.onTokensCallback = callback;
+    }
+    setOnSessionCompacted(callback) {
+        this.onSessionCompactedCallback = callback;
+    }
+    setOnSessionError(callback) {
+        this.onSessionErrorCallback = callback;
+    }
+    setOnSessionRetry(callback) {
+        this.onSessionRetryCallback = callback;
+    }
+    setOnPermission(callback) {
+        this.onPermissionCallback = callback;
+    }
+    setOnSessionDiff(callback) {
+        this.onSessionDiffCallback = callback;
+    }
+    setOnFileChange(callback) {
+        this.onFileChangeCallback = callback;
+    }
+    setOnCleared(callback) {
+        this.onClearedCallback = callback;
+    }
+    hasActiveMessageForSession(sessionId) {
+        for (const value of this.messages.values()) {
+            if (value.sessionId === sessionId && value.role === "assistant") {
+                return true;
+            }
+        }
+        return false;
+    }
+    emitTypingIndicators() {
+        const callback = this.onTypingIndicatorCallback;
+        if (!callback) {
+            return;
+        }
+        for (const sessionId of this.activeTypingSessions) {
+            try {
+                callback(sessionId);
+            }
+            catch (error) {
+                logger.error("[Aggregator] Typing callback failed", { sessionId }, error);
+            }
+        }
+    }
+    startTypingIndicator(sessionId) {
+        this.activeTypingSessions.add(sessionId);
+        if (this.typingTimer) {
+            return;
+        }
+        this.emitTypingIndicators();
+        this.typingTimer = setInterval(() => {
+            this.emitTypingIndicators();
+        }, 4000);
+    }
+    stopTypingIndicator(sessionId) {
+        if (sessionId) {
+            this.activeTypingSessions.delete(sessionId);
+        }
+        else {
+            this.activeTypingSessions.clear();
+        }
+        if (!this.typingTimer || this.activeTypingSessions.size > 0) {
+            return;
+        }
+        clearInterval(this.typingTimer);
+        this.typingTimer = null;
+    }
+    processEvent(event) {
+        try {
+            // 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 "session.error":
+                    this.handleSessionError(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;
+            }
+        }
+        catch (error) {
+            logger.error("[Aggregator] Failed to process event", {
+                eventType: event.type,
+                sessionId: extractEventSessionId(event),
+            }, error);
+        }
+    }
+    setSession(sessionId) {
+        this.trackedSessionIds.add(sessionId);
+    }
+    clearSession(sessionId) {
+        this.trackedSessionIds.delete(sessionId);
+        this.stopTypingIndicator(sessionId);
+        for (const [messageKey, message] of this.messages.entries()) {
+            if (message.sessionId !== sessionId) {
+                continue;
+            }
+            this.messages.delete(messageKey);
+            this.currentMessageParts.delete(messageKey);
+            this.pendingParts.delete(messageKey);
+            this.partHashes.delete(messageKey);
+            this.thinkingFiredForMessages.delete(messageKey);
+        }
+    }
+    clear() {
+        this.stopTypingIndicator();
+        this.trackedSessionIds.clear();
+        this.currentMessageParts.clear();
+        this.pendingParts.clear();
+        this.messages.clear();
+        this.partHashes.clear();
+        this.processedToolStates.clear();
+        this.thinkingFiredForMessages.clear();
+        this.messageCount = 0;
+        this.lastUpdated = 0;
+        if (this.onClearedCallback) {
+            try {
+                this.onClearedCallback();
+            }
+            catch (err) {
+                logger.error("[Aggregator] Error in clear callback:", err);
+            }
+        }
+    }
+    handleMessageUpdated(event) {
+        const { info } = event.properties;
+        if (!this.isTrackedSession(info.sessionID)) {
+            return;
+        }
+        const messageID = info.id;
+        const messageKey = this.getMessageKey(info.sessionID, messageID);
+        this.messages.set(messageKey, { role: info.role, sessionId: info.sessionID });
+        if (info.role === "assistant") {
+            if (!this.currentMessageParts.has(messageKey)) {
+                this.currentMessageParts.set(messageKey, []);
+                this.messageCount++;
+                this.startTypingIndicator(info.sessionID);
+            }
+            const pending = this.pendingParts.get(messageKey) || [];
+            const current = this.currentMessageParts.get(messageKey) || [];
+            this.currentMessageParts.set(messageKey, [...current, ...pending]);
+            this.pendingParts.delete(messageKey);
+            const assistantMessage = info;
+            const time = assistantMessage.time;
+            if (time?.completed) {
+                const parts = this.currentMessageParts.get(messageKey) || [];
+                const lastPart = parts[parts.length - 1] || "";
+                logger.debug(`[Aggregator] Message part completed: messageId=${messageID}, textLength=${lastPart.length}, totalParts=${parts.length}, session=${info.sessionID}`);
+                // 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(info.sessionID, tokens);
+                }
+                if (this.onCompleteCallback && lastPart.length > 0) {
+                    this.onCompleteCallback(info.sessionID, lastPart);
+                }
+                this.currentMessageParts.delete(messageKey);
+                this.messages.delete(messageKey);
+                this.partHashes.delete(messageKey);
+                logger.debug(`[Aggregator] Message completed cleanup: remaining messages=${this.currentMessageParts.size}`);
+                if (!this.hasActiveMessageForSession(info.sessionID)) {
+                    logger.debug(`[Aggregator] No more active messages for session ${info.sessionID}, stopping typing indicator`);
+                    this.stopTypingIndicator(info.sessionID);
+                }
+            }
+            this.lastUpdated = Date.now();
+        }
+    }
+    handleMessagePartUpdated(event) {
+        const { part } = event.properties;
+        if (!this.isTrackedSession(part.sessionID)) {
+            return;
+        }
+        const messageID = part.messageID;
+        const messageKey = this.getMessageKey(part.sessionID, messageID);
+        const messageInfo = this.messages.get(messageKey);
+        if (part.type === "reasoning") {
+            // Fire the thinking callback once per message on the first reasoning part.
+            // This is the signal that the model is actually doing extended thinking.
+            if (!this.thinkingFiredForMessages.has(messageKey) && this.onThinkingCallback) {
+                this.thinkingFiredForMessages.add(messageKey);
+                const callback = this.onThinkingCallback;
+                const sessionID = part.sessionID;
+                setImmediate(() => {
+                    if (typeof callback === "function") {
+                        callback(sessionID);
+                    }
+                });
+            }
+        }
+        else if (part.type === "text" && "text" in part && part.text) {
+            const partHash = this.hashString(part.text);
+            if (!this.partHashes.has(messageKey)) {
+                this.partHashes.set(messageKey, new Set());
+            }
+            const hashes = this.partHashes.get(messageKey);
+            if (hashes.has(partHash)) {
+                return;
+            }
+            hashes.add(partHash);
+            if (messageInfo && messageInfo.role === "assistant") {
+                if (!this.currentMessageParts.has(messageKey)) {
+                    this.currentMessageParts.set(messageKey, []);
+                    this.startTypingIndicator(part.sessionID);
+                }
+                const parts = this.currentMessageParts.get(messageKey);
+                parts.push(part.text);
+            }
+            else {
+                if (!this.pendingParts.has(messageKey)) {
+                    this.pendingParts.set(messageKey, []);
+                }
+                const pending = this.pendingParts.get(messageKey);
+                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));
+                // If the question tool fails, clear the active poll
+                // so the agent can recreate it with corrected data
+                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 completedKey = `completed-${part.callID}`;
+                if (!this.processedToolStates.has(completedKey)) {
+                    this.processedToolStates.add(completedKey);
+                    const preparedFileContext = this.prepareToolFileContext(part.tool, input, title, state.metadata);
+                    const toolData = {
+                        sessionId: part.sessionID,
+                        messageId: messageID,
+                        callId: part.callID,
+                        tool: part.tool,
+                        state: part.state,
+                        input,
+                        title,
+                        metadata: state.metadata,
+                        hasFileAttachment: !!preparedFileContext.fileData,
+                    };
+                    logger.debug(`[Aggregator] Sending tool notification to Telegram: tool=${part.tool}, title=${title || "N/A"}`);
+                    if (this.onToolCallback) {
+                        this.onToolCallback(toolData);
+                    }
+                    if (preparedFileContext.fileData && this.onToolFileCallback) {
+                        logger.debug(`[Aggregator] Sending ${part.tool} file: ${preparedFileContext.fileData.filename} (${preparedFileContext.fileData.buffer.length} bytes)`);
+                        this.onToolFileCallback({
+                            ...toolData,
+                            hasFileAttachment: true,
+                            fileData: preparedFileContext.fileData,
+                        });
+                    }
+                    if (preparedFileContext.fileChange && this.onFileChangeCallback) {
+                        this.onFileChangeCallback(preparedFileContext.fileChange, toolData.sessionId);
+                    }
+                }
+            }
+        }
+        this.lastUpdated = Date.now();
+    }
+    prepareToolFileContext(tool, input, title, metadata) {
+        if (tool === "write" && input) {
+            const filePath = typeof input.filePath === "string" ? normalizePathForDisplay(input.filePath) : "";
+            const hasContent = typeof input.content === "string";
+            const content = hasContent ? input.content : "";
+            if (!filePath || !hasContent) {
+                return { fileData: null, fileChange: null };
+            }
+            return {
+                fileData: prepareCodeFile(content, filePath, "write"),
+                fileChange: {
+                    file: filePath,
+                    additions: content.split("\n").length,
+                    deletions: 0,
+                },
+            };
+        }
+        if (tool === "edit" && metadata) {
+            const editMetadata = metadata;
+            const filePath = editMetadata.filediff?.file
+                ? normalizePathForDisplay(editMetadata.filediff.file)
+                : "";
+            const diffText = typeof editMetadata.diff === "string" ? editMetadata.diff : "";
+            if (!filePath || !diffText) {
+                return { fileData: null, fileChange: null };
+            }
+            return {
+                fileData: prepareCodeFile(diffText, filePath, "edit"),
+                fileChange: {
+                    file: filePath,
+                    additions: editMetadata.filediff?.additions || 0,
+                    deletions: editMetadata.filediff?.deletions || 0,
+                },
+            };
+        }
+        if (tool === "apply_patch") {
+            const patchMetadata = metadata;
+            const filePathFromInput = input && typeof input.filePath === "string"
+                ? normalizePathForDisplay(input.filePath)
+                : input && typeof input.path === "string"
+                    ? normalizePathForDisplay(input.path)
+                    : "";
+            const filePathFromTitle = title ? extractFirstUpdatedFileFromTitle(title) : "";
+            const filePath = (patchMetadata?.filediff?.file && normalizePathForDisplay(patchMetadata.filediff.file)) ||
+                filePathFromInput ||
+                normalizePathForDisplay(filePathFromTitle);
+            const diffText = typeof patchMetadata?.diff === "string"
+                ? patchMetadata.diff
+                : input && typeof input.patchText === "string"
+                    ? input.patchText
+                    : "";
+            if (!filePath) {
+                return { fileData: null, fileChange: null };
+            }
+            const fileChange = patchMetadata?.filediff
+                ? {
+                    file: filePath,
+                    additions: patchMetadata.filediff.additions || 0,
+                    deletions: patchMetadata.filediff.deletions || 0,
+                }
+                : diffText
+                    ? (() => {
+                        const changes = countDiffChangesFromText(diffText);
+                        return {
+                            file: filePath,
+                            additions: changes.additions,
+                            deletions: changes.deletions,
+                        };
+                    })()
+                    : null;
+            return {
+                fileData: diffText ? prepareCodeFile(diffText, filePath, "edit") : null,
+                fileChange,
+            };
+        }
+        return { fileData: null, fileChange: null };
+    }
+    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, status } = event.properties;
+        if (!this.isTrackedSession(sessionID)) {
+            return;
+        }
+        if (status?.type !== "retry" || !this.onSessionRetryCallback) {
+            return;
+        }
+        const callback = this.onSessionRetryCallback;
+        const message = status.message?.trim() || "Unknown retry error";
+        logger.warn(`[Aggregator] Session retry: session=${sessionID}, attempt=${status.attempt ?? "n/a"}, message=${message}`);
+        setImmediate(() => {
+            callback({
+                sessionId: sessionID,
+                attempt: status.attempt,
+                message,
+                next: status.next,
+            });
+        });
+    }
+    handleSessionIdle(event) {
+        const { sessionID } = event.properties;
+        if (!this.isTrackedSession(sessionID)) {
+            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 (!this.isTrackedSession(sessionID)) {
+            return;
+        }
+        logger.info(`[Aggregator] Session compacted: ${sessionID}`);
+        // Reload context from history after compaction
+        if (this.onSessionCompactedCallback) {
+            setImmediate(() => {
+                const session = getSessionById(sessionID);
+                if (session?.directory) {
+                    this.onSessionCompactedCallback(sessionID, session.directory);
+                }
+            });
+        }
+    }
+    handleSessionError(event) {
+        const { sessionID, error } = event.properties;
+        if (!this.isTrackedSession(sessionID)) {
+            return;
+        }
+        const message = error?.data?.message || error?.message || error?.name || "Unknown session error";
+        logger.warn(`[Aggregator] Session error: ${sessionID}: ${message}`);
+        this.stopTypingIndicator();
+        if (this.onSessionErrorCallback) {
+            const callback = this.onSessionErrorCallback;
+            setImmediate(() => {
+                callback(sessionID, message);
+            });
+        }
+    }
+    handleQuestionAsked(event) {
+        const { id, sessionID, questions } = event.properties;
+        if (!this.isTrackedSession(sessionID)) {
+            logger.debug(`[Aggregator] Ignoring question.asked for untracked session: ${sessionID}`);
+            return;
+        }
+        logger.info(`[Aggregator] Question asked: requestID=${id}, questions=${questions.length}`);
+        if (this.onQuestionCallback) {
+            const callback = this.onQuestionCallback;
+            setImmediate(async () => {
+                try {
+                    await callback(sessionID, questions, id);
+                }
+                catch (err) {
+                    logger.error("[Aggregator] Error in question callback:", err);
+                }
+            });
+        }
+    }
+    handleSessionDiff(event) {
+        const properties = event.properties;
+        if (!this.isTrackedSession(properties.sessionID)) {
+            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 (!this.isTrackedSession(request.sessionID)) {
+            logger.debug(`[Aggregator] Ignoring permission.asked for untracked session: ${request.sessionID}`);
+            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();