@grinev/opencode-telegram-bot 0.21.1 → 0.22.0

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

@@ -0,0 +1,97 @@
+import { clearAllInteractionState } from "../../app/managers/interaction-manager.js";
+import { getProjectByWorktree } from "../../app/services/project-service.js";
+import { isForegroundBusy } from "../../app/services/run-control-service.js";
+import { switchToProject } from "../../app/services/project-switch-service.js";
+import { getGitWorktreeContext } from "../../app/services/worktree-service.js";
+import { upsertSessionDirectory } from "../../app/services/session-cache-service.js";
+import { getCurrentProject } 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 { buildWorktreeMenuView, parseWorktreeIndexCallback, parseWorktreePageCallback, WORKTREE_CALLBACK_PREFIX, } from "../menus/worktree-selection-menu.js";
+import { replyBusyBlocked } from "../messages/busy-blocked-renderer.js";
+import { createProjectSwitchPresentation } from "../services/project-switch-presentation.js";
+async function loadCurrentWorktreeContext() {
+    const currentProject = getCurrentProject();
+    if (!currentProject) {
+        return { currentProject: null, context: null };
+    }
+    const context = await getGitWorktreeContext(currentProject.worktree);
+    return { currentProject, context };
+}
+export async function handleWorktreeCallback(ctx, deps = {}) {
+    const callbackQuery = ctx.callbackQuery;
+    if (!callbackQuery?.data || !callbackQuery.data.startsWith(WORKTREE_CALLBACK_PREFIX)) {
+        return false;
+    }
+    if (isForegroundBusy()) {
+        await replyBusyBlocked(ctx);
+        return true;
+    }
+    const page = parseWorktreePageCallback(callbackQuery.data);
+    const index = parseWorktreeIndexCallback(callbackQuery.data);
+    const isActiveMenu = await ensureActiveInlineMenu(ctx, "worktree");
+    if (!isActiveMenu) {
+        return true;
+    }
+    try {
+        const { currentProject, context } = await loadCurrentWorktreeContext();
+        if (!currentProject) {
+            clearAllInteractionState("worktree_project_missing");
+            await ctx.answerCallbackQuery();
+            await ctx.reply(t("worktree.project_not_selected"));
+            return true;
+        }
+        if (!context) {
+            clearAllInteractionState("worktree_git_context_missing");
+            await ctx.answerCallbackQuery({ text: t("worktree.not_git_repo_callback") });
+            return true;
+        }
+        if (page !== null) {
+            if (context.worktrees.length === 0) {
+                await ctx.answerCallbackQuery({ text: t("worktree.page_empty_callback") });
+                return true;
+            }
+            const { text, keyboard } = buildWorktreeMenuView(context.worktrees, page);
+            await ctx.answerCallbackQuery();
+            await ctx.editMessageText(text, {
+                reply_markup: appendInlineMenuCancelButton(keyboard, "worktree"),
+            });
+            return true;
+        }
+        if (index === null) {
+            await ctx.answerCallbackQuery({ text: t("callback.processing_error") });
+            return true;
+        }
+        const selectedWorktree = context.worktrees[index];
+        if (!selectedWorktree) {
+            await ctx.answerCallbackQuery({ text: t("worktree.selection_missing_callback") });
+            return true;
+        }
+        if (selectedWorktree.isCurrent) {
+            await ctx.answerCallbackQuery({ text: t("worktree.already_selected_callback") });
+            return true;
+        }
+        logger.info(`[Bot] Worktree selected: ${selectedWorktree.path}`);
+        await upsertSessionDirectory(selectedWorktree.path, Date.now());
+        const projectInfo = await getProjectByWorktree(selectedWorktree.path);
+        const selectedProjectInfo = { ...projectInfo, name: selectedWorktree.path };
+        const replyKeyboard = await switchToProject(ctx, selectedProjectInfo, "worktree_switched", {
+            ensureEventSubscription: deps.ensureEventSubscription,
+            presentation: createProjectSwitchPresentation(),
+        });
+        await ctx.answerCallbackQuery();
+        await ctx.reply(t("worktree.selected", { worktree: selectedWorktree.path }), {
+            reply_markup: replyKeyboard,
+        });
+        await ctx.deleteMessage();
+        return true;
+    }
+    catch (error) {
+        logger.error("[Bot] Error handling worktree callback:", error);
+        clearAllInteractionState("worktree_select_error");
+        await ctx.answerCallbackQuery({ text: t("callback.processing_error") });
+        await ctx.reply(t("worktree.select_error"));
+        return true;
+    }
+}

package/dist/bot/commands/{abort.js → abort-command.js}

@@ -1,13 +1,13 @@
 import { opencodeClient } from "../../opencode/client.js";
-import { getCurrentSession } from "../../session/manager.js";
-import { clearAllInteractionState } from "../../interaction/cleanup.js";
+import { getCurrentSession } from "../../app/services/session-service.js";
+import { clearAllInteractionState } from "../../app/managers/interaction-manager.js";
 import { logger } from "../../utils/logger.js";
 import { t } from "../../i18n/index.js";
-import { foregroundSessionState } from "../../scheduled-task/foreground-state.js";
-import { assistantRunState } from "../assistant-run-state.js";
-import { markAttachedSessionIdle } from "../../attach/service.js";
+import { foregroundSessionState } from "../../app/managers/foreground-session-state-manager.js";
+import { assistantRunState } from "../../app/managers/assistant-run-state-manager.js";
+import { markAttachedSessionIdle } from "../../app/services/attach-service.js";
 import { clearPromptResponseMode } from "../handlers/prompt.js";
-import { markUserAbortRequested } from "../utils/abort-error-suppression.js";
+import { markUserAbortRequested } from "../../app/managers/abort-suppression-manager.js";
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 function abortLocalStreaming() {
     clearAllInteractionState("abort_command");

package/dist/bot/commands/command-catalog-command.js

@@ -0,0 +1,42 @@
+import { config } from "../../config.js";
+import { interactionManager } from "../../app/managers/interaction-manager.js";
+import { loadCommandCatalog } from "../../app/services/command-catalog-service.js";
+import { getCurrentProject } from "../../app/stores/settings-store.js";
+import { t } from "../../i18n/index.js";
+import { logger } from "../../utils/logger.js";
+import { buildCommandsListKeyboard, formatCommandsSelectText } from "../menus/command-catalog-menu.js";
+export async function commandsCommand(ctx) {
+    try {
+        const currentProject = getCurrentProject();
+        if (!currentProject) {
+            await ctx.reply(t("bot.project_not_selected"));
+            return;
+        }
+        const commands = await loadCommandCatalog(currentProject.worktree);
+        if (commands.length === 0) {
+            await ctx.reply(t("commands.empty"));
+            return;
+        }
+        const pageSize = config.bot.commandsListLimit;
+        const keyboard = buildCommandsListKeyboard(commands, 0, pageSize);
+        const message = await ctx.reply(formatCommandsSelectText(0), {
+            reply_markup: keyboard,
+        });
+        interactionManager.start({
+            kind: "custom",
+            expectedInput: "callback",
+            metadata: {
+                flow: "commands",
+                stage: "list",
+                messageId: message.message_id,
+                projectDirectory: currentProject.worktree,
+                commands,
+                page: 0,
+            },
+        });
+    }
+    catch (error) {
+        logger.error("[Commands] Error fetching commands list:", error);
+        await ctx.reply(t("commands.fetch_error"));
+    }
+}

package/dist/bot/commands/definitions.js

@@ -10,7 +10,7 @@ const COMMAND_DEFINITIONS = [
     { command: "detach", descriptionKey: "cmd.description.detach" },
     { command: "sessions", descriptionKey: "cmd.description.sessions" },
     { command: "messages", descriptionKey: "cmd.description.messages" },
-    { command: "tts", descriptionKey: "cmd.description.tts" },
+    { command: "settings", descriptionKey: "cmd.description.settings" },
     { command: "projects", descriptionKey: "cmd.description.projects" },
     { command: "worktree", descriptionKey: "cmd.description.worktree" },
     { command: "task", descriptionKey: "cmd.description.task" },

package/dist/bot/commands/{detach.js → detach-command.js}

@@ -1,11 +1,11 @@
-import { getCurrentProject } from "../../settings/manager.js";
-import { clearSession, getCurrentSession } from "../../session/manager.js";
-import { detachAttachedSession } from "../../attach/service.js";
-import { clearAllInteractionState } from "../../interaction/cleanup.js";
-import { pinnedMessageManager } from "../../pinned/manager.js";
-import { keyboardManager } from "../../keyboard/manager.js";
-import { foregroundSessionState } from "../../scheduled-task/foreground-state.js";
-import { assistantRunState } from "../assistant-run-state.js";
+import { getCurrentProject } from "../../app/stores/settings-store.js";
+import { clearSession, getCurrentSession } from "../../app/services/session-service.js";
+import { detachAttachedSession } from "../../app/services/attach-service.js";
+import { clearAllInteractionState } from "../../app/managers/interaction-manager.js";
+import { pinnedMessageManager } from "../pinned/pinned-message-manager.js";
+import { keyboardManager } from "../keyboards/keyboard-manager.js";
+import { foregroundSessionState } from "../../app/managers/foreground-session-state-manager.js";
+import { assistantRunState } from "../../app/managers/assistant-run-state-manager.js";
 import { clearPromptResponseMode } from "../handlers/prompt.js";
 import { logger } from "../../utils/logger.js";
 import { t } from "../../i18n/index.js";

package/dist/bot/commands/ls-command.js

@@ -0,0 +1,48 @@
+import { getProjectRoot, isWithinProjectRoot } from "../../app/services/file-browser-service.js";
+import { interactionManager } from "../../app/managers/interaction-manager.js";
+import { isForegroundBusy } from "../../app/services/run-control-service.js";
+import { t } from "../../i18n/index.js";
+import { clearLsPathIndex, renderLsBrowseView } from "../menus/file-browser-menu.js";
+import { replyBusyBlocked } from "../messages/busy-blocked-renderer.js";
+import { rememberLsDirectory, resolveInitialLsDirectory } from "../callbacks/file-browser-callback-handler.js";
+export async function lsCommand(ctx) {
+    if (isForegroundBusy()) {
+        await replyBusyBlocked(ctx);
+        return;
+    }
+    clearLsPathIndex();
+    const projectRoot = getProjectRoot();
+    if (!projectRoot) {
+        await ctx.reply(t("bot.project_not_selected"));
+        return;
+    }
+    const args = typeof ctx.match === "string" ? ctx.match.trim() : undefined;
+    const targetDir = args || resolveInitialLsDirectory(ctx.from?.id);
+    if (!targetDir) {
+        await ctx.reply(t("bot.project_not_selected"));
+        return;
+    }
+    if (!isWithinProjectRoot(targetDir)) {
+        await ctx.reply(`❌ ${t("ls.access_denied")}`);
+        return;
+    }
+    const view = await renderLsBrowseView(targetDir);
+    if ("error" in view) {
+        await ctx.reply(`❌ ${view.error}`);
+        return;
+    }
+    rememberLsDirectory(ctx.from?.id, targetDir);
+    if (!view.hasActions) {
+        await ctx.reply(view.text, { parse_mode: "HTML" });
+        return;
+    }
+    const message = await ctx.reply(view.text, { parse_mode: "HTML", reply_markup: view.keyboard });
+    interactionManager.start({
+        kind: "inline",
+        expectedInput: "callback",
+        metadata: {
+            menuKind: "ls",
+            messageId: message.message_id,
+        },
+    });
+}

package/dist/bot/commands/mcp-catalog-command.js

@@ -0,0 +1,39 @@
+import { interactionManager } from "../../app/managers/interaction-manager.js";
+import { loadMcpCatalog } from "../../app/services/mcp-catalog-service.js";
+import { getCurrentProject } from "../../app/stores/settings-store.js";
+import { t } from "../../i18n/index.js";
+import { logger } from "../../utils/logger.js";
+import { buildMcpsListKeyboard } from "../menus/mcp-catalog-menu.js";
+export async function mcpsCommand(ctx) {
+    try {
+        const currentProject = getCurrentProject();
+        if (!currentProject) {
+            await ctx.reply(t("bot.project_not_selected"));
+            return;
+        }
+        const servers = await loadMcpCatalog(currentProject.worktree);
+        if (servers.length === 0) {
+            await ctx.reply(t("mcps.empty"));
+            return;
+        }
+        const keyboard = buildMcpsListKeyboard(servers);
+        const message = await ctx.reply(t("mcps.select"), {
+            reply_markup: keyboard,
+        });
+        interactionManager.start({
+            kind: "custom",
+            expectedInput: "callback",
+            metadata: {
+                flow: "mcps",
+                stage: "list",
+                messageId: message.message_id,
+                projectDirectory: currentProject.worktree,
+                servers,
+            },
+        });
+    }
+    catch (error) {
+        logger.error("[Mcps] Error fetching MCP servers list:", error);
+        await ctx.reply(t("mcps.fetch_error"));
+    }
+}

package/dist/bot/commands/messages-command.js

@@ -0,0 +1,59 @@
+import { config } from "../../config.js";
+import { interactionManager } from "../../app/managers/interaction-manager.js";
+import { getCurrentSession } from "../../app/services/session-service.js";
+import { loadUserMessages } from "../../app/services/message-history-service.js";
+import { isForegroundBusy } from "../../app/services/run-control-service.js";
+import { getCurrentProject } from "../../app/stores/settings-store.js";
+import { t } from "../../i18n/index.js";
+import { logger } from "../../utils/logger.js";
+import { replyBusyBlocked } from "../messages/busy-blocked-renderer.js";
+import { buildMessagesListKeyboard, formatMessagesSelectText } from "../menus/message-history-menu.js";
+export async function messagesCommand(ctx) {
+    try {
+        if (isForegroundBusy()) {
+            await replyBusyBlocked(ctx);
+            return;
+        }
+        const currentProject = getCurrentProject();
+        if (!currentProject) {
+            await ctx.reply(t("messages.project_not_selected"));
+            return;
+        }
+        const currentSession = getCurrentSession();
+        if (!currentSession) {
+            await ctx.reply(t("messages.session_not_selected"));
+            return;
+        }
+        if (currentSession.directory !== currentProject.worktree) {
+            await ctx.reply(t("messages.session_project_mismatch"));
+            return;
+        }
+        const messages = await loadUserMessages(currentSession.id, currentSession.directory);
+        if (messages.length === 0) {
+            await ctx.reply(t("messages.empty"));
+            return;
+        }
+        const pageSize = config.bot.messagesListLimit;
+        const keyboard = buildMessagesListKeyboard(messages, 0, pageSize);
+        const message = await ctx.reply(formatMessagesSelectText(0), {
+            reply_markup: keyboard,
+        });
+        interactionManager.start({
+            kind: "custom",
+            expectedInput: "callback",
+            metadata: {
+                flow: "messages",
+                stage: "list",
+                messageId: message.message_id,
+                projectDirectory: currentProject.worktree,
+                sessionId: currentSession.id,
+                messages,
+                page: 0,
+            },
+        });
+    }
+    catch (error) {
+        logger.error("[Messages] Error fetching messages list:", error);
+        await ctx.reply(t("messages.fetch_error"));
+    }
+}

package/dist/bot/commands/{new.js → new-command.js}

@@ -1,17 +1,18 @@
 import { opencodeClient } from "../../opencode/client.js";
-import { setCurrentSession } from "../../session/manager.js";
-import { ingestSessionInfoForCache } from "../../session/cache-manager.js";
-import { getCurrentProject } from "../../settings/manager.js";
-import { clearAllInteractionState } from "../../interaction/cleanup.js";
-import { keyboardManager } from "../../keyboard/manager.js";
-import { getStoredAgent, resolveProjectAgent } from "../../agent/manager.js";
-import { getStoredModel } from "../../model/manager.js";
-import { formatVariantForButton } from "../../variant/manager.js";
-import { createMainKeyboard } from "../utils/keyboard.js";
-import { isForegroundBusy, replyBusyBlocked } from "../utils/busy-guard.js";
+import { setCurrentSession } from "../../app/services/session-service.js";
+import { ingestSessionInfoForCache } from "../../app/services/session-cache-service.js";
+import { getCurrentProject } from "../../app/stores/settings-store.js";
+import { clearAllInteractionState } from "../../app/managers/interaction-manager.js";
+import { keyboardManager } from "../keyboards/keyboard-manager.js";
+import { getStoredAgent, resolveProjectAgent } from "../../app/services/agent-selection-service.js";
+import { getStoredModel } from "../../app/services/model-selection-service.js";
+import { formatVariantForButton } from "../../app/services/variant-selection-service.js";
+import { createMainKeyboard } from "../keyboards/main-reply-keyboard.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 { t } from "../../i18n/index.js";
-import { attachToSession } from "../../attach/service.js";
+import { attachToSession } from "../../app/services/attach-service.js";
 export async function newCommand(ctx, deps) {
     try {
         if (isForegroundBusy()) {

package/dist/bot/commands/open-command.js

@@ -0,0 +1,45 @@
+import { getBrowserRoots } from "../../app/services/file-browser-service.js";
+import { interactionManager } from "../../app/managers/interaction-manager.js";
+import { isForegroundBusy } from "../../app/services/run-control-service.js";
+import { t } from "../../i18n/index.js";
+import { logger } from "../../utils/logger.js";
+import { buildOpenRootsKeyboard, clearOpenPathIndex, renderOpenBrowseView } from "../menus/file-browser-menu.js";
+import { replyBusyBlocked } from "../messages/busy-blocked-renderer.js";
+export async function openCommand(ctx) {
+    try {
+        if (isForegroundBusy()) {
+            await replyBusyBlocked(ctx);
+            return;
+        }
+        clearOpenPathIndex();
+        const roots = getBrowserRoots();
+        let text;
+        let keyboard;
+        if (roots.length === 1) {
+            const view = await renderOpenBrowseView(roots[0]);
+            if ("error" in view) {
+                await ctx.reply(t("open.scan_error", { error: view.error }));
+                return;
+            }
+            text = view.text;
+            keyboard = view.keyboard;
+        }
+        else {
+            text = t("open.select_root");
+            keyboard = buildOpenRootsKeyboard();
+        }
+        const message = await ctx.reply(text, { reply_markup: keyboard });
+        interactionManager.start({
+            kind: "inline",
+            expectedInput: "callback",
+            metadata: {
+                menuKind: "open",
+                messageId: message.message_id,
+            },
+        });
+    }
+    catch (error) {
+        logger.error("[Bot] Error opening directory browser:", error);
+        await ctx.reply(t("open.open_error"));
+    }
+}

package/dist/bot/commands/{opencode-start.js → opencode-start-command.js}

@@ -4,7 +4,7 @@ import { resolveLocalOpencodeTarget, startLocalOpencodeServer } from "../../open
 import { opencodeReadyLifecycle } from "../../opencode/ready-lifecycle.js";
 import { logger } from "../../utils/logger.js";
 import { t } from "../../i18n/index.js";
-import { editBotText } from "../utils/telegram-text.js";
+import { editBotText } from "../messages/telegram-text.js";
 const SERVER_READY_TIMEOUT_MS = 10_000;
 const SERVER_READY_POLL_INTERVAL_MS = 500;
 const HEALTH_CHECK_TIMEOUT_MS = 3_000;

package/dist/bot/commands/{opencode-stop.js → opencode-stop-command.js}

@@ -3,7 +3,7 @@ import { opencodeClient } from "../../opencode/client.js";
 import { findServerPid, killServerProcess, resolveLocalOpencodeTarget, } from "../../opencode/process.js";
 import { logger } from "../../utils/logger.js";
 import { t } from "../../i18n/index.js";
-import { editBotText } from "../utils/telegram-text.js";
+import { editBotText } from "../messages/telegram-text.js";
 /**
  * Command handler for /opencode-stop
  * Stops the OpenCode server process

package/dist/bot/commands/projects-command.js

@@ -0,0 +1,32 @@
+import { getProjects } from "../../app/services/project-service.js";
+import { isForegroundBusy } from "../../app/services/run-control-service.js";
+import { syncSessionDirectoryCache } from "../../app/services/session-cache-service.js";
+import { t } from "../../i18n/index.js";
+import { logger } from "../../utils/logger.js";
+import { buildProjectsMenuView } from "../menus/project-selection-menu.js";
+import { replyWithInlineMenu } from "../menus/inline-menu.js";
+import { replyBusyBlocked } from "../messages/busy-blocked-renderer.js";
+export async function projectsCommand(ctx) {
+    try {
+        if (isForegroundBusy()) {
+            await replyBusyBlocked(ctx);
+            return;
+        }
+        await syncSessionDirectoryCache();
+        const projects = await getProjects();
+        if (projects.length === 0) {
+            await ctx.reply(t("projects.empty"));
+            return;
+        }
+        const { text, keyboard } = await buildProjectsMenuView(projects, 0);
+        await replyWithInlineMenu(ctx, {
+            menuKind: "project",
+            text,
+            keyboard,
+        });
+    }
+    catch (error) {
+        logger.error("[Bot] Error fetching projects:", error);
+        await ctx.reply(t("projects.fetch_error"));
+    }
+}

package/dist/bot/commands/rename-command.js

@@ -0,0 +1,33 @@
+import { getCurrentSession } from "../../app/services/session-service.js";
+import { renameManager } from "../../app/managers/rename-manager.js";
+import { interactionManager } from "../../app/managers/interaction-manager.js";
+import { logger } from "../../utils/logger.js";
+import { t } from "../../i18n/index.js";
+import { buildRenameCancelKeyboard } from "../menus/rename-menu.js";
+export async function renameCommand(ctx) {
+    try {
+        const currentSession = getCurrentSession();
+        if (!currentSession) {
+            await ctx.reply(t("rename.no_session"));
+            return;
+        }
+        const message = await ctx.reply(t("rename.prompt", { title: currentSession.title }), {
+            reply_markup: buildRenameCancelKeyboard(),
+        });
+        renameManager.startWaiting(currentSession.id, currentSession.directory, currentSession.title);
+        renameManager.setMessageId(message.message_id);
+        interactionManager.start({
+            kind: "rename",
+            expectedInput: "text",
+            metadata: {
+                sessionId: currentSession.id,
+                messageId: message.message_id,
+            },
+        });
+        logger.info(`[RenameCommand] Waiting for new title for session: ${currentSession.id}`);
+    }
+    catch (error) {
+        logger.error("[RenameCommand] Error starting rename flow:", error);
+        await ctx.reply(t("rename.error"));
+    }
+}

package/dist/bot/commands/sessions-command.js

@@ -0,0 +1,42 @@
+import { getCurrentProject } from "../../app/stores/settings-store.js";
+import { replyWithInlineMenu } 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 { config } from "../../config.js";
+import { t } from "../../i18n/index.js";
+import { buildSessionSelectionMenuView, loadSessionPage } from "../menus/session-selection-menu.js";
+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 { text, keyboard } = buildSessionSelectionMenuView(firstPage, pageSize);
+        await replyWithInlineMenu(ctx, {
+            menuKind: "session",
+            text,
+            keyboard,
+        });
+    }
+    catch (error) {
+        logger.error("[Sessions] Error fetching sessions:", error);
+        await ctx.reply(t("sessions.fetch_error"));
+    }
+}

package/dist/bot/commands/settings-command.js

@@ -0,0 +1,10 @@
+import { buildSettingsMenuView } from "../menus/settings-menu.js";
+import { replyWithInlineMenu } from "../menus/inline-menu.js";
+export async function settingsCommand(ctx) {
+    const { text, keyboard } = buildSettingsMenuView();
+    await replyWithInlineMenu(ctx, {
+        menuKind: "settings",
+        text,
+        keyboard,
+    });
+}

package/dist/bot/commands/skills-catalog-command.js

@@ -0,0 +1,42 @@
+import { config } from "../../config.js";
+import { interactionManager } from "../../app/managers/interaction-manager.js";
+import { loadSkillsCatalog } from "../../app/services/skills-catalog-service.js";
+import { getCurrentProject } from "../../app/stores/settings-store.js";
+import { t } from "../../i18n/index.js";
+import { logger } from "../../utils/logger.js";
+import { buildSkillsListKeyboard, formatSkillsSelectText } from "../menus/skills-catalog-menu.js";
+export async function skillsCommand(ctx) {
+    try {
+        const currentProject = getCurrentProject();
+        if (!currentProject) {
+            await ctx.reply(t("bot.project_not_selected"));
+            return;
+        }
+        const skills = await loadSkillsCatalog(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"));
+    }
+}

package/dist/bot/commands/{start.js → start-command.js}

@@ -1,16 +1,16 @@
-import { createMainKeyboard } from "../utils/keyboard.js";
-import { getStoredAgent } from "../../agent/manager.js";
-import { getStoredModel } from "../../model/manager.js";
-import { formatVariantForButton } from "../../variant/manager.js";
-import { pinnedMessageManager } from "../../pinned/manager.js";
-import { keyboardManager } from "../../keyboard/manager.js";
-import { clearSession } from "../../session/manager.js";
-import { clearProject } from "../../settings/manager.js";
-import { foregroundSessionState } from "../../scheduled-task/foreground-state.js";
-import { abortCurrentOperation } from "./abort.js";
+import { createMainKeyboard } from "../keyboards/main-reply-keyboard.js";
+import { getStoredAgent } from "../../app/services/agent-selection-service.js";
+import { getStoredModel } from "../../app/services/model-selection-service.js";
+import { formatVariantForButton } from "../../app/services/variant-selection-service.js";
+import { pinnedMessageManager } from "../pinned/pinned-message-manager.js";
+import { keyboardManager } from "../keyboards/keyboard-manager.js";
+import { clearSession } from "../../app/services/session-service.js";
+import { clearProject } from "../../app/stores/settings-store.js";
+import { foregroundSessionState } from "../../app/managers/foreground-session-state-manager.js";
+import { abortCurrentOperation } from "./abort-command.js";
 import { t } from "../../i18n/index.js";
-import { assistantRunState } from "../assistant-run-state.js";
-import { detachAttachedSession } from "../../attach/service.js";
+import { assistantRunState } from "../../app/managers/assistant-run-state-manager.js";
+import { detachAttachedSession } from "../../app/services/attach-service.js";
 export async function startCommand(ctx) {
     if (ctx.chat) {
         if (!pinnedMessageManager.isInitialized()) {