kimaki 0.4.37 → 0.4.39

package/src/commands/agent.ts

@@ -1,4 +1,5 @@
 // /agent command - Set the preferred agent for this channel or session.
+// Also provides quick agent commands like /plan-agent, /build-agent that switch instantly.
 
 import {
   ChatInputCommandInteraction,
@@ -10,10 +11,11 @@ import {
   type TextChannel,
 } from 'discord.js'
 import crypto from 'node:crypto'
-import { getDatabase, setChannelAgent, setSessionAgent, runModelMigrations } from '../database.js'
+import { getDatabase, setChannelAgent, setSessionAgent, clearSessionModel, runModelMigrations } from '../database.js'
 import { initializeOpencodeForDirectory } from '../opencode.js'
 import { resolveTextChannel, getKimakiMetadata } from '../discord-utils.js'
 import { createLogger } from '../logger.js'
+import * as errore from 'errore'
 
 const agentLogger = createLogger('AGENT')
 
@@ -27,22 +29,40 @@ const pendingAgentContexts = new Map<
   }
 >()
 
-export async function handleAgentCommand({
+/**
+ * Context for agent commands, containing channel/session info.
+ */
+export type AgentCommandContext = {
+  dir: string
+  channelId: string
+  sessionId?: string
+  isThread: boolean
+}
+
+/**
+ * Sanitize an agent name to be a valid Discord command name component.
+ * Lowercase, alphanumeric and hyphens only.
+ */
+export function sanitizeAgentName(name: string): string {
+  return name.toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/-+/g, '-').replace(/^-|-$/g, '')
+}
+
+/**
+ * Resolve the context for an agent command (directory, channel, session).
+ * Returns null if the command cannot be executed in this context.
+ */
+export async function resolveAgentCommandContext({
   interaction,
   appId,
 }: {
   interaction: ChatInputCommandInteraction
   appId: string
-}): Promise<void> {
-  await interaction.deferReply({ ephemeral: true })
-
-  runModelMigrations()
-
+}): Promise<AgentCommandContext | null> {
   const channel = interaction.channel
 
   if (!channel) {
     await interaction.editReply({ content: 'This command can only be used in a channel' })
-    return
+    return null
   }
 
   const isThread = [
@@ -78,26 +98,77 @@ export async function handleAgentCommand({
     await interaction.editReply({
       content: 'This command can only be used in text channels or threads',
     })
-    return
+    return null
   }
 
   if (channelAppId && channelAppId !== appId) {
     await interaction.editReply({ content: 'This channel is not configured for this bot' })
-    return
+    return null
   }
 
   if (!projectDirectory) {
     await interaction.editReply({
       content: 'This channel is not configured with a project directory',
     })
+    return null
+  }
+
+  return {
+    dir: projectDirectory,
+    channelId: targetChannelId,
+    sessionId,
+    isThread,
+  }
+}
+
+/**
+ * Set the agent preference for a context (session or channel).
+ * When switching agents for a session, also clears the session model preference
+ * so the new agent's model takes effect.
+ */
+export function setAgentForContext({
+  context,
+  agentName,
+}: {
+  context: AgentCommandContext
+  agentName: string
+}): void {
+  if (context.isThread && context.sessionId) {
+    setSessionAgent(context.sessionId, agentName)
+    // Clear session model so the new agent's model takes effect
+    clearSessionModel(context.sessionId)
+    agentLogger.log(`Set agent ${agentName} for session ${context.sessionId} (cleared model preference)`)
+  } else {
+    setChannelAgent(context.channelId, agentName)
+    agentLogger.log(`Set agent ${agentName} for channel ${context.channelId}`)
+  }
+}
+
+export async function handleAgentCommand({
+  interaction,
+  appId,
+}: {
+  interaction: ChatInputCommandInteraction
+  appId: string
+}): Promise<void> {
+  await interaction.deferReply({ ephemeral: true })
+
+  runModelMigrations()
+
+  const context = await resolveAgentCommandContext({ interaction, appId })
+  if (!context) {
     return
   }
 
   try {
-    const getClient = await initializeOpencodeForDirectory(projectDirectory)
+    const getClient = await initializeOpencodeForDirectory(context.dir)
+    if (errore.isError(getClient)) {
+      await interaction.editReply({ content: getClient.message })
+      return
+    }
 
     const agentsResponse = await getClient().app.agents({
-      query: { directory: projectDirectory },
+      query: { directory: context.dir },
     })
 
     if (!agentsResponse.data || agentsResponse.data.length === 0) {
@@ -106,7 +177,10 @@ export async function handleAgentCommand({
     }
 
     const agents = agentsResponse.data
-      .filter((a) => a.mode === 'primary' || a.mode === 'all')
+      .filter((agent) => {
+        const hidden = (agent as { hidden?: boolean }).hidden
+        return (agent.mode === 'primary' || agent.mode === 'all') && !hidden
+      })
       .slice(0, 25)
 
     if (agents.length === 0) {
@@ -115,12 +189,7 @@ export async function handleAgentCommand({
     }
 
     const contextHash = crypto.randomBytes(8).toString('hex')
-    pendingAgentContexts.set(contextHash, {
-      dir: projectDirectory,
-      channelId: targetChannelId,
-      sessionId,
-      isThread,
-    })
+    pendingAgentContexts.set(contextHash, context)
 
     const options = agents.map((agent) => ({
       label: agent.name.slice(0, 100),
@@ -179,18 +248,14 @@ export async function handleAgentSelectMenu(
   }
 
   try {
-    if (context.isThread && context.sessionId) {
-      setSessionAgent(context.sessionId, selectedAgent)
-      agentLogger.log(`Set agent ${selectedAgent} for session ${context.sessionId}`)
+    setAgentForContext({ context, agentName: selectedAgent })
 
+    if (context.isThread && 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: [],
@@ -206,3 +271,73 @@ export async function handleAgentSelectMenu(
     })
   }
 }
+
+/**
+ * Handle quick agent commands like /plan-agent, /build-agent.
+ * These instantly switch to the specified agent without showing a dropdown.
+ */
+export async function handleQuickAgentCommand({
+  command,
+  appId,
+}: {
+  command: ChatInputCommandInteraction
+  appId: string
+}): Promise<void> {
+  await command.deferReply({ ephemeral: true })
+
+  runModelMigrations()
+
+  // Extract agent name from command: "plan-agent" → "plan"
+  const sanitizedAgentName = command.commandName.replace(/-agent$/, '')
+
+  const context = await resolveAgentCommandContext({ interaction: command, appId })
+  if (!context) {
+    return
+  }
+
+  try {
+    const getClient = await initializeOpencodeForDirectory(context.dir)
+    if (errore.isError(getClient)) {
+      await command.editReply({ content: getClient.message })
+      return
+    }
+
+    const agentsResponse = await getClient().app.agents({
+      query: { directory: context.dir },
+    })
+
+    if (!agentsResponse.data || agentsResponse.data.length === 0) {
+      await command.editReply({ content: 'No agents available in this project' })
+      return
+    }
+
+    // Find the agent matching the sanitized command name
+    const matchingAgent = agentsResponse.data.find(
+      (a) => sanitizeAgentName(a.name) === sanitizedAgentName
+    )
+
+    if (!matchingAgent) {
+      await command.editReply({
+        content: `Agent not found. Available agents: ${agentsResponse.data.map((a) => a.name).join(', ')}`,
+      })
+      return
+    }
+
+    setAgentForContext({ context, agentName: matchingAgent.name })
+
+    if (context.isThread && context.sessionId) {
+      await command.editReply({
+        content: `Switched to **${matchingAgent.name}** agent for this session`,
+      })
+    } else {
+      await command.editReply({
+        content: `Switched to **${matchingAgent.name}** agent for this channel\n\nAll new sessions will use this agent.`,
+      })
+    }
+  } catch (error) {
+    agentLogger.error('Error in quick agent command:', error)
+    await command.editReply({
+      content: `Failed to switch agent: ${error instanceof Error ? error.message : 'Unknown error'}`,
+    })
+  }
+}

package/src/commands/fork.ts

@@ -14,6 +14,7 @@ import { initializeOpencodeForDirectory } from '../opencode.js'
 import { resolveTextChannel, getKimakiMetadata, sendThreadMessage } from '../discord-utils.js'
 import { collectLastAssistantParts } from '../message-formatting.js'
 import { createLogger } from '../logger.js'
+import * as errore from 'errore'
 
 const sessionLogger = createLogger('SESSION')
 const forkLogger = createLogger('FORK')
@@ -71,9 +72,15 @@ export async function handleForkCommand(interaction: ChatInputCommandInteraction
 
   const sessionId = row.session_id
 
-  try {
-    const getClient = await initializeOpencodeForDirectory(directory)
+  const getClient = await initializeOpencodeForDirectory(directory)
+  if (errore.isError(getClient)) {
+    await interaction.editReply({
+      content: `Failed to load messages: ${getClient.message}`,
+    })
+    return
+  }
 
+  try {
     const messagesResponse = await getClient().session.messages({
       path: { id: sessionId },
     })
@@ -85,7 +92,7 @@ export async function handleForkCommand(interaction: ChatInputCommandInteraction
       return
     }
 
-    const userMessages = messagesResponse.data.filter((m) => m.info.role === 'user')
+    const userMessages = messagesResponse.data.filter((m: { info: { role: string } }) => m.info.role === 'user')
 
     if (userMessages.length === 0) {
       await interaction.editReply({
@@ -96,8 +103,8 @@ 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
+    const options = recentMessages.map((m: { parts: Array<{ type: string; text?: string }>; info: { id: string; time: { created: number } } }, index: number) => {
+      const textPart = m.parts.find((p: { type: string }) => p.type === 'text') as
         | { type: 'text'; text: string }
         | undefined
       const preview = textPart?.text?.slice(0, 80) || '(no text)'
@@ -163,9 +170,13 @@ export async function handleForkSelectMenu(
 
   await interaction.deferReply({ ephemeral: false })
 
-  try {
-    const getClient = await initializeOpencodeForDirectory(directory)
+  const getClient = await initializeOpencodeForDirectory(directory)
+  if (errore.isError(getClient)) {
+    await interaction.editReply(`Failed to fork session: ${getClient.message}`)
+    return
+  }
 
+  try {
     const forkResponse = await getClient().session.fork({
       path: { id: sessionId },
       body: { messageID: selectedMessageId },

package/src/commands/model.ts

@@ -15,6 +15,7 @@ import { initializeOpencodeForDirectory } from '../opencode.js'
 import { resolveTextChannel, getKimakiMetadata } from '../discord-utils.js'
 import { abortAndRetrySession } from '../session-handler.js'
 import { createLogger } from '../logger.js'
+import * as errore from 'errore'
 
 const modelLogger = createLogger('MODEL')
 
@@ -128,6 +129,10 @@ export async function handleModelCommand({
 
   try {
     const getClient = await initializeOpencodeForDirectory(projectDirectory)
+    if (errore.isError(getClient)) {
+      await interaction.editReply({ content: getClient.message })
+      return
+    }
 
     const providersResponse = await getClient().provider.list({
       query: { directory: projectDirectory },
@@ -232,6 +237,13 @@ export async function handleProviderSelectMenu(
 
   try {
     const getClient = await initializeOpencodeForDirectory(context.dir)
+    if (errore.isError(getClient)) {
+      await interaction.editReply({
+        content: getClient.message,
+        components: [],
+      })
+      return
+    }
 
     const providersResponse = await getClient().provider.list({
       query: { directory: context.dir },

package/src/commands/remove-project.ts

@@ -1,6 +1,7 @@
 // /remove-project command - Remove Discord channels for a project.
 
 import path from 'node:path'
+import * as errore from 'errore'
 import type { CommandContext, AutocompleteContext } from './types.js'
 import { getDatabase } from '../database.js'
 import { createLogger } from '../logger.js'
@@ -36,19 +37,27 @@ export async function handleRemoveProjectCommand({ command, appId }: CommandCont
     const failedChannels: string[] = []
 
     for (const { channel_id, channel_type } of channels) {
-      try {
-        const channel = await guild.channels.fetch(channel_id).catch(() => null)
-
-        if (channel) {
+      const channel = await errore.tryAsync({
+        try: () => guild.channels.fetch(channel_id),
+        catch: (e) => e as Error,
+      })
+      
+      if (errore.isError(channel)) {
+        logger.error(`Failed to fetch channel ${channel_id}:`, channel)
+        failedChannels.push(`${channel_type}: ${channel_id}`)
+        continue
+      }
+      
+      if (channel) {
+        try {
           await channel.delete(`Removed by /remove-project command`)
           deletedChannels.push(`${channel_type}: ${channel_id}`)
-        } else {
-          // Channel doesn't exist in this guild or was already deleted
-          deletedChannels.push(`${channel_type}: ${channel_id} (already deleted)`)
+        } catch (error) {
+          logger.error(`Failed to delete channel ${channel_id}:`, error)
+          failedChannels.push(`${channel_type}: ${channel_id}`)
         }
-      } catch (error) {
-        logger.error(`Failed to delete channel ${channel_id}:`, error)
-        failedChannels.push(`${channel_type}: ${channel_id}`)
+      } else {
+        deletedChannels.push(`${channel_type}: ${channel_id} (already deleted)`)
       }
     }
 
@@ -103,13 +112,16 @@ export async function handleRemoveProjectAutocomplete({
     const projectsInGuild: { directory: string; channelId: string }[] = []
 
     for (const { directory, channel_id } of allChannels) {
-      try {
-        const channel = await guild.channels.fetch(channel_id).catch(() => null)
-        if (channel) {
-          projectsInGuild.push({ directory, channelId: channel_id })
-        }
-      } catch {
+      const channel = await errore.tryAsync({
+        try: () => guild.channels.fetch(channel_id),
+        catch: (e) => e as Error,
+      })
+      if (errore.isError(channel)) {
         // Channel not in this guild, skip
+        continue
+      }
+      if (channel) {
+        projectsInGuild.push({ directory, channelId: channel_id })
       }
     }
 

package/src/commands/resume.ts

@@ -14,6 +14,7 @@ import { sendThreadMessage, resolveTextChannel, getKimakiMetadata } from '../dis
 import { extractTagsArrays } from '../xml.js'
 import { collectLastAssistantParts } from '../message-formatting.js'
 import { createLogger } from '../logger.js'
+import * as errore from 'errore'
 
 const logger = createLogger('RESUME')
 
@@ -60,6 +61,10 @@ export async function handleResumeCommand({ command, appId }: CommandContext): P
 
   try {
     const getClient = await initializeOpencodeForDirectory(projectDirectory)
+    if (errore.isError(getClient)) {
+      await command.editReply(getClient.message)
+      return
+    }
 
     const sessionResponse = await getClient().session.get({
       path: { id: sessionId },
@@ -168,6 +173,10 @@ export async function handleResumeAutocomplete({
 
   try {
     const getClient = await initializeOpencodeForDirectory(projectDirectory)
+    if (errore.isError(getClient)) {
+      await interaction.respond([])
+      return
+    }
 
     const sessionsResponse = await getClient().session.list()
     if (!sessionsResponse.data) {

package/src/commands/session.ts

@@ -10,6 +10,7 @@ import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js'
 import { extractTagsArrays } from '../xml.js'
 import { handleOpencodeSession } from '../session-handler.js'
 import { createLogger } from '../logger.js'
+import * as errore from 'errore'
 
 const logger = createLogger('SESSION')
 
@@ -58,6 +59,10 @@ export async function handleSessionCommand({ command, appId }: CommandContext):
 
   try {
     const getClient = await initializeOpencodeForDirectory(projectDirectory)
+    if (errore.isError(getClient)) {
+      await command.editReply(getClient.message)
+      return
+    }
 
     const files = filesString
       .split(',')
@@ -128,6 +133,10 @@ async function handleAgentAutocomplete({ interaction, appId }: AutocompleteConte
 
   try {
     const getClient = await initializeOpencodeForDirectory(projectDirectory)
+    if (errore.isError(getClient)) {
+      await interaction.respond([])
+      return
+    }
 
     const agentsResponse = await getClient().app.agents({
       query: { directory: projectDirectory },
@@ -207,6 +216,10 @@ export async function handleSessionAutocomplete({
 
   try {
     const getClient = await initializeOpencodeForDirectory(projectDirectory)
+    if (errore.isError(getClient)) {
+      await interaction.respond([])
+      return
+    }
 
     const response = await getClient().find.files({
       query: {

package/src/commands/share.ts

@@ -6,6 +6,7 @@ import { getDatabase } from '../database.js'
 import { initializeOpencodeForDirectory } from '../opencode.js'
 import { resolveTextChannel, getKimakiMetadata, SILENT_MESSAGE_FLAGS } from '../discord-utils.js'
 import { createLogger } from '../logger.js'
+import * as errore from 'errore'
 
 const logger = createLogger('SHARE')
 
@@ -63,8 +64,17 @@ export async function handleShareCommand({ command }: CommandContext): Promise<v
 
   const sessionId = row.session_id
 
+  const getClient = await initializeOpencodeForDirectory(directory)
+  if (errore.isError(getClient)) {
+    await command.reply({
+      content: `Failed to share session: ${getClient.message}`,
+      ephemeral: true,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
   try {
-    const getClient = await initializeOpencodeForDirectory(directory)
     const response = await getClient().session.share({
       path: { id: sessionId },
     })

package/src/commands/undo-redo.ts

@@ -6,6 +6,7 @@ import { getDatabase } from '../database.js'
 import { initializeOpencodeForDirectory } from '../opencode.js'
 import { resolveTextChannel, getKimakiMetadata, SILENT_MESSAGE_FLAGS } from '../discord-utils.js'
 import { createLogger } from '../logger.js'
+import * as errore from 'errore'
 
 const logger = createLogger('UNDO-REDO')
 
@@ -63,11 +64,15 @@ export async function handleUndoCommand({ command }: CommandContext): Promise<vo
 
   const sessionId = row.session_id
 
-  try {
-    await command.deferReply({ flags: SILENT_MESSAGE_FLAGS })
+  await command.deferReply({ flags: SILENT_MESSAGE_FLAGS })
 
-    const getClient = await initializeOpencodeForDirectory(directory)
+  const getClient = await initializeOpencodeForDirectory(directory)
+  if (errore.isError(getClient)) {
+    await command.editReply(`Failed to undo: ${getClient.message}`)
+    return
+  }
 
+  try {
     // Fetch messages to find the last assistant message
     const messagesResponse = await getClient().session.messages({
       path: { id: sessionId },
@@ -166,11 +171,15 @@ export async function handleRedoCommand({ command }: CommandContext): Promise<vo
 
   const sessionId = row.session_id
 
-  try {
-    await command.deferReply({ flags: SILENT_MESSAGE_FLAGS })
+  await command.deferReply({ flags: SILENT_MESSAGE_FLAGS })
 
-    const getClient = await initializeOpencodeForDirectory(directory)
+  const getClient = await initializeOpencodeForDirectory(directory)
+  if (errore.isError(getClient)) {
+    await command.editReply(`Failed to redo: ${getClient.message}`)
+    return
+  }
 
+  try {
     // Check if session has reverted state
     const sessionResponse = await getClient().session.get({
       path: { id: sessionId },

package/src/database.ts

@@ -5,6 +5,7 @@
 import Database from 'better-sqlite3'
 import fs from 'node:fs'
 import path from 'node:path'
+import * as errore from 'errore'
 import { createLogger } from './logger.js'
 import { getDataDir } from './config.js'
 
@@ -16,10 +17,14 @@ export function getDatabase(): Database.Database {
   if (!db) {
     const dataDir = getDataDir()
 
-    try {
-      fs.mkdirSync(dataDir, { recursive: true })
-    } catch (error) {
-      dbLogger.error(`Failed to create data directory ${dataDir}:`, error)
+    const mkdirError = errore.tryFn({
+      try: () => {
+        fs.mkdirSync(dataDir, { recursive: true })
+      },
+      catch: (e) => e as Error,
+    })
+    if (errore.isError(mkdirError)) {
+      dbLogger.error(`Failed to create data directory ${dataDir}:`, mkdirError.message)
     }
 
     const dbPath = path.join(dataDir, 'discord-sessions.db')
@@ -68,6 +73,14 @@ export function getDatabase(): Database.Database {
       // Column already exists, ignore
     }
 
+    // Table for threads that should auto-start a session (created by CLI without --notify-only)
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS pending_auto_start (
+        thread_id TEXT PRIMARY KEY,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `)
+
     db.exec(`
       CREATE TABLE IF NOT EXISTS bot_api_keys (
         app_id TEXT PRIMARY KEY,
@@ -176,6 +189,15 @@ export function setSessionModel(sessionId: string, modelId: string): void {
   )
 }
 
+/**
+ * Clear the model preference for a session.
+ * Used when switching agents so the agent's model takes effect.
+ */
+export function clearSessionModel(sessionId: string): void {
+  const db = getDatabase()
+  db.prepare('DELETE FROM session_models WHERE session_id = ?').run(sessionId)
+}
+
 /**
  * Get the agent preference for a channel.
  */