kimaki 0.4.24 → 0.4.26

package/src/interaction-handler.ts

@@ -1,43 +1,27 @@
-import {
-  ChannelType,
-  Events,
-  ThreadAutoArchiveDuration,
-  type Client,
-  type Interaction,
-  type TextChannel,
-  type ThreadChannel,
-} from 'discord.js'
-import fs from 'node:fs'
-import os from 'node:os'
-import path from 'node:path'
-import { getDatabase } from './database.js'
-import { initializeOpencodeForDirectory } from './opencode.js'
-import {
-  sendThreadMessage,
-  resolveTextChannel,
-  getKimakiMetadata,
-  SILENT_MESSAGE_FLAGS,
-} from './discord-utils.js'
-import { handleForkCommand, handleForkSelectMenu } from './fork.js'
-import {
-  handleModelCommand,
-  handleProviderSelectMenu,
-  handleModelSelectMenu,
-} from './model-command.js'
-import { formatPart } from './message-formatting.js'
-import { createProjectChannels } from './channel-management.js'
-import {
-  handleOpencodeSession,
-  parseSlashCommand,
-  abortControllers,
-  pendingPermissions,
-} from './session-handler.js'
-import { extractTagsArrays } from './xml.js'
+// Discord slash command and interaction handler.
+// Processes all slash commands (/session, /resume, /fork, /model, /abort, etc.)
+// and manages autocomplete, select menu interactions for the bot.
+
+import { Events, type Client, type Interaction } from 'discord.js'
+import { handleSessionCommand, handleSessionAutocomplete } from './commands/session.js'
+import { handleResumeCommand, handleResumeAutocomplete } from './commands/resume.js'
+import { handleAddProjectCommand, handleAddProjectAutocomplete } from './commands/add-project.js'
+import { handleCreateNewProjectCommand } from './commands/create-new-project.js'
+import { handleAcceptCommand, handleRejectCommand } from './commands/permissions.js'
+import { handleAbortCommand } from './commands/abort.js'
+import { handleShareCommand } from './commands/share.js'
+import { handleForkCommand, handleForkSelectMenu } from './commands/fork.js'
+import { handleModelCommand, handleProviderSelectMenu, handleModelSelectMenu } from './commands/model.js'
+import { handleAgentCommand, handleAgentSelectMenu } from './commands/agent.js'
+import { handleAskQuestionSelectMenu } from './commands/ask-question.js'
+import { handleQueueCommand, handleClearQueueCommand } from './commands/queue.js'
+import { handleUndoCommand, handleRedoCommand } from './commands/undo-redo.js'
+import { handleUserCommand } from './commands/user-command.js'
 import { createLogger } from './logger.js'
 
-const discordLogger = createLogger('DISCORD')
 const interactionLogger = createLogger('INTERACTION')
 
+
 export function registerInteractionHandler({
   discordClient,
   appId,
@@ -51,939 +35,142 @@ export function registerInteractionHandler({
     Events.InteractionCreate,
     async (interaction: Interaction) => {
       try {
-        interactionLogger.log(`[INTERACTION] Received: ${interaction.type} - ${interaction.isChatInputCommand() ? interaction.commandName : interaction.isAutocomplete() ? `autocomplete:${interaction.commandName}` : 'other'}`)
+        interactionLogger.log(
+          `[INTERACTION] Received: ${interaction.type} - ${
+            interaction.isChatInputCommand()
+              ? interaction.commandName
+              : interaction.isAutocomplete()
+                ? `autocomplete:${interaction.commandName}`
+                : 'other'
+          }`,
+        )
 
         if (interaction.isAutocomplete()) {
-          if (interaction.commandName === 'resume') {
-            const focusedValue = interaction.options.getFocused()
-
-            let projectDirectory: string | undefined
-            if (interaction.channel) {
-              const textChannel = await resolveTextChannel(
-                interaction.channel as TextChannel | ThreadChannel | null,
-              )
-              if (textChannel) {
-                const { projectDirectory: directory, channelAppId } =
-                  getKimakiMetadata(textChannel)
-                if (channelAppId && channelAppId !== appId) {
-                  await interaction.respond([])
-                  return
-                }
-                projectDirectory = directory
-              }
-            }
-
-            if (!projectDirectory) {
-              await interaction.respond([])
+          switch (interaction.commandName) {
+            case 'session':
+              await handleSessionAutocomplete({ interaction, appId })
               return
-            }
-
-            try {
-              const getClient =
-                await initializeOpencodeForDirectory(projectDirectory)
-
-              const sessionsResponse = await getClient().session.list()
-              if (!sessionsResponse.data) {
-                await interaction.respond([])
-                return
-              }
-
-              const existingSessionIds = new Set(
-                (
-                  getDatabase()
-                    .prepare('SELECT session_id FROM thread_sessions')
-                    .all() as { session_id: string }[]
-                ).map((row) => row.session_id),
-              )
-
-              const sessions = sessionsResponse.data
-                .filter((session) => !existingSessionIds.has(session.id))
-                .filter((session) =>
-                  session.title
-                    .toLowerCase()
-                    .includes(focusedValue.toLowerCase()),
-                )
-                .slice(0, 25)
-                .map((session) => {
-                  const dateStr = new Date(
-                    session.time.updated,
-                  ).toLocaleString()
-                  const suffix = ` (${dateStr})`
-                  const maxTitleLength = 100 - suffix.length
-
-                  let title = session.title
-                  if (title.length > maxTitleLength) {
-                    title = title.slice(0, Math.max(0, maxTitleLength - 1)) + '…'
-                  }
-
-                  return {
-                    name: `${title}${suffix}`,
-                    value: session.id,
-                  }
-                })
-
-              await interaction.respond(sessions)
-            } catch (error) {
-              interactionLogger.error(
-                '[AUTOCOMPLETE] Error fetching sessions:',
-                error,
-              )
-              await interaction.respond([])
-            }
-          } else if (interaction.commandName === 'session') {
-            const focusedOption = interaction.options.getFocused(true)
-
-            if (focusedOption.name === 'files') {
-              const focusedValue = focusedOption.value
-
-              const parts = focusedValue.split(',')
-              const previousFiles = parts
-                .slice(0, -1)
-                .map((f) => f.trim())
-                .filter((f) => f)
-              const currentQuery = (parts[parts.length - 1] || '').trim()
-
-              let projectDirectory: string | undefined
-              if (interaction.channel) {
-                const textChannel = await resolveTextChannel(
-                  interaction.channel as TextChannel | ThreadChannel | null,
-                )
-                if (textChannel) {
-                  const { projectDirectory: directory, channelAppId } =
-                    getKimakiMetadata(textChannel)
-                  if (channelAppId && channelAppId !== appId) {
-                    await interaction.respond([])
-                    return
-                  }
-                  projectDirectory = directory
-                }
-              }
-
-              if (!projectDirectory) {
-                await interaction.respond([])
-                return
-              }
-
-              try {
-                const getClient =
-                  await initializeOpencodeForDirectory(projectDirectory)
-
-                const response = await getClient().find.files({
-                  query: {
-                    query: currentQuery || '',
-                  },
-                })
-
-                const files = response.data || []
-
-                const prefix =
-                  previousFiles.length > 0
-                    ? previousFiles.join(', ') + ', '
-                    : ''
-
-                const choices = files
-                  .map((file: string) => {
-                    const fullValue = prefix + file
-                    const allFiles = [...previousFiles, file]
-                    const allBasenames = allFiles.map(
-                      (f) => f.split('/').pop() || f,
-                    )
-                    let displayName = allBasenames.join(', ')
-                    if (displayName.length > 100) {
-                      displayName = '…' + displayName.slice(-97)
-                    }
-                    return {
-                      name: displayName,
-                      value: fullValue,
-                    }
-                  })
-                  .filter((choice) => choice.value.length <= 100)
-                  .slice(0, 25)
-
-                await interaction.respond(choices)
-              } catch (error) {
-                interactionLogger.error('[AUTOCOMPLETE] Error fetching files:', error)
-                await interaction.respond([])
-              }
-            }
-          } else if (interaction.commandName === 'add-project') {
-            const focusedValue = interaction.options.getFocused()
-
-            try {
-              const currentDir = process.cwd()
-              const getClient = await initializeOpencodeForDirectory(currentDir)
-
-              const projectsResponse = await getClient().project.list({})
-              if (!projectsResponse.data) {
-                await interaction.respond([])
-                return
-              }
-
-              const db = getDatabase()
-              const existingDirs = db
-                .prepare(
-                  'SELECT DISTINCT directory FROM channel_directories WHERE channel_type = ?',
-                )
-                .all('text') as { directory: string }[]
-              const existingDirSet = new Set(
-                existingDirs.map((row) => row.directory),
-              )
-
-              const availableProjects = projectsResponse.data.filter(
-                (project) => !existingDirSet.has(project.worktree),
-              )
-
-              const projects = availableProjects
-                .filter((project) => {
-                  const baseName = path.basename(project.worktree)
-                  const searchText = `${baseName} ${project.worktree}`.toLowerCase()
-                  return searchText.includes(focusedValue.toLowerCase())
-                })
-                .sort((a, b) => {
-                  const aTime = a.time.initialized || a.time.created
-                  const bTime = b.time.initialized || b.time.created
-                  return bTime - aTime
-                })
-                .slice(0, 25)
-                .map((project) => {
-                  const name = `${path.basename(project.worktree)} (${project.worktree})`
-                  return {
-                    name: name.length > 100 ? name.slice(0, 99) + '…' : name,
-                    value: project.id,
-                  }
-                })
-
-              await interaction.respond(projects)
-            } catch (error) {
-              interactionLogger.error(
-                '[AUTOCOMPLETE] Error fetching projects:',
-                error,
-              )
+
+            case 'resume':
+              await handleResumeAutocomplete({ interaction, appId })
+              return
+
+            case 'add-project':
+              await handleAddProjectAutocomplete({ interaction, appId })
+              return
+
+            default:
               await interaction.respond([])
-            }
+              return
           }
         }
 
         if (interaction.isChatInputCommand()) {
-          const command = interaction
-          interactionLogger.log(`[COMMAND] Processing: ${command.commandName}`)
+          interactionLogger.log(`[COMMAND] Processing: ${interaction.commandName}`)
 
-          if (command.commandName === 'session') {
-            await command.deferReply({ ephemeral: false })
-
-            const prompt = command.options.getString('prompt', true)
-            const filesString = command.options.getString('files') || ''
-            const channel = command.channel
-
-            if (!channel || channel.type !== ChannelType.GuildText) {
-              await command.editReply(
-                'This command can only be used in text channels',
-              )
+          switch (interaction.commandName) {
+            case 'session':
+              await handleSessionCommand({ command: interaction, appId })
               return
-            }
-
-            const textChannel = channel as TextChannel
 
-            let projectDirectory: string | undefined
-            let channelAppId: string | undefined
-
-            if (textChannel.topic) {
-              const extracted = extractTagsArrays({
-                xml: textChannel.topic,
-                tags: ['kimaki.directory', 'kimaki.app'],
-              })
-
-              projectDirectory = extracted['kimaki.directory']?.[0]?.trim()
-              channelAppId = extracted['kimaki.app']?.[0]?.trim()
-            }
-
-            if (channelAppId && channelAppId !== appId) {
-              await command.editReply(
-                'This channel is not configured for this bot',
-              )
+            case 'resume':
+              await handleResumeCommand({ command: interaction, appId })
               return
-            }
 
-            if (!projectDirectory) {
-              await command.editReply(
-                'This channel is not configured with a project directory',
-              )
+            case 'add-project':
+              await handleAddProjectCommand({ command: interaction, appId })
               return
-            }
 
-            if (!fs.existsSync(projectDirectory)) {
-              await command.editReply(
-                `Directory does not exist: ${projectDirectory}`,
-              )
+            case 'create-new-project':
+              await handleCreateNewProjectCommand({ command: interaction, appId })
               return
-            }
-
-            try {
-              const getClient =
-                await initializeOpencodeForDirectory(projectDirectory)
-
-              const files = filesString
-                .split(',')
-                .map((f) => f.trim())
-                .filter((f) => f)
-
-              let fullPrompt = prompt
-              if (files.length > 0) {
-                fullPrompt = `${prompt}\n\n@${files.join(' @')}`
-              }
-
-              const starterMessage = await textChannel.send({
-                content: `🚀 **Starting OpenCode session**\n📝 ${prompt.slice(0, 200)}${prompt.length > 200 ? '…' : ''}${files.length > 0 ? `\n📎 Files: ${files.join(', ')}` : ''}`,
-                flags: SILENT_MESSAGE_FLAGS,
-              })
-
-              const thread = await starterMessage.startThread({
-                name: prompt.slice(0, 100),
-                autoArchiveDuration: 1440,
-                reason: 'OpenCode session',
-              })
-
-              await command.editReply(
-                `Created new session in ${thread.toString()}`,
-              )
-
-              const parsedCommand = parseSlashCommand(fullPrompt)
-              await handleOpencodeSession({
-                prompt: fullPrompt,
-                thread,
-                projectDirectory,
-                parsedCommand,
-                channelId: textChannel.id,
-              })
-            } catch (error) {
-              interactionLogger.error('[SESSION] Error:', error)
-              await command.editReply(
-                `Failed to create session: ${error instanceof Error ? error.message : 'Unknown error'}`,
-              )
-            }
-          } else if (command.commandName === 'resume') {
-            await command.deferReply({ ephemeral: false })
-
-            const sessionId = command.options.getString('session', true)
-            const channel = command.channel
-
-            if (!channel || channel.type !== ChannelType.GuildText) {
-              await command.editReply(
-                'This command can only be used in text channels',
-              )
-              return
-            }
-
-            const textChannel = channel as TextChannel
-
-            let projectDirectory: string | undefined
-            let channelAppId: string | undefined
 
-            if (textChannel.topic) {
-              const extracted = extractTagsArrays({
-                xml: textChannel.topic,
-                tags: ['kimaki.directory', 'kimaki.app'],
-              })
-
-              projectDirectory = extracted['kimaki.directory']?.[0]?.trim()
-              channelAppId = extracted['kimaki.app']?.[0]?.trim()
-            }
-
-            if (channelAppId && channelAppId !== appId) {
-              await command.editReply(
-                'This channel is not configured for this bot',
-              )
+            case 'accept':
+            case 'accept-always':
+              await handleAcceptCommand({ command: interaction, appId })
               return
-            }
 
-            if (!projectDirectory) {
-              await command.editReply(
-                'This channel is not configured with a project directory',
-              )
+            case 'reject':
+              await handleRejectCommand({ command: interaction, appId })
               return
-            }
 
-            if (!fs.existsSync(projectDirectory)) {
-              await command.editReply(
-                `Directory does not exist: ${projectDirectory}`,
-              )
-              return
-            }
-
-            try {
-              const getClient =
-                await initializeOpencodeForDirectory(projectDirectory)
-
-              const sessionResponse = await getClient().session.get({
-                path: { id: sessionId },
-              })
-
-              if (!sessionResponse.data) {
-                await command.editReply('Session not found')
-                return
-              }
-
-              const sessionTitle = sessionResponse.data.title
-
-              const thread = await textChannel.threads.create({
-                name: `Resume: ${sessionTitle}`.slice(0, 100),
-                autoArchiveDuration: ThreadAutoArchiveDuration.OneDay,
-                reason: `Resuming session ${sessionId}`,
-              })
-
-              getDatabase()
-                .prepare(
-                  'INSERT OR REPLACE INTO thread_sessions (thread_id, session_id) VALUES (?, ?)',
-                )
-                .run(thread.id, sessionId)
-
-              interactionLogger.log(
-                `[RESUME] Created thread ${thread.id} for session ${sessionId}`,
-              )
-
-              const messagesResponse = await getClient().session.messages({
-                path: { id: sessionId },
-              })
-
-              if (!messagesResponse.data) {
-                throw new Error('Failed to fetch session messages')
-              }
-
-              const messages = messagesResponse.data
-
-              await command.editReply(
-                `Resumed session "${sessionTitle}" in ${thread.toString()}`,
-              )
-
-              await sendThreadMessage(
-                thread,
-                `📂 **Resumed session:** ${sessionTitle}\n📅 **Created:** ${new Date(sessionResponse.data.time.created).toLocaleString()}\n\n*Loading ${messages.length} messages...*`,
-              )
-
-              const allAssistantParts: { id: string; content: string }[] = []
-              for (const message of messages) {
-                if (message.info.role === 'assistant') {
-                  for (const part of message.parts) {
-                    const content = formatPart(part)
-                    if (content.trim()) {
-                      allAssistantParts.push({ id: part.id, content })
-                    }
-                  }
-                }
-              }
-
-              const partsToRender = allAssistantParts.slice(-30)
-              const skippedCount = allAssistantParts.length - partsToRender.length
-
-              if (skippedCount > 0) {
-                await sendThreadMessage(
-                  thread,
-                  `*Skipped ${skippedCount} older assistant parts...*`,
-                )
-              }
-
-              if (partsToRender.length > 0) {
-                const combinedContent = partsToRender
-                  .map((p) => p.content)
-                  .join('\n')
-
-                const discordMessage = await sendThreadMessage(
-                  thread,
-                  combinedContent,
-                )
-
-                const stmt = getDatabase().prepare(
-                  'INSERT OR REPLACE INTO part_messages (part_id, message_id, thread_id) VALUES (?, ?, ?)',
-                )
-
-                const transaction = getDatabase().transaction(
-                  (parts: { id: string }[]) => {
-                    for (const part of parts) {
-                      stmt.run(part.id, discordMessage.id, thread.id)
-                    }
-                  },
-                )
-
-                transaction(partsToRender)
-              }
-
-              const messageCount = messages.length
-
-              await sendThreadMessage(
-                thread,
-                `✅ **Session resumed!** Loaded ${messageCount} messages.\n\nYou can now continue the conversation by sending messages in this thread.`,
-              )
-            } catch (error) {
-              interactionLogger.error('[RESUME] Error:', error)
-              await command.editReply(
-                `Failed to resume session: ${error instanceof Error ? error.message : 'Unknown error'}`,
-              )
-            }
-          } else if (command.commandName === 'add-project') {
-            await command.deferReply({ ephemeral: false })
-
-            const projectId = command.options.getString('project', true)
-            const guild = command.guild
-
-            if (!guild) {
-              await command.editReply('This command can only be used in a guild')
+            case 'abort':
+            case 'stop':
+              await handleAbortCommand({ command: interaction, appId })
               return
-            }
-
-            try {
-              const currentDir = process.cwd()
-              const getClient = await initializeOpencodeForDirectory(currentDir)
-
-              const projectsResponse = await getClient().project.list({})
-              if (!projectsResponse.data) {
-                await command.editReply('Failed to fetch projects')
-                return
-              }
-
-              const project = projectsResponse.data.find(
-                (p) => p.id === projectId,
-              )
-
-              if (!project) {
-                await command.editReply('Project not found')
-                return
-              }
-
-              const directory = project.worktree
-
-              if (!fs.existsSync(directory)) {
-                await command.editReply(`Directory does not exist: ${directory}`)
-                return
-              }
-
-              const db = getDatabase()
-              const existingChannel = db
-                .prepare(
-                  'SELECT channel_id FROM channel_directories WHERE directory = ? AND channel_type = ?',
-                )
-                .get(directory, 'text') as { channel_id: string } | undefined
-
-              if (existingChannel) {
-                await command.editReply(
-                  `A channel already exists for this directory: <#${existingChannel.channel_id}>`,
-                )
-                return
-              }
-
-              const { textChannelId, voiceChannelId, channelName } =
-                await createProjectChannels({
-                  guild,
-                  projectDirectory: directory,
-                  appId,
-                })
-
-              await command.editReply(
-                `✅ Created channels for project:\n📝 Text: <#${textChannelId}>\n🔊 Voice: <#${voiceChannelId}>\n📁 Directory: \`${directory}\``,
-              )
-
-              discordLogger.log(
-                `Created channels for project ${channelName} at ${directory}`,
-              )
-            } catch (error) {
-              interactionLogger.error('[ADD-PROJECT] Error:', error)
-              await command.editReply(
-                `Failed to create channels: ${error instanceof Error ? error.message : 'Unknown error'}`,
-              )
-            }
-          } else if (command.commandName === 'create-new-project') {
-            await command.deferReply({ ephemeral: false })
-
-            const projectName = command.options.getString('name', true)
-            const guild = command.guild
-            const channel = command.channel
-
-            if (!guild) {
-              await command.editReply('This command can only be used in a guild')
-              return
-            }
 
-            if (!channel || channel.type !== ChannelType.GuildText) {
-              await command.editReply('This command can only be used in a text channel')
+            case 'share':
+              await handleShareCommand({ command: interaction, appId })
               return
-            }
-
-            const sanitizedName = projectName
-              .toLowerCase()
-              .replace(/[^a-z0-9-]/g, '-')
-              .replace(/-+/g, '-')
-              .replace(/^-|-$/g, '')
-              .slice(0, 100)
 
-            if (!sanitizedName) {
-              await command.editReply('Invalid project name')
-              return
-            }
-
-            const kimakiDir = path.join(os.homedir(), 'kimaki')
-            const projectDirectory = path.join(kimakiDir, sanitizedName)
-
-            try {
-              if (!fs.existsSync(kimakiDir)) {
-                fs.mkdirSync(kimakiDir, { recursive: true })
-                discordLogger.log(`Created kimaki directory: ${kimakiDir}`)
-              }
-
-              if (fs.existsSync(projectDirectory)) {
-                await command.editReply(`Project directory already exists: ${projectDirectory}`)
-                return
-              }
-
-              fs.mkdirSync(projectDirectory, { recursive: true })
-              discordLogger.log(`Created project directory: ${projectDirectory}`)
-
-              const { execSync } = await import('node:child_process')
-              execSync('git init', { cwd: projectDirectory, stdio: 'pipe' })
-              discordLogger.log(`Initialized git in: ${projectDirectory}`)
-
-              const { textChannelId, voiceChannelId, channelName } =
-                await createProjectChannels({
-                  guild,
-                  projectDirectory,
-                  appId,
-                })
-
-              const textChannel = await guild.channels.fetch(textChannelId) as TextChannel
-
-              await command.editReply(
-                `✅ Created new project **${sanitizedName}**\n📁 Directory: \`${projectDirectory}\`\n📝 Text: <#${textChannelId}>\n🔊 Voice: <#${voiceChannelId}>\n\n_Starting session..._`,
-              )
-
-              const starterMessage = await textChannel.send({
-                content: `🚀 **New project initialized**\n📁 \`${projectDirectory}\``,
-                flags: SILENT_MESSAGE_FLAGS,
-              })
-
-              const thread = await starterMessage.startThread({
-                name: `Init: ${sanitizedName}`,
-                autoArchiveDuration: 1440,
-                reason: 'New project session',
-              })
-
-              await handleOpencodeSession({
-                prompt: 'The project was just initialized. Say hi and ask what the user wants to build.',
-                thread,
-                projectDirectory,
-                channelId: textChannel.id,
-              })
-
-              discordLogger.log(
-                `Created new project ${channelName} at ${projectDirectory}`,
-              )
-            } catch (error) {
-              interactionLogger.error('[ADD-NEW-PROJECT] Error:', error)
-              await command.editReply(
-                `Failed to create new project: ${error instanceof Error ? error.message : 'Unknown error'}`,
-              )
-            }
-          } else if (
-            command.commandName === 'accept' ||
-            command.commandName === 'accept-always'
-          ) {
-            const scope = command.commandName === 'accept-always' ? 'always' : 'once'
-            const channel = command.channel
-
-            if (!channel) {
-              await command.reply({
-                content: 'This command can only be used in a channel',
-                ephemeral: true,
-                flags: SILENT_MESSAGE_FLAGS,
-              })
+            case 'fork':
+              await handleForkCommand(interaction)
               return
-            }
-
-            const isThread = [
-              ChannelType.PublicThread,
-              ChannelType.PrivateThread,
-              ChannelType.AnnouncementThread,
-            ].includes(channel.type)
-
-            if (!isThread) {
-              await command.reply({
-                content: 'This command can only be used in a thread with an active session',
-                ephemeral: true,
-                flags: SILENT_MESSAGE_FLAGS,
-              })
-              return
-            }
-
-            const pending = pendingPermissions.get(channel.id)
-            if (!pending) {
-              await command.reply({
-                content: 'No pending permission request in this thread',
-                ephemeral: true,
-                flags: SILENT_MESSAGE_FLAGS,
-              })
-              return
-            }
-
-            try {
-              const getClient = await initializeOpencodeForDirectory(pending.directory)
-              await getClient().postSessionIdPermissionsPermissionId({
-                path: {
-                  id: pending.permission.sessionID,
-                  permissionID: pending.permission.id,
-                },
-                body: {
-                  response: scope,
-                },
-              })
-
-              pendingPermissions.delete(channel.id)
-              const msg =
-                scope === 'always'
-                  ? `✅ Permission **accepted** (auto-approve similar requests)`
-                  : `✅ Permission **accepted**`
-              await command.reply({ content: msg, flags: SILENT_MESSAGE_FLAGS })
-              discordLogger.log(
-                `Permission ${pending.permission.id} accepted with scope: ${scope}`,
-              )
-            } catch (error) {
-              interactionLogger.error('[ACCEPT] Error:', error)
-              await command.reply({
-                content: `Failed to accept permission: ${error instanceof Error ? error.message : 'Unknown error'}`,
-                ephemeral: true,
-                flags: SILENT_MESSAGE_FLAGS,
-              })
-            }
-          } else if (command.commandName === 'reject') {
-            const channel = command.channel
-
-            if (!channel) {
-              await command.reply({
-                content: 'This command can only be used in a channel',
-                ephemeral: true,
-                flags: SILENT_MESSAGE_FLAGS,
-              })
-              return
-            }
-
-            const isThread = [
-              ChannelType.PublicThread,
-              ChannelType.PrivateThread,
-              ChannelType.AnnouncementThread,
-            ].includes(channel.type)
-
-            if (!isThread) {
-              await command.reply({
-                content: 'This command can only be used in a thread with an active session',
-                ephemeral: true,
-                flags: SILENT_MESSAGE_FLAGS,
-              })
-              return
-            }
-
-            const pending = pendingPermissions.get(channel.id)
-            if (!pending) {
-              await command.reply({
-                content: 'No pending permission request in this thread',
-                ephemeral: true,
-                flags: SILENT_MESSAGE_FLAGS,
-              })
-              return
-            }
-
-            try {
-              const getClient = await initializeOpencodeForDirectory(pending.directory)
-              await getClient().postSessionIdPermissionsPermissionId({
-                path: {
-                  id: pending.permission.sessionID,
-                  permissionID: pending.permission.id,
-                },
-                body: {
-                  response: 'reject',
-                },
-              })
-
-              pendingPermissions.delete(channel.id)
-              await command.reply({ content: `❌ Permission **rejected**`, flags: SILENT_MESSAGE_FLAGS })
-              discordLogger.log(`Permission ${pending.permission.id} rejected`)
-            } catch (error) {
-              interactionLogger.error('[REJECT] Error:', error)
-              await command.reply({
-                content: `Failed to reject permission: ${error instanceof Error ? error.message : 'Unknown error'}`,
-                ephemeral: true,
-                flags: SILENT_MESSAGE_FLAGS,
-              })
-            }
-          } else if (command.commandName === 'abort') {
-            const channel = command.channel
-
-            if (!channel) {
-              await command.reply({
-                content: 'This command can only be used in a channel',
-                ephemeral: true,
-                flags: SILENT_MESSAGE_FLAGS,
-              })
-              return
-            }
-
-            const isThread = [
-              ChannelType.PublicThread,
-              ChannelType.PrivateThread,
-              ChannelType.AnnouncementThread,
-            ].includes(channel.type)
-
-            if (!isThread) {
-              await command.reply({
-                content: 'This command can only be used in a thread with an active session',
-                ephemeral: true,
-                flags: SILENT_MESSAGE_FLAGS,
-              })
-              return
-            }
-
-            const textChannel = await resolveTextChannel(channel as ThreadChannel)
-            const { projectDirectory: directory } = getKimakiMetadata(textChannel)
 
-            if (!directory) {
-              await command.reply({
-                content: 'Could not determine project directory for this channel',
-                ephemeral: true,
-                flags: SILENT_MESSAGE_FLAGS,
-              })
-              return
-            }
-
-            const row = getDatabase()
-              .prepare('SELECT session_id FROM thread_sessions WHERE thread_id = ?')
-              .get(channel.id) as { session_id: string } | undefined
-
-            if (!row?.session_id) {
-              await command.reply({
-                content: 'No active session in this thread',
-                ephemeral: true,
-                flags: SILENT_MESSAGE_FLAGS,
-              })
+            case 'model':
+              await handleModelCommand({ interaction, appId })
               return
-            }
-
-            const sessionId = row.session_id
-
-            try {
-              const existingController = abortControllers.get(sessionId)
-              if (existingController) {
-                existingController.abort(new Error('User requested abort'))
-                abortControllers.delete(sessionId)
-              }
-
-              const getClient = await initializeOpencodeForDirectory(directory)
-              await getClient().session.abort({
-                path: { id: sessionId },
-              })
-
-              await command.reply({ content: `🛑 Request **aborted**`, flags: SILENT_MESSAGE_FLAGS })
-              discordLogger.log(`Session ${sessionId} aborted by user`)
-            } catch (error) {
-              interactionLogger.error('[ABORT] Error:', error)
-              await command.reply({
-                content: `Failed to abort: ${error instanceof Error ? error.message : 'Unknown error'}`,
-                ephemeral: true,
-                flags: SILENT_MESSAGE_FLAGS,
-              })
-            }
-          } else if (command.commandName === 'share') {
-            const channel = command.channel
-
-            if (!channel) {
-              await command.reply({
-                content: 'This command can only be used in a channel',
-                ephemeral: true,
-                flags: SILENT_MESSAGE_FLAGS,
-              })
+
+            case 'agent':
+              await handleAgentCommand({ interaction, appId })
               return
-            }
-
-            const isThread = [
-              ChannelType.PublicThread,
-              ChannelType.PrivateThread,
-              ChannelType.AnnouncementThread,
-            ].includes(channel.type)
-
-            if (!isThread) {
-              await command.reply({
-                content: 'This command can only be used in a thread with an active session',
-                ephemeral: true,
-                flags: SILENT_MESSAGE_FLAGS,
-              })
+
+            case 'queue':
+              await handleQueueCommand({ command: interaction, appId })
               return
-            }
 
-            const textChannel = await resolveTextChannel(channel as ThreadChannel)
-            const { projectDirectory: directory } = getKimakiMetadata(textChannel)
+            case 'clear-queue':
+              await handleClearQueueCommand({ command: interaction, appId })
+              return
 
-            if (!directory) {
-              await command.reply({
-                content: 'Could not determine project directory for this channel',
-                ephemeral: true,
-                flags: SILENT_MESSAGE_FLAGS,
-              })
+            case 'undo':
+              await handleUndoCommand({ command: interaction, appId })
               return
-            }
-
-            const row = getDatabase()
-              .prepare('SELECT session_id FROM thread_sessions WHERE thread_id = ?')
-              .get(channel.id) as { session_id: string } | undefined
-
-            if (!row?.session_id) {
-              await command.reply({
-                content: 'No active session in this thread',
-                ephemeral: true,
-                flags: SILENT_MESSAGE_FLAGS,
-              })
+
+            case 'redo':
+              await handleRedoCommand({ command: interaction, appId })
               return
-            }
-
-            const sessionId = row.session_id
-
-            try {
-              const getClient = await initializeOpencodeForDirectory(directory)
-              const response = await getClient().session.share({
-                path: { id: sessionId },
-              })
-
-              if (!response.data?.share?.url) {
-                await command.reply({
-                  content: 'Failed to generate share URL',
-                  ephemeral: true,
-                  flags: SILENT_MESSAGE_FLAGS,
-                })
-                return
-              }
-
-              await command.reply({ content: `🔗 **Session shared:** ${response.data.share.url}`, flags: SILENT_MESSAGE_FLAGS })
-              discordLogger.log(`Session ${sessionId} shared: ${response.data.share.url}`)
-            } catch (error) {
-              interactionLogger.error('[SHARE] Error:', error)
-              await command.reply({
-                content: `Failed to share session: ${error instanceof Error ? error.message : 'Unknown error'}`,
-                ephemeral: true,
-                flags: SILENT_MESSAGE_FLAGS,
-              })
-            }
-          } else if (command.commandName === 'fork') {
-            await handleForkCommand(command)
-          } else if (command.commandName === 'model') {
-            await handleModelCommand({ interaction: command, appId })
           }
+
+          // Handle user-defined commands (ending with -cmd suffix)
+          if (interaction.commandName.endsWith('-cmd')) {
+            await handleUserCommand({ command: interaction, appId })
+            return
+          }
+          return
         }
 
         if (interaction.isStringSelectMenu()) {
-          if (interaction.customId.startsWith('fork_select:')) {
+          const customId = interaction.customId
+
+          if (customId.startsWith('fork_select:')) {
             await handleForkSelectMenu(interaction)
-          } else if (interaction.customId.startsWith('model_provider:')) {
+            return
+          }
+
+          if (customId.startsWith('model_provider:')) {
             await handleProviderSelectMenu(interaction)
-          } else if (interaction.customId.startsWith('model_select:')) {
+            return
+          }
+
+          if (customId.startsWith('model_select:')) {
             await handleModelSelectMenu(interaction)
+            return
+          }
+
+          if (customId.startsWith('agent_select:')) {
+            await handleAgentSelectMenu(interaction)
+            return
+          }
+
+          if (customId.startsWith('ask_question:')) {
+            await handleAskQuestionSelectMenu(interaction)
+            return
           }
+          return
         }
       } catch (error) {
         interactionLogger.error('[INTERACTION] Error handling interaction:', error)
-        // Try to respond to the interaction if possible
         try {
           if (interaction.isRepliable() && !interaction.replied && !interaction.deferred) {
             await interaction.reply({