kimaki 0.4.25 → 0.4.26

package/src/commands/ask-question.ts

@@ -0,0 +1,276 @@
+// 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 } 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],
+    })
+  }
+
+  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/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) {

package/src/commands/user-command.ts

@@ -0,0 +1,178 @@
+// User-defined OpenCode command handler.
+// Handles slash commands that map to user-configured commands in opencode.json.
+
+import type { CommandContext, CommandHandler } from './types.js'
+import { ChannelType, type TextChannel, type ThreadChannel } from 'discord.js'
+import { extractTagsArrays } from '../xml.js'
+import { handleOpencodeSession } from '../session-handler.js'
+import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js'
+import { createLogger } from '../logger.js'
+import { getDatabase } from '../database.js'
+import fs from 'node:fs'
+
+const userCommandLogger = createLogger('USER_CMD')
+
+export const handleUserCommand: CommandHandler = async ({
+  command,
+  appId,
+}: CommandContext) => {
+  const discordCommandName = command.commandName
+  // Strip the -cmd suffix to get the actual OpenCode command name
+  const commandName = discordCommandName.replace(/-cmd$/, '')
+  const args = command.options.getString('arguments') || ''
+
+  userCommandLogger.log(
+    `Executing /${commandName} (from /${discordCommandName}) with args: ${args}`,
+  )
+
+  const channel = command.channel
+
+  userCommandLogger.log(
+    `Channel info: type=${channel?.type}, id=${channel?.id}, isNull=${channel === null}`,
+  )
+
+  const isThread = channel && [
+    ChannelType.PublicThread,
+    ChannelType.PrivateThread,
+    ChannelType.AnnouncementThread,
+  ].includes(channel.type)
+
+  const isTextChannel = channel?.type === ChannelType.GuildText
+
+  if (!channel || (!isTextChannel && !isThread)) {
+    await command.reply({
+      content: 'This command can only be used in text channels or threads',
+      ephemeral: true,
+    })
+    return
+  }
+
+  let projectDirectory: string | undefined
+  let channelAppId: string | undefined
+  let textChannel: TextChannel | null = null
+  let thread: ThreadChannel | null = null
+
+  if (isThread) {
+    // Running in an existing thread - get project directory from parent channel
+    thread = channel as ThreadChannel
+    textChannel = thread.parent as TextChannel | null
+
+    // Verify this thread has an existing session
+    const row = getDatabase()
+      .prepare('SELECT session_id FROM thread_sessions WHERE thread_id = ?')
+      .get(thread.id) as { session_id: string } | undefined
+
+    if (!row) {
+      await command.reply({
+        content: 'This thread does not have an active session. Use this command in a project channel to create a new thread.',
+        ephemeral: true,
+      })
+      return
+    }
+
+    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()
+    }
+  } else {
+    // Running in a text channel - will create a new thread
+    textChannel = channel as TextChannel
+
+    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.reply({
+      content: 'This channel is not configured for this bot',
+      ephemeral: true,
+    })
+    return
+  }
+
+  if (!projectDirectory) {
+    await command.reply({
+      content: 'This channel is not configured with a project directory',
+      ephemeral: true,
+    })
+    return
+  }
+
+  if (!fs.existsSync(projectDirectory)) {
+    await command.reply({
+      content: `Directory does not exist: ${projectDirectory}`,
+      ephemeral: true,
+    })
+    return
+  }
+
+  await command.deferReply({ ephemeral: false })
+
+  try {
+    // Use the dedicated session.command API instead of formatting as text prompt
+    const commandPayload = { name: commandName, arguments: args }
+
+    if (isThread && thread) {
+      // Running in existing thread - just send the command
+      await command.editReply(`Running /${commandName}...`)
+
+      await handleOpencodeSession({
+        prompt: '', // Not used when command is set
+        thread,
+        projectDirectory,
+        channelId: textChannel?.id,
+        command: commandPayload,
+      })
+    } else if (textChannel) {
+      // Running in text channel - create a new thread
+      const starterMessage = await textChannel.send({
+        content: `**/${commandName}**${args ? ` ${args.slice(0, 200)}${args.length > 200 ? '…' : ''}` : ''}`,
+        flags: SILENT_MESSAGE_FLAGS,
+      })
+
+      const threadName = `/${commandName} ${args.slice(0, 80)}${args.length > 80 ? '…' : ''}`
+      const newThread = await starterMessage.startThread({
+        name: threadName.slice(0, 100),
+        autoArchiveDuration: 1440,
+        reason: `OpenCode command: ${commandName}`,
+      })
+
+      await command.editReply(`Started /${commandName} in ${newThread.toString()}`)
+
+      await handleOpencodeSession({
+        prompt: '', // Not used when command is set
+        thread: newThread,
+        projectDirectory,
+        channelId: textChannel.id,
+        command: commandPayload,
+      })
+    }
+  } catch (error) {
+    userCommandLogger.error(`Error executing /${commandName}:`, error)
+
+    const errorMessage = error instanceof Error ? error.message : String(error)
+
+    if (command.deferred) {
+      await command.editReply({
+        content: `Failed to execute /${commandName}: ${errorMessage}`,
+      })
+    } else {
+      await command.reply({
+        content: `Failed to execute /${commandName}: ${errorMessage}`,
+        ephemeral: true,
+      })
+    }
+  }
+}

package/src/database.ts

@@ -100,6 +100,23 @@ export function runModelMigrations(database?: Database.Database): void {
     )
   `)
 
+  targetDb.exec(`
+    CREATE TABLE IF NOT EXISTS channel_agents (
+      channel_id TEXT PRIMARY KEY,
+      agent_name TEXT NOT NULL,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+      updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    )
+  `)
+
+  targetDb.exec(`
+    CREATE TABLE IF NOT EXISTS session_agents (
+      session_id TEXT PRIMARY KEY,
+      agent_name TEXT NOT NULL,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    )
+  `)
+
   dbLogger.log('Model preferences migrations complete')
 }
 
@@ -151,6 +168,50 @@ export function setSessionModel(sessionId: string, modelId: string): void {
   ).run(sessionId, modelId)
 }
 
+/**
+ * Get the agent preference for a channel.
+ */
+export function getChannelAgent(channelId: string): string | undefined {
+  const db = getDatabase()
+  const row = db
+    .prepare('SELECT agent_name FROM channel_agents WHERE channel_id = ?')
+    .get(channelId) as { agent_name: string } | undefined
+  return row?.agent_name
+}
+
+/**
+ * Set the agent preference for a channel.
+ */
+export function setChannelAgent(channelId: string, agentName: string): void {
+  const db = getDatabase()
+  db.prepare(
+    `INSERT INTO channel_agents (channel_id, agent_name, updated_at) 
+     VALUES (?, ?, CURRENT_TIMESTAMP)
+     ON CONFLICT(channel_id) DO UPDATE SET agent_name = ?, updated_at = CURRENT_TIMESTAMP`
+  ).run(channelId, agentName, agentName)
+}
+
+/**
+ * Get the agent preference for a session.
+ */
+export function getSessionAgent(sessionId: string): string | undefined {
+  const db = getDatabase()
+  const row = db
+    .prepare('SELECT agent_name FROM session_agents WHERE session_id = ?')
+    .get(sessionId) as { agent_name: string } | undefined
+  return row?.agent_name
+}
+
+/**
+ * Set the agent preference for a session.
+ */
+export function setSessionAgent(sessionId: string, agentName: string): void {
+  const db = getDatabase()
+  db.prepare(
+    `INSERT OR REPLACE INTO session_agents (session_id, agent_name) VALUES (?, ?)`
+  ).run(sessionId, agentName)
+}
+
 export function closeDatabase(): void {
   if (db) {
     db.close()