@otto-assistant/otto 0.1.2 → 0.7.16

package/src/commands/ask-question.ts

@@ -0,0 +1,455 @@
+// 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,
+  type ThreadChannel,
+  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)
+
+// Schema matching the question tool input
+export type AskUserQuestionInput = {
+  questions: Array<{
+    question: string
+    header: string // max 12 chars
+    options: Array<{
+      label: string
+      description: string
+    }>
+    multiple?: boolean // optional, defaults to false
+  }>
+}
+
+export type CancelQuestionResult = 'no-pending' | 'replied' | 'reply-failed'
+
+type PendingQuestionContext = {
+  sessionId: string
+  directory: string
+  thread: ThreadChannel
+  requestId: string // OpenCode question request ID for replying
+  questions: AskUserQuestionInput['questions']
+  answers: Record<number, string[]> // questionIndex -> selected labels
+  totalQuestions: number
+  answeredCount: number
+  contextHash: string
+
+}
+
+// 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<string, PendingQuestionContext>()
+
+export function findPendingQuestionContextForRequest({
+  threadId,
+  requestId,
+}: {
+  threadId: string
+  requestId: string
+}): { contextHash: string; context: PendingQuestionContext } | null {
+  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,
+}: {
+  threadId: string
+  requestId: string
+}): number {
+  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: string): boolean {
+  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,
+}: {
+  thread: ThreadChannel
+  sessionId: string
+  directory: string
+  requestId: string // OpenCode question request ID
+  input: AskUserQuestionInput
+  /** Suppress notification when queue has pending items */
+  silent?: boolean
+}): Promise<void> {
+  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: PendingQuestionContext = {
+    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<StringSelectMenuBuilder>().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: StringSelectMenuInteraction,
+): Promise<void> {
+  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: PendingQuestionContext,
+): Promise<void> {
+  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: {
+  type: string
+  tool?: string
+  state?: { input?: unknown }
+}): AskUserQuestionInput | null {
+  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 as AskUserQuestionInput | undefined
+
+  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: string,
+  userMessage?: string,
+): Promise<CancelQuestionResult> {
+  // Find pending question for this thread
+  let contextHash: string | undefined
+  let context: PendingQuestionContext | undefined
+  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'
+}

package/src/commands/btw.ts

@@ -0,0 +1,184 @@
+// /btw command - Fork the current session with full context and send a new prompt.
+// Unlike /fork, this does not replay past messages in Discord. It just creates
+// a new thread, forks the entire session (no messageID), and immediately
+// dispatches the user's prompt so the forked session starts working right away.
+
+import {
+  ChannelType,
+  ThreadAutoArchiveDuration,
+  type ThreadChannel,
+  MessageFlags,
+} from 'discord.js'
+import { getThreadSession, setThreadSession } from '../database.js'
+import {
+  resolveWorkingDirectory,
+  resolveTextChannel,
+  sendThreadMessage,
+} from '../discord-utils.js'
+import { getOrCreateRuntime } from '../session-handler/thread-session-runtime.js'
+import { createLogger, LogPrefix } from '../logger.js'
+import type { CommandContext } from './types.js'
+import { initializeOpencodeForDirectory } from '../opencode.js'
+
+const logger = createLogger(LogPrefix.FORK)
+
+export async function forkSessionToBtwThread({
+  sourceThread,
+  projectDirectory,
+  prompt,
+  userId,
+  username,
+  appId,
+}: {
+  sourceThread: ThreadChannel
+  projectDirectory: string
+  prompt: string
+  userId: string
+  username: string
+  appId: string | undefined
+}): Promise<{ thread: ThreadChannel; forkedSessionId: string } | Error> {
+  const sessionId = await getThreadSession(sourceThread.id)
+  if (!sessionId) {
+    return new Error('No active session in this thread')
+  }
+
+  const getClient = await initializeOpencodeForDirectory(projectDirectory)
+  if (getClient instanceof Error) {
+    return new Error(`Failed to fork session: ${getClient.message}`, {
+      cause: getClient,
+    })
+  }
+
+  const forkResponse = await getClient().session.fork({
+    sessionID: sessionId,
+  })
+  if (!forkResponse.data) {
+    return new Error('Failed to fork session')
+  }
+
+  const textChannel = await resolveTextChannel(sourceThread)
+  if (!textChannel) {
+    return new Error('Could not resolve parent text channel')
+  }
+
+  const forkedSession = forkResponse.data
+  const thread = await textChannel.threads.create({
+    name: `btw: ${prompt}`.slice(0, 100),
+    autoArchiveDuration: ThreadAutoArchiveDuration.OneDay,
+    reason: `btw fork from session ${sessionId}`,
+  })
+
+  await setThreadSession(thread.id, forkedSession.id)
+  await thread.members.add(userId)
+
+  logger.log(
+    `Created btw fork session ${forkedSession.id} in thread ${thread.id} from ${sessionId}`,
+  )
+
+  const sourceThreadLink = `<#${sourceThread.id}>`
+  await sendThreadMessage(
+    thread,
+    `Reusing context from ${sourceThreadLink} to answer prompt...\n${prompt}`,
+  )
+
+  const wrappedPrompt = [
+    `The user asked a side question while you were working on another task.`,
+    `This is a forked session whose ONLY goal is to answer this question.`,
+    `Do NOT continue, resume, or reference the previous task. Only answer the question below.\n`,
+    prompt,
+  ].join('\n')
+
+  const runtime = getOrCreateRuntime({
+    threadId: thread.id,
+    thread,
+    projectDirectory,
+    sdkDirectory: projectDirectory,
+    channelId: sourceThread.parentId || sourceThread.id,
+    appId,
+  })
+  await runtime.enqueueIncoming({
+    prompt: wrappedPrompt,
+    userId,
+    username,
+    appId,
+    mode: 'opencode',
+  })
+
+  return {
+    thread,
+    forkedSessionId: forkedSession.id,
+  }
+}
+
+export async function handleBtwCommand({
+  command,
+  appId,
+}: CommandContext): Promise<void> {
+  const channel = command.channel
+
+  if (!channel) {
+    await command.reply({
+      content: 'This command can only be used in a channel',
+      flags: MessageFlags.Ephemeral,
+    })
+    return
+  }
+
+  if (
+    channel.type !== ChannelType.PublicThread
+    && channel.type !== ChannelType.PrivateThread
+    && channel.type !== ChannelType.AnnouncementThread
+  ) {
+    await command.reply({
+      content:
+        'This command can only be used in a thread with an active session',
+      flags: MessageFlags.Ephemeral,
+    })
+    return
+  }
+
+  const threadChannel = channel
+
+  const prompt = command.options.getString('prompt', true)
+
+  const resolved = await resolveWorkingDirectory({
+    channel: threadChannel,
+  })
+
+  if (!resolved) {
+    await command.reply({
+      content: 'Could not determine project directory for this channel',
+      flags: MessageFlags.Ephemeral,
+    })
+    return
+  }
+
+  const { projectDirectory } = resolved
+
+  await command.deferReply({ flags: MessageFlags.Ephemeral })
+
+  try {
+    const result = await forkSessionToBtwThread({
+      sourceThread: threadChannel,
+      projectDirectory,
+      prompt,
+      userId: command.user.id,
+      username: command.user.displayName,
+      appId,
+    })
+
+    if (result instanceof Error) {
+      await command.editReply(result.message)
+      return
+    }
+
+    await command.editReply(
+      `Session forked! Continue in ${result.thread.toString()}`,
+    )
+  } catch (error) {
+    logger.error('Error in /btw:', error)
+    await command.editReply(
+      `Failed to fork session: ${error instanceof Error ? error.message : 'Unknown error'}`,
+    )
+  }
+}