@otto-assistant/otto 0.1.1 → 0.7.15

package/src/commands/agent.ts

@@ -0,0 +1,496 @@
+// /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,
+  type ThreadChannel,
+  type TextChannel,
+  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<
+  string,
+  {
+    dir: string
+    channelId: string
+    sessionId?: string
+    isThread: boolean
+  }
+>()
+
+/**
+ * Context for agent commands, containing channel/session info.
+ */
+export type AgentCommandContext = {
+  dir: string
+  channelId: string
+  sessionId?: string
+  isThread: boolean
+}
+
+export type CurrentAgentInfo =
+  | { type: 'session'; agent: string }
+  | { type: 'channel'; agent: string }
+  | { type: 'none' }
+
+/**
+ * Get the current agent info for a channel/session, including where it comes from.
+ * Priority: session > channel > none
+ */
+export async function getCurrentAgentInfo({
+  sessionId,
+  channelId,
+}: {
+  sessionId?: string
+  channelId?: string
+}): Promise<CurrentAgentInfo> {
+  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: string): string {
+  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,
+}: {
+  agentName: string
+  description?: string
+}): string {
+  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: string | undefined,
+): string | undefined {
+  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,
+}: {
+  command: ChatInputCommandInteraction
+}): Promise<string | undefined> {
+  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,
+}: {
+  interaction: ChatInputCommandInteraction
+  appId: string
+}): Promise<AgentCommandContext | null> {
+  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: string | undefined
+  let targetChannelId: string
+  let sessionId: string | undefined
+
+  if (isThread) {
+    const thread = channel as ThreadChannel
+    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 as TextChannel
+    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,
+}: {
+  context: AgentCommandContext
+  agentName: string
+}): Promise<void> {
+  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,
+}: {
+  interaction: ChatInputCommandInteraction
+  appId: string
+}): Promise<void> {
+  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 as { hidden?: boolean }).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<StringSelectMenuBuilder>().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: StringSelectMenuInteraction,
+): Promise<void> {
+  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,
+}: {
+  command: ChatInputCommandInteraction
+  appId: string
+}): Promise<void> {
+  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' as const }
+      }
+      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/src/commands/ask-question.test.ts

@@ -0,0 +1,111 @@
+// Tests AskUserQuestion request deduplication and cleanup helpers.
+
+import { afterEach, describe, expect, test, vi } from 'vitest'
+import type { ThreadChannel } from 'discord.js'
+import {
+  deletePendingQuestionContextsForRequest,
+  pendingQuestionContexts,
+  showAskUserQuestionDropdowns,
+} from './ask-question.js'
+
+function createFakeThread(): ThreadChannel {
+  const send = vi.fn(async () => {
+    return { id: 'msg-1' }
+  })
+
+  return {
+    id: 'thread-1',
+    send,
+  } as unknown as ThreadChannel
+}
+
+afterEach(() => {
+  pendingQuestionContexts.clear()
+  vi.restoreAllMocks()
+})
+
+describe('ask-question', () => {
+  test('dedupes duplicate question requests for the same thread', async () => {
+    const thread = createFakeThread()
+
+    await showAskUserQuestionDropdowns({
+      thread,
+      sessionId: 'ses-1',
+      directory: '/project',
+      requestId: 'req-1',
+      input: {
+        questions: [{
+          question: 'Choose one',
+          header: 'Pick',
+          options: [
+            { label: 'Alpha', description: 'A' },
+            { label: 'Beta', description: 'B' },
+          ],
+        }],
+      },
+    })
+
+    await showAskUserQuestionDropdowns({
+      thread,
+      sessionId: 'ses-1',
+      directory: '/project',
+      requestId: 'req-1',
+      input: {
+        questions: [{
+          question: 'Choose one',
+          header: 'Pick',
+          options: [
+            { label: 'Alpha', description: 'A' },
+            { label: 'Beta', description: 'B' },
+          ],
+        }],
+      },
+    })
+
+    expect(thread.send).toHaveBeenCalledTimes(1)
+    expect(pendingQuestionContexts.size).toBe(1)
+  })
+
+  test('removes all duplicate contexts for one request', () => {
+    const thread = createFakeThread()
+    const baseContext: typeof pendingQuestionContexts extends Map<string, infer T>
+      ? T
+      : never = {
+      sessionId: 'ses-1',
+      directory: '/project',
+      thread,
+      requestId: 'req-1',
+      questions: [{
+        question: 'Choose one',
+        header: 'Pick',
+        options: [
+          { label: 'Alpha', description: 'A' },
+          { label: 'Beta', description: 'B' },
+        ],
+      }],
+      answers: {},
+      totalQuestions: 1,
+      answeredCount: 0,
+      contextHash: 'ctx-1',
+    }
+
+    pendingQuestionContexts.set('ctx-1', baseContext)
+    pendingQuestionContexts.set('ctx-2', {
+      ...baseContext,
+      contextHash: 'ctx-2',
+    })
+    pendingQuestionContexts.set('ctx-3', {
+      ...baseContext,
+      requestId: 'req-2',
+      contextHash: 'ctx-3',
+    })
+
+    const removed = deletePendingQuestionContextsForRequest({
+      threadId: thread.id,
+      requestId: 'req-1',
+    })
+
+    expect(removed).toBe(2)
+    expect([...pendingQuestionContexts.keys()]).toEqual(['ctx-3'])
+  })
+})