kimaki 0.4.12 → 0.4.14

package/src/discordBot.ts

@@ -54,9 +54,34 @@ import { setGlobalDispatcher, Agent } from 'undici'
 // disables the automatic 5 minutes abort after no body
 setGlobalDispatcher(new Agent({ headersTimeout: 0, bodyTimeout: 0 }))
 
-export const OPENCODE_SYSTEM_MESSAGE = `
+type ParsedCommand = {
+  isCommand: true
+  command: string
+  arguments: string
+} | {
+  isCommand: false
+}
+
+function parseSlashCommand(text: string): ParsedCommand {
+  const trimmed = text.trim()
+  if (!trimmed.startsWith('/')) {
+    return { isCommand: false }
+  }
+  const match = trimmed.match(/^\/(\S+)(?:\s+(.*))?$/)
+  if (!match) {
+    return { isCommand: false }
+  }
+  const command = match[1]!
+  const args = match[2]?.trim() || ''
+  return { isCommand: true, command, arguments: args }
+}
+
+export function getOpencodeSystemMessage({ sessionId }: { sessionId: string }) {
+  return `
 The user is reading your messages from inside Discord, via kimaki.xyz
 
+Your current OpenCode session ID is: ${sessionId}
+
 After each message, if you implemented changes, you can show the user a diff via an url running the command, to show the changes in working directory:
 
 bunx critique web
@@ -98,6 +123,7 @@ code blocks for tables and diagrams MUST have Max length of 85 characters. other
 
 you can create diagrams wrapping them in code blocks too.
 `
+}
 
 const discordLogger = createLogger('DISCORD')
 const voiceLogger = createLogger('VOICE')
@@ -213,11 +239,13 @@ async function setupVoiceHandling({
   guildId,
   channelId,
   appId,
+  discordClient,
 }: {
   connection: VoiceConnection
   guildId: string
   channelId: string
   appId: string
+  discordClient: Client
 }) {
   voiceLogger.log(
     `Setting up voice handling for guild ${guildId}, channel ${channelId}`,
@@ -330,8 +358,28 @@ async function setupVoiceHandling({
 
       genAiWorker.sendTextInput(text)
     },
-    onError(error) {
+    async onError(error) {
       voiceLogger.error('GenAI worker error:', error)
+      const textChannelRow = getDatabase()
+        .prepare(
+          `SELECT cd2.channel_id FROM channel_directories cd1
+           JOIN channel_directories cd2 ON cd1.directory = cd2.directory
+           WHERE cd1.channel_id = ? AND cd1.channel_type = 'voice' AND cd2.channel_type = 'text'`,
+        )
+        .get(channelId) as { channel_id: string } | undefined
+
+      if (textChannelRow) {
+        try {
+          const textChannel = await discordClient.channels.fetch(
+            textChannelRow.channel_id,
+          )
+          if (textChannel?.isTextBased() && 'send' in textChannel) {
+            await textChannel.send(`⚠️ Voice session error: ${error}`)
+          }
+        } catch (e) {
+          voiceLogger.error('Failed to send error to text channel:', e)
+        }
+      }
     },
   })
 
@@ -1212,30 +1260,31 @@ function getToolOutputToDisplay(part: Part): string {
     return part.state.error || 'Unknown error'
   }
 
-  if (part.tool === 'todowrite') {
-    const todos =
-      (part.state.input?.todos as {
-        content: string
-        status: 'pending' | 'in_progress' | 'completed' | 'cancelled'
-      }[]) || []
-    return todos
-      .map((todo) => {
-        let statusIcon = '▢'
-        if (todo.status === 'in_progress') {
-          statusIcon = '●'
-        }
-        if (todo.status === 'completed' || todo.status === 'cancelled') {
-          statusIcon = '■'
-        }
-        return `\`${statusIcon}\` ${todo.content}`
-      })
-      .filter(Boolean)
-      .join('\n')
-  }
-
   return ''
 }
 
+function formatTodoList(part: Part): string {
+  if (part.type !== 'tool' || part.tool !== 'todowrite') return ''
+  const todos =
+    (part.state.input?.todos as {
+      content: string
+      status: 'pending' | 'in_progress' | 'completed' | 'cancelled'
+    }[]) || []
+  if (todos.length === 0) return ''
+  return todos
+    .map((todo, i) => {
+      const num = `${i + 1}.`
+      if (todo.status === 'in_progress') {
+        return `${num} **${todo.content}**`
+      }
+      if (todo.status === 'completed' || todo.status === 'cancelled') {
+        return `${num} ~~${todo.content}~~`
+      }
+      return `${num} ${todo.content}`
+    })
+    .join('\n')
+}
+
 function formatPart(part: Part): string {
   if (part.type === 'text') {
     return part.text || ''
@@ -1263,6 +1312,10 @@ function formatPart(part: Part): string {
   }
 
   if (part.type === 'tool') {
+    if (part.tool === 'todowrite') {
+      return formatTodoList(part)
+    }
+
     if (part.state.status !== 'completed' && part.state.status !== 'error') {
       return ''
     }
@@ -1270,9 +1323,20 @@ function formatPart(part: Part): string {
     const summaryText = getToolSummaryText(part)
     const outputToDisplay = getToolOutputToDisplay(part)
 
-    let toolTitle = part.state.status === 'completed' ? part.state.title || '' : 'error'
-    if (toolTitle) {
-      toolTitle = `*${toolTitle}*`
+    let toolTitle = ''
+    if (part.state.status === 'error') {
+      toolTitle = 'error'
+    } else if (part.tool === 'bash') {
+      const command = (part.state.input?.command as string) || ''
+      const isSingleLine = !command.includes('\n')
+      const hasBackticks = command.includes('`')
+      if (isSingleLine && command.length <= 120 && !hasBackticks) {
+        toolTitle = `\`${command}\``
+      } else {
+        toolTitle = part.state.title ? `*${part.state.title}*` : ''
+      }
+    } else if (part.state.title) {
+      toolTitle = `*${part.state.title}*`
     }
 
     const icon = part.state.status === 'completed' ? '◼︎' : part.state.status === 'error' ? '⨯' : ''
@@ -1311,12 +1375,14 @@ async function handleOpencodeSession({
   projectDirectory,
   originalMessage,
   images = [],
+  parsedCommand,
 }: {
   prompt: string
   thread: ThreadChannel
   projectDirectory?: string
   originalMessage?: Message
   images?: FilePartInput[]
+  parsedCommand?: ParsedCommand
 }): Promise<{ sessionID: string; result: any; port?: number } | undefined> {
   voiceLogger.log(
     `[OPENCODE SESSION] Starting for thread ${thread.id} with prompt: "${prompt.slice(0, 50)}${prompt.length > 50 ? '...' : ''}"`,
@@ -1439,6 +1505,8 @@ async function handleOpencodeSession({
   let currentParts: Part[] = []
   let stopTyping: (() => void) | null = null
   let usedModel: string | undefined
+  let usedProviderID: string | undefined
+  let inputTokens = 0
 
   const sendPartMessage = async (part: Part) => {
     const content = formatPart(part) + '\n\n'
@@ -1449,22 +1517,12 @@ async function handleOpencodeSession({
 
     // Skip if already sent
     if (partIdToMessage.has(part.id)) {
-      voiceLogger.log(
-        `[SEND SKIP] Part ${part.id} already sent as message ${partIdToMessage.get(part.id)?.id}`,
-      )
       return
     }
 
     try {
-      voiceLogger.log(
-        `[SEND] Sending part ${part.id} (type: ${part.type}) to Discord, content length: ${content.length}`,
-      )
-
       const firstMessage = await sendThreadMessage(thread, content)
       partIdToMessage.set(part.id, firstMessage)
-      voiceLogger.log(
-        `[SEND SUCCESS] Part ${part.id} sent as message ${firstMessage.id}`,
-      )
 
       // Store part-message mapping in database
       getDatabase()
@@ -1487,13 +1545,10 @@ async function handleOpencodeSession({
         discordLogger.log(`Not starting typing, already aborted`)
         return () => {}
       }
-      discordLogger.log(`Starting typing for thread ${thread.id}`)
-
       // Clear any previous typing interval
       if (typingInterval) {
         clearInterval(typingInterval)
         typingInterval = null
-        discordLogger.log(`Cleared previous typing interval`)
       }
 
       // Send initial typing
@@ -1529,7 +1584,6 @@ async function handleOpencodeSession({
         if (typingInterval) {
           clearInterval(typingInterval)
           typingInterval = null
-          discordLogger.log(`Stopped typing for thread ${thread.id}`)
         }
       }
     }
@@ -1538,45 +1592,31 @@ async function handleOpencodeSession({
       let assistantMessageId: string | undefined
 
       for await (const event of events) {
-        sessionLogger.log(`Received: ${event.type}`)
         if (event.type === 'message.updated') {
           const msg = event.properties.info
 
           if (msg.sessionID !== session.id) {
-            voiceLogger.log(
-              `[EVENT IGNORED] Message from different session (expected: ${session.id}, got: ${msg.sessionID})`,
-            )
             continue
           }
 
           // Track assistant message ID
           if (msg.role === 'assistant') {
             assistantMessageId = msg.id
-
-
             usedModel = msg.modelID
-
-            voiceLogger.log(
-              `[EVENT] Tracking assistant message ${assistantMessageId}`,
-            )
-          } else {
-            sessionLogger.log(`Message role: ${msg.role}`)
+            usedProviderID = msg.providerID
+            if (msg.tokens.input > 0) {
+              inputTokens = msg.tokens.input
+            }
           }
         } else if (event.type === 'message.part.updated') {
           const part = event.properties.part
 
           if (part.sessionID !== session.id) {
-            voiceLogger.log(
-              `[EVENT IGNORED] Part from different session (expected: ${session.id}, got: ${part.sessionID})`,
-            )
             continue
           }
 
           // Only process parts from assistant messages
           if (part.messageID !== assistantMessageId) {
-            voiceLogger.log(
-              `[EVENT IGNORED] Part from non-assistant message (expected: ${assistantMessageId}, got: ${part.messageID})`,
-            )
             continue
           }
 
@@ -1589,9 +1629,7 @@ async function handleOpencodeSession({
             currentParts.push(part)
           }
 
-          voiceLogger.log(
-            `[PART] Update: id=${part.id}, type=${part.type}, text=${'text' in part && typeof part.text === 'string' ? part.text.slice(0, 50) : ''}`,
-          )
+
 
           // Start typing on step-start
           if (part.type === 'step-start') {
@@ -1600,10 +1638,12 @@ async function handleOpencodeSession({
 
           // Check if this is a step-finish part
           if (part.type === 'step-finish') {
+            // Track tokens from step-finish part
+            if (part.tokens?.input && part.tokens.input > 0) {
+              inputTokens = part.tokens.input
+              voiceLogger.log(`[STEP-FINISH] Captured tokens: ${inputTokens}`)
+            }
             // Send all parts accumulated so far to Discord
-            voiceLogger.log(
-              `[STEP-FINISH] Sending ${currentParts.length} parts to Discord`,
-            )
             for (const p of currentParts) {
               // Skip step-start and step-finish parts as they have no visual content
               if (p.type !== 'step-start' && p.type !== 'step-finish') {
@@ -1690,10 +1730,6 @@ async function handleOpencodeSession({
           if (pending && pending.permission.id === permissionID) {
             pendingPermissions.delete(thread.id)
           }
-        } else if (event.type === 'file.edited') {
-          sessionLogger.log(`File edited event received`)
-        } else {
-          sessionLogger.log(`Unhandled event type: ${event.type}`)
         }
       }
     } catch (e) {
@@ -1707,37 +1743,20 @@ async function handleOpencodeSession({
       throw e
     } finally {
       // Send any remaining parts that weren't sent
-      voiceLogger.log(
-        `[CLEANUP] Checking ${currentParts.length} parts for unsent messages`,
-      )
-      let unsentCount = 0
       for (const part of currentParts) {
         if (!partIdToMessage.has(part.id)) {
-          unsentCount++
-          voiceLogger.log(
-            `[CLEANUP] Sending unsent part: id=${part.id}, type=${part.type}`,
-          )
           try {
             await sendPartMessage(part)
           } catch (error) {
-            sessionLogger.log(
-              `Failed to send part ${part.id} during cleanup:`,
-              error,
-            )
+            sessionLogger.error(`Failed to send part ${part.id}:`, error)
           }
         }
       }
-      if (unsentCount === 0) {
-        sessionLogger.log(`All parts were already sent`)
-      } else {
-        sessionLogger.log(`Sent ${unsentCount} previously unsent parts`)
-      }
 
       // Stop typing when session ends
       if (stopTyping) {
         stopTyping()
         stopTyping = null
-        sessionLogger.log(`Stopped typing for session`)
       }
 
       // Only send duration message if request was not aborted or was aborted with 'finished' reason
@@ -1750,8 +1769,22 @@ async function handleOpencodeSession({
         )
         const attachCommand = port ? ` ⋅ ${session.id}` : ''
         const modelInfo = usedModel ? ` ⋅ ${usedModel}` : ''
-        await sendThreadMessage(thread, `_Completed in ${sessionDuration}_${attachCommand}${modelInfo}`)
-        sessionLogger.log(`DURATION: Session completed in ${sessionDuration}, port ${port}, model ${usedModel}`)
+        let contextInfo = ''
+        if (inputTokens > 0 && usedProviderID && usedModel) {
+          try {
+            const providersResponse = await getClient().provider.list({ query: { directory } })
+            const provider = providersResponse.data?.all?.find((p) => p.id === usedProviderID)
+            const model = provider?.models?.[usedModel]
+            if (model?.limit?.context) {
+              const percentage = Math.round((inputTokens / model.limit.context) * 100)
+              contextInfo = ` ⋅ ${percentage}%`
+            }
+          } catch (e) {
+            sessionLogger.error('Failed to fetch provider info for context percentage:', e)
+          }
+        }
+        await sendThreadMessage(thread, `_Completed in ${sessionDuration}${contextInfo}_${attachCommand}${modelInfo}`)
+        sessionLogger.log(`DURATION: Session completed in ${sessionDuration}, port ${port}, model ${usedModel}, tokens ${inputTokens}`)
       } else {
         sessionLogger.log(
           `Session was aborted (reason: ${abortController.signal.reason}), skipping duration message`,
@@ -1761,27 +1794,42 @@ async function handleOpencodeSession({
   }
 
   try {
-    voiceLogger.log(
-      `[PROMPT] Sending prompt to session ${session.id}: "${prompt.slice(0, 100)}${prompt.length > 100 ? '...' : ''}"`,
-    )
-    if (images.length > 0) {
-      sessionLogger.log(`[PROMPT] Sending ${images.length} image(s):`, images.map((img) => ({ mime: img.mime, filename: img.filename, url: img.url.slice(0, 100) })))
-    }
-
     // Start the event handler
     const eventHandlerPromise = eventHandler()
 
-    const parts = [{ type: 'text' as const, text: prompt }, ...images]
-    sessionLogger.log(`[PROMPT] Parts to send:`, parts.length)
+    let response: { data?: unknown }
+    if (parsedCommand?.isCommand) {
+      sessionLogger.log(
+        `[COMMAND] Sending command /${parsedCommand.command} to session ${session.id} with args: "${parsedCommand.arguments.slice(0, 100)}${parsedCommand.arguments.length > 100 ? '...' : ''}"`,
+      )
+      response = await getClient().session.command({
+        path: { id: session.id },
+        body: {
+          command: parsedCommand.command,
+          arguments: parsedCommand.arguments,
+        },
+        signal: abortController.signal,
+      })
+    } else {
+      voiceLogger.log(
+        `[PROMPT] Sending prompt to session ${session.id}: "${prompt.slice(0, 100)}${prompt.length > 100 ? '...' : ''}"`,
+      )
+      if (images.length > 0) {
+        sessionLogger.log(`[PROMPT] Sending ${images.length} image(s):`, images.map((img) => ({ mime: img.mime, filename: img.filename, url: img.url.slice(0, 100) })))
+      }
+
+      const parts = [{ type: 'text' as const, text: prompt }, ...images]
+      sessionLogger.log(`[PROMPT] Parts to send:`, parts.length)
 
-    const response = await getClient().session.prompt({
-      path: { id: session.id },
-      body: {
-        parts,
-        system: OPENCODE_SYSTEM_MESSAGE,
-      },
-      signal: abortController.signal,
-    })
+      response = await getClient().session.prompt({
+        path: { id: session.id },
+        body: {
+          parts,
+          system: getOpencodeSystemMessage({ sessionId: session.id }),
+        },
+        signal: abortController.signal,
+      })
+    }
     abortController.abort('finished')
 
     sessionLogger.log(`Successfully sent prompt, got response`)
@@ -1938,9 +1986,6 @@ export async function startDiscordBot({
   discordClient.on(Events.MessageCreate, async (message: Message) => {
     try {
       if (message.author?.bot) {
-        voiceLogger.log(
-          `[IGNORED] Bot message from ${message.author.tag} in channel ${message.channelId}`,
-        )
         return
       }
       if (message.partial) {
@@ -1964,15 +2009,8 @@ export async function startDiscordBot({
         )
 
         if (!isOwner && !isAdmin) {
-          voiceLogger.log(
-            `[IGNORED] Non-authoritative user ${message.author.tag} (ID: ${message.author.id}) - not owner or admin`,
-          )
           return
         }
-
-        voiceLogger.log(
-          `[AUTHORIZED] Message from ${message.author.tag} (Owner: ${isOwner}, Admin: ${isAdmin})`,
-        )
       }
 
       const channel = message.channel
@@ -2046,12 +2084,14 @@ export async function startDiscordBot({
         }
 
         const images = getImageAttachments(message)
+        const parsedCommand = parseSlashCommand(messageContent)
         await handleOpencodeSession({
           prompt: messageContent,
           thread,
           projectDirectory,
           originalMessage: message,
           images,
+          parsedCommand,
         })
         return
       }
@@ -2141,12 +2181,14 @@ export async function startDiscordBot({
         }
 
         const images = getImageAttachments(message)
+        const parsedCommand = parseSlashCommand(messageContent)
         await handleOpencodeSession({
           prompt: messageContent,
           thread,
           projectDirectory,
           originalMessage: message,
           images,
+          parsedCommand,
         })
       } else {
         discordLogger.log(`Channel type ${channel.type} is not supported`)
@@ -2482,10 +2524,12 @@ export async function startDiscordBot({
               )
 
               // Start the OpenCode session
+              const parsedCommand = parseSlashCommand(fullPrompt)
               await handleOpencodeSession({
                 prompt: fullPrompt,
                 thread,
                 projectDirectory,
+                parsedCommand,
               })
             } catch (error) {
               voiceLogger.error('[SESSION] Error:', error)
@@ -2600,68 +2644,56 @@ export async function startDiscordBot({
                 `📂 **Resumed session:** ${sessionTitle}\n📅 **Created:** ${new Date(sessionResponse.data.time.created).toLocaleString()}\n\n*Loading ${messages.length} messages...*`,
               )
 
-              // Render all existing messages
-              let messageCount = 0
+              // Collect all assistant parts first, then only render the last 30
+              const allAssistantParts: { id: string; content: string }[] = []
               for (const message of messages) {
-                if (message.info.role === 'user') {
-                  // Render user messages
-                  const userParts = message.parts.filter(
-                    (p) => p.type === 'text' && !p.synthetic,
-                  )
-                  const userTexts = userParts
-                    .map((p) => {
-                      if (p.type === 'text') {
-                        return p.text
-                      }
-                      return ''
-                    })
-                    .filter((t) => t.trim())
-
-                  const userText = userTexts.join('\n\n')
-                  if (userText) {
-                    // Escape backticks in user messages to prevent formatting issues
-                    const escapedText = escapeDiscordFormatting(userText)
-                    await sendThreadMessage(thread, `**User:**\n${escapedText}`)
-                  }
-                } else if (message.info.role === 'assistant') {
-                  // Render assistant parts
-                  const partsToRender: { id: string; content: string }[] = []
-
+                if (message.info.role === 'assistant') {
                   for (const part of message.parts) {
                     const content = formatPart(part)
                     if (content.trim()) {
-                      partsToRender.push({ id: part.id, content })
+                      allAssistantParts.push({ id: part.id, content })
                     }
                   }
+                }
+              }
 
-                  if (partsToRender.length > 0) {
-                    const combinedContent = partsToRender
-                      .map((p) => p.content)
-                      .join('\n\n')
+              const partsToRender = allAssistantParts.slice(-30)
+              const skippedCount = allAssistantParts.length - partsToRender.length
 
-                    const discordMessage = await sendThreadMessage(
-                      thread,
-                      combinedContent,
-                    )
+              if (skippedCount > 0) {
+                await sendThreadMessage(
+                  thread,
+                  `*Skipped ${skippedCount} older assistant parts...*`,
+                )
+              }
 
-                    const stmt = getDatabase().prepare(
-                      'INSERT OR REPLACE INTO part_messages (part_id, message_id, thread_id) VALUES (?, ?, ?)',
-                    )
+              if (partsToRender.length > 0) {
+                const combinedContent = partsToRender
+                  .map((p) => p.content)
+                  .join('\n\n')
 
-                    const transaction = getDatabase().transaction(
-                      (parts: { id: string }[]) => {
-                        for (const part of parts) {
-                          stmt.run(part.id, discordMessage.id, thread.id)
-                        }
-                      },
-                    )
+                const discordMessage = await sendThreadMessage(
+                  thread,
+                  combinedContent,
+                )
 
-                    transaction(partsToRender)
-                  }
-                }
-                messageCount++
+                const stmt = getDatabase().prepare(
+                  'INSERT OR REPLACE INTO part_messages (part_id, message_id, thread_id) VALUES (?, ?, ?)',
+                )
+
+                const transaction = getDatabase().transaction(
+                  (parts: { id: string }[]) => {
+                    for (const part of parts) {
+                      stmt.run(part.id, discordMessage.id, thread.id)
+                    }
+                  },
+                )
+
+                transaction(partsToRender)
               }
 
+              const messageCount = messages.length
+
               await sendThreadMessage(
                 thread,
                 `✅ **Session resumed!** Loaded ${messageCount} messages.\n\nYou can now continue the conversation by sending messages in this thread.`,
@@ -2865,6 +2897,77 @@ export async function startDiscordBot({
                 ephemeral: true,
               })
             }
+          } else if (command.commandName === 'abort') {
+            const channel = command.channel
+
+            if (!channel) {
+              await command.reply({
+                content: 'This command can only be used in a channel',
+                ephemeral: true,
+              })
+              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,
+              })
+              return
+            }
+
+            const textChannel = 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,
+              })
+              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,
+              })
+              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(`🛑 Request **aborted**`)
+              sessionLogger.log(`Session ${sessionId} aborted by user`)
+            } catch (error) {
+              voiceLogger.error('[ABORT] Error:', error)
+              await command.reply({
+                content: `Failed to abort: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                ephemeral: true,
+              })
+            }
           }
         }
       } catch (error) {
@@ -3101,6 +3204,7 @@ export async function startDiscordBot({
           guildId: newState.guild.id,
           channelId: voiceChannel.id,
           appId: currentAppId!,
+          discordClient,
         })
 
         // Handle connection state changes