kimaki 0.4.25 → 0.4.27

package/src/commands/ask-question.ts

@@ -0,0 +1,277 @@
+// 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,
+} from 'discord.js'
+import crypto from 'node:crypto'
+import { sendThreadMessage, NOTIFY_MESSAGE_FLAGS } from '../discord-utils.js'
+import { getOpencodeServerPort } from '../opencode.js'
+import { createLogger } from '../logger.js'
+
+const logger = createLogger('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
+  }>
+}
+
+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
+export const pendingQuestionContexts = new Map<string, PendingQuestionContext>()
+
+/**
+ * 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,
+}: {
+  thread: ThreadChannel
+  sessionId: string
+  directory: string
+  requestId: string // OpenCode question request ID
+  input: AskUserQuestionInput
+}): Promise<void> {
+  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)
+
+  // 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 selectMenu = new StringSelectMenuBuilder()
+      .setCustomId(`ask_question:${contextHash}:${i}`)
+      .setPlaceholder(`Select an option`)
+      .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}**\n${q.question}`,
+      components: [actionRow],
+      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.',
+      ephemeral: true,
+    })
+    return
+  }
+
+  const context = pendingQuestionContexts.get(contextHash)
+
+  if (!context) {
+    await interaction.reply({
+      content: 'This question has expired. Please ask the AI again.',
+      ephemeral: true,
+    })
+    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)
+    pendingQuestionContexts.delete(contextHash)
+  }
+}
+
+/**
+ * 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 {
+    // Build answers array: each element is an array of selected labels for that question
+    const answersPayload = context.questions.map((_, i) => {
+      return context.answers[i] || []
+    })
+
+    // Reply to the question using direct HTTP call to OpenCode API
+    // (v1 SDK doesn't have question.reply, so we call it directly)
+    const port = getOpencodeServerPort(context.directory)
+    if (!port) {
+      throw new Error('OpenCode server not found for directory')
+    }
+
+    const response = await fetch(
+      `http://127.0.0.1:${port}/question/${context.requestId}/reply`,
+      {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ answers: answersPayload }),
+      }
+    )
+
+    if (!response.ok) {
+      const text = await response.text()
+      throw new Error(`Failed to reply to question: ${response.status} ${text}`)
+    }
+
+    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
+}

package/src/commands/fork.ts

@@ -9,7 +9,6 @@ import {
   ThreadAutoArchiveDuration,
   type ThreadChannel,
 } from 'discord.js'
-import type { TextPart } from '@opencode-ai/sdk'
 import { getDatabase } from '../database.js'
 import { initializeOpencodeForDirectory } from '../opencode.js'
 import { resolveTextChannel, getKimakiMetadata, sendThreadMessage } from '../discord-utils.js'
@@ -100,7 +99,7 @@ export async function handleForkCommand(interaction: ChatInputCommandInteraction
     const recentMessages = userMessages.slice(-25)
 
     const options = recentMessages.map((m, index) => {
-      const textPart = m.parts.find((p) => p.type === 'text') as TextPart | undefined
+      const textPart = m.parts.find((p) => p.type === 'text') as { type: 'text'; text: string } | undefined
       const preview = textPart?.text?.slice(0, 80) || '(no text)'
       const label = `${index + 1}. ${preview}${preview.length >= 80 ? '...' : ''}`
 

package/src/commands/model.ts

@@ -13,6 +13,7 @@ import crypto from 'node:crypto'
 import { getDatabase, setChannelModel, setSessionModel, runModelMigrations } from '../database.js'
 import { initializeOpencodeForDirectory } from '../opencode.js'
 import { resolveTextChannel, getKimakiMetadata } from '../discord-utils.js'
+import { abortAndRetrySession } from '../session-handler.js'
 import { createLogger } from '../logger.js'
 
 const modelLogger = createLogger('MODEL')
@@ -25,6 +26,7 @@ const pendingModelContexts = new Map<string, {
   isThread: boolean
   providerId?: string
   providerName?: string
+  thread?: ThreadChannel
 }>()
 
 export type ProviderInfo = {
@@ -156,6 +158,7 @@ export async function handleModelCommand({
       channelId: targetChannelId,
       sessionId: sessionId,
       isThread: isThread,
+      thread: isThread ? (channel as ThreadChannel) : undefined,
     }
     const contextHash = crypto.randomBytes(8).toString('hex')
     pendingModelContexts.set(contextHash, context)
@@ -355,10 +358,27 @@ export async function handleModelSelectMenu(
       setSessionModel(context.sessionId, fullModelId)
       modelLogger.log(`Set model ${fullModelId} for session ${context.sessionId}`)
 
-      await interaction.editReply({
-        content: `Model preference set for this session:\n**${context.providerName}** / **${selectedModelId}**\n\n\`${fullModelId}\``,
-        components: [],
-      })
+      // Check if there's a running request and abort+retry with new model
+      let retried = false
+      if (context.thread) {
+        retried = await abortAndRetrySession({
+          sessionId: context.sessionId,
+          thread: context.thread,
+          projectDirectory: context.dir,
+        })
+      }
+
+      if (retried) {
+        await interaction.editReply({
+          content: `Model changed for this session:\n**${context.providerName}** / **${selectedModelId}**\n\n\`${fullModelId}\`\n\n_Retrying current request with new model..._`,
+          components: [],
+        })
+      } else {
+        await interaction.editReply({
+          content: `Model preference set for this session:\n**${context.providerName}** / **${selectedModelId}**\n\n\`${fullModelId}\``,
+          components: [],
+        })
+      }
     } else {
       // Store for channel
       setChannelModel(context.channelId, fullModelId)

package/src/commands/permissions.ts

@@ -1,146 +1,171 @@
-// Permission commands - /accept, /accept-always, /reject
-
-import { ChannelType } from 'discord.js'
-import type { CommandContext } from './types.js'
+// Permission dropdown handler - Shows dropdown for permission requests.
+// When OpenCode asks for permission, this module renders a dropdown
+// with Accept, Accept Always, and Deny options.
+
+import {
+  StringSelectMenuBuilder,
+  StringSelectMenuInteraction,
+  ActionRowBuilder,
+  type ThreadChannel,
+} from 'discord.js'
+import crypto from 'node:crypto'
+import type { PermissionRequest } from '@opencode-ai/sdk/v2'
 import { initializeOpencodeForDirectory } from '../opencode.js'
-import { pendingPermissions } from '../session-handler.js'
-import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js'
+import { NOTIFY_MESSAGE_FLAGS } from '../discord-utils.js'
 import { createLogger } from '../logger.js'
 
 const logger = createLogger('PERMISSIONS')
 
-export async function handleAcceptCommand({
-  command,
-}: CommandContext): Promise<void> {
-  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,
-    })
-    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
-  }
+type PendingPermissionContext = {
+  permission: PermissionRequest
+  directory: string
+  thread: ThreadChannel
+  contextHash: string
+}
 
-  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
+// Store pending permission contexts by hash
+export const pendingPermissionContexts = new Map<string, PendingPermissionContext>()
+
+/**
+ * Show permission dropdown for a permission request.
+ * Returns the message ID and context hash for tracking.
+ */
+export async function showPermissionDropdown({
+  thread,
+  permission,
+  directory,
+}: {
+  thread: ThreadChannel
+  permission: PermissionRequest
+  directory: string
+}): Promise<{ messageId: string; contextHash: string }> {
+  const contextHash = crypto.randomBytes(8).toString('hex')
+
+  const context: PendingPermissionContext = {
+    permission,
+    directory,
+    thread,
+    contextHash,
   }
 
-  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 })
-    logger.log(`Permission ${pending.permission.id} accepted with scope: ${scope}`)
-  } catch (error) {
-    logger.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,
-    })
-  }
+  pendingPermissionContexts.set(contextHash, context)
+
+  const patternStr = permission.patterns.join(', ')
+
+  // Build dropdown options
+  const options = [
+    {
+      label: 'Accept',
+      value: 'once',
+      description: 'Allow this request only',
+    },
+    {
+      label: 'Accept Always',
+      value: 'always',
+      description: 'Auto-approve similar requests',
+    },
+    {
+      label: 'Deny',
+      value: 'reject',
+      description: 'Reject this permission request',
+    },
+  ]
+
+  const selectMenu = new StringSelectMenuBuilder()
+    .setCustomId(`permission:${contextHash}`)
+    .setPlaceholder('Choose an action')
+    .addOptions(options)
+
+  const actionRow = new ActionRowBuilder<StringSelectMenuBuilder>().addComponents(selectMenu)
+
+  const permissionMessage = await thread.send({
+    content:
+      `⚠️ **Permission Required**\n\n` +
+      `**Type:** \`${permission.permission}\`\n` +
+      (patternStr ? `**Pattern:** \`${patternStr}\`` : ''),
+    components: [actionRow],
+    flags: NOTIFY_MESSAGE_FLAGS,
+  })
+
+  logger.log(`Showed permission dropdown for ${permission.id}`)
+
+  return { messageId: permissionMessage.id, contextHash }
 }
 
-export async function handleRejectCommand({
-  command,
-}: CommandContext): Promise<void> {
-  const channel = command.channel
+/**
+ * Handle dropdown selection for permission.
+ */
+export async function handlePermissionSelectMenu(
+  interaction: StringSelectMenuInteraction
+): Promise<void> {
+  const customId = interaction.customId
 
-  if (!channel) {
-    await command.reply({
-      content: 'This command can only be used in a channel',
-      ephemeral: true,
-      flags: SILENT_MESSAGE_FLAGS,
-    })
+  if (!customId.startsWith('permission:')) {
     return
   }
 
-  const isThread = [
-    ChannelType.PublicThread,
-    ChannelType.PrivateThread,
-    ChannelType.AnnouncementThread,
-  ].includes(channel.type)
+  const contextHash = customId.replace('permission:', '')
+  const context = pendingPermissionContexts.get(contextHash)
 
-  if (!isThread) {
-    await command.reply({
-      content: 'This command can only be used in a thread with an active session',
+  if (!context) {
+    await interaction.reply({
+      content: 'This permission request has expired or was already handled.',
       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
-  }
+  await interaction.deferUpdate()
+
+  const response = interaction.values[0] as 'once' | 'always' | 'reject'
 
   try {
-    const getClient = await initializeOpencodeForDirectory(pending.directory)
+    const getClient = await initializeOpencodeForDirectory(context.directory)
     await getClient().postSessionIdPermissionsPermissionId({
       path: {
-        id: pending.permission.sessionID,
-        permissionID: pending.permission.id,
-      },
-      body: {
-        response: 'reject',
+        id: context.permission.sessionID,
+        permissionID: context.permission.id,
       },
+      body: { response },
     })
 
-    pendingPermissions.delete(channel.id)
-    await command.reply({
-      content: `❌ Permission **rejected**`,
-      flags: SILENT_MESSAGE_FLAGS,
+    pendingPermissionContexts.delete(contextHash)
+
+    // Update message: show result and remove dropdown
+    const resultText = (() => {
+      switch (response) {
+        case 'once':
+          return '✅ Permission **accepted**'
+        case 'always':
+          return '✅ Permission **accepted** (auto-approve similar requests)'
+        case 'reject':
+          return '❌ Permission **rejected**'
+      }
+    })()
+
+    const patternStr = context.permission.patterns.join(', ')
+    await interaction.editReply({
+      content:
+        `⚠️ **Permission Required**\n\n` +
+        `**Type:** \`${context.permission.permission}\`\n` +
+        (patternStr ? `**Pattern:** \`${patternStr}\`\n\n` : '\n') +
+        resultText,
+      components: [], // Remove the dropdown
     })
-    logger.log(`Permission ${pending.permission.id} rejected`)
+
+    logger.log(`Permission ${context.permission.id} ${response}`)
   } catch (error) {
-    logger.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,
+    logger.error('Error handling permission:', error)
+    await interaction.editReply({
+      content: `Failed to process permission: ${error instanceof Error ? error.message : 'Unknown error'}`,
+      components: [],
     })
   }
 }
+
+/**
+ * Clean up a pending permission context (e.g., on auto-reject).
+ */
+export function cleanupPermissionContext(contextHash: string): void {
+  pendingPermissionContexts.delete(contextHash)
+}

package/src/commands/session.ts

@@ -8,7 +8,7 @@ import { getDatabase } from '../database.js'
 import { initializeOpencodeForDirectory } from '../opencode.js'
 import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js'
 import { extractTagsArrays } from '../xml.js'
-import { handleOpencodeSession, parseSlashCommand } from '../session-handler.js'
+import { handleOpencodeSession } from '../session-handler.js'
 import { createLogger } from '../logger.js'
 
 const logger = createLogger('SESSION')
@@ -86,12 +86,10 @@ export async function handleSessionCommand({
 
     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) {