kimaki 0.4.1 → 0.4.4

package/src/discordBot.ts

@@ -16,6 +16,7 @@ import {
   Partials,
   PermissionsBitField,
   ThreadAutoArchiveDuration,
+  type CategoryChannel,
   type Guild,
   type Interaction,
   type Message,
@@ -459,7 +460,6 @@ function frameMono16khz(): Transform {
 
 export function getDatabase(): Database.Database {
   if (!db) {
-    // Create ~/.kimaki directory if it doesn't exist
     const kimakiDir = path.join(os.homedir(), '.kimaki')
 
     try {
@@ -473,7 +473,6 @@ export function getDatabase(): Database.Database {
     dbLogger.log(`Opening database at: ${dbPath}`)
     db = new Database(dbPath)
 
-    // Initialize tables
     db.exec(`
       CREATE TABLE IF NOT EXISTS thread_sessions (
         thread_id TEXT PRIMARY KEY,
@@ -520,6 +519,76 @@ export function getDatabase(): Database.Database {
   return db
 }
 
+export async function ensureKimakiCategory(guild: Guild): Promise<CategoryChannel> {
+  const existingCategory = guild.channels.cache.find(
+    (channel): channel is CategoryChannel => {
+      if (channel.type !== ChannelType.GuildCategory) {
+        return false
+      }
+
+      return channel.name.toLowerCase() === 'kimaki'
+    },
+  )
+
+  if (existingCategory) {
+    return existingCategory
+  }
+
+  return guild.channels.create({
+    name: 'Kimaki',
+    type: ChannelType.GuildCategory,
+  })
+}
+
+export async function createProjectChannels({
+  guild,
+  projectDirectory,
+  appId,
+}: {
+  guild: Guild
+  projectDirectory: string
+  appId: string
+}): Promise<{ textChannelId: string; voiceChannelId: string; channelName: string }> {
+  const baseName = path.basename(projectDirectory)
+  const channelName = `${baseName}`
+    .toLowerCase()
+    .replace(/[^a-z0-9-]/g, '-')
+    .slice(0, 100)
+
+  const kimakiCategory = await ensureKimakiCategory(guild)
+
+  const textChannel = await guild.channels.create({
+    name: channelName,
+    type: ChannelType.GuildText,
+    parent: kimakiCategory,
+    topic: `<kimaki><directory>${projectDirectory}</directory><app>${appId}</app></kimaki>`,
+  })
+
+  const voiceChannel = await guild.channels.create({
+    name: channelName,
+    type: ChannelType.GuildVoice,
+    parent: kimakiCategory,
+  })
+
+  getDatabase()
+    .prepare(
+      'INSERT OR REPLACE INTO channel_directories (channel_id, directory, channel_type) VALUES (?, ?, ?)',
+    )
+    .run(textChannel.id, projectDirectory, 'text')
+
+  getDatabase()
+    .prepare(
+      'INSERT OR REPLACE INTO channel_directories (channel_id, directory, channel_type) VALUES (?, ?, ?)',
+    )
+    .run(voiceChannel.id, projectDirectory, 'voice')
+
+  return {
+    textChannelId: textChannel.id,
+    voiceChannelId: voiceChannel.id,
+    channelName,
+  }
+}
+
 async function getOpenPort(): Promise<number> {
   return new Promise((resolve, reject) => {
     const server = net.createServer()
@@ -550,6 +619,8 @@ async function sendThreadMessage(
 ): Promise<Message> {
   const MAX_LENGTH = 2000
 
+  content = escapeBackticksInCodeBlocks(content)
+
   // Simple case: content fits in one message
   if (content.length <= MAX_LENGTH) {
     return await thread.send(content)
@@ -742,6 +813,24 @@ async function processVoiceAttachment({
   return transcription
 }
 
+export function escapeBackticksInCodeBlocks(markdown: string): string {
+  const lexer = new Lexer()
+  const tokens = lexer.lex(markdown)
+
+  let result = ''
+
+  for (const token of tokens) {
+    if (token.type === 'code') {
+      const escapedCode = token.text.replace(/`/g, '\\`')
+      result += '```' + (token.lang || '') + '\n' + escapedCode + '\n```\n'
+    } else {
+      result += token.raw
+    }
+  }
+
+  return result
+}
+
 /**
  * Escape Discord formatting characters to prevent breaking code blocks and inline code
  */
@@ -945,129 +1034,146 @@ export async function initializeOpencodeForDirectory(directory: string) {
   }
 }
 
+function getToolSummaryText(part: Part): string {
+  if (part.type !== 'tool') return ''
+  if (part.state.status !== 'completed' && part.state.status !== 'error') return ''
 
-function formatPart(part: Part): string {
-  switch (part.type) {
-    case 'text':
-      return escapeDiscordFormatting(part.text || '')
-    case 'reasoning':
-      if (!part.text?.trim()) return ''
-      return `▪︎ thinking: ${escapeDiscordFormatting(part.text || '')}`
-    case 'tool':
-      if (part.state.status === 'completed' || part.state.status === 'error') {
-        let outputToDisplay = ''
-        let summaryText = ''
-
-        if (part.tool === 'bash') {
-          const output =
-            part.state.status === 'completed'
-              ? part.state.output
-              : part.state.error
-          const lines = (output || '').split('\n').filter((l) => l.trim())
-          summaryText = `(${lines.length} line${lines.length === 1 ? '' : 's'})`
-        } else if (part.tool === 'edit') {
-          const newString = (part.state.input?.newString as string) || ''
-          const oldString = (part.state.input?.oldString as string) || ''
-          const added = newString.split('\n').length
-          const removed = oldString.split('\n').length
-          summaryText = `(+${added}-${removed})`
-        } else if (part.tool === 'write') {
-          const content = (part.state.input?.content as string) || ''
-          const lines = content.split('\n').length
-          summaryText = `(${lines} line${lines === 1 ? '' : 's'})`
-        } else if (part.tool === 'read') {
-        } else if (part.tool === 'write') {
-        } else if (part.tool === 'edit') {
-        } else if (part.tool === 'list') {
-        } else if (part.tool === 'glob') {
-        } else if (part.tool === 'grep') {
-        } else if (part.tool === 'task') {
-        } else if (part.tool === 'todoread') {
-          // Special handling for read - don't show arguments
-        } else if (part.tool === 'todowrite') {
-          const todos =
-            (part.state.input?.todos as {
-              content: string
-              status: 'pending' | 'in_progress' | 'completed' | 'cancelled'
-            }[]) || []
-          outputToDisplay = todos
-            .map((todo) => {
-              let statusIcon = '▢'
-              switch (todo.status) {
-                case 'pending':
-                  statusIcon = '▢'
-                  break
-                case 'in_progress':
-                  statusIcon = '●'
-                  break
-                case 'completed':
-                  statusIcon = '■'
-                  break
-                case 'cancelled':
-                  statusIcon = '■'
-                  break
-              }
-              return `\`${statusIcon}\` ${todo.content}`
-            })
-            .filter(Boolean)
-            .join('\n')
-        } else if (part.tool === 'webfetch') {
-          const url = (part.state.input?.url as string) || ''
-          const urlWithoutProtocol = url.replace(/^https?:\/\//, '')
-          summaryText = urlWithoutProtocol ? `(${urlWithoutProtocol})` : ''
-        } else if (part.state.input) {
-          const inputFields = Object.entries(part.state.input)
-            .map(([key, value]) => {
-              if (value === null || value === undefined) return null
-              const stringValue =
-                typeof value === 'string' ? value : JSON.stringify(value)
-              const truncatedValue =
-                stringValue.length > 100
-                  ? stringValue.slice(0, 100) + '…'
-                  : stringValue
-              return `${key}: ${truncatedValue}`
-            })
-            .filter(Boolean)
-          if (inputFields.length > 0) {
-            outputToDisplay = inputFields.join(', ')
-          }
-        }
+  if (part.tool === 'bash') {
+    const output = part.state.status === 'completed' ? part.state.output : part.state.error
+    const lines = (output || '').split('\n').filter((l: string) => l.trim())
+    return `(${lines.length} line${lines.length === 1 ? '' : 's'})`
+  }
+
+  if (part.tool === 'edit') {
+    const newString = (part.state.input?.newString as string) || ''
+    const oldString = (part.state.input?.oldString as string) || ''
+    const added = newString.split('\n').length
+    const removed = oldString.split('\n').length
+    return `(+${added}-${removed})`
+  }
+
+  if (part.tool === 'write') {
+    const content = (part.state.input?.content as string) || ''
+    const lines = content.split('\n').length
+    return `(${lines} line${lines === 1 ? '' : 's'})`
+  }
+
+  if (part.tool === 'webfetch') {
+    const url = (part.state.input?.url as string) || ''
+    const urlWithoutProtocol = url.replace(/^https?:\/\//, '')
+    return urlWithoutProtocol ? `(${urlWithoutProtocol})` : ''
+  }
+
+  if (
+    part.tool === 'read' ||
+    part.tool === 'list' ||
+    part.tool === 'glob' ||
+    part.tool === 'grep' ||
+    part.tool === 'task' ||
+    part.tool === 'todoread' ||
+    part.tool === 'todowrite'
+  ) {
+    return ''
+  }
+
+  if (!part.state.input) return ''
+
+  const inputFields = Object.entries(part.state.input)
+    .map(([key, value]) => {
+      if (value === null || value === undefined) return null
+      const stringValue = typeof value === 'string' ? value : JSON.stringify(value)
+      const truncatedValue = stringValue.length > 100 ? stringValue.slice(0, 100) + '…' : stringValue
+      return `${key}: ${truncatedValue}`
+    })
+    .filter(Boolean)
+
+  if (inputFields.length === 0) return ''
+
+  return `(${inputFields.join(', ')})`
+}
+
+function getToolOutputToDisplay(part: Part): string {
+  if (part.type !== 'tool') return ''
+  if (part.state.status !== 'completed' && part.state.status !== 'error') return ''
+
+  if (part.state.status === 'error') {
+    return part.state.error || 'Unknown error'
+  }
 
-        let toolTitle =
-          part.state.status === 'completed' ? part.state.title || '' : 'error'
-        if (toolTitle) {
-          toolTitle = `\`${escapeInlineCode(toolTitle)}\``
+  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 = '●'
         }
-        const icon =
-          part.state.status === 'completed'
-            ? '◼︎'
-            : part.state.status === 'error'
-              ? '⨯'
-              : ''
-        const title = `${icon} ${part.tool} ${toolTitle} ${summaryText}`
-
-        let text = title
-
-        if (outputToDisplay) {
-          text += '\n\n' + outputToDisplay
+        if (todo.status === 'completed' || todo.status === 'cancelled') {
+          statusIcon = '■'
         }
-        return text
-      }
-      return ''
-    case 'file':
-      return `📄 ${part.filename || 'File'}`
-    case 'step-start':
-    case 'step-finish':
-    case 'patch':
-      return ''
-    case 'agent':
-      return `◼︎ agent ${part.id}`
-    case 'snapshot':
-      return `◼︎ snapshot ${part.snapshot}`
-    default:
-      discordLogger.warn('Unknown part type:', part)
+        return `\`${statusIcon}\` ${todo.content}`
+      })
+      .filter(Boolean)
+      .join('\n')
+  }
+
+  return ''
+}
+
+function formatPart(part: Part): string {
+  if (part.type === 'text') {
+    return part.text || ''
+  }
+
+  if (part.type === 'reasoning') {
+    if (!part.text?.trim()) return ''
+    return `◼︎ thinking`
+  }
+
+  if (part.type === 'file') {
+    return `📄 ${part.filename || 'File'}`
+  }
+
+  if (part.type === 'step-start' || part.type === 'step-finish' || part.type === 'patch') {
+    return ''
+  }
+
+  if (part.type === 'agent') {
+    return `◼︎ agent ${part.id}`
+  }
+
+  if (part.type === 'snapshot') {
+    return `◼︎ snapshot ${part.snapshot}`
+  }
+
+  if (part.type === 'tool') {
+    if (part.state.status !== 'completed' && part.state.status !== 'error') {
       return ''
+    }
+
+    const summaryText = getToolSummaryText(part)
+    const outputToDisplay = getToolOutputToDisplay(part)
+
+    let toolTitle = part.state.status === 'completed' ? part.state.title || '' : 'error'
+    if (toolTitle) {
+      toolTitle = `\`${escapeInlineCode(toolTitle)}\``
+    }
+
+    const icon = part.state.status === 'completed' ? '◼︎' : part.state.status === 'error' ? '⨯' : ''
+    const title = `${icon} ${part.tool} ${toolTitle} ${summaryText}`
+
+    if (outputToDisplay) {
+      return title + '\n\n' + outputToDisplay
+    }
+    return title
   }
+
+  discordLogger.warn('Unknown part type:', part)
+  return ''
 }
 
 export async function createDiscordClient() {
@@ -1092,7 +1198,7 @@ async function handleOpencodeSession(
   thread: ThreadChannel,
   projectDirectory?: string,
   originalMessage?: Message,
-) {
+): 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 ? '...' : ''}"`,
   )
@@ -1118,6 +1224,10 @@ async function handleOpencodeSession(
 
   const getClient = await initializeOpencodeForDirectory(directory)
 
+  // Get the port for this directory
+  const serverEntry = opencodeServers.get(directory)
+  const port = serverEntry?.port
+
   // Get session ID from database
   const row = getDatabase()
     .prepare('SELECT session_id FROM thread_sessions WHERE thread_id = ?')
@@ -1175,10 +1285,13 @@ async function handleOpencodeSession(
   if (abortControllers.has(session.id)) {
     abortControllers.get(session.id)?.abort(new Error('new reply'))
   }
-  const promptAbortController = new AbortController()
-  abortControllers.set(session.id, promptAbortController)
+  const abortController = new AbortController()
+  // Store this controller for this session
+  abortControllers.set(session.id, abortController)
 
-  const eventsResult = await getClient().event.subscribe({})
+  const eventsResult = await getClient().event.subscribe({
+    signal: abortController.signal,
+  })
   const events = eventsResult.stream
   sessionLogger.log(`Subscribed to OpenCode events`)
 
@@ -1206,6 +1319,7 @@ async function handleOpencodeSession(
 
   let currentParts: Part[] = []
   let stopTyping: (() => void) | null = null
+  let usedModel: string | undefined
 
   const sendPartMessage = async (part: Part) => {
     const content = formatPart(part) + '\n\n'
@@ -1250,7 +1364,7 @@ async function handleOpencodeSession(
     let typingInterval: NodeJS.Timeout | null = null
 
     function startTyping(thread: ThreadChannel): () => void {
-      if (promptAbortController.signal.aborted) {
+      if (abortController.signal.aborted) {
         discordLogger.log(`Not starting typing, already aborted`)
         return () => {}
       }
@@ -1276,8 +1390,8 @@ async function handleOpencodeSession(
       }, 8000)
 
       // Only add listener if not already aborted
-      if (!promptAbortController.signal.aborted) {
-        promptAbortController.signal.addEventListener(
+      if (!abortController.signal.aborted) {
+        abortController.signal.addEventListener(
           'abort',
           () => {
             if (typingInterval) {
@@ -1319,6 +1433,10 @@ async function handleOpencodeSession(
           // Track assistant message ID
           if (msg.role === 'assistant') {
             assistantMessageId = msg.id
+
+
+            usedModel = msg.modelID
+
             voiceLogger.log(
               `[EVENT] Tracking assistant message ${assistantMessageId}`,
             )
@@ -1375,7 +1493,7 @@ async function handleOpencodeSession(
             }
             // start typing in a moment, so that if the session finished, because step-finish is at the end of the message, we do not show typing status
             setTimeout(() => {
-              if (promptAbortController.signal.aborted) return
+              if (abortController.signal.aborted) return
               stopTyping = startTyping(thread)
             }, 300)
           }
@@ -1415,6 +1533,12 @@ async function handleOpencodeSession(
         }
       }
     } catch (e) {
+      if (isAbortError(e, abortController.signal)) {
+        sessionLogger.log(
+          'AbortController aborted event handling (normal exit)',
+        )
+        return
+      }
       sessionLogger.error(`Unexpected error in event handling code`, e)
       throw e
     } finally {
@@ -1454,17 +1578,19 @@ async function handleOpencodeSession(
 
       // Only send duration message if request was not aborted or was aborted with 'finished' reason
       if (
-        !promptAbortController.signal.aborted ||
-        promptAbortController.signal.reason === 'finished'
+        !abortController.signal.aborted ||
+        abortController.signal.reason === 'finished'
       ) {
         const sessionDuration = prettyMilliseconds(
           Date.now() - sessionStartTime,
         )
-        await sendThreadMessage(thread, `_Completed in ${sessionDuration}_`)
-        sessionLogger.log(`DURATION: Session completed in ${sessionDuration}`)
+        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}`)
       } else {
         sessionLogger.log(
-          `Session was aborted (reason: ${promptAbortController.signal.reason}), skipping duration message`,
+          `Session was aborted (reason: ${abortController.signal.reason}), skipping duration message`,
         )
       }
     }
@@ -1483,14 +1609,12 @@ async function handleOpencodeSession(
       body: {
         parts: [{ type: 'text', text: prompt }],
       },
-      signal: promptAbortController.signal,
+      signal: abortController.signal,
     })
-    promptAbortController.abort(new Error('finished'))
+    abortController.abort('finished')
 
     sessionLogger.log(`Successfully sent prompt, got response`)
 
-    abortControllers.delete(session.id)
-
     // Update reaction to success
     if (originalMessage) {
       try {
@@ -1502,12 +1626,12 @@ async function handleOpencodeSession(
       }
     }
 
-    return { sessionID: session.id, result: response.data }
+    return { sessionID: session.id, result: response.data, port }
   } catch (error) {
     sessionLogger.error(`ERROR: Failed to send prompt:`, error)
 
-    if (!isAbortError(error, promptAbortController.signal)) {
-      promptAbortController.abort(new Error('error'))
+    if (!isAbortError(error, abortController.signal)) {
+      abortController.abort('error')
 
       if (originalMessage) {
         try {
@@ -1518,7 +1642,6 @@ async function handleOpencodeSession(
           discordLogger.log(`Could not update reaction:`, e)
         }
       }
-      // Always log the error's constructor name (if any) and make error reporting more readable
       const errorName =
         error &&
         typeof error === 'object' &&
@@ -1919,10 +2042,24 @@ export async function startDiscordBot({
                     .includes(focusedValue.toLowerCase()),
                 )
                 .slice(0, 25) // Discord limit
-                .map((session) => ({
-                  name: `${session.title} (${new Date(session.time.updated).toLocaleString()})`,
-                  value: session.id,
-                }))
+                .map((session) => {
+                  const dateStr = new Date(
+                    session.time.updated,
+                  ).toLocaleString()
+                  const suffix = ` (${dateStr})`
+                  // Discord limit is 100 chars. Reserve space for suffix.
+                  const maxTitleLength = 100 - suffix.length
+
+                  let title = session.title
+                  if (title.length > maxTitleLength) {
+                    title = title.slice(0, Math.max(0, maxTitleLength - 1)) + '…'
+                  }
+
+                  return {
+                    name: `${title}${suffix}`,
+                    value: session.id,
+                  }
+                })
 
               await interaction.respond(sessions)
             } catch (error) {
@@ -1994,7 +2131,6 @@ export async function startDiscordBot({
 
                 // Map to Discord autocomplete format
                 const choices = files
-                  .slice(0, 25) // Discord limit
                   .map((file: string) => {
                     const fullValue = prefix + file
                     // Get all basenames for display
@@ -2012,6 +2148,10 @@ export async function startDiscordBot({
                       value: fullValue,
                     }
                   })
+                  // Discord API limits choice value to 100 characters
+                  .filter((choice) => choice.value.length <= 100)
+                  .slice(0, 25) // Discord limit
+
 
                 await interaction.respond(choices)
               } catch (error) {
@@ -2019,6 +2159,61 @@ export async function startDiscordBot({
                 await interaction.respond([])
               }
             }
+          } else if (interaction.commandName === 'add-project') {
+            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) {
+              voiceLogger.error(
+                '[AUTOCOMPLETE] Error fetching projects:',
+                error,
+              )
+              await interaction.respond([])
+            }
           }
         }
 
@@ -2281,6 +2476,77 @@ export async function startDiscordBot({
                 `Failed to resume session: ${error instanceof Error ? error.message : 'Unknown error'}`,
               )
             }
+          } else if (command.commandName === 'add-project') {
+            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: currentAppId!,
+                })
+
+              await command.editReply(
+                `✅ Created channels for project:\n📝 Text: <#${textChannelId}>\n🔊 Voice: <#${voiceChannelId}>\n📁 Directory: \`${directory}\``,
+              )
+
+              discordLogger.log(
+                `Created channels for project ${channelName} at ${directory}`,
+              )
+            } catch (error) {
+              voiceLogger.error('[ADD-PROJECT] Error:', error)
+              await command.editReply(
+                `Failed to create channels: ${error instanceof Error ? error.message : 'Unknown error'}`,
+              )
+            }
           }
         }
       } catch (error) {