@brianli/kimaki 0.4.72-brianli.1

package/src/commands/ask-question.ts

@@ -0,0 +1,330 @@
+// AskUserQuestion tool handler - Shows Discord dropdowns for AI questions.
+// When the AI uses the AskUserQuestion tool, this module renders dropdowns
+// for each question and collects user responses.
+
+import {
+  StringSelectMenuBuilder,
+  StringSelectMenuInteraction,
+  ActionRowBuilder,
+  type ThreadChannel,
+  MessageFlags,
+} from 'discord.js'
+import crypto from 'node:crypto'
+import { sendThreadMessage, NOTIFY_MESSAGE_FLAGS } from '../discord-utils.js'
+import { getOpencodeClient } from '../opencode.js'
+import { createLogger, LogPrefix } from '../logger.js'
+
+const logger = createLogger(LogPrefix.ASK_QUESTION)
+
+// Schema matching the question tool input
+export type AskUserQuestionInput = {
+  questions: Array<{
+    question: string
+    header: string // max 12 chars
+    options: Array<{
+      label: string
+      description: string
+    }>
+    multiple?: boolean // optional, defaults to false
+  }>
+}
+
+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 placeholder =
+      options.find((x) => x.label)?.label || 'Select an option'
+    const selectMenu = new StringSelectMenuBuilder()
+      .setCustomId(`ask_question:${contextHash}:${i}`)
+      .setPlaceholder(placeholder)
+      .addOptions(options)
+
+    // Enable multi-select if the question supports it
+    if (q.multiple) {
+      selectMenu.setMinValues(1)
+      selectMenu.setMaxValues(options.length)
+    }
+
+    const actionRow =
+      new ActionRowBuilder<StringSelectMenuBuilder>().addComponents(selectMenu)
+
+    await thread.send({
+      content: `**${(q.header || '').slice(0, 200)}**\n${q.question.slice(0, 1700)}`,
+      components: [actionRow],
+      flags: NOTIFY_MESSAGE_FLAGS,
+    })
+  }
+
+  logger.log(
+    `Showed ${input.questions.length} question dropdown(s) for session ${sessionId}`,
+  )
+}
+
+/**
+ * Handle dropdown selection for AskUserQuestion.
+ */
+export async function handleAskQuestionSelectMenu(
+  interaction: StringSelectMenuInteraction,
+): Promise<void> {
+  const customId = interaction.customId
+
+  if (!customId.startsWith('ask_question:')) {
+    return
+  }
+
+  const parts = customId.split(':')
+  const contextHash = parts[1]
+  const questionIndex = parseInt(parts[2]!, 10)
+
+  if (!contextHash) {
+    await interaction.reply({
+      content: 'Invalid selection.',
+      flags: MessageFlags.Ephemeral,
+    })
+    return
+  }
+
+  const context = pendingQuestionContexts.get(contextHash)
+
+  if (!context) {
+    await interaction.reply({
+      content: 'This question has expired. Please ask the AI again.',
+      flags: MessageFlags.Ephemeral,
+    })
+    return
+  }
+
+  await interaction.deferUpdate()
+
+  const selectedValues = interaction.values
+  const question = context.questions[questionIndex]
+
+  if (!question) {
+    logger.error(`Question index ${questionIndex} not found in context`)
+    return
+  }
+
+  // Check if "other" was selected
+  if (selectedValues.includes('other')) {
+    // User wants to provide custom answer
+    // For now, mark as "Other" - they can type in chat
+    context.answers[questionIndex] = ['Other (please type your answer in chat)']
+  } else {
+    // Map value indices back to option labels
+    context.answers[questionIndex] = selectedValues.map((v) => {
+      const optIdx = parseInt(v, 10)
+      return question.options[optIdx]?.label || `Option ${optIdx + 1}`
+    })
+  }
+
+  context.answeredCount++
+
+  // Update this question's message: show answer and remove dropdown
+  const answeredText = context.answers[questionIndex]!.join(', ')
+  await interaction.editReply({
+    content: `**${question.header}**\n${question.question}\n✓ _${answeredText}_`,
+    components: [], // Remove the dropdown
+  })
+
+  // Check if all questions are answered
+  if (context.answeredCount >= context.totalQuestions) {
+    // All questions answered - send result back to session
+    await submitQuestionAnswers(context)
+    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 {
+    const client = getOpencodeClient(context.directory)
+    if (!client) {
+      throw new Error('OpenCode server not found for directory')
+    }
+
+    // Build answers array: each element is an array of selected labels for that question
+    const answers = context.questions.map((_, i) => {
+      return context.answers[i] || []
+    })
+
+    await client.question.reply({
+      requestID: context.requestId,
+      directory: context.directory,
+      answers,
+    })
+
+    logger.log(
+      `Submitted answers for question ${context.requestId} in session ${context.sessionId}`,
+    )
+  } catch (error) {
+    logger.error('Failed to submit answers:', error)
+    await sendThreadMessage(
+      context.thread,
+      `✗ Failed to submit answers: ${error instanceof Error ? error.message : 'Unknown error'}`,
+    )
+  }
+}
+
+/**
+ * Check if a tool part is an AskUserQuestion tool.
+ * Returns the parsed input if valid, null otherwise.
+ */
+export function parseAskUserQuestionTool(part: {
+  type: string
+  tool?: string
+  state?: { input?: unknown }
+}): AskUserQuestionInput | null {
+  if (part.type !== 'tool') {
+    return null
+  }
+
+  // Check for the tool name (case-insensitive)
+  const toolName = part.tool?.toLowerCase()
+  if (toolName !== 'question') {
+    return null
+  }
+
+  const input = part.state?.input as AskUserQuestionInput | undefined
+
+  if (
+    !input?.questions ||
+    !Array.isArray(input.questions) ||
+    input.questions.length === 0
+  ) {
+    return null
+  }
+
+  // Validate structure
+  for (const q of input.questions) {
+    if (
+      typeof q.question !== 'string' ||
+      typeof q.header !== 'string' ||
+      !Array.isArray(q.options) ||
+      q.options.length < 2
+    ) {
+      return null
+    }
+  }
+
+  return input
+}
+
+/**
+ * Cancel a pending question for a thread (e.g., when user sends a new message).
+ * Sends the user's message as the answer to OpenCode so the model sees their actual response.
+ */
+export async function cancelPendingQuestion(
+  threadId: string,
+  userMessage?: string,
+): Promise<boolean> {
+  // Find pending question for this thread
+  let contextHash: string | undefined
+  let context: PendingQuestionContext | undefined
+  for (const [hash, ctx] of pendingQuestionContexts) {
+    if (ctx.thread.id === threadId) {
+      contextHash = hash
+      context = ctx
+      break
+    }
+  }
+
+  if (!contextHash || !context) {
+    return false
+  }
+
+  try {
+    const client = getOpencodeClient(context.directory)
+    if (!client) {
+      throw new Error('OpenCode server not found for directory')
+    }
+
+    // Use user's message as answer if provided, otherwise mark as "Other"
+    const customAnswer = userMessage || 'Other'
+    const answers = context.questions.map((_, i) => {
+      return context.answers[i] || [customAnswer]
+    })
+
+    await client.question.reply({
+      requestID: context.requestId,
+      directory: context.directory,
+      answers,
+    })
+
+    logger.log(`Answered question ${context.requestId} with user message`)
+  } catch (error) {
+    logger.error('Failed to answer question:', error)
+  }
+
+  // Clean up regardless of whether the API call succeeded
+  pendingQuestionContexts.delete(contextHash)
+  return true
+}

package/src/commands/compact.ts

@@ -0,0 +1,157 @@
+// /compact command - Trigger context compaction (summarization) for the current session.
+
+import {
+  ChannelType,
+  MessageFlags,
+  type TextChannel,
+  type ThreadChannel,
+} from 'discord.js'
+import type { CommandContext } from './types.js'
+import { getThreadSession } from '../database.js'
+import {
+  initializeOpencodeForDirectory,
+  getOpencodeClient,
+} from '../opencode.js'
+import {
+  resolveWorkingDirectory,
+  SILENT_MESSAGE_FLAGS,
+} from '../discord-utils.js'
+import { createLogger, LogPrefix } from '../logger.js'
+
+const logger = createLogger(LogPrefix.COMPACT)
+
+export async function handleCompactCommand({
+  command,
+}: CommandContext): Promise<void> {
+  const channel = command.channel
+
+  if (!channel) {
+    await command.reply({
+      content: 'This command can only be used in a channel',
+      flags: MessageFlags.Ephemeral | 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',
+      flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  const resolved = await resolveWorkingDirectory({
+    channel: channel as TextChannel | ThreadChannel,
+  })
+
+  if (!resolved) {
+    await command.reply({
+      content: 'Could not determine project directory for this channel',
+      flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  const { projectDirectory, workingDirectory } = resolved
+
+  const sessionId = await getThreadSession(channel.id)
+
+  if (!sessionId) {
+    await command.reply({
+      content: 'No active session in this thread',
+      flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  // Ensure server is running for the base project directory
+  const getClient = await initializeOpencodeForDirectory(projectDirectory)
+  if (getClient instanceof Error) {
+    await command.reply({
+      content: `Failed to compact: ${getClient.message}`,
+      flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  const client = getOpencodeClient(projectDirectory)
+  if (!client) {
+    await command.reply({
+      content: 'Failed to get OpenCode client',
+      flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  // Defer reply since compaction may take a moment
+  await command.deferReply({ flags: SILENT_MESSAGE_FLAGS })
+
+  try {
+    // Get session messages to find the model from the last user message
+    const messagesResult = await client.session.messages({
+      sessionID: sessionId,
+      directory: workingDirectory,
+    })
+
+    if (messagesResult.error || !messagesResult.data) {
+      logger.error('[COMPACT] Failed to get messages:', messagesResult.error)
+      await command.editReply({
+        content: 'Failed to compact: Could not retrieve session messages',
+      })
+      return
+    }
+
+    // Find the last user message to get the model
+    const lastUserMessage = [...messagesResult.data]
+      .reverse()
+      .find((msg) => msg.info.role === 'user')
+
+    if (!lastUserMessage || lastUserMessage.info.role !== 'user') {
+      await command.editReply({
+        content: 'Failed to compact: No user message found in session',
+      })
+      return
+    }
+
+    const { providerID, modelID } = lastUserMessage.info.model
+
+    const result = await client.session.summarize({
+      sessionID: sessionId,
+      directory: workingDirectory,
+      providerID,
+      modelID,
+      auto: false,
+    })
+
+    if (result.error) {
+      logger.error('[COMPACT] Error:', result.error)
+      const errorMessage =
+        'data' in result.error && result.error.data
+          ? (result.error.data as { message?: string }).message ||
+            'Unknown error'
+          : 'Unknown error'
+      await command.editReply({
+        content: `Failed to compact: ${errorMessage}`,
+      })
+      return
+    }
+
+    await command.editReply({
+      content: `📦 Session **compacted** successfully`,
+    })
+    logger.log(`Session ${sessionId} compacted by user`)
+  } catch (error) {
+    logger.error('[COMPACT] Error:', error)
+    await command.editReply({
+      content: `Failed to compact: ${error instanceof Error ? error.message : 'Unknown error'}`,
+    })
+  }
+}

package/src/commands/context-usage.ts

@@ -0,0 +1,199 @@
+// /context-usage command - Show token usage and context window percentage for the current session.
+
+import {
+  ChannelType,
+  MessageFlags,
+  type TextChannel,
+  type ThreadChannel,
+} from 'discord.js'
+import type { CommandContext } from './types.js'
+import { getThreadSession } from '../database.js'
+import { initializeOpencodeForDirectory } from '../opencode.js'
+import {
+  resolveWorkingDirectory,
+  SILENT_MESSAGE_FLAGS,
+} from '../discord-utils.js'
+import { createLogger, LogPrefix } from '../logger.js'
+import * as errore from 'errore'
+
+const logger = createLogger(LogPrefix.SESSION)
+
+function getTokenTotal({
+  input,
+  output,
+  reasoning,
+  cache,
+}: {
+  input: number
+  output: number
+  reasoning: number
+  cache: { read: number; write: number }
+}): number {
+  return input + output + reasoning + cache.read + cache.write
+}
+
+export async function handleContextUsageCommand({
+  command,
+}: CommandContext): Promise<void> {
+  const channel = command.channel
+
+  if (!channel) {
+    await command.reply({
+      content: 'This command can only be used in a channel',
+      flags: MessageFlags.Ephemeral | 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',
+      flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  const resolved = await resolveWorkingDirectory({
+    channel: channel as TextChannel | ThreadChannel,
+  })
+
+  if (!resolved) {
+    await command.reply({
+      content: 'Could not determine project directory for this channel',
+      flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  const { projectDirectory, workingDirectory } = resolved
+
+  const sessionId = await getThreadSession(channel.id)
+
+  if (!sessionId) {
+    await command.reply({
+      content: 'No active session in this thread',
+      flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  const getClient = await initializeOpencodeForDirectory(projectDirectory)
+  if (getClient instanceof Error) {
+    await command.reply({
+      content: `Failed to get context usage: ${getClient.message}`,
+      flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  await command.deferReply({ flags: SILENT_MESSAGE_FLAGS })
+
+  try {
+    const messagesResponse = await getClient().session.messages({
+      sessionID: sessionId,
+      directory: workingDirectory,
+    })
+
+    const messages = messagesResponse.data || []
+    const assistantMessages = messages.filter(
+      (m) => m.info.role === 'assistant',
+    )
+
+    if (assistantMessages.length === 0) {
+      await command.editReply({
+        content: 'No assistant messages in this session yet',
+      })
+      return
+    }
+
+    const lastAssistant = [...assistantMessages].reverse().find((m) => {
+      if (m.info.role !== 'assistant') {
+        return false
+      }
+      if (!('tokens' in m.info) || !m.info.tokens) {
+        return false
+      }
+      return getTokenTotal(m.info.tokens) > 0
+    })
+
+    if (!lastAssistant || lastAssistant.info.role !== 'assistant') {
+      await command.editReply({
+        content: 'Token usage not available for this session yet',
+      })
+      return
+    }
+
+    const { tokens, modelID, providerID } = lastAssistant.info
+    const totalTokens = getTokenTotal(tokens)
+
+    // Sum cost across all assistant messages for accurate session total
+    // (AssistantMessage.cost is per-message, not cumulative)
+    const totalCost = assistantMessages.reduce((sum, m) => {
+      if (m.info.role === 'assistant' && 'cost' in m.info) {
+        return sum + (m.info.cost || 0)
+      }
+      return sum
+    }, 0)
+
+    // Fetch model context limit from provider API
+    let contextLimit: number | undefined
+    const providersResult = await errore.tryAsync(() => {
+      return getClient().provider.list({ directory: workingDirectory })
+    })
+    if (providersResult instanceof Error) {
+      logger.error(
+        '[CONTEXT-USAGE] Failed to fetch provider info:',
+        providersResult,
+      )
+    } else {
+      const provider = providersResult.data?.all?.find(
+        (p) => p.id === providerID,
+      )
+      const model = provider?.models?.[modelID]
+      if (model?.limit?.context) {
+        contextLimit = model.limit.context
+      }
+    }
+
+    const formattedTokens = totalTokens.toLocaleString('en-US')
+    const formattedCost = totalCost > 0 ? `$${totalCost.toFixed(4)}` : '$0.00'
+
+    const lines: string[] = []
+
+    if (contextLimit) {
+      const percentage = Math.round((totalTokens / contextLimit) * 100)
+      const formattedLimit = contextLimit.toLocaleString('en-US')
+      lines.push(
+        `**Context usage:** ${percentage}%, ${formattedTokens} / ${formattedLimit} tokens`,
+      )
+    } else {
+      lines.push(
+        `**Context usage:** ${formattedTokens} tokens (context limit unavailable)`,
+      )
+    }
+
+    if (modelID) {
+      lines.push(`**Model:** ${modelID}`)
+    }
+    if (totalCost > 0) {
+      lines.push(`**Session cost:** ${formattedCost}`)
+    }
+
+    await command.editReply({ content: lines.join('\n') })
+    logger.log(
+      `Context usage shown for session ${sessionId}: ${totalTokens} tokens`,
+    )
+  } catch (error) {
+    logger.error('[CONTEXT-USAGE] Error:', error)
+    await command.editReply({
+      content: `Failed to get context usage: ${error instanceof Error ? error.message : 'Unknown error'}`,
+    })
+  }
+}