@otto-assistant/otto 0.1.1 → 0.7.15

package/dist/commands/agent.js

@@ -0,0 +1,355 @@
+// /agent command - Set the preferred agent for this channel or session.
+// Also provides quick agent commands like /plan-agent, /build-agent that switch instantly.
+import { ChatInputCommandInteraction, StringSelectMenuInteraction, StringSelectMenuBuilder, ActionRowBuilder, ChannelType, MessageFlags, } from 'discord.js';
+import crypto from 'node:crypto';
+import { setChannelAgent, setSessionAgent, clearSessionModel, getThreadSession, getSessionAgent, getChannelAgent, } from '../database.js';
+import { initializeOpencodeForDirectory } from '../opencode.js';
+import { resolveTextChannel, getOttoMetadata } from '../discord-utils.js';
+import { createLogger, LogPrefix } from '../logger.js';
+import { getCurrentModelInfo } from './model.js';
+const agentLogger = createLogger(LogPrefix.AGENT);
+const AGENT_CONTEXT_TTL_MS = 10 * 60 * 1000;
+const pendingAgentContexts = new Map();
+/**
+ * Get the current agent info for a channel/session, including where it comes from.
+ * Priority: session > channel > none
+ */
+export async function getCurrentAgentInfo({ sessionId, channelId, }) {
+    if (sessionId) {
+        const sessionAgent = await getSessionAgent(sessionId);
+        if (sessionAgent) {
+            return { type: 'session', agent: sessionAgent };
+        }
+    }
+    if (channelId) {
+        const channelAgent = await getChannelAgent(channelId);
+        if (channelAgent) {
+            return { type: 'channel', agent: channelAgent };
+        }
+    }
+    return { type: 'none' };
+}
+/**
+ * Sanitize an agent name to be a valid Discord command name component.
+ * Lowercase, alphanumeric and hyphens only.
+ */
+export function sanitizeAgentName(name) {
+    return name
+        .toLowerCase()
+        .replace(/[^a-z0-9-]/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '');
+}
+const QUICK_AGENT_DESCRIPTION_PATTERN = /^\[agent:([^\]]+)\]/;
+/**
+ * Build quick-agent command description with an embedded original agent name.
+ * Metadata format: [agent:<original-name>] <visible description>
+ */
+export function buildQuickAgentCommandDescription({ agentName, description, }) {
+    const metadataPrefix = `[agent:${agentName}]`;
+    if (metadataPrefix.length > 100) {
+        return metadataPrefix.slice(0, 100);
+    }
+    const visibleDescription = description || `Switch to ${agentName} agent`;
+    const maxVisibleLength = 100 - metadataPrefix.length - 1;
+    if (maxVisibleLength <= 0) {
+        return metadataPrefix;
+    }
+    const trimmedVisible = visibleDescription.slice(0, maxVisibleLength).trim();
+    if (!trimmedVisible) {
+        return metadataPrefix;
+    }
+    return `${metadataPrefix} ${trimmedVisible}`;
+}
+function parseQuickAgentNameFromDescription(description) {
+    if (!description) {
+        return undefined;
+    }
+    const match = QUICK_AGENT_DESCRIPTION_PATTERN.exec(description);
+    if (!match) {
+        return undefined;
+    }
+    const agentName = match[1]?.trim();
+    if (!agentName) {
+        return undefined;
+    }
+    return agentName;
+}
+async function resolveQuickAgentNameFromInteraction({ command, }) {
+    const fromCommandObject = parseQuickAgentNameFromDescription(command.command?.description);
+    if (fromCommandObject) {
+        return fromCommandObject;
+    }
+    if (!command.guild) {
+        return undefined;
+    }
+    const fetchedCommand = await command.guild.commands.fetch(command.commandId);
+    if (!fetchedCommand) {
+        return undefined;
+    }
+    return parseQuickAgentNameFromDescription(fetchedCommand.description);
+}
+/**
+ * Resolve the context for an agent command (directory, channel, session).
+ * Returns null if the command cannot be executed in this context.
+ */
+export async function resolveAgentCommandContext({ interaction, }) {
+    const channel = interaction.channel;
+    if (!channel) {
+        await interaction.editReply({
+            content: 'This command can only be used in a channel',
+        });
+        return null;
+    }
+    const isThread = [
+        ChannelType.PublicThread,
+        ChannelType.PrivateThread,
+        ChannelType.AnnouncementThread,
+    ].includes(channel.type);
+    let projectDirectory;
+    let targetChannelId;
+    let sessionId;
+    if (isThread) {
+        const thread = channel;
+        const textChannel = await resolveTextChannel(thread);
+        const metadata = await getOttoMetadata(textChannel);
+        projectDirectory = metadata.projectDirectory;
+        targetChannelId = textChannel?.id || channel.id;
+        sessionId = await getThreadSession(thread.id);
+    }
+    else if (channel.type === ChannelType.GuildText) {
+        const textChannel = channel;
+        const metadata = await getOttoMetadata(textChannel);
+        projectDirectory = metadata.projectDirectory;
+        targetChannelId = channel.id;
+    }
+    else {
+        await interaction.editReply({
+            content: 'This command can only be used in text channels or threads',
+        });
+        return null;
+    }
+    if (!projectDirectory) {
+        await interaction.editReply({
+            content: 'This channel is not configured with a project directory',
+        });
+        return null;
+    }
+    return {
+        dir: projectDirectory,
+        channelId: targetChannelId,
+        sessionId,
+        isThread,
+    };
+}
+/**
+ * Set the agent preference for a context (session or channel).
+ * When switching agents for a session, clears session model preference
+ * so the new agent's model takes effect (agent model > channel model).
+ */
+export async function setAgentForContext({ context, agentName, }) {
+    if (context.isThread && context.sessionId) {
+        await setSessionAgent(context.sessionId, agentName);
+        // Clear session model so the new agent's model takes effect
+        await clearSessionModel(context.sessionId);
+        agentLogger.log(`Set agent ${agentName} for session ${context.sessionId} (cleared session model)`);
+    }
+    else {
+        await setChannelAgent(context.channelId, agentName);
+        agentLogger.log(`Set agent ${agentName} for channel ${context.channelId}`);
+    }
+}
+export async function handleAgentCommand({ interaction, appId, }) {
+    await interaction.deferReply({ flags: MessageFlags.Ephemeral });
+    const context = await resolveAgentCommandContext({ interaction, appId });
+    if (!context) {
+        return;
+    }
+    try {
+        const getClient = await initializeOpencodeForDirectory(context.dir);
+        if (getClient instanceof Error) {
+            await interaction.editReply({ content: getClient.message });
+            return;
+        }
+        const agentsResponse = await getClient().app.agents({
+            directory: context.dir,
+        });
+        if (!agentsResponse.data || agentsResponse.data.length === 0) {
+            await interaction.editReply({ content: 'No agents available' });
+            return;
+        }
+        const agents = agentsResponse.data
+            .filter((agent) => {
+            const hidden = agent.hidden;
+            return (agent.mode === 'primary' || agent.mode === 'all') && !hidden;
+        })
+            .slice(0, 25);
+        if (agents.length === 0) {
+            await interaction.editReply({ content: 'No primary agents available' });
+            return;
+        }
+        const currentAgentInfo = await getCurrentAgentInfo({
+            sessionId: context.sessionId,
+            channelId: context.channelId,
+        });
+        const currentAgentText = (() => {
+            switch (currentAgentInfo.type) {
+                case 'session':
+                    return `**Current (session override):** \`${currentAgentInfo.agent}\``;
+                case 'channel':
+                    return `**Current (channel override):** \`${currentAgentInfo.agent}\``;
+                case 'none':
+                    return '**Current:** none';
+            }
+        })();
+        const contextHash = crypto.randomBytes(8).toString('hex');
+        pendingAgentContexts.set(contextHash, context);
+        setTimeout(() => {
+            pendingAgentContexts.delete(contextHash);
+        }, AGENT_CONTEXT_TTL_MS).unref();
+        const options = agents.map((agent) => ({
+            label: agent.name.slice(0, 100),
+            value: agent.name,
+            description: (agent.description || `${agent.mode} agent`).slice(0, 100),
+        }));
+        const selectMenu = new StringSelectMenuBuilder()
+            .setCustomId(`agent_select:${contextHash}`)
+            .setPlaceholder('Select an agent')
+            .addOptions(options);
+        const actionRow = new ActionRowBuilder().addComponents(selectMenu);
+        await interaction.editReply({
+            content: `**Set Agent Preference**\n${currentAgentText}\nSelect an agent:`,
+            components: [actionRow],
+        });
+    }
+    catch (error) {
+        agentLogger.error('Error loading agents:', error);
+        await interaction.editReply({
+            content: `Failed to load agents: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        });
+    }
+}
+export async function handleAgentSelectMenu(interaction) {
+    const customId = interaction.customId;
+    if (!customId.startsWith('agent_select:')) {
+        return;
+    }
+    await interaction.deferUpdate();
+    const contextHash = customId.replace('agent_select:', '');
+    const context = pendingAgentContexts.get(contextHash);
+    if (!context) {
+        await interaction.editReply({
+            content: 'Selection expired. Please run /agent again.',
+            components: [],
+        });
+        return;
+    }
+    const selectedAgent = interaction.values[0];
+    if (!selectedAgent) {
+        await interaction.editReply({
+            content: 'No agent selected',
+            components: [],
+        });
+        return;
+    }
+    try {
+        await setAgentForContext({ context, agentName: selectedAgent });
+        if (context.isThread && context.sessionId) {
+            await interaction.editReply({
+                content: `Agent preference set for this session: **${selectedAgent}**\nThe agent will change on the next message.`,
+                components: [],
+            });
+        }
+        else {
+            await interaction.editReply({
+                content: `Agent preference set for this channel: **${selectedAgent}**\nAll new sessions in this channel will use this agent.`,
+                components: [],
+            });
+        }
+        pendingAgentContexts.delete(contextHash);
+    }
+    catch (error) {
+        agentLogger.error('Error saving agent preference:', error);
+        await interaction.editReply({
+            content: `Failed to save agent preference: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            components: [],
+        });
+    }
+}
+/**
+ * Handle quick agent commands like /plan-agent, /build-agent.
+ * These instantly switch to the specified agent without showing a dropdown.
+ *
+ * The slash command name is sanitized for Discord and can be lossy
+ * (for example gpt5.4 -> gpt5-4-agent). To keep the original agent name,
+ * registration stores [agent:<name>] metadata in the description and this
+ * handler resolves from that metadata first.
+ */
+export async function handleQuickAgentCommand({ command, appId, }) {
+    const fallbackAgentName = command.commandName.replace(/-agent$/, '');
+    await command.deferReply({ flags: MessageFlags.Ephemeral });
+    const context = await resolveAgentCommandContext({
+        interaction: command,
+        appId,
+    });
+    if (!context) {
+        return;
+    }
+    try {
+        const resolvedAgentName = (await resolveQuickAgentNameFromInteraction({ command })) ||
+            fallbackAgentName;
+        // Check current agent and set new one.
+        // getCurrentAgentInfo is fast (DB only), use it for the "was X" text.
+        const previousAgent = await getCurrentAgentInfo({
+            sessionId: context.sessionId,
+            channelId: context.channelId,
+        });
+        const previousAgentName = previousAgent.type !== 'none' ? previousAgent.agent : undefined;
+        if (previousAgentName === resolvedAgentName) {
+            await command.editReply({
+                content: `Already using **${resolvedAgentName}** agent`,
+            });
+            return;
+        }
+        // Set the agent preference in DB for this context.
+        await setAgentForContext({ context, agentName: resolvedAgentName });
+        const previousText = previousAgentName
+            ? ` (was **${previousAgentName}**)`
+            : '';
+        // Resolve the model that will now be used for the new agent so we can
+        // show it in the reply. setAgentForContext already cleared any session
+        // model preference, so getCurrentModelInfo falls through to the agent's
+        // configured model (or channel/global/default).
+        const modelInfo = await (async () => {
+            const getClient = await initializeOpencodeForDirectory(context.dir);
+            if (getClient instanceof Error) {
+                return { type: 'none' };
+            }
+            return getCurrentModelInfo({
+                sessionId: context.sessionId,
+                channelId: context.channelId,
+                appId,
+                agentPreference: resolvedAgentName,
+                getClient,
+                directory: context.dir,
+            });
+        })();
+        const modelText = modelInfo.type === 'none' ? '' : `\nModel: *${modelInfo.model}*`;
+        if (context.isThread && context.sessionId) {
+            await command.editReply({
+                content: `Switched to **${resolvedAgentName}** agent for this session${previousText}${modelText}\nThe agent will change on the next message.`,
+            });
+        }
+        else {
+            await command.editReply({
+                content: `Switched to **${resolvedAgentName}** agent for this channel${previousText}${modelText}\nAll new sessions will use this agent.`,
+            });
+        }
+    }
+    catch (error) {
+        agentLogger.error('Error in quick agent command:', error);
+        await command.editReply({
+            content: `Failed to switch agent: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        });
+    }
+}

package/dist/commands/ask-question.js

@@ -0,0 +1,320 @@
+// AskUserQuestion tool handler - Shows Discord dropdowns for AI questions.
+// When the AI uses the AskUserQuestion tool, this module renders dropdowns
+// for each question and collects user responses.
+import { StringSelectMenuBuilder, StringSelectMenuInteraction, ActionRowBuilder, MessageFlags, } from 'discord.js';
+import crypto from 'node:crypto';
+import { sendThreadMessage, NOTIFY_MESSAGE_FLAGS, SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
+import { getOpencodeClient } from '../opencode.js';
+import { createLogger, LogPrefix } from '../logger.js';
+const logger = createLogger(LogPrefix.ASK_QUESTION);
+// Store pending question contexts by hash.
+// TTL prevents unbounded growth if user never answers a question.
+const QUESTION_CONTEXT_TTL_MS = 10 * 60 * 1000;
+export const pendingQuestionContexts = new Map();
+export function findPendingQuestionContextForRequest({ threadId, requestId, }) {
+    for (const [contextHash, context] of pendingQuestionContexts) {
+        if (context.thread.id !== threadId) {
+            continue;
+        }
+        if (context.requestId !== requestId) {
+            continue;
+        }
+        return { contextHash, context };
+    }
+    return null;
+}
+export function deletePendingQuestionContextsForRequest({ threadId, requestId, }) {
+    const matchingContextHashes = [...pendingQuestionContexts.entries()]
+        .filter(([, context]) => {
+        return context.thread.id === threadId && context.requestId === requestId;
+    })
+        .map(([contextHash]) => {
+        return contextHash;
+    });
+    matchingContextHashes.map((contextHash) => {
+        pendingQuestionContexts.delete(contextHash);
+        return contextHash;
+    });
+    return matchingContextHashes.length;
+}
+export function hasPendingQuestionForThread(threadId) {
+    return [...pendingQuestionContexts.values()].some((ctx) => {
+        return ctx.thread.id === threadId;
+    });
+}
+/**
+ * Show dropdown menus for question tool input.
+ * Sends one message per question with the dropdown directly under the question text.
+ */
+export async function showAskUserQuestionDropdowns({ thread, sessionId, directory, requestId, input, silent, }) {
+    const existingPending = findPendingQuestionContextForRequest({
+        threadId: thread.id,
+        requestId,
+    });
+    if (existingPending) {
+        logger.log(`Deduped question ${requestId} for thread ${thread.id} (existing context ${existingPending.contextHash})`);
+        return;
+    }
+    const contextHash = crypto.randomBytes(8).toString('hex');
+    const context = {
+        sessionId,
+        directory,
+        thread,
+        requestId,
+        questions: input.questions,
+        answers: {},
+        totalQuestions: input.questions.length,
+        answeredCount: 0,
+        contextHash,
+    };
+    pendingQuestionContexts.set(contextHash, context);
+    // On TTL expiry: hide the dropdown UI and abort the session so OpenCode
+    // unblocks. We intentionally do NOT call question.reply() — sending 'Other'
+    // made the model think the user chose an option when they didn't.
+    setTimeout(async () => {
+        const ctx = pendingQuestionContexts.get(contextHash);
+        if (!ctx) {
+            return;
+        }
+        // Delete context first so the dropdown becomes inert immediately.
+        // Without this, a user clicking during the abort() await would still
+        // be accepted by handleAskQuestionSelectMenu, then abort() would
+        // kill that valid run.
+        deletePendingQuestionContextsForRequest({
+            threadId: ctx.thread.id,
+            requestId: ctx.requestId,
+        });
+        // Abort the session so OpenCode isn't stuck waiting for a reply
+        const client = getOpencodeClient(ctx.directory);
+        if (client) {
+            await client.session.abort({
+                sessionID: ctx.sessionId,
+            }).catch((error) => {
+                logger.error('Failed to abort session after question expiry:', error);
+            });
+        }
+    }, QUESTION_CONTEXT_TTL_MS).unref();
+    // Send one message per question with its dropdown directly underneath
+    for (let i = 0; i < input.questions.length; i++) {
+        const q = input.questions[i];
+        // Map options to Discord select menu options
+        // Discord max: 25 options per select menu
+        const options = [
+            ...q.options.slice(0, 24).map((opt, optIdx) => ({
+                label: opt.label.slice(0, 100),
+                value: `${optIdx}`,
+                description: opt.description.slice(0, 100),
+            })),
+            {
+                label: 'Other',
+                value: 'other',
+                description: 'Provide a custom answer in chat',
+            },
+        ];
+        const placeholder = options.find((x) => x.label)?.label || 'Select an option';
+        const selectMenu = new StringSelectMenuBuilder()
+            .setCustomId(`ask_question:${contextHash}:${i}`)
+            .setPlaceholder(placeholder)
+            .addOptions(options);
+        // Enable multi-select if the question supports it
+        if (q.multiple) {
+            selectMenu.setMinValues(1);
+            selectMenu.setMaxValues(options.length);
+        }
+        const actionRow = new ActionRowBuilder().addComponents(selectMenu);
+        await thread.send({
+            content: `**${(q.header || '').slice(0, 200)}**\n${q.question.slice(0, 1700)}`,
+            components: [actionRow],
+            flags: silent ? SILENT_MESSAGE_FLAGS : NOTIFY_MESSAGE_FLAGS,
+        });
+    }
+    logger.log(`Showed ${input.questions.length} question dropdown(s) for session ${sessionId}`);
+}
+/**
+ * Handle dropdown selection for AskUserQuestion.
+ */
+export async function handleAskQuestionSelectMenu(interaction) {
+    const customId = interaction.customId;
+    if (!customId.startsWith('ask_question:')) {
+        return;
+    }
+    const parts = customId.split(':');
+    const contextHash = parts[1];
+    const questionIndex = parseInt(parts[2], 10);
+    if (!contextHash) {
+        await interaction.reply({
+            content: 'Invalid selection.',
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    const context = pendingQuestionContexts.get(contextHash);
+    if (!context) {
+        await interaction.reply({
+            content: 'This question has expired. Please ask the AI again.',
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    await interaction.deferUpdate();
+    const selectedValues = interaction.values;
+    const question = context.questions[questionIndex];
+    if (!question) {
+        logger.error(`Question index ${questionIndex} not found in context`);
+        return;
+    }
+    // Check if "other" was selected
+    if (selectedValues.includes('other')) {
+        // User wants to provide custom answer
+        // For now, mark as "Other" - they can type in chat
+        context.answers[questionIndex] = ['Other (please type your answer in chat)'];
+    }
+    else {
+        // Map value indices back to option labels
+        context.answers[questionIndex] = selectedValues.map((v) => {
+            const optIdx = parseInt(v, 10);
+            return question.options[optIdx]?.label || `Option ${optIdx + 1}`;
+        });
+    }
+    context.answeredCount++;
+    // Update this question's message: show answer and remove dropdown
+    const answeredText = context.answers[questionIndex].join(', ');
+    await interaction.editReply({
+        content: `**${question.header}**\n${question.question}\n✓ _${answeredText}_`,
+        components: [], // Remove the dropdown
+    });
+    // Check if all questions are answered
+    if (context.answeredCount >= context.totalQuestions) {
+        // All questions answered - send result back to session
+        await submitQuestionAnswers(context);
+        deletePendingQuestionContextsForRequest({
+            threadId: context.thread.id,
+            requestId: context.requestId,
+        });
+    }
+}
+/**
+ * Submit all collected answers back to the OpenCode session.
+ * Uses the question.reply API to provide answers to the waiting tool.
+ */
+async function submitQuestionAnswers(context) {
+    try {
+        const client = getOpencodeClient(context.directory);
+        if (!client) {
+            throw new Error('OpenCode server not found for directory');
+        }
+        // Build answers array: each element is an array of selected labels for that question
+        const answers = context.questions.map((_, i) => {
+            return context.answers[i] || [];
+        });
+        await client.question.reply({
+            requestID: context.requestId,
+            directory: context.directory,
+            answers,
+        });
+        logger.log(`Submitted answers for question ${context.requestId} in session ${context.sessionId}`);
+    }
+    catch (error) {
+        logger.error('Failed to submit answers:', error);
+        await sendThreadMessage(context.thread, `✗ Failed to submit answers: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}
+/**
+ * Check if a tool part is an AskUserQuestion tool.
+ * Returns the parsed input if valid, null otherwise.
+ */
+export function parseAskUserQuestionTool(part) {
+    if (part.type !== 'tool') {
+        return null;
+    }
+    // Check for the tool name (case-insensitive)
+    const toolName = part.tool?.toLowerCase();
+    if (toolName !== 'question') {
+        return null;
+    }
+    const input = part.state?.input;
+    if (!input?.questions ||
+        !Array.isArray(input.questions) ||
+        input.questions.length === 0) {
+        return null;
+    }
+    // Validate structure
+    for (const q of input.questions) {
+        if (typeof q.question !== 'string' ||
+            typeof q.header !== 'string' ||
+            !Array.isArray(q.options) ||
+            q.options.length < 2) {
+            return null;
+        }
+    }
+    return input;
+}
+/**
+ * Cancel a pending question for a thread.
+ *
+ * Two modes depending on whether `userMessage` is provided:
+ *
+ * - `cancelPendingQuestion(threadId)` — cleanup only. Removes the context
+ *   without replying to OpenCode. Use when aborting the blocked session
+ *   separately (e.g. voice/attachment messages whose content needs
+ *   transcription first). Returns 'no-pending' in both "found+cleaned" and
+ *   "nothing found" cases.
+ *
+ * - `cancelPendingQuestion(threadId, text)` — reply path. Sends the text as
+ *   the tool answer so the model sees the user's response. The caller should
+ *   NOT also enqueue the message as a new prompt.
+ *   Returns 'replied' on success, 'reply-failed' if the reply call fails
+ *   (context kept pending so TTL can retry).
+ */
+export async function cancelPendingQuestion(threadId, userMessage) {
+    // Find pending question for this thread
+    let contextHash;
+    let context;
+    for (const [hash, ctx] of pendingQuestionContexts) {
+        if (ctx.thread.id === threadId) {
+            contextHash = hash;
+            context = ctx;
+            break;
+        }
+    }
+    if (!contextHash || !context) {
+        return 'no-pending';
+    }
+    // undefined means teardown/cleanup — just remove context, don't reply.
+    // The session is already being torn down or the caller wants to dismiss
+    // the question without providing an answer (e.g. voice/attachment-only
+    // messages where content needs transcription before it can be an answer).
+    if (userMessage === undefined) {
+        deletePendingQuestionContextsForRequest({
+            threadId: context.thread.id,
+            requestId: context.requestId,
+        });
+        return 'no-pending';
+    }
+    try {
+        const client = getOpencodeClient(context.directory);
+        if (!client) {
+            throw new Error('OpenCode server not found for directory');
+        }
+        const answers = context.questions.map((_, i) => {
+            return context.answers[i] || [userMessage];
+        });
+        await client.question.reply({
+            requestID: context.requestId,
+            directory: context.directory,
+            answers,
+        });
+        logger.log(`Answered question ${context.requestId} with user message`);
+    }
+    catch (error) {
+        logger.error('Failed to answer question:', error);
+        // Keep context pending so TTL can still fire.
+        // Caller should not consume the user message since reply failed.
+        return 'reply-failed';
+    }
+    deletePendingQuestionContextsForRequest({
+        threadId: context.thread.id,
+        requestId: context.requestId,
+    });
+    return 'replied';
+}