kimaki 0.4.2 → 0.4.6

package/src/discordBot.ts

@@ -3,6 +3,7 @@ import {
   type OpencodeClient,
   type Part,
   type Config,
+  type FilePartInput,
 } from '@opencode-ai/sdk'
 
 import { createGenAIWorker, type GenAIWorker } from './genai-worker-wrapper.js'
@@ -16,6 +17,7 @@ import {
   Partials,
   PermissionsBitField,
   ThreadAutoArchiveDuration,
+  type CategoryChannel,
   type Guild,
   type Interaction,
   type Message,
@@ -459,7 +461,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 +474,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 +520,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 +620,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 +814,37 @@ async function processVoiceAttachment({
   return transcription
 }
 
+function getImageAttachments(message: Message): FilePartInput[] {
+  const imageAttachments = Array.from(message.attachments.values()).filter(
+    (attachment) => attachment.contentType?.startsWith('image/'),
+  )
+
+  return imageAttachments.map((attachment) => ({
+    type: 'file' as const,
+    mime: attachment.contentType || 'image/png',
+    filename: attachment.name,
+    url: attachment.url,
+  }))
+}
+
+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 +1048,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})` : ''
+  }
 
-        let toolTitle =
-          part.state.status === 'completed' ? part.state.title || '' : 'error'
-        if (toolTitle) {
-          toolTitle = `\`${escapeInlineCode(toolTitle)}\``
+  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'
+  }
+
+  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 = `*${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() {
@@ -1087,12 +1207,19 @@ export async function createDiscordClient() {
   })
 }
 
-async function handleOpencodeSession(
-  prompt: string,
-  thread: ThreadChannel,
-  projectDirectory?: string,
-  originalMessage?: Message,
-) {
+async function handleOpencodeSession({
+  prompt,
+  thread,
+  projectDirectory,
+  originalMessage,
+  images = [],
+}: {
+  prompt: string
+  thread: ThreadChannel
+  projectDirectory?: string
+  originalMessage?: Message
+  images?: FilePartInput[]
+}): 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 +1245,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 = ?')
@@ -1209,6 +1340,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'
@@ -1322,6 +1454,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}`,
             )
@@ -1469,8 +1605,10 @@ async function handleOpencodeSession(
         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: ${abortController.signal.reason}), skipping duration message`,
@@ -1483,23 +1621,27 @@ async function handleOpencodeSession(
     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)
+
     const response = await getClient().session.prompt({
       path: { id: session.id },
       body: {
-        parts: [{ type: 'text', text: prompt }],
+        parts,
       },
       signal: abortController.signal,
     })
-    abortController.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 {
@@ -1511,12 +1653,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, abortController.signal)) {
-      abortController.abort(new Error('error'))
+      abortController.abort('error')
 
       if (originalMessage) {
         try {
@@ -1527,7 +1669,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' &&
@@ -1760,12 +1901,14 @@ export async function startDiscordBot({
           messageContent = transcription
         }
 
-        await handleOpencodeSession(
-          messageContent,
+        const images = getImageAttachments(message)
+        await handleOpencodeSession({
+          prompt: messageContent,
           thread,
           projectDirectory,
-          message,
-        )
+          originalMessage: message,
+          images,
+        })
         return
       }
 
@@ -1853,12 +1996,14 @@ export async function startDiscordBot({
           messageContent = transcription
         }
 
-        await handleOpencodeSession(
-          messageContent,
+        const images = getImageAttachments(message)
+        await handleOpencodeSession({
+          prompt: messageContent,
           thread,
           projectDirectory,
-          message,
-        )
+          originalMessage: message,
+          images,
+        })
       } else {
         discordLogger.log(`Channel type ${channel.type} is not supported`)
       }
@@ -1928,10 +2073,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) {
@@ -2003,7 +2162,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
@@ -2021,6 +2179,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) {
@@ -2028,6 +2190,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([])
+            }
           }
         }
 
@@ -2121,7 +2338,11 @@ export async function startDiscordBot({
               )
 
               // Start the OpenCode session
-              await handleOpencodeSession(fullPrompt, thread, projectDirectory)
+              await handleOpencodeSession({
+                prompt: fullPrompt,
+                thread,
+                projectDirectory,
+              })
             } catch (error) {
               voiceLogger.error('[SESSION] Error:', error)
               await command.editReply(
@@ -2260,22 +2481,39 @@ export async function startDiscordBot({
                   }
                 } else if (message.info.role === 'assistant') {
                   // Render assistant parts
+                  const partsToRender: { id: string; content: string }[] = []
+
                   for (const part of message.parts) {
                     const content = formatPart(part)
                     if (content.trim()) {
-                      const discordMessage = await sendThreadMessage(
-                        thread,
-                        content,
-                      )
-
-                      // Store part-message mapping in database
-                      getDatabase()
-                        .prepare(
-                          'INSERT OR REPLACE INTO part_messages (part_id, message_id, thread_id) VALUES (?, ?, ?)',
-                        )
-                        .run(part.id, discordMessage.id, thread.id)
+                      partsToRender.push({ id: part.id, content })
                     }
                   }
+
+                  if (partsToRender.length > 0) {
+                    const combinedContent = partsToRender
+                      .map((p) => p.content)
+                      .join('\n\n')
+
+                    const discordMessage = await sendThreadMessage(
+                      thread,
+                      combinedContent,
+                    )
+
+                    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)
+                  }
                 }
                 messageCount++
               }
@@ -2290,6 +2528,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) {