@grinev/opencode-telegram-bot 0.16.0 → 0.17.0

package/dist/bot/commands/projects.js

@@ -1,5 +1,6 @@
 import { InlineKeyboard } from "grammy";
 import { getCurrentProject } from "../../settings/manager.js";
+import { getGitWorktreeContext } from "../../git/worktree.js";
 import { getProjects } from "../../project/manager.js";
 import { syncSessionDirectoryCache } from "../../session/cache-manager.js";
 import { appendInlineMenuCancelButton, ensureActiveInlineMenu, replyWithInlineMenu, } from "../handlers/inline-menu.js";
@@ -68,14 +69,37 @@ function buildProjectsMenuText(currentProjectName, page, totalPages) {
         total: String(totalPages),
     })}`;
 }
-function buildProjectsKeyboard(projects, page) {
+function worktreeKey(worktree) {
+    return process.platform === "win32" ? worktree.toLowerCase() : worktree;
+}
+async function getActiveProjectWorktree() {
+    const currentProject = getCurrentProject();
+    if (!currentProject) {
+        return null;
+    }
+    try {
+        const worktreeContext = await getGitWorktreeContext(currentProject.worktree);
+        if (worktreeContext) {
+            return worktreeContext.mainProjectPath;
+        }
+    }
+    catch (error) {
+        logger.debug("[Projects] Could not resolve active git worktree metadata:", error);
+    }
+    return currentProject.worktree;
+}
+async function buildProjectsKeyboard(projects, page) {
     const keyboard = new InlineKeyboard();
     const currentProject = getCurrentProject();
+    const activeProjectWorktree = await getActiveProjectWorktree();
     const pageSize = config.bot.projectsListLimit;
     const { page: normalizedPage, totalPages, startIndex, endIndex, } = calculateProjectsPaginationRange(projects.length, page, pageSize);
     projects.slice(startIndex, endIndex).forEach((project, index) => {
         const isActive = currentProject &&
-            (project.id === currentProject.id || project.worktree === currentProject.worktree);
+            (project.id === currentProject.id ||
+                project.worktree === currentProject.worktree ||
+                (activeProjectWorktree !== null &&
+                    worktreeKey(project.worktree) === worktreeKey(activeProjectWorktree)));
         const label = buildProjectButtonLabel(startIndex + index, project.worktree);
         const labelWithCheck = formatProjectButtonLabel(label, Boolean(isActive));
         keyboard.text(labelWithCheck, `project:${project.id}`).row();
@@ -90,14 +114,14 @@ function buildProjectsKeyboard(projects, page) {
     }
     return keyboard;
 }
-function buildProjectsMenuView(projects, page) {
+async function buildProjectsMenuView(projects, page) {
     const currentProject = getCurrentProject();
     const pageSize = config.bot.projectsListLimit;
     const { page: normalizedPage, totalPages } = calculateProjectsPaginationRange(projects.length, page, pageSize);
     const currentProjectName = currentProject?.name || currentProject?.worktree || null;
     return {
         text: buildProjectsMenuText(currentProjectName, normalizedPage, totalPages),
-        keyboard: buildProjectsKeyboard(projects, normalizedPage),
+        keyboard: await buildProjectsKeyboard(projects, normalizedPage),
     };
 }
 export async function projectsCommand(ctx) {
@@ -112,7 +136,7 @@ export async function projectsCommand(ctx) {
             await ctx.reply(t("projects.empty"));
             return;
         }
-        const { text, keyboard } = buildProjectsMenuView(projects, 0);
+        const { text, keyboard } = await buildProjectsMenuView(projects, 0);
         await replyWithInlineMenu(ctx, {
             menuKind: "project",
             text,
@@ -146,7 +170,7 @@ export async function handleProjectSelect(ctx) {
                 await ctx.reply(t("projects.empty"));
                 return true;
             }
-            const { text, keyboard } = buildProjectsMenuView(projects, page);
+            const { text, keyboard } = await buildProjectsMenuView(projects, page);
             await ctx.answerCallbackQuery();
             await ctx.editMessageText(text, {
                 reply_markup: appendInlineMenuCancelButton(keyboard, "project"),

package/dist/bot/commands/skills.js

@@ -0,0 +1,376 @@
+import { InlineKeyboard } from "grammy";
+import { opencodeClient } from "../../opencode/client.js";
+import { getCurrentProject } from "../../settings/manager.js";
+import { interactionManager } from "../../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, "/");
+}
+function getCallbackMessageId(ctx) {
+    const message = ctx.callbackQuery?.message;
+    if (!message || !("message_id" in message)) {
+        return null;
+    }
+    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;
+    }
+    const skills = [];
+    for (const item of value) {
+        if (!item || typeof item !== "object") {
+            return null;
+        }
+        const skillName = item.name;
+        if (typeof skillName !== "string" || !skillName.trim()) {
+            return null;
+        }
+        const description = item.description;
+        skills.push({
+            name: skillName,
+            description: typeof description === "string" ? description : undefined,
+        });
+    }
+    return skills;
+}
+function parseSkillsMetadata(state) {
+    if (!state || state.kind !== "custom") {
+        return null;
+    }
+    const flow = state.metadata.flow;
+    const stage = state.metadata.stage;
+    const messageId = state.metadata.messageId;
+    const projectDirectory = state.metadata.projectDirectory;
+    if (flow !== "skills" || typeof messageId !== "number" || typeof projectDirectory !== "string") {
+        return null;
+    }
+    if (stage === "list") {
+        const skills = parseSkillItems(state.metadata.skills);
+        if (!skills) {
+            return null;
+        }
+        const page = typeof state.metadata.page === "number" && Number.isInteger(state.metadata.page)
+            ? Math.max(0, state.metadata.page)
+            : 0;
+        return {
+            flow,
+            stage,
+            messageId,
+            projectDirectory,
+            skills,
+            page,
+        };
+    }
+    if (stage === "confirm") {
+        const skillName = state.metadata.skillName;
+        if (typeof skillName !== "string" || !skillName.trim()) {
+            return null;
+        }
+        return {
+            flow,
+            stage,
+            messageId,
+            projectDirectory,
+            skillName,
+        };
+    }
+    return null;
+}
+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) {
+    const currentProject = getCurrentProject();
+    if (!currentProject) {
+        await ctx.reply(t("bot.project_not_selected"));
+        return;
+    }
+    if (currentProject.worktree !== params.projectDirectory) {
+        logger.warn(`[Skills] Project changed between selection and execution. listedProject=${params.projectDirectory}, currentProject=${currentProject.worktree}. Using current project.`);
+    }
+    const args = params.argumentsText.trim();
+    const executingMessage = formatExecutingSkillMessage(params.skillName, args);
+    await ctx.reply(executingMessage.text, { entities: executingMessage.entities });
+    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)) {
+        return false;
+    }
+    const metadata = parseSkillsMetadata(interactionManager.getSnapshot());
+    const callbackMessageId = getCallbackMessageId(ctx);
+    if (!metadata || callbackMessageId === null || metadata.messageId !== callbackMessageId) {
+        await ctx.answerCallbackQuery({ text: t("skills.inactive_callback"), show_alert: true });
+        return true;
+    }
+    try {
+        if (data === SKILLS_CALLBACK_CANCEL) {
+            clearSkillsInteraction("skills_cancelled");
+            await ctx.answerCallbackQuery({ text: t("skills.cancelled_callback") });
+            await ctx.deleteMessage().catch(() => { });
+            return true;
+        }
+        if (data === SKILLS_CALLBACK_EXECUTE) {
+            if (metadata.stage !== "confirm") {
+                await ctx.answerCallbackQuery({ text: t("skills.inactive_callback"), show_alert: true });
+                return true;
+            }
+            clearSkillsInteraction("skills_execute_clicked");
+            await ctx.answerCallbackQuery({ text: t("skills.execute_callback") });
+            await ctx.deleteMessage().catch(() => { });
+            await executeSkill(ctx, deps, {
+                projectDirectory: metadata.projectDirectory,
+                skillName: metadata.skillName,
+                argumentsText: "",
+            });
+            return true;
+        }
+        const page = parseSkillPageCallback(data);
+        if (page !== null) {
+            if (metadata.stage !== "list") {
+                await ctx.answerCallbackQuery({ text: t("callback.processing_error"), show_alert: true });
+                return true;
+            }
+            const pageSize = config.bot.commandsListLimit;
+            const { page: normalizedPage, totalPages } = calculateSkillsPaginationRange(metadata.skills.length, page, pageSize);
+            if (page >= totalPages || page < 0) {
+                await ctx.answerCallbackQuery({ text: t("skills.page_empty_callback") });
+                return true;
+            }
+            const keyboard = buildSkillsListKeyboard(metadata.skills, normalizedPage, pageSize);
+            await ctx.editMessageText(formatSkillsSelectText(normalizedPage), {
+                reply_markup: keyboard,
+            });
+            await ctx.answerCallbackQuery();
+            interactionManager.transition({
+                expectedInput: "callback",
+                metadata: {
+                    flow: "skills",
+                    stage: "list",
+                    messageId: metadata.messageId,
+                    projectDirectory: metadata.projectDirectory,
+                    skills: metadata.skills,
+                    page: normalizedPage,
+                },
+            });
+            return true;
+        }
+        const skillIndex = parseSelectIndex(data);
+        if (skillIndex === null || metadata.stage !== "list") {
+            await ctx.answerCallbackQuery({ text: t("callback.processing_error"), show_alert: true });
+            return true;
+        }
+        const selectedSkill = metadata.skills[skillIndex];
+        if (!selectedSkill) {
+            await ctx.answerCallbackQuery({ text: t("skills.inactive_callback"), show_alert: true });
+            return true;
+        }
+        await ctx.answerCallbackQuery();
+        await ctx.editMessageText(t("skills.confirm", { skill: `/${selectedSkill.name}` }), {
+            reply_markup: buildSkillsConfirmKeyboard(),
+        });
+        interactionManager.transition({
+            expectedInput: "mixed",
+            metadata: {
+                flow: "skills",
+                stage: "confirm",
+                messageId: metadata.messageId,
+                projectDirectory: metadata.projectDirectory,
+                skillName: selectedSkill.name,
+            },
+        });
+        return true;
+    }
+    catch (error) {
+        logger.error("[Skills] Error handling skill callback:", error);
+        clearSkillsInteraction("skills_callback_error");
+        await ctx.answerCallbackQuery({ text: t("callback.processing_error") }).catch(() => { });
+        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/commands/status.js

@@ -1,10 +1,10 @@
 import { opencodeClient } from "../../opencode/client.js";
+import { getGitWorktreeContext } from "../../git/worktree.js";
 import { getCurrentSession } from "../../session/manager.js";
 import { getCurrentProject, isTtsEnabled } from "../../settings/manager.js";
 import { fetchCurrentAgent } from "../../agent/manager.js";
 import { getAgentDisplayName } from "../../agent/types.js";
 import { fetchCurrentModel } from "../../model/manager.js";
-import { processManager } from "../../process/manager.js";
 import { keyboardManager } from "../../keyboard/manager.js";
 import { pinnedMessageManager } from "../../pinned/manager.js";
 import { logger } from "../../utils/logger.js";
@@ -25,17 +25,6 @@ export async function statusCommand(ctx) {
         message += `${t("status.line.tts", {
             tts: isTtsEnabled() ? t("status.tts.on") : t("status.tts.off"),
         })}\n`;
-        // Add process management information
-        if (processManager.isRunning()) {
-            const uptime = processManager.getUptime();
-            const uptimeStr = uptime ? Math.floor(uptime / 1000) : 0;
-            message += `${t("status.line.managed_yes")}\n`;
-            message += `${t("status.line.pid", { pid: processManager.getPID() ?? "-" })}\n`;
-            message += `${t("status.line.uptime_sec", { seconds: uptimeStr })}\n`;
-        }
-        else {
-            message += `${t("status.line.managed_no")}\n`;
-        }
         // Add agent information
         const currentAgent = await fetchCurrentAgent();
         const agentDisplay = currentAgent
@@ -48,8 +37,26 @@ export async function statusCommand(ctx) {
         message += `${t("status.line.model", { model: modelDisplay })}\n`;
         const currentProject = getCurrentProject();
         if (currentProject) {
-            const projectName = currentProject.name || currentProject.worktree;
-            message += `\n${t("status.project_selected", { project: projectName })}\n`;
+            let projectDisplay = currentProject.worktree;
+            let linkedWorktreePath = null;
+            try {
+                const worktreeContext = await getGitWorktreeContext(currentProject.worktree);
+                if (worktreeContext) {
+                    projectDisplay = worktreeContext.branch
+                        ? `${worktreeContext.mainProjectPath}: ${worktreeContext.branch}`
+                        : worktreeContext.mainProjectPath;
+                    linkedWorktreePath = worktreeContext.isLinkedWorktree
+                        ? worktreeContext.activeWorktreePath
+                        : null;
+                }
+            }
+            catch (error) {
+                logger.debug("[Status] Could not resolve git worktree metadata", error);
+            }
+            message += `\n${t("status.project_selected", { project: projectDisplay })}\n`;
+            if (linkedWorktreePath) {
+                message += `${t("status.worktree_selected", { worktree: linkedWorktreePath })}\n`;
+            }
         }
         else {
             message += `\n${t("status.project_not_selected")}\n`;