@grinev/opencode-telegram-bot 0.21.1 → 0.22.0

package/dist/{summary/aggregator.js → app/managers/summary-aggregation-manager.js}

@@ -1,6 +1,6 @@
-import { normalizePathForDisplay, prepareCodeFile } from "./formatter.js";
-import { logger } from "../utils/logger.js";
-import { getCurrentProject } from "../settings/manager.js";
+import { normalizePathForDisplay, prepareCodeFile } from "../formatters/summary-formatter.js";
+import { logger } from "../../utils/logger.js";
+import { getCurrentProject } from "../stores/settings-store.js";
 function extractFirstUpdatedFileFromTitle(title) {
     for (const rawLine of title.split("\n")) {
         const line = rawLine.trim();
@@ -38,6 +38,7 @@ function normalizeSnapshotValue(value) {
 class SummaryAggregator {
     currentSessionId = null;
     textMessageStates = new Map();
+    thinkingMessageStates = new Map();
     messages = new Map();
     messageCount = 0;
     lastUpdated = 0;
@@ -45,10 +46,12 @@ class SummaryAggregator {
     onPartialCallback = null;
     onExternalUserInputCallback = null;
     onToolCallback = null;
+    onRootToolUpdateCallback = null;
     onToolFileCallback = null;
     onQuestionCallback = null;
     onQuestionErrorCallback = null;
     onThinkingCallback = null;
+    onThinkingFinishedCallback = null;
     onTokensCallback = null;
     onCostCallback = null;
     onSubagentCallback = null;
@@ -62,6 +65,7 @@ class SummaryAggregator {
     onClearedCallback = null;
     processedToolStates = new Set();
     thinkingFiredForMessages = new Set();
+    thinkingFinishedForMessages = new Set();
     deliveredExternalUserMessageIds = new Set();
     knownTextPartIds = new Map();
     bot = null;
@@ -93,6 +97,9 @@ class SummaryAggregator {
     setOnTool(callback) {
         this.onToolCallback = callback;
     }
+    setOnRootToolUpdate(callback) {
+        this.onRootToolUpdateCallback = callback;
+    }
     setOnToolFile(callback) {
         this.onToolFileCallback = callback;
     }
@@ -105,6 +112,9 @@ class SummaryAggregator {
     setOnThinking(callback) {
         this.onThinkingCallback = callback;
     }
+    setOnThinkingFinished(callback) {
+        this.onThinkingFinishedCallback = callback;
+    }
     setOnTokens(callback) {
         this.onTokensCallback = callback;
     }
@@ -242,11 +252,13 @@ class SummaryAggregator {
         this.stopTypingIndicator();
         this.currentSessionId = null;
         this.textMessageStates.clear();
+        this.thinkingMessageStates.clear();
         this.messages.clear();
         this.partHashes.clear();
         this.knownTextPartIds.clear();
         this.processedToolStates.clear();
         this.thinkingFiredForMessages.clear();
+        this.thinkingFinishedForMessages.clear();
         this.deliveredExternalUserMessageIds.clear();
         this.trackedSessionParents.clear();
         this.subagentStates.clear();
@@ -755,26 +767,38 @@ class SummaryAggregator {
             this.registerKnownTextPart(messageID, part.id);
             this.registerTextPart(messageID, part.id);
         }
+        if (part.type === "reasoning") {
+            this.registerThinkingPart(messageID, part.id, this.extractReasoningTitle(part));
+        }
         const deltaFromUpdated = event.properties.delta;
         if (part.type === "text" &&
             typeof deltaFromUpdated === "string" &&
             deltaFromUpdated.length > 0) {
+            this.emitThinkingFinishedOnce(part.sessionID, messageID);
             this.applyTextDelta(part.sessionID, messageID, part.id, deltaFromUpdated, part.text);
             this.lastUpdated = Date.now();
             return;
         }
+        if (part.type === "reasoning" &&
+            typeof deltaFromUpdated === "string" &&
+            deltaFromUpdated.length > 0) {
+            const partText = "text" in part && typeof part.text === "string" ? part.text : undefined;
+            this.applyThinkingDelta(part.sessionID, messageID, part.id, deltaFromUpdated, partText, this.extractReasoningTitle(part));
+            this.lastUpdated = Date.now();
+            return;
+        }
         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(messageID) && this.onThinkingCallback) {
+            // Fire the thinking callback on every reasoning update. The first update
+            // preserves the old lightweight indicator behavior for callers that do
+            // not display full reasoning content.
+            const isFirstUpdate = !this.thinkingFiredForMessages.has(messageID);
+            if (isFirstUpdate) {
                 this.thinkingFiredForMessages.add(messageID);
-                const callback = this.onThinkingCallback;
-                const sessionID = part.sessionID;
-                setImmediate(() => {
-                    if (typeof callback === "function") {
-                        callback(sessionID);
-                    }
-                });
+            }
+            const partText = "text" in part && typeof part.text === "string" ? part.text : "";
+            const wasUpdated = this.setThinkingPartSnapshot(messageID, part.id, partText, this.extractReasoningTitle(part));
+            if (isFirstUpdate || wasUpdated) {
+                this.emitThinkingUpdate(part.sessionID, messageID, isFirstUpdate);
             }
         }
         else if (part.type === "text" && "text" in part && part.text) {
@@ -784,6 +808,7 @@ class SummaryAggregator {
             if (!wasUpdated) {
                 return;
             }
+            this.emitThinkingFinishedOnce(part.sessionID, messageID);
             const fullText = this.getCombinedMessageText(messageID);
             if (messageInfo && messageInfo.role === "assistant") {
                 this.startTypingIndicator();
@@ -808,6 +833,19 @@ class SummaryAggregator {
                 this.updateSubagentFromTaskTool(part.sessionID, input);
             }
             logger.debug(`[Aggregator] Tool event: callID=${part.callID}, tool=${part.tool}, status=${"status" in state ? state.status : "unknown"}`);
+            if (this.onRootToolUpdateCallback) {
+                this.onRootToolUpdateCallback({
+                    sessionId: part.sessionID,
+                    messageId: messageID,
+                    callId: part.callID,
+                    tool: part.tool,
+                    state: part.state,
+                    input,
+                    title,
+                    metadata: "metadata" in state ? state.metadata : undefined,
+                    hasFileAttachment: false,
+                });
+            }
             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
@@ -871,6 +909,13 @@ class SummaryAggregator {
         if (!sessionID || !messageID || typeof delta !== "string" || delta.length === 0) {
             return;
         }
+        if (partType === "reasoning" || (!partType && this.isKnownThinkingPart(messageID, partID))) {
+            const title = part
+                ? this.extractReasoningTitle(part)
+                : undefined;
+            this.applyThinkingDelta(sessionID, messageID, partID, delta, part?.text, title);
+            return;
+        }
         if (partType && partType !== "text") {
             return;
         }
@@ -890,6 +935,7 @@ class SummaryAggregator {
                 this.registerTextPart(messageID, partID);
             }
         }
+        this.emitThinkingFinishedOnce(sessionID, messageID);
         this.applyTextDelta(sessionID, messageID, partID, delta, part?.text);
     }
     applyTextDelta(sessionID, messageID, partID, delta, fullTextHint) {
@@ -916,6 +962,121 @@ class SummaryAggregator {
         this.startTypingIndicator();
         this.emitPartialText(sessionID, messageID, combined);
     }
+    extractReasoningTitle(part) {
+        for (const key of ["title", "heading", "summary", "name"]) {
+            const value = part[key];
+            if (typeof value === "string" && value.trim()) {
+                return value;
+            }
+        }
+        const metadata = part.metadata;
+        if (metadata && typeof metadata === "object") {
+            for (const key of ["title", "heading", "summary", "name"]) {
+                const value = metadata[key];
+                if (typeof value === "string" && value.trim()) {
+                    return value;
+                }
+            }
+        }
+        return undefined;
+    }
+    getOrCreateThinkingMessageState(messageID) {
+        let state = this.thinkingMessageStates.get(messageID);
+        if (!state) {
+            state = {
+                orderedPartIds: [],
+                sections: new Map(),
+            };
+            this.thinkingMessageStates.set(messageID, state);
+        }
+        return state;
+    }
+    isKnownThinkingPart(messageID, partID) {
+        return this.thinkingMessageStates.get(messageID)?.sections.has(partID) ?? false;
+    }
+    registerThinkingPart(messageID, partID, title) {
+        const state = this.getOrCreateThinkingMessageState(messageID);
+        if (!state.orderedPartIds.includes(partID)) {
+            state.orderedPartIds.push(partID);
+        }
+        const existing = state.sections.get(partID);
+        if (!existing) {
+            const section = { id: partID, text: "" };
+            if (title) {
+                section.title = title;
+            }
+            state.sections.set(partID, section);
+            return;
+        }
+        if (title && existing.title !== title) {
+            existing.title = title;
+        }
+    }
+    setThinkingPartSnapshot(messageID, partID, text, title) {
+        this.registerThinkingPart(messageID, partID, title);
+        const state = this.getOrCreateThinkingMessageState(messageID);
+        const existing = state.sections.get(partID);
+        const nextTitle = title ?? existing?.title;
+        if (existing && existing.text === text && existing.title === nextTitle) {
+            return false;
+        }
+        const next = { id: partID, text };
+        if (nextTitle) {
+            next.title = nextTitle;
+        }
+        state.sections.set(partID, next);
+        return true;
+    }
+    applyThinkingDelta(sessionID, messageID, partID, delta, fullTextHint, title) {
+        if (sessionID !== this.currentSessionId) {
+            return;
+        }
+        this.registerThinkingPart(messageID, partID, title);
+        const state = this.getOrCreateThinkingMessageState(messageID);
+        const existing = state.sections.get(partID);
+        const previous = existing?.text ?? "";
+        let accumulated = `${previous}${delta}`;
+        if (typeof fullTextHint === "string" && fullTextHint.length > accumulated.length) {
+            accumulated = fullTextHint;
+        }
+        this.setThinkingPartSnapshot(messageID, partID, accumulated, title ?? existing?.title);
+        this.emitThinkingUpdate(sessionID, messageID, false);
+    }
+    getThinkingSections(messageID) {
+        const state = this.thinkingMessageStates.get(messageID);
+        if (!state) {
+            return [];
+        }
+        return state.orderedPartIds
+            .map((partID) => state.sections.get(partID))
+            .filter((section) => Boolean(section))
+            .map((section) => ({ ...section }));
+    }
+    emitThinkingUpdate(sessionId, messageId, isFirstUpdate) {
+        if (!this.onThinkingCallback) {
+            return;
+        }
+        const sections = this.getThinkingSections(messageId);
+        if (sections.length === 0) {
+            return;
+        }
+        const callback = this.onThinkingCallback;
+        setImmediate(() => {
+            callback({ sessionId, messageId, sections, isFirstUpdate });
+        });
+    }
+    emitThinkingFinishedOnce(sessionId, messageId) {
+        if (!this.onThinkingFinishedCallback ||
+            !this.thinkingFiredForMessages.has(messageId) ||
+            this.thinkingFinishedForMessages.has(messageId)) {
+            return;
+        }
+        this.thinkingFinishedForMessages.add(messageId);
+        const callback = this.onThinkingFinishedCallback;
+        setImmediate(() => {
+            callback(sessionId, messageId);
+        });
+    }
     emitExternalUserInputIfReady(sessionId, messageId) {
         if (sessionId !== this.currentSessionId || this.deliveredExternalUserMessageIds.has(messageId)) {
             return;
@@ -942,9 +1103,12 @@ class SummaryAggregator {
     }
     cleanupCompletedMessage(messageId) {
         this.textMessageStates.delete(messageId);
+        this.thinkingMessageStates.delete(messageId);
         this.messages.delete(messageId);
         this.partHashes.delete(messageId);
         this.knownTextPartIds.delete(messageId);
+        this.thinkingFiredForMessages.delete(messageId);
+        this.thinkingFinishedForMessages.delete(messageId);
         if (this.textMessageStates.size === 0) {
             logger.debug("[Aggregator] No more active messages, stopping typing indicator");
             this.stopTypingIndicator();

package/dist/{agent/manager.js → app/services/agent-selection-service.js}

@@ -1,8 +1,7 @@
-import { opencodeClient } from "../opencode/client.js";
-import { getCurrentProject } from "../settings/manager.js";
-import { getCurrentSession } from "../session/manager.js";
-import { getCurrentAgent, setCurrentAgent } from "../settings/manager.js";
-import { logger } from "../utils/logger.js";
+import { opencodeClient } from "../../opencode/client.js";
+import { getCurrentAgent, getCurrentProject, setCurrentAgent } from "../stores/settings-store.js";
+import { getCurrentSession } from "./session-service.js";
+import { logger } from "../../utils/logger.js";
 /**
  * Get list of available agents from OpenCode API
  * @returns Array of available agents (filtered by mode and hidden flag)

package/dist/{attach/service.js → app/services/attach-service.js}

@@ -1,17 +1,17 @@
-import { opencodeClient } from "../opencode/client.js";
-import { isOpencodeServerHealthy } from "../opencode/ready-refresh.js";
-import { summaryAggregator } from "../summary/aggregator.js";
-import { pinnedMessageManager } from "../pinned/manager.js";
-import { keyboardManager } from "../keyboard/manager.js";
-import { questionManager } from "../question/manager.js";
-import { permissionManager } from "../permission/manager.js";
-import { showCurrentQuestion } from "../bot/handlers/question.js";
-import { showPermissionRequest } from "../bot/handlers/permission.js";
-import { getCurrentSession } from "../session/manager.js";
-import { getCurrentProject } from "../settings/manager.js";
-import { attachManager } from "./manager.js";
-import { logger } from "../utils/logger.js";
-import { isExpectedOpencodeUnavailableError } from "../utils/opencode-error.js";
+import { opencodeClient } from "../../opencode/client.js";
+import { isOpencodeServerHealthy } from "../../opencode/ready-refresh.js";
+import { summaryAggregator } from "../managers/summary-aggregation-manager.js";
+import { questionManager } from "../managers/question-manager.js";
+import { permissionManager } from "../managers/permission-manager.js";
+import { getCurrentSession } from "./session-service.js";
+import { getCurrentProject } from "../stores/settings-store.js";
+import { attachManager } from "../managers/attach-manager.js";
+import { logger } from "../../utils/logger.js";
+import { isExpectedOpencodeUnavailableError } from "../../utils/opencode-error.js";
+let attachPresentation = null;
+export function configureAttachPresentation(deps) {
+    attachPresentation = deps;
+}
 function getAttachBusyStatus(sessionId, statuses) {
     if (!statuses || typeof statuses !== "object") {
         return false;
@@ -19,36 +19,12 @@ function getAttachBusyStatus(sessionId, statuses) {
     const sessionStatus = statuses[sessionId];
     return sessionStatus?.type === "busy";
 }
-async function ensureAttachPinnedSession({ api, chatId, session, forceFullRestore = false, }) {
-    if (!pinnedMessageManager.isInitialized()) {
-        pinnedMessageManager.initialize(api, chatId);
-    }
-    keyboardManager.initialize(api, chatId);
-    const pinnedState = pinnedMessageManager.getState();
-    if (pinnedState.sessionId === session.id && pinnedState.messageId) {
-        if (forceFullRestore) {
-            await pinnedMessageManager.loadContextFromHistory(session.id, session.directory);
-        }
-        return;
-    }
-    if (pinnedState.messageId && pinnedState.sessionId === null) {
-        await pinnedMessageManager.restoreExistingSession(session.id, session.title);
-    }
-    else {
-        await pinnedMessageManager.onSessionChange(session.id, session.title);
-    }
-    await pinnedMessageManager.loadContextFromHistory(session.id, session.directory);
-    const contextInfo = pinnedMessageManager.getContextInfo();
-    if (contextInfo) {
-        keyboardManager.updateContext(contextInfo.tokensUsed, contextInfo.tokensLimit);
-    }
-}
 async function syncPinnedAttachState() {
-    if (!pinnedMessageManager.isInitialized()) {
+    if (!attachPresentation) {
         return;
     }
     const attached = attachManager.getSnapshot();
-    await pinnedMessageManager.setAttachState(attached !== null, attached?.busy ?? false);
+    await attachPresentation.syncAttachState(attached !== null, attached?.busy ?? false);
 }
 async function restorePendingQuestion(bot, chatId, sessionId, directory) {
     const { data, error } = await opencodeClient.question.list({
@@ -64,11 +40,11 @@ async function restorePendingQuestion(bot, chatId, sessionId, directory) {
         return false;
     }
     const pendingQuestion = data.find((request) => request.sessionID === sessionId);
-    if (!pendingQuestion) {
+    if (!pendingQuestion || !attachPresentation) {
         return false;
     }
     questionManager.startQuestions(pendingQuestion.questions, pendingQuestion.id);
-    await showCurrentQuestion(bot.api, chatId);
+    await attachPresentation.showCurrentQuestion(bot.api, chatId);
     return true;
 }
 async function restorePendingPermissions(bot, chatId, sessionId, directory) {
@@ -85,15 +61,18 @@ async function restorePendingPermissions(bot, chatId, sessionId, directory) {
         return 0;
     }
     const pendingPermissions = data.filter((request) => request.sessionID === sessionId);
+    if (!attachPresentation) {
+        return 0;
+    }
     for (const request of pendingPermissions) {
-        await showPermissionRequest(bot.api, chatId, request);
+        await attachPresentation.showPermissionRequest(bot.api, chatId, request);
     }
     return pendingPermissions.length;
 }
 export async function attachToSession(deps) {
     const { bot, chatId, session, ensureEventSubscription, forceFullRestore = false } = deps;
     const alreadyAttached = attachManager.isAttachedSession(session.id, session.directory);
-    await ensureAttachPinnedSession({
+    await attachPresentation?.ensurePinnedSession({
         api: bot.api,
         chatId,
         session,

package/dist/{bot/utils/busy-reconciliation.js → app/services/busy-reconciliation-service.js}

@@ -1,19 +1,22 @@
 import { opencodeClient } from "../../opencode/client.js";
-import { foregroundSessionState, } from "../../scheduled-task/foreground-state.js";
-import { scheduledTaskRuntime } from "../../scheduled-task/runtime.js";
-import { attachManager } from "../../attach/manager.js";
-import { markAttachedSessionBusy, markAttachedSessionIdle } from "../../attach/service.js";
-import { assistantRunState } from "../assistant-run-state.js";
-import { clearPromptResponseMode } from "../handlers/prompt.js";
+import { foregroundSessionState, } from "../managers/foreground-session-state-manager.js";
+import { scheduledTaskRuntime } from "./scheduled-task-runtime-service.js";
+import { attachManager } from "../managers/attach-manager.js";
+import { markAttachedSessionBusy, markAttachedSessionIdle } from "./attach-service.js";
+import { assistantRunState } from "../managers/assistant-run-state-manager.js";
 import { logger } from "../../utils/logger.js";
 const RECONCILE_MIN_INTERVAL_MS = 10_000;
 const FOREGROUND_BUSY_RECONCILE_GRACE_MS = 2_000;
 const inFlightDirectories = new Set();
 const lastReconcileAtByDirectory = new Map();
 let responseStreamerInstance = null;
+let clearPromptResponseModeForReconciliation = null;
 export function setResponseStreamerForReconciliation(streamer) {
     responseStreamerInstance = streamer;
 }
+export function setPromptResponseModeClearerForReconciliation(clearer) {
+    clearPromptResponseModeForReconciliation = clearer;
+}
 function getReconciliationTargets(directory) {
     const foregroundBusySessions = foregroundSessionState
         .getBusySessions()
@@ -38,7 +41,7 @@ function isWithinForegroundBusyGracePeriod(session, now) {
 async function clearForegroundBusySession(sessionId, reason) {
     foregroundSessionState.markIdle(sessionId);
     assistantRunState.clearRun(sessionId, reason);
-    clearPromptResponseMode(sessionId);
+    clearPromptResponseModeForReconciliation?.(sessionId);
 }
 export async function reconcileBusyStateNow(directory, now = Date.now()) {
     if (!directory) {
@@ -118,4 +121,6 @@ export async function reconcileBusyState(directory, now = Date.now()) {
 export function __resetBusyReconciliationForTests() {
     inFlightDirectories.clear();
     lastReconcileAtByDirectory.clear();
+    responseStreamerInstance = null;
+    clearPromptResponseModeForReconciliation = null;
 }

package/dist/app/services/command-catalog-service.js

@@ -0,0 +1,21 @@
+import { opencodeClient } from "../../opencode/client.js";
+function normalizeDirectoryForCommandApi(directory) {
+    return directory.replace(/\\/g, "/");
+}
+export async function loadCommandCatalog(projectDirectory) {
+    const { data, error } = await opencodeClient.command.list({
+        directory: normalizeDirectoryForCommandApi(projectDirectory),
+    });
+    if (error || !data) {
+        throw error || new Error("No command data received");
+    }
+    return data
+        .filter((command) => {
+        const source = command.source;
+        return (typeof command.name === "string" && command.name.trim().length > 0 && source === "command");
+    })
+        .map((command) => ({
+        name: command.name,
+        description: command.description,
+    }));
+}

package/dist/{bot/utils/external-user-input.js → app/services/external-user-input-service.js}

@@ -1,7 +1,9 @@
 import { t } from "../../i18n/index.js";
-import { escapePlainTextForTelegramMarkdownV2 } from "../../summary/formatter.js";
-import { sendBotText } from "./telegram-text.js";
 const EXTERNAL_USER_INPUT_MAX_DISPLAY_LENGTH = 2000;
+const MARKDOWN_V2_RESERVED_CHARS = /([_\*\[\]\(\)~`>#+\-=|{}.!\\])/g;
+function escapePlainTextForTelegramMarkdownV2(text) {
+    return text.replace(MARKDOWN_V2_RESERVED_CHARS, "\\$1");
+}
 function normalizeExternalUserInputText(text) {
     return text.replace(/\r\n/g, "\n").trim();
 }
@@ -35,20 +37,3 @@ export function buildExternalUserInputNotification(text) {
         rawFallbackText: `${title}\n\n${buildQuotedPlainText(displayText)}`,
     };
 }
-export async function deliverExternalUserInputNotification({ api, chatId, currentSessionId, sessionId, text, consumeSuppressedInput, }) {
-    const notification = buildExternalUserInputNotification(text);
-    if (!notification || currentSessionId !== sessionId) {
-        return false;
-    }
-    if (consumeSuppressedInput(sessionId, text)) {
-        return false;
-    }
-    await sendBotText({
-        api,
-        chatId,
-        text: notification.text,
-        rawFallbackText: notification.rawFallbackText,
-        format: "markdown_v2",
-    });
-    return true;
-}