shuvmaki 0.4.26

package/src/commands/abort.ts

@@ -0,0 +1,94 @@
+// /abort command - Abort the current OpenCode request in this thread.
+
+import { ChannelType, type ThreadChannel } from 'discord.js'
+import type { CommandContext } from './types.js'
+import { getDatabase } from '../database.js'
+import { initializeOpencodeForDirectory } from '../opencode.js'
+import { resolveTextChannel, getKimakiMetadata, SILENT_MESSAGE_FLAGS } from '../discord-utils.js'
+import { abortControllers } from '../session-handler.js'
+import { createLogger } from '../logger.js'
+
+const logger = createLogger('ABORT')
+
+export async function handleAbortCommand({
+  command,
+}: CommandContext): Promise<void> {
+  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,
+    })
+    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,
+    })
+    logger.log(`Session ${sessionId} aborted by user`)
+  } catch (error) {
+    logger.error('[ABORT] Error:', error)
+    await command.reply({
+      content: `Failed to abort: ${error instanceof Error ? error.message : 'Unknown error'}`,
+      ephemeral: true,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+  }
+}

package/src/commands/add-project.ts

@@ -0,0 +1,139 @@
+// /add-project command - Create Discord channels for an existing OpenCode project.
+
+import fs from 'node:fs'
+import path from 'node:path'
+import type { CommandContext, AutocompleteContext } from './types.js'
+import { getDatabase } from '../database.js'
+import { initializeOpencodeForDirectory } from '../opencode.js'
+import { createProjectChannels } from '../channel-management.js'
+import { createLogger } from '../logger.js'
+
+const logger = createLogger('ADD-PROJECT')
+
+export async function handleAddProjectCommand({
+  command,
+  appId,
+}: CommandContext): Promise<void> {
+  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')
+    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,
+        botName: command.client.user?.username,
+      })
+
+    await command.editReply(
+      `✅ Created channels for project:\n📝 Text: <#${textChannelId}>\n🔊 Voice: <#${voiceChannelId}>\n📁 Directory: \`${directory}\``,
+    )
+
+    logger.log(`Created channels for project ${channelName} at ${directory}`)
+  } catch (error) {
+    logger.error('[ADD-PROJECT] Error:', error)
+    await command.editReply(
+      `Failed to create channels: ${error instanceof Error ? error.message : 'Unknown error'}`,
+    )
+  }
+}
+
+export async function handleAddProjectAutocomplete({
+  interaction,
+  appId,
+}: AutocompleteContext): Promise<void> {
+  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) {
+    logger.error('[AUTOCOMPLETE] Error fetching projects:', error)
+    await interaction.respond([])
+  }
+}

package/src/commands/agent.ts

@@ -0,0 +1,201 @@
+// /agent command - Set the preferred agent for this channel or session.
+
+import {
+  ChatInputCommandInteraction,
+  StringSelectMenuInteraction,
+  StringSelectMenuBuilder,
+  ActionRowBuilder,
+  ChannelType,
+  type ThreadChannel,
+  type TextChannel,
+} from 'discord.js'
+import crypto from 'node:crypto'
+import { getDatabase, setChannelAgent, setSessionAgent, runModelMigrations } from '../database.js'
+import { initializeOpencodeForDirectory } from '../opencode.js'
+import { resolveTextChannel, getKimakiMetadata } from '../discord-utils.js'
+import { createLogger } from '../logger.js'
+
+const agentLogger = createLogger('AGENT')
+
+const pendingAgentContexts = new Map<string, {
+  dir: string
+  channelId: string
+  sessionId?: string
+  isThread: boolean
+}>()
+
+export async function handleAgentCommand({
+  interaction,
+  appId,
+}: {
+  interaction: ChatInputCommandInteraction
+  appId: string
+}): Promise<void> {
+  await interaction.deferReply({ ephemeral: true })
+
+  runModelMigrations()
+
+  const channel = interaction.channel
+
+  if (!channel) {
+    await interaction.editReply({ content: 'This command can only be used in a channel' })
+    return
+  }
+
+  const isThread = [
+    ChannelType.PublicThread,
+    ChannelType.PrivateThread,
+    ChannelType.AnnouncementThread,
+  ].includes(channel.type)
+
+  let projectDirectory: string | undefined
+  let channelAppId: string | undefined
+  let targetChannelId: string
+  let sessionId: string | undefined
+
+  if (isThread) {
+    const thread = channel as ThreadChannel
+    const textChannel = await resolveTextChannel(thread)
+    const metadata = getKimakiMetadata(textChannel)
+    projectDirectory = metadata.projectDirectory
+    channelAppId = metadata.channelAppId
+    targetChannelId = textChannel?.id || channel.id
+
+    const row = getDatabase()
+      .prepare('SELECT session_id FROM thread_sessions WHERE thread_id = ?')
+      .get(thread.id) as { session_id: string } | undefined
+    sessionId = row?.session_id
+  } else if (channel.type === ChannelType.GuildText) {
+    const textChannel = channel as TextChannel
+    const metadata = getKimakiMetadata(textChannel)
+    projectDirectory = metadata.projectDirectory
+    channelAppId = metadata.channelAppId
+    targetChannelId = channel.id
+  } else {
+    await interaction.editReply({ content: 'This command can only be used in text channels or threads' })
+    return
+  }
+
+  if (channelAppId && channelAppId !== appId) {
+    await interaction.editReply({ content: 'This channel is not configured for this bot' })
+    return
+  }
+
+  if (!projectDirectory) {
+    await interaction.editReply({ content: 'This channel is not configured with a project directory' })
+    return
+  }
+
+  try {
+    const getClient = await initializeOpencodeForDirectory(projectDirectory)
+
+    const agentsResponse = await getClient().app.agents({
+      query: { directory: projectDirectory },
+    })
+
+    if (!agentsResponse.data || agentsResponse.data.length === 0) {
+      await interaction.editReply({ content: 'No agents available' })
+      return
+    }
+
+    const agents = agentsResponse.data
+      .filter((a) => a.mode === 'primary' || a.mode === 'all')
+      .slice(0, 25)
+
+    if (agents.length === 0) {
+      await interaction.editReply({ content: 'No primary agents available' })
+      return
+    }
+
+    const contextHash = crypto.randomBytes(8).toString('hex')
+    pendingAgentContexts.set(contextHash, {
+      dir: projectDirectory,
+      channelId: targetChannelId,
+      sessionId,
+      isThread,
+    })
+
+    const options = agents.map((agent) => ({
+      label: agent.name.slice(0, 100),
+      value: agent.name,
+      description: (agent.description || `${agent.mode} agent`).slice(0, 100),
+    }))
+
+    const selectMenu = new StringSelectMenuBuilder()
+      .setCustomId(`agent_select:${contextHash}`)
+      .setPlaceholder('Select an agent')
+      .addOptions(options)
+
+    const actionRow = new ActionRowBuilder<StringSelectMenuBuilder>().addComponents(selectMenu)
+
+    await interaction.editReply({
+      content: '**Set Agent Preference**\nSelect an agent:',
+      components: [actionRow],
+    })
+  } catch (error) {
+    agentLogger.error('Error loading agents:', error)
+    await interaction.editReply({
+      content: `Failed to load agents: ${error instanceof Error ? error.message : 'Unknown error'}`,
+    })
+  }
+}
+
+export async function handleAgentSelectMenu(
+  interaction: StringSelectMenuInteraction
+): Promise<void> {
+  const customId = interaction.customId
+
+  if (!customId.startsWith('agent_select:')) {
+    return
+  }
+
+  await interaction.deferUpdate()
+
+  const contextHash = customId.replace('agent_select:', '')
+  const context = pendingAgentContexts.get(contextHash)
+
+  if (!context) {
+    await interaction.editReply({
+      content: 'Selection expired. Please run /agent again.',
+      components: [],
+    })
+    return
+  }
+
+  const selectedAgent = interaction.values[0]
+  if (!selectedAgent) {
+    await interaction.editReply({
+      content: 'No agent selected',
+      components: [],
+    })
+    return
+  }
+
+  try {
+    if (context.isThread && context.sessionId) {
+      setSessionAgent(context.sessionId, selectedAgent)
+      agentLogger.log(`Set agent ${selectedAgent} for session ${context.sessionId}`)
+
+      await interaction.editReply({
+        content: `Agent preference set for this session: **${selectedAgent}**`,
+        components: [],
+      })
+    } else {
+      setChannelAgent(context.channelId, selectedAgent)
+      agentLogger.log(`Set agent ${selectedAgent} for channel ${context.channelId}`)
+
+      await interaction.editReply({
+        content: `Agent preference set for this channel: **${selectedAgent}**\n\nAll new sessions in this channel will use this agent.`,
+        components: [],
+      })
+    }
+
+    pendingAgentContexts.delete(contextHash)
+  } catch (error) {
+    agentLogger.error('Error saving agent preference:', error)
+    await interaction.editReply({
+      content: `Failed to save agent preference: ${error instanceof Error ? error.message : 'Unknown error'}`,
+      components: [],
+    })
+  }
+}

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
+}