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

package/dist/bot/handlers/question.js

@@ -0,0 +1,294 @@
+import { InlineKeyboard } from "grammy";
+import { questionManager } from "../../question/manager.js";
+import { opencodeClient } from "../../opencode/client.js";
+import { getCurrentProject } from "../../settings/manager.js";
+import { summaryAggregator } from "../../summary/aggregator.js";
+import { logger } from "../../utils/logger.js";
+import { safeBackgroundTask } from "../../utils/safe-background-task.js";
+const MAX_BUTTON_LENGTH = 60;
+export async function handleQuestionCallback(ctx) {
+    const data = ctx.callbackQuery?.data;
+    if (!data)
+        return false;
+    if (!data.startsWith("question:")) {
+        return false;
+    }
+    logger.debug(`[QuestionHandler] Received callback: ${data}`);
+    if (!questionManager.isActive()) {
+        await ctx.answerCallbackQuery({ text: "Опрос неактивен", show_alert: true });
+        return true;
+    }
+    const parts = data.split(":");
+    const action = parts[1];
+    const questionIndex = parseInt(parts[2], 10);
+    try {
+        switch (action) {
+            case "select":
+                await handleSelectOption(ctx, questionIndex, parseInt(parts[3], 10));
+                break;
+            case "submit":
+                await handleSubmitAnswer(ctx, questionIndex);
+                break;
+            case "custom":
+                await handleCustomAnswer(ctx, questionIndex);
+                break;
+            case "cancel":
+                await handleCancelPoll(ctx);
+                break;
+        }
+    }
+    catch (err) {
+        logger.error("[QuestionHandler] Error handling callback:", err);
+        await ctx.answerCallbackQuery({ text: "Ошибка при обработке", show_alert: true });
+    }
+    return true;
+}
+async function handleSelectOption(ctx, questionIndex, optionIndex) {
+    logger.debug(`[QuestionHandler] handleSelectOption: qIndex=${questionIndex}, oIndex=${optionIndex}`);
+    const question = questionManager.getCurrentQuestion();
+    if (!question) {
+        logger.debug("[QuestionHandler] No current question");
+        return;
+    }
+    questionManager.selectOption(questionIndex, optionIndex);
+    if (question.multiple) {
+        logger.debug("[QuestionHandler] Multiple choice mode, updating message");
+        await updateQuestionMessage(ctx);
+        await ctx.answerCallbackQuery();
+    }
+    else {
+        logger.debug("[QuestionHandler] Single choice mode, moving to next question");
+        await ctx.answerCallbackQuery();
+        const answer = questionManager.getSelectedAnswer(questionIndex);
+        logger.debug(`[QuestionHandler] Selected answer for question ${questionIndex}: ${answer}`);
+        // Удаляем сообщение с вопросом перед показом следующего
+        await ctx.deleteMessage().catch(() => { });
+        // НЕ отправляем ответ сразу - переходим к следующему вопросу
+        // Все ответы будут отправлены вместе когда пользователь ответит на все вопросы
+        await showNextQuestion(ctx);
+    }
+}
+async function handleSubmitAnswer(ctx, questionIndex) {
+    const answer = questionManager.getSelectedAnswer(questionIndex);
+    if (!answer) {
+        await ctx.answerCallbackQuery({
+            text: "Выберите хотя бы один вариант",
+            show_alert: true,
+        });
+        return;
+    }
+    logger.debug(`[QuestionHandler] Submit answer for question ${questionIndex}: ${answer}`);
+    await ctx.answerCallbackQuery();
+    // Удаляем сообщение с вопросом перед показом следующего
+    await ctx.deleteMessage().catch(() => { });
+    // НЕ отправляем ответ сразу - переходим к следующему вопросу
+    // Все ответы будут отправлены вместе когда пользователь ответит на все вопросы
+    await showNextQuestion(ctx);
+}
+async function handleCustomAnswer(ctx, _questionIndex) {
+    await ctx.answerCallbackQuery({
+        text: "Введите свой ответ сообщением",
+        show_alert: true,
+    });
+}
+async function handleCancelPoll(ctx) {
+    questionManager.cancel();
+    await ctx.editMessageText("❌ Опрос отменен");
+    await ctx.answerCallbackQuery();
+}
+async function updateQuestionMessage(ctx) {
+    const question = questionManager.getCurrentQuestion();
+    if (!question) {
+        logger.debug("[QuestionHandler] updateQuestionMessage: no current question");
+        return;
+    }
+    const text = formatQuestionText(question);
+    const keyboard = buildQuestionKeyboard(question, questionManager.getSelectedOptions(questionManager.getCurrentIndex()));
+    logger.debug("[QuestionHandler] Updating question message");
+    try {
+        await ctx.editMessageText(text, {
+            reply_markup: keyboard,
+            parse_mode: "Markdown",
+        });
+    }
+    catch (err) {
+        logger.error("[QuestionHandler] Failed to update message:", err);
+    }
+}
+export async function showCurrentQuestion(bot, chatId) {
+    const question = questionManager.getCurrentQuestion();
+    if (!question) {
+        await showPollSummary(bot, chatId);
+        return;
+    }
+    logger.debug(`[QuestionHandler] Showing question: ${question.header} - ${question.question}`);
+    const text = formatQuestionText(question);
+    const keyboard = buildQuestionKeyboard(question, questionManager.getSelectedOptions(questionManager.getCurrentIndex()));
+    logger.debug(`[QuestionHandler] Sending message with keyboard, chatId=${chatId}`);
+    try {
+        const message = await bot.sendMessage(chatId, text, {
+            reply_markup: keyboard,
+            parse_mode: "Markdown",
+        });
+        logger.debug(`[QuestionHandler] Message sent, messageId=${message.message_id}`);
+        questionManager.addMessageId(message.message_id);
+        summaryAggregator.stopTypingIndicator();
+    }
+    catch (err) {
+        logger.error("[QuestionHandler] Failed to send question message:", err);
+        throw err;
+    }
+}
+export async function handleQuestionTextAnswer(ctx) {
+    const text = ctx.message?.text;
+    if (!text)
+        return;
+    const currentIndex = questionManager.getCurrentIndex();
+    if (questionManager.hasCustomAnswer(currentIndex)) {
+        await ctx.reply("Ответ уже получен, подождите...");
+        return;
+    }
+    logger.debug(`[QuestionHandler] Custom text answer for question ${currentIndex}: ${text}`);
+    questionManager.setCustomAnswer(currentIndex, text);
+    // Удаляем предыдущее сообщение с вопросом
+    const messageIds = questionManager.getMessageIds();
+    if (messageIds.length > 0 && ctx.chat) {
+        const lastMessageId = messageIds[messageIds.length - 1];
+        await ctx.api.deleteMessage(ctx.chat.id, lastMessageId).catch(() => { });
+    }
+    // НЕ отправляем ответ сразу - переходим к следующему вопросу
+    // Все ответы будут отправлены вместе когда пользователь ответит на все вопросы
+    await showNextQuestion(ctx);
+}
+async function showNextQuestion(ctx) {
+    questionManager.nextQuestion();
+    if (!ctx.chat) {
+        return;
+    }
+    if (questionManager.hasNextQuestion()) {
+        await showCurrentQuestion(ctx.api, ctx.chat.id);
+    }
+    else {
+        await showPollSummary(ctx.api, ctx.chat.id);
+    }
+}
+async function showPollSummary(bot, chatId) {
+    const answers = questionManager.getAllAnswers();
+    const totalQuestions = questionManager.getTotalQuestions();
+    logger.info(`[QuestionHandler] Poll completed: ${answers.length}/${totalQuestions} questions answered`);
+    // Отправляем все ответы в OpenCode API
+    await sendAllAnswersToAgent(bot, chatId);
+    if (answers.length === 0) {
+        await bot.sendMessage(chatId, "✅ Опрос завершен (без ответов)");
+    }
+    else {
+        const summary = formatAnswersSummary(answers);
+        await bot.sendMessage(chatId, summary);
+    }
+    questionManager.clear();
+    logger.debug("[QuestionHandler] Poll completed and cleared");
+}
+async function sendAllAnswersToAgent(bot, chatId) {
+    const currentProject = getCurrentProject();
+    const requestID = questionManager.getRequestID();
+    const totalQuestions = questionManager.getTotalQuestions();
+    if (!currentProject) {
+        logger.error("[QuestionHandler] No project for sending answers");
+        await bot.sendMessage(chatId, "❌ Нет активного проекта");
+        return;
+    }
+    if (!requestID) {
+        logger.error("[QuestionHandler] No requestID for sending answers");
+        await bot.sendMessage(chatId, "❌ Нет активного запроса");
+        return;
+    }
+    // Собираем ответы на все вопросы
+    // Формат: Array<Array<string>> - для каждого вопроса массив строк (выбранные опции)
+    const allAnswers = [];
+    for (let i = 0; i < totalQuestions; i++) {
+        const customAnswer = questionManager.getCustomAnswer(i);
+        const selectedAnswer = questionManager.getSelectedAnswer(i);
+        // Приоритет: custom answer > selected options
+        const answer = customAnswer || selectedAnswer || "";
+        if (answer) {
+            // Split by newlines if multiple options were selected (in multiple choice mode)
+            // Each option is formatted as "* Label: Description"
+            const answerParts = answer.split("\n").filter((part) => part.trim());
+            allAnswers.push(answerParts);
+        }
+        else {
+            // Empty answer for unanswered questions
+            allAnswers.push([]);
+        }
+    }
+    logger.info(`[QuestionHandler] Sending all ${totalQuestions} answers to agent via question.reply: requestID=${requestID}`);
+    logger.debug(`[QuestionHandler] Answers payload:`, JSON.stringify(allAnswers, null, 2));
+    // КРИТИЧНО: Fire-and-forget! Не ждём завершения question.reply,
+    // иначе может заблокировать следующие updates
+    safeBackgroundTask({
+        taskName: "question.reply",
+        task: () => opencodeClient.question.reply({
+            requestID,
+            directory: currentProject.worktree,
+            answers: allAnswers,
+        }),
+        onSuccess: ({ error }) => {
+            if (error) {
+                logger.error("[QuestionHandler] Failed to send answers via question.reply:", error);
+                void bot.sendMessage(chatId, "❌ Не удалось отправить ответы агенту").catch(() => { });
+                return;
+            }
+            logger.info("[QuestionHandler] All answers sent to agent successfully via question.reply");
+        },
+    });
+}
+function formatQuestionText(question) {
+    const currentIndex = questionManager.getCurrentIndex();
+    const totalQuestions = questionManager.getTotalQuestions();
+    const progressText = totalQuestions > 0 ? `${currentIndex + 1}/${totalQuestions}` : "";
+    const headerTitle = [progressText, question.header].filter(Boolean).join(" ");
+    const header = headerTitle ? `**${headerTitle}**\n\n` : "";
+    const multiple = question.multiple ? "\n*Можно выбрать несколько вариантов*" : "";
+    return `${header}${question.question}${multiple}`;
+}
+function buildQuestionKeyboard(question, selectedOptions) {
+    const keyboard = new InlineKeyboard();
+    const questionIndex = questionManager.getCurrentIndex();
+    logger.debug(`[QuestionHandler] Building keyboard for question ${questionIndex}`);
+    question.options.forEach((option, index) => {
+        const isSelected = selectedOptions.has(index);
+        const icon = isSelected ? "✅ " : "";
+        const buttonText = formatButtonText(option.label, option.description, icon);
+        const callbackData = `question:select:${questionIndex}:${index}`;
+        logger.debug(`[QuestionHandler] Button ${index}: "${buttonText}" -> "${callbackData}"`);
+        keyboard.text(buttonText, callbackData).row();
+    });
+    if (question.multiple) {
+        keyboard.text("✅ Готово", `question:submit:${questionIndex}`);
+        logger.debug(`[QuestionHandler] Added submit button`);
+    }
+    keyboard.text("🔤 Свой ответ", `question:custom:${questionIndex}`);
+    logger.debug(`[QuestionHandler] Added custom answer button`);
+    keyboard.text("❌ Отмена", `question:cancel:${questionIndex}`);
+    logger.debug(`[QuestionHandler] Added cancel button`);
+    logger.debug(`[QuestionHandler] Final keyboard: ${JSON.stringify(keyboard.inline_keyboard)}`);
+    return keyboard;
+}
+function formatButtonText(label, description, icon) {
+    let text = `${icon}${label}`;
+    if (description && icon === "") {
+        text += ` - ${description}`;
+    }
+    if (text.length > MAX_BUTTON_LENGTH) {
+        text = text.substring(0, MAX_BUTTON_LENGTH - 3) + "...";
+    }
+    return text;
+}
+function formatAnswersSummary(answers) {
+    let summary = "✅ Опрос завершен!\n\n";
+    answers.forEach((item, index) => {
+        summary += `Вопрос ${index + 1}:\n${item.question}\n\n`;
+        summary += `Ответ:\n${item.answer}\n\n`;
+    });
+    return summary;
+}

package/dist/bot/handlers/variant.js

@@ -0,0 +1,126 @@
+import { InlineKeyboard } from "grammy";
+import { getAvailableVariants, getCurrentVariant, setCurrentVariant, formatVariantForDisplay, formatVariantForButton, } from "../../variant/manager.js";
+import { getStoredModel } from "../../model/manager.js";
+import { getStoredAgent } from "../../agent/manager.js";
+import { logger } from "../../utils/logger.js";
+import { keyboardManager } from "../../keyboard/manager.js";
+import { pinnedMessageManager } from "../../pinned/manager.js";
+import { createMainKeyboard } from "../utils/keyboard.js";
+/**
+ * Handle variant selection callback
+ * @param ctx grammY context
+ * @returns true if handled, false otherwise
+ */
+export async function handleVariantSelect(ctx) {
+    const callbackQuery = ctx.callbackQuery;
+    if (!callbackQuery?.data || !callbackQuery.data.startsWith("variant:")) {
+        return false;
+    }
+    logger.debug(`[VariantHandler] Received callback: ${callbackQuery.data}`);
+    try {
+        if (ctx.chat) {
+            keyboardManager.initialize(ctx.api, ctx.chat.id);
+        }
+        if (pinnedMessageManager.getContextLimit() === 0) {
+            await pinnedMessageManager.refreshContextLimit();
+        }
+        // Parse callback data: "variant:variantId"
+        const variantId = callbackQuery.data.replace("variant:", "");
+        // Get current model
+        const currentModel = getStoredModel();
+        if (!currentModel.providerID || !currentModel.modelID) {
+            logger.error("[VariantHandler] No model selected");
+            await ctx.answerCallbackQuery({ text: "Ошибка: модель не выбрана" });
+            return false;
+        }
+        // Set variant
+        setCurrentVariant(variantId);
+        // Re-read model after variant update
+        const updatedModel = getStoredModel();
+        // Update keyboard manager state
+        keyboardManager.updateModel(updatedModel);
+        keyboardManager.updateVariant(variantId);
+        // Build keyboard with correct context info
+        const currentAgent = getStoredAgent();
+        const contextInfo = pinnedMessageManager.getContextInfo() ??
+            (pinnedMessageManager.getContextLimit() > 0
+                ? { tokensUsed: 0, tokensLimit: pinnedMessageManager.getContextLimit() }
+                : null);
+        if (contextInfo) {
+            keyboardManager.updateContext(contextInfo.tokensUsed, contextInfo.tokensLimit);
+        }
+        const variantName = formatVariantForButton(variantId);
+        const keyboard = createMainKeyboard(currentAgent, updatedModel, contextInfo ?? undefined, variantName);
+        // Send confirmation message with updated keyboard
+        const displayName = formatVariantForDisplay(variantId);
+        await ctx.answerCallbackQuery({ text: `Variant изменен: ${displayName}` });
+        await ctx.reply(`✅ Variant изменен на: ${displayName}`, {
+            reply_markup: keyboard,
+        });
+        // Delete the inline menu message
+        await ctx.deleteMessage().catch(() => { });
+        return true;
+    }
+    catch (err) {
+        logger.error("[VariantHandler] Error handling variant select:", err);
+        await ctx.answerCallbackQuery({ text: "Ошибка при смене variant" }).catch(() => { });
+        return false;
+    }
+}
+/**
+ * Build inline keyboard with available variants
+ * @param currentVariant Current variant for highlighting
+ * @param providerID Provider ID
+ * @param modelID Model ID
+ * @returns InlineKeyboard with variant selection buttons
+ */
+export async function buildVariantSelectionMenu(currentVariant, providerID, modelID) {
+    const keyboard = new InlineKeyboard();
+    const variants = await getAvailableVariants(providerID, modelID);
+    if (variants.length === 0) {
+        logger.warn("[VariantHandler] No variants found");
+        return keyboard;
+    }
+    // Filter only active variants (not disabled)
+    const activeVariants = variants.filter((v) => !v.disabled);
+    if (activeVariants.length === 0) {
+        logger.warn("[VariantHandler] No active variants found");
+        // If no active variants, show default at least
+        keyboard.text("✅ Default", "variant:default").row();
+        return keyboard;
+    }
+    // Add button for each variant (one per row)
+    activeVariants.forEach((variant) => {
+        const isActive = variant.id === currentVariant;
+        const label = formatVariantForDisplay(variant.id);
+        const labelWithCheck = isActive ? `✅ ${label}` : label;
+        keyboard.text(labelWithCheck, `variant:${variant.id}`).row();
+    });
+    return keyboard;
+}
+/**
+ * Show variant selection menu
+ * @param ctx grammY context
+ */
+export async function showVariantSelectionMenu(ctx) {
+    try {
+        const currentModel = getStoredModel();
+        if (!currentModel.providerID || !currentModel.modelID) {
+            await ctx.reply("⚠️ Сначала выберите модель");
+            return;
+        }
+        const currentVariant = getCurrentVariant();
+        const keyboard = await buildVariantSelectionMenu(currentVariant, currentModel.providerID, currentModel.modelID);
+        if (keyboard.inline_keyboard.length === 0) {
+            await ctx.reply("⚠️ Нет доступных вариантов");
+            return;
+        }
+        const displayName = formatVariantForDisplay(currentVariant);
+        const text = `Текущий variant: ${displayName}\n\nВыберите variant:`;
+        await ctx.reply(text, { reply_markup: keyboard });
+    }
+    catch (err) {
+        logger.error("[VariantHandler] Error showing variant menu:", err);
+        await ctx.reply("🔴 Не удалось получить список вариантов");
+    }
+}