@grinev/opencode-telegram-bot 0.21.1 → 0.22.0

package/dist/bot/{commands/sessions.js → callbacks/session-callback-handler.js}

@@ -1,75 +1,24 @@
-import { InlineKeyboard } from "grammy";
 import { opencodeClient } from "../../opencode/client.js";
-import { resolveProjectAgent } from "../../agent/manager.js";
-import { setCurrentSession } from "../../session/manager.js";
-import { getCurrentProject } from "../../settings/manager.js";
-import { clearAllInteractionState } from "../../interaction/cleanup.js";
-import { interactionManager } from "../../interaction/manager.js";
-import { keyboardManager } from "../../keyboard/manager.js";
-import { appendInlineMenuCancelButton, ensureActiveInlineMenu, replyWithInlineMenu, } from "../handlers/inline-menu.js";
-import { isForegroundBusy, replyBusyBlocked } from "../utils/busy-guard.js";
+import { resolveProjectAgent } from "../../app/services/agent-selection-service.js";
+import { setCurrentSession } from "../../app/services/session-service.js";
+import { getCurrentProject } from "../../app/stores/settings-store.js";
+import { clearAllInteractionState, interactionManager } from "../../app/managers/interaction-manager.js";
+import { keyboardManager } from "../keyboards/keyboard-manager.js";
+import { appendInlineMenuCancelButton, ensureActiveInlineMenu } from "../menus/inline-menu.js";
+import { isForegroundBusy } from "../../app/services/run-control-service.js";
+import { replyBusyBlocked } from "../messages/busy-blocked-renderer.js";
 import { logger } from "../../utils/logger.js";
 import { safeBackgroundTask } from "../../utils/safe-background-task.js";
 import { config } from "../../config.js";
-import { getDateLocale, t } from "../../i18n/index.js";
-import { attachToSession } from "../../attach/service.js";
-import { renderAssistantFinalPartsSafe } from "../utils/assistant-rendering.js";
-import { sendRenderedBotPart } from "../utils/telegram-text.js";
-const SESSION_CALLBACK_PREFIX = "session:";
-const SESSION_PAGE_CALLBACK_PREFIX = "session:page:";
-const BACKGROUND_SESSION_CALLBACK_PREFIX = "background-session:";
-const SESSION_FETCH_EXTRA_COUNT = 1;
-const BACKGROUND_SESSION_KIND_CALLBACK_MARKERS = {
-    assistant_response: "a",
-    question_asked: "q",
-    permission_asked: "p",
-};
-const BACKGROUND_SESSION_KIND_BY_CALLBACK_MARKER = {
-    a: "assistant_response",
-    q: "question_asked",
-    p: "permission_asked",
-};
-function buildSessionPageCallback(page) {
-    return `${SESSION_PAGE_CALLBACK_PREFIX}${page}`;
-}
-function parseSessionPageCallback(data) {
-    if (!data.startsWith(SESSION_PAGE_CALLBACK_PREFIX)) {
-        return null;
-    }
-    const rawPage = data.slice(SESSION_PAGE_CALLBACK_PREFIX.length);
-    const page = Number(rawPage);
-    if (!Number.isInteger(page) || page < 0) {
-        return null;
-    }
-    return page;
-}
-function parseSessionIdCallback(data) {
-    if (!data.startsWith(SESSION_CALLBACK_PREFIX)) {
-        return null;
-    }
-    if (data.startsWith(SESSION_PAGE_CALLBACK_PREFIX)) {
-        return null;
-    }
-    const sessionId = data.slice(SESSION_CALLBACK_PREFIX.length);
-    return sessionId.length > 0 ? sessionId : null;
-}
-function parseBackgroundSessionCallback(data) {
-    if (!data.startsWith(BACKGROUND_SESSION_CALLBACK_PREFIX)) {
-        return null;
-    }
-    const payload = data.slice(BACKGROUND_SESSION_CALLBACK_PREFIX.length);
-    const markerSeparatorIndex = payload.indexOf(":");
-    if (markerSeparatorIndex < 0) {
-        return payload.length > 0 ? { sessionId: payload, kind: null } : null;
-    }
-    const marker = payload.slice(0, markerSeparatorIndex);
-    const sessionId = payload.slice(markerSeparatorIndex + 1);
-    const kind = BACKGROUND_SESSION_KIND_BY_CALLBACK_MARKER[marker];
-    if (!kind || sessionId.length === 0) {
-        return null;
-    }
-    return { sessionId, kind };
-}
+import { t } from "../../i18n/index.js";
+import { attachToSession } from "../../app/services/attach-service.js";
+import { renderAssistantFinalPartsSafe } from "../messages/assistant-rendering.js";
+import { sendRenderedBotPart } from "../messages/telegram-text.js";
+import { buildSessionSelectionMenuView, parseBackgroundSessionCallback, parseSessionIdCallback, parseSessionPageCallback, SESSION_CALLBACK_PREFIX, loadSessionPage, } from "../menus/session-selection-menu.js";
+const PREVIEW_MESSAGES_LIMIT = 6;
+const LATEST_ASSISTANT_RESPONSE_MESSAGES_LIMIT = 20;
+const PREVIEW_ITEM_MAX_LENGTH = 420;
+const TELEGRAM_MESSAGE_LIMIT = 4096;
 async function removeCallbackReplyMarkup(ctx) {
     try {
         await ctx.editMessageReplyMarkup();
@@ -78,90 +27,6 @@ async function removeCallbackReplyMarkup(ctx) {
         logger.debug("[Sessions] Failed to remove background session button:", err);
     }
 }
-export function buildBackgroundSessionOpenKeyboard(sessionId, kind) {
-    const marker = BACKGROUND_SESSION_KIND_CALLBACK_MARKERS[kind];
-    return new InlineKeyboard().text(t("background.open_session_button"), `${BACKGROUND_SESSION_CALLBACK_PREFIX}${marker}:${sessionId}`);
-}
-function formatSessionsSelectText(page) {
-    if (page === 0) {
-        return t("sessions.select");
-    }
-    return t("sessions.select_page", { page: page + 1 });
-}
-async function loadSessionPage(directory, page, pageSize) {
-    const startIndex = page * pageSize;
-    const endExclusive = startIndex + pageSize;
-    const { data: sessions, error } = await opencodeClient.session.list({
-        directory,
-        limit: endExclusive + SESSION_FETCH_EXTRA_COUNT,
-        roots: true,
-    });
-    if (error || !sessions) {
-        throw error || new Error("No data received from server");
-    }
-    const hasNext = sessions.length > endExclusive;
-    const pagedSessions = sessions.slice(startIndex, endExclusive);
-    logger.debug(`[Sessions] Loaded page=${page + 1}, startIndex=${startIndex}, endExclusive=${endExclusive}, pageSize=${pageSize}, items=${pagedSessions.length}, hasNext=${hasNext}`);
-    return {
-        sessions: pagedSessions,
-        hasNext,
-        page,
-    };
-}
-function buildSessionsKeyboard(pageData, pageSize) {
-    const keyboard = new InlineKeyboard();
-    const localeForDate = getDateLocale();
-    const pageStartIndex = pageData.page * pageSize;
-    pageData.sessions.forEach((session, index) => {
-        const date = new Date(session.time.created).toLocaleDateString(localeForDate);
-        const label = `${pageStartIndex + index + 1}. ${session.title} (${date})`;
-        keyboard.text(label, `${SESSION_CALLBACK_PREFIX}${session.id}`).row();
-    });
-    if (pageData.page > 0) {
-        keyboard.text(t("sessions.button.prev_page"), buildSessionPageCallback(pageData.page - 1));
-    }
-    if (pageData.hasNext) {
-        keyboard.text(t("sessions.button.next_page"), buildSessionPageCallback(pageData.page + 1));
-    }
-    if (pageData.page > 0 || pageData.hasNext) {
-        keyboard.row();
-    }
-    return keyboard;
-}
-export async function sessionsCommand(ctx) {
-    try {
-        if (isForegroundBusy()) {
-            await replyBusyBlocked(ctx);
-            return;
-        }
-        const pageSize = config.bot.sessionsListLimit;
-        const currentProject = getCurrentProject();
-        if (!currentProject) {
-            await ctx.reply(t("sessions.project_not_selected"));
-            return;
-        }
-        logger.debug(`[Sessions] Fetching sessions for directory: ${currentProject.worktree}`);
-        const firstPage = await loadSessionPage(currentProject.worktree, 0, pageSize);
-        logger.debug(`[Sessions] Found ${firstPage.sessions.length} sessions on page 1`);
-        firstPage.sessions.forEach((session) => {
-            logger.debug(`[Sessions] Session: ${session.title} | ${session.directory}`);
-        });
-        if (firstPage.sessions.length === 0) {
-            await ctx.reply(t("sessions.empty"));
-            return;
-        }
-        const keyboard = buildSessionsKeyboard(firstPage, pageSize);
-        await replyWithInlineMenu(ctx, {
-            menuKind: "session",
-            text: formatSessionsSelectText(firstPage.page),
-            keyboard,
-        });
-    }
-    catch (error) {
-        logger.error("[Sessions] Error fetching sessions:", error);
-        await ctx.reply(t("sessions.fetch_error"));
-    }
-}
 async function selectSessionById(ctx, deps, sessionId, options) {
     const currentProject = getCurrentProject();
     if (!currentProject) {
@@ -327,9 +192,9 @@ export async function handleSessionSelect(ctx, deps) {
                     await ctx.answerCallbackQuery({ text: t("sessions.page_empty_callback") });
                     return true;
                 }
-                const keyboard = buildSessionsKeyboard(pageData, pageSize);
+                const { text, keyboard } = buildSessionSelectionMenuView(pageData, pageSize);
                 appendInlineMenuCancelButton(keyboard, "session");
-                await ctx.editMessageText(formatSessionsSelectText(pageData.page), {
+                await ctx.editMessageText(text, {
                     reply_markup: keyboard,
                 });
                 await ctx.answerCallbackQuery();
@@ -359,10 +224,6 @@ export async function handleSessionSelect(ctx, deps) {
     }
     return true;
 }
-const PREVIEW_MESSAGES_LIMIT = 6;
-const LATEST_ASSISTANT_RESPONSE_MESSAGES_LIMIT = 20;
-const PREVIEW_ITEM_MAX_LENGTH = 420;
-const TELEGRAM_MESSAGE_LIMIT = 4096;
 function extractTextParts(parts, options = {}) {
     const textParts = parts
         .filter((part) => part.type === "text" && typeof part.text === "string")

package/dist/bot/callbacks/settings-callback-handler.js

@@ -0,0 +1,105 @@
+import { isTtsConfigured } from "../../app/services/tts-service.js";
+import { getCompactOutputMode, getResponseStreamingMode, getSendDiffFileAttachments, getShowAssistantRunFooter, getShowThinkingContent, getTtsMode, setCompactOutputMode, setResponseStreamingMode, setSendDiffFileAttachments, setShowAssistantRunFooter, setShowThinkingContent, setTtsMode, } from "../../app/stores/settings-store.js";
+import { t } from "../../i18n/index.js";
+import { logger } from "../../utils/logger.js";
+import { appendInlineMenuCancelButton, ensureActiveInlineMenu } from "../menus/inline-menu.js";
+import { buildSettingsMenuView, SETTINGS_ASSISTANT_FOOTER_CALLBACK, SETTINGS_CALLBACK_PREFIX, SETTINGS_COMPACT_OUTPUT_CALLBACK, SETTINGS_DIFF_FILES_CALLBACK, SETTINGS_RESPONSE_STREAMING_CALLBACK, SETTINGS_THINKING_CONTENT_CALLBACK, SETTINGS_TTS_CALLBACK, } from "../menus/settings-menu.js";
+function getTtsSavedMessageKey(mode) {
+    if (mode === "all") {
+        return "tts.all";
+    }
+    if (mode === "auto") {
+        return "tts.auto";
+    }
+    return "tts.off";
+}
+function getNextTtsMode(mode) {
+    if (mode === "off") {
+        return "all";
+    }
+    if (mode === "all") {
+        return "auto";
+    }
+    return "off";
+}
+function getNextResponseStreamingMode(mode) {
+    return mode === "edit" ? "draft" : "edit";
+}
+export async function handleSettingsCallback(ctx) {
+    const callbackData = ctx.callbackQuery?.data;
+    if (!callbackData?.startsWith(SETTINGS_CALLBACK_PREFIX)) {
+        return false;
+    }
+    const isActiveMenu = await ensureActiveInlineMenu(ctx, "settings");
+    if (!isActiveMenu) {
+        return true;
+    }
+    try {
+        if (callbackData === SETTINGS_COMPACT_OUTPUT_CALLBACK) {
+            setCompactOutputMode(!getCompactOutputMode());
+            const { text, keyboard } = buildSettingsMenuView();
+            await ctx.answerCallbackQuery({ text: t("settings.saved") });
+            await ctx.editMessageText(text, {
+                reply_markup: appendInlineMenuCancelButton(keyboard, "settings"),
+            });
+            return true;
+        }
+        if (callbackData === SETTINGS_THINKING_CONTENT_CALLBACK) {
+            setShowThinkingContent(!getShowThinkingContent());
+            const { text, keyboard } = buildSettingsMenuView();
+            await ctx.answerCallbackQuery({ text: t("settings.saved") });
+            await ctx.editMessageText(text, {
+                reply_markup: appendInlineMenuCancelButton(keyboard, "settings"),
+            });
+            return true;
+        }
+        if (callbackData === SETTINGS_RESPONSE_STREAMING_CALLBACK) {
+            setResponseStreamingMode(getNextResponseStreamingMode(getResponseStreamingMode()));
+            const { text, keyboard } = buildSettingsMenuView();
+            await ctx.answerCallbackQuery({ text: t("settings.saved") });
+            await ctx.editMessageText(text, {
+                reply_markup: appendInlineMenuCancelButton(keyboard, "settings"),
+            });
+            return true;
+        }
+        if (callbackData === SETTINGS_DIFF_FILES_CALLBACK) {
+            setSendDiffFileAttachments(!getSendDiffFileAttachments());
+            const { text, keyboard } = buildSettingsMenuView();
+            await ctx.answerCallbackQuery({ text: t("settings.saved") });
+            await ctx.editMessageText(text, {
+                reply_markup: appendInlineMenuCancelButton(keyboard, "settings"),
+            });
+            return true;
+        }
+        if (callbackData === SETTINGS_ASSISTANT_FOOTER_CALLBACK) {
+            setShowAssistantRunFooter(!getShowAssistantRunFooter());
+            const { text, keyboard } = buildSettingsMenuView();
+            await ctx.answerCallbackQuery({ text: t("settings.saved") });
+            await ctx.editMessageText(text, {
+                reply_markup: appendInlineMenuCancelButton(keyboard, "settings"),
+            });
+            return true;
+        }
+        if (callbackData === SETTINGS_TTS_CALLBACK) {
+            const nextMode = getNextTtsMode(getTtsMode());
+            if (nextMode !== "off" && !isTtsConfigured()) {
+                await ctx.answerCallbackQuery({ text: t("tts.not_configured"), show_alert: true });
+                return true;
+            }
+            setTtsMode(nextMode);
+            const { text, keyboard } = buildSettingsMenuView();
+            await ctx.answerCallbackQuery({ text: t(getTtsSavedMessageKey(nextMode)) });
+            await ctx.editMessageText(text, {
+                reply_markup: appendInlineMenuCancelButton(keyboard, "settings"),
+            });
+            return true;
+        }
+        await ctx.answerCallbackQuery({ text: t("callback.processing_error") });
+        return true;
+    }
+    catch (error) {
+        logger.error("[Settings] Error handling settings callback:", error);
+        await ctx.answerCallbackQuery({ text: t("callback.processing_error") }).catch(() => { });
+        return true;
+    }
+}

package/dist/bot/{commands/skills.js → callbacks/skills-catalog-callback-handler.js}

@@ -1,55 +1,10 @@
-import { InlineKeyboard } from "grammy";
-import { opencodeClient } from "../../opencode/client.js";
-import { getCurrentProject } from "../../settings/manager.js";
-import { interactionManager } from "../../interaction/manager.js";
+import { config } from "../../config.js";
+import { getCurrentProject } from "../../app/stores/settings-store.js";
+import { interactionManager } from "../../app/managers/interaction-manager.js";
 import { logger } from "../../utils/logger.js";
 import { t } from "../../i18n/index.js";
-import { config } from "../../config.js";
 import { processUserPrompt } from "../handlers/prompt.js";
-const SKILLS_CALLBACK_PREFIX = "skills:";
-const SKILLS_CALLBACK_SELECT_PREFIX = `${SKILLS_CALLBACK_PREFIX}select:`;
-const SKILLS_CALLBACK_PAGE_PREFIX = `${SKILLS_CALLBACK_PREFIX}page:`;
-const SKILLS_CALLBACK_CANCEL = `${SKILLS_CALLBACK_PREFIX}cancel`;
-const SKILLS_CALLBACK_EXECUTE = `${SKILLS_CALLBACK_PREFIX}execute`;
-const MAX_INLINE_BUTTON_LABEL_LENGTH = 64;
-function formatExecutingSkillMessage(skillName, args) {
-    const prefix = t("skills.executing_prefix");
-    const skillText = `/${skillName}`;
-    const argsSuffix = args ? ` ${args}` : "";
-    return {
-        text: `${prefix}\n${skillText}${argsSuffix}`,
-        entities: [
-            {
-                type: "code",
-                offset: prefix.length + 1,
-                length: skillText.length,
-            },
-        ],
-    };
-}
-export function buildSkillPageCallback(page) {
-    return `${SKILLS_CALLBACK_PAGE_PREFIX}${page}`;
-}
-export function parseSkillPageCallback(data) {
-    if (!data.startsWith(SKILLS_CALLBACK_PAGE_PREFIX)) {
-        return null;
-    }
-    const rawPage = data.slice(SKILLS_CALLBACK_PAGE_PREFIX.length);
-    const page = Number(rawPage);
-    if (!Number.isInteger(page) || page < 0) {
-        return null;
-    }
-    return page;
-}
-export function formatSkillsSelectText(page) {
-    if (page === 0) {
-        return t("skills.select");
-    }
-    return t("skills.select_page", { page: page + 1 });
-}
-function normalizeDirectoryForCommandApi(directory) {
-    return directory.replace(/\\/g, "/");
-}
+import { buildSkillsConfirmKeyboard, buildSkillsListKeyboard, calculateSkillsPaginationRange, formatExecutingSkillMessage, formatSkillsSelectText, parseSkillPageCallback, parseSkillSelectCallback, SKILLS_CALLBACK_CANCEL, SKILLS_CALLBACK_EXECUTE, SKILLS_CALLBACK_PREFIX, } from "../menus/skills-catalog-menu.js";
 function getCallbackMessageId(ctx) {
     const message = ctx.callbackQuery?.message;
     if (!message || !("message_id" in message)) {
@@ -58,53 +13,6 @@ function getCallbackMessageId(ctx) {
     const messageId = message.message_id;
     return typeof messageId === "number" ? messageId : null;
 }
-function formatSkillButtonLabel(skill) {
-    const description = skill.description?.trim() || t("skills.no_description");
-    const rawLabel = `/${skill.name} - ${description}`;
-    if (rawLabel.length <= MAX_INLINE_BUTTON_LABEL_LENGTH) {
-        return rawLabel;
-    }
-    return `${rawLabel.slice(0, MAX_INLINE_BUTTON_LABEL_LENGTH - 3)}...`;
-}
-export function calculateSkillsPaginationRange(totalSkills, page, pageSize) {
-    const safePageSize = Math.max(1, pageSize);
-    const totalPages = Math.max(1, Math.ceil(totalSkills / safePageSize));
-    const normalizedPage = Math.min(Math.max(0, page), totalPages - 1);
-    const startIndex = normalizedPage * safePageSize;
-    const endIndex = Math.min(startIndex + safePageSize, totalSkills);
-    return {
-        page: normalizedPage,
-        totalPages,
-        startIndex,
-        endIndex,
-    };
-}
-function buildSkillsListKeyboard(skills, page, pageSize) {
-    const keyboard = new InlineKeyboard();
-    const { page: normalizedPage, totalPages, startIndex, endIndex, } = calculateSkillsPaginationRange(skills.length, page, pageSize);
-    skills.slice(startIndex, endIndex).forEach((skill, index) => {
-        const globalIndex = startIndex + index;
-        keyboard
-            .text(formatSkillButtonLabel(skill), `${SKILLS_CALLBACK_SELECT_PREFIX}${globalIndex}`)
-            .row();
-    });
-    if (totalPages > 1) {
-        if (normalizedPage > 0) {
-            keyboard.text(t("skills.button.prev_page"), buildSkillPageCallback(normalizedPage - 1));
-        }
-        if (normalizedPage < totalPages - 1) {
-            keyboard.text(t("skills.button.next_page"), buildSkillPageCallback(normalizedPage + 1));
-        }
-        keyboard.row();
-    }
-    keyboard.text(t("skills.button.cancel"), SKILLS_CALLBACK_CANCEL);
-    return keyboard;
-}
-function buildSkillsConfirmKeyboard() {
-    return new InlineKeyboard()
-        .text(t("skills.button.execute"), SKILLS_CALLBACK_EXECUTE)
-        .text(t("skills.button.cancel"), SKILLS_CALLBACK_CANCEL);
-}
 function parseSkillItems(value) {
     if (!Array.isArray(value)) {
         return null;
@@ -126,7 +34,7 @@ function parseSkillItems(value) {
     }
     return skills;
 }
-function parseSkillsMetadata(state) {
+export function parseSkillsMetadata(state) {
     if (!state || state.kind !== "custom") {
         return null;
     }
@@ -169,41 +77,13 @@ function parseSkillsMetadata(state) {
     }
     return null;
 }
-function clearSkillsInteraction(reason) {
+export function clearSkillsInteraction(reason) {
     const metadata = parseSkillsMetadata(interactionManager.getSnapshot());
     if (metadata) {
         interactionManager.clear(reason);
     }
 }
-async function getSkillList(projectDirectory) {
-    const { data, error } = await opencodeClient.command.list({
-        directory: normalizeDirectoryForCommandApi(projectDirectory),
-    });
-    if (error || !data) {
-        throw error || new Error("No skill data received");
-    }
-    return data
-        .filter((skill) => {
-        const source = skill.source;
-        return typeof skill.name === "string" && skill.name.trim().length > 0 && source === "skill";
-    })
-        .map((skill) => ({
-        name: skill.name,
-        description: skill.description,
-    }));
-}
-function parseSelectIndex(data) {
-    if (!data.startsWith(SKILLS_CALLBACK_SELECT_PREFIX)) {
-        return null;
-    }
-    const rawIndex = data.slice(SKILLS_CALLBACK_SELECT_PREFIX.length);
-    const index = Number(rawIndex);
-    if (!Number.isInteger(index) || index < 0) {
-        return null;
-    }
-    return index;
-}
-async function executeSkill(ctx, deps, params) {
+export async function executeSkill(ctx, deps, params) {
     const currentProject = getCurrentProject();
     if (!currentProject) {
         await ctx.reply(t("bot.project_not_selected"));
@@ -218,41 +98,6 @@ async function executeSkill(ctx, deps, params) {
     const promptText = args ? `/${params.skillName} ${args}` : `/${params.skillName}`;
     await processUserPrompt(ctx, promptText, deps);
 }
-export async function skillsCommand(ctx) {
-    try {
-        const currentProject = getCurrentProject();
-        if (!currentProject) {
-            await ctx.reply(t("bot.project_not_selected"));
-            return;
-        }
-        const skills = await getSkillList(currentProject.worktree);
-        if (skills.length === 0) {
-            await ctx.reply(t("skills.empty"));
-            return;
-        }
-        const pageSize = config.bot.commandsListLimit;
-        const keyboard = buildSkillsListKeyboard(skills, 0, pageSize);
-        const message = await ctx.reply(formatSkillsSelectText(0), {
-            reply_markup: keyboard,
-        });
-        interactionManager.start({
-            kind: "custom",
-            expectedInput: "callback",
-            metadata: {
-                flow: "skills",
-                stage: "list",
-                messageId: message.message_id,
-                projectDirectory: currentProject.worktree,
-                skills,
-                page: 0,
-            },
-        });
-    }
-    catch (error) {
-        logger.error("[Skills] Error fetching skills list:", error);
-        await ctx.reply(t("skills.fetch_error"));
-    }
-}
 export async function handleSkillsCallback(ctx, deps) {
     const data = ctx.callbackQuery?.data;
     if (!data || !data.startsWith(SKILLS_CALLBACK_PREFIX)) {
@@ -316,7 +161,7 @@ export async function handleSkillsCallback(ctx, deps) {
             });
             return true;
         }
-        const skillIndex = parseSelectIndex(data);
+        const skillIndex = parseSkillSelectCallback(data);
         if (skillIndex === null || metadata.stage !== "list") {
             await ctx.answerCallbackQuery({ text: t("callback.processing_error"), show_alert: true });
             return true;
@@ -349,28 +194,3 @@ export async function handleSkillsCallback(ctx, deps) {
         return true;
     }
 }
-export async function handleSkillTextArguments(ctx, deps) {
-    const text = ctx.message?.text;
-    if (!text || text.startsWith("/")) {
-        return false;
-    }
-    const metadata = parseSkillsMetadata(interactionManager.getSnapshot());
-    if (!metadata || metadata.stage !== "confirm") {
-        return false;
-    }
-    const argumentsText = text.trim();
-    if (!argumentsText) {
-        await ctx.reply(t("skills.arguments_empty"));
-        return true;
-    }
-    clearSkillsInteraction("skills_arguments_submitted");
-    if (ctx.chat) {
-        await ctx.api.deleteMessage(ctx.chat.id, metadata.messageId).catch(() => { });
-    }
-    await executeSkill(ctx, deps, {
-        projectDirectory: metadata.projectDirectory,
-        skillName: metadata.skillName,
-        argumentsText,
-    });
-    return true;
-}

package/dist/bot/{handlers/variant.js → callbacks/variant-selection-callback-handler.js}

@@ -1,13 +1,12 @@
-import { InlineKeyboard } from "grammy";
-import { getAvailableVariants, getCurrentVariant, setCurrentVariant, formatVariantForDisplay, formatVariantForButton, } from "../../variant/manager.js";
-import { getStoredModel } from "../../model/manager.js";
-import { getStoredAgent, resolveProjectAgent } from "../../agent/manager.js";
+import { getStoredAgent, resolveProjectAgent } from "../../app/services/agent-selection-service.js";
+import { getStoredModel } from "../../app/services/model-selection-service.js";
+import { formatVariantForButton, formatVariantForDisplay, setCurrentVariant, } from "../../app/services/variant-selection-service.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";
-import { clearActiveInlineMenu, ensureActiveInlineMenu, replyWithInlineMenu, } from "./inline-menu.js";
 import { t } from "../../i18n/index.js";
+import { createMainKeyboard } from "../keyboards/main-reply-keyboard.js";
+import { keyboardManager } from "../keyboards/keyboard-manager.js";
+import { pinnedMessageManager } from "../pinned/pinned-message-manager.js";
+import { clearActiveInlineMenu, ensureActiveInlineMenu } from "../menus/inline-menu.js";
 /**
  * Handle variant selection callback
  * @param ctx grammY context
@@ -76,64 +75,3 @@ export async function handleVariantSelect(ctx) {
         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(`✅ ${formatVariantForDisplay("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(t("variant.select_model_first"));
-            return;
-        }
-        const currentVariant = getCurrentVariant();
-        const keyboard = await buildVariantSelectionMenu(currentVariant, currentModel.providerID, currentModel.modelID);
-        if (keyboard.inline_keyboard.length === 0) {
-            await ctx.reply(t("variant.menu.empty"));
-            return;
-        }
-        const displayName = formatVariantForDisplay(currentVariant);
-        const text = t("variant.menu.current", { name: displayName });
-        await replyWithInlineMenu(ctx, {
-            menuKind: "variant",
-            text,
-            keyboard,
-        });
-    }
-    catch (err) {
-        logger.error("[VariantHandler] Error showing variant menu:", err);
-        await ctx.reply(t("variant.menu.error"));
-    }
-}