kimaki 0.4.43 → 0.4.45

package/src/discord-bot.ts

@@ -2,8 +2,20 @@
 // Bridges Discord messages to OpenCode sessions, manages voice connections,
 // and orchestrates the main event loop for the Kimaki bot.
 
-import { getDatabase, closeDatabase, getThreadWorktree } from './database.js'
-import { initializeOpencodeForDirectory, getOpencodeServers } from './opencode.js'
+import {
+  getDatabase,
+  closeDatabase,
+  getThreadWorktree,
+  createPendingWorktree,
+  setWorktreeReady,
+  setWorktreeError,
+  getChannelWorktreesEnabled,
+  getChannelDirectory,
+} from './database.js'
+import { initializeOpencodeForDirectory, getOpencodeServers, getOpencodeClientV2 } from './opencode.js'
+import { formatWorktreeName } from './commands/worktree.js'
+import { WORKTREE_PREFIX } from './commands/merge-worktree.js'
+import { createWorktreeWithSubmodules } from './worktree-utils.js'
 import {
   escapeBackticksInCodeBlocks,
   splitMarkdownForDiscord,
@@ -28,7 +40,7 @@ import { getCompactSessionContext, getLastSessionId } from './markdown.js'
 import { handleOpencodeSession } from './session-handler.js'
 import { registerInteractionHandler } from './interaction-handler.js'
 
-export { getDatabase, closeDatabase } from './database.js'
+export { getDatabase, closeDatabase, getChannelDirectory } from './database.js'
 export { initializeOpencodeForDirectory } from './opencode.js'
 export { escapeBackticksInCodeBlocks, splitMarkdownForDiscord } from './discord-utils.js'
 export { getOpencodeSystemMessage } from './system-message.js'
@@ -54,7 +66,6 @@ import {
 } from 'discord.js'
 import fs from 'node:fs'
 import * as errore from 'errore'
-import { extractTagsArrays } from './xml.js'
 import { createLogger } from './logger.js'
 import { setGlobalDispatcher, Agent } from 'undici'
 
@@ -69,6 +80,8 @@ const voiceLogger = createLogger('VOICE')
 type StartOptions = {
   token: string
   appId?: string
+  /** When true, all new sessions from channel messages create git worktrees */
+  useWorktrees?: boolean
 }
 
 export async function createDiscordClient() {
@@ -87,6 +100,7 @@ export async function startDiscordBot({
   token,
   appId,
   discordClient,
+  useWorktrees,
 }: StartOptions & { discordClient?: Client }) {
   if (!discordClient) {
     discordClient = await createDiscordClient()
@@ -197,14 +211,12 @@ export async function startDiscordBot({
         let projectDirectory: string | undefined
         let channelAppId: string | undefined
 
-        if (parent?.topic) {
-          const extracted = extractTagsArrays({
-            xml: parent.topic,
-            tags: ['kimaki.directory', 'kimaki.app'],
-          })
-
-          projectDirectory = extracted['kimaki.directory']?.[0]?.trim()
-          channelAppId = extracted['kimaki.app']?.[0]?.trim()
+        if (parent) {
+          const channelConfig = getChannelDirectory(parent.id)
+          if (channelConfig) {
+            projectDirectory = channelConfig.directory
+            channelAppId = channelConfig.appId || undefined
+          }
         }
 
         // Check if this thread is a worktree thread
@@ -224,9 +236,11 @@ export async function startDiscordBot({
             })
             return
           }
-          if (worktreeInfo.worktree_directory) {
-            projectDirectory = worktreeInfo.worktree_directory
-            discordLogger.log(`Using worktree directory: ${projectDirectory}`)
+          // Use original project directory for OpenCode server (session lives there)
+          // The worktree directory is passed via query.directory in prompt/command calls
+          if (worktreeInfo.project_directory) {
+            projectDirectory = worktreeInfo.project_directory
+            discordLogger.log(`Using project directory: ${projectDirectory} (worktree: ${worktreeInfo.worktree_directory})`)
           }
         }
 
@@ -360,24 +374,16 @@ export async function startDiscordBot({
           `[GUILD_TEXT] Message in text channel #${textChannel.name} (${textChannel.id})`,
         )
 
-        if (!textChannel.topic) {
-          voiceLogger.log(`[IGNORED] Channel #${textChannel.name} has no description`)
-          return
-        }
-
-        const extracted = extractTagsArrays({
-          xml: textChannel.topic,
-          tags: ['kimaki.directory', 'kimaki.app'],
-        })
-
-        const projectDirectory = extracted['kimaki.directory']?.[0]?.trim()
-        const channelAppId = extracted['kimaki.app']?.[0]?.trim()
+        const channelConfig = getChannelDirectory(textChannel.id)
 
-        if (!projectDirectory) {
-          voiceLogger.log(`[IGNORED] Channel #${textChannel.name} has no kimaki.directory tag`)
+        if (!channelConfig) {
+          voiceLogger.log(`[IGNORED] Channel #${textChannel.name} has no project directory configured`)
           return
         }
 
+        const projectDirectory = channelConfig.directory
+        const channelAppId = channelConfig.appId || undefined
+
         if (channelAppId && channelAppId !== currentAppId) {
           voiceLogger.log(
             `[IGNORED] Channel belongs to different bot app (expected: ${currentAppId}, got: ${channelAppId})`,
@@ -401,10 +407,18 @@ export async function startDiscordBot({
 
         const hasVoice = message.attachments.some((a) => a.contentType?.startsWith('audio/'))
 
-        const threadName = hasVoice
+        const baseThreadName = hasVoice
           ? 'Voice Message'
           : message.content?.replace(/\s+/g, ' ').trim() || 'Claude Thread'
 
+        // Check if worktrees should be enabled (CLI flag OR channel setting)
+        const shouldUseWorktrees = useWorktrees || getChannelWorktreesEnabled(textChannel.id)
+
+        // Add worktree prefix if worktrees are enabled
+        const threadName = shouldUseWorktrees
+          ? `${WORKTREE_PREFIX}${baseThreadName}`
+          : baseThreadName
+
         const thread = await message.startThread({
           name: threadName.slice(0, 80),
           autoArchiveDuration: ThreadAutoArchiveDuration.OneDay,
@@ -413,12 +427,65 @@ export async function startDiscordBot({
 
         discordLogger.log(`Created thread "${thread.name}" (${thread.id})`)
 
+        // Create worktree if worktrees are enabled (CLI flag OR channel setting)
+        let sessionDirectory = projectDirectory
+        if (shouldUseWorktrees) {
+          const worktreeName = formatWorktreeName(
+            hasVoice ? `voice-${Date.now()}` : threadName.slice(0, 50),
+          )
+          discordLogger.log(`[WORKTREE] Creating worktree: ${worktreeName}`)
+
+          // Store pending worktree immediately so bot knows about it
+          createPendingWorktree({
+            threadId: thread.id,
+            worktreeName,
+            projectDirectory,
+          })
+
+          // Initialize OpenCode and create worktree
+          const getClient = await initializeOpencodeForDirectory(projectDirectory)
+          if (getClient instanceof Error) {
+            discordLogger.error(`[WORKTREE] Failed to init OpenCode: ${getClient.message}`)
+            setWorktreeError({ threadId: thread.id, errorMessage: getClient.message })
+            await thread.send({
+              content: `⚠️ Failed to create worktree: ${getClient.message}\nUsing main project directory instead.`,
+              flags: SILENT_MESSAGE_FLAGS,
+            })
+          } else {
+            const clientV2 = getOpencodeClientV2(projectDirectory)
+            if (!clientV2) {
+              discordLogger.error(`[WORKTREE] No v2 client for ${projectDirectory}`)
+              setWorktreeError({ threadId: thread.id, errorMessage: 'No OpenCode v2 client' })
+            } else {
+              const worktreeResult = await createWorktreeWithSubmodules({
+                clientV2,
+                directory: projectDirectory,
+                name: worktreeName,
+              })
+
+              if (worktreeResult instanceof Error) {
+                const errMsg = worktreeResult.message
+                discordLogger.error(`[WORKTREE] Creation failed: ${errMsg}`)
+                setWorktreeError({ threadId: thread.id, errorMessage: errMsg })
+                await thread.send({
+                  content: `⚠️ Failed to create worktree: ${errMsg}\nUsing main project directory instead.`,
+                  flags: SILENT_MESSAGE_FLAGS,
+                })
+              } else {
+                setWorktreeReady({ threadId: thread.id, worktreeDirectory: worktreeResult.directory })
+                sessionDirectory = worktreeResult.directory
+                discordLogger.log(`[WORKTREE] Created: ${worktreeResult.directory} (branch: ${worktreeResult.branch})`)
+              }
+            }
+          }
+        }
+
         let messageContent = message.content || ''
 
         const transcription = await processVoiceAttachment({
           message,
           thread,
-          projectDirectory,
+          projectDirectory: sessionDirectory,
           isNewThread: true,
           appId: currentAppId,
         })
@@ -434,7 +501,7 @@ export async function startDiscordBot({
         await handleOpencodeSession({
           prompt: promptWithAttachments,
           thread,
-          projectDirectory,
+          projectDirectory: sessionDirectory,
           originalMessage: message,
           images: fileAttachments,
           channelId: textChannel.id,
@@ -454,65 +521,54 @@ export async function startDiscordBot({
   })
 
   // Handle bot-initiated threads created by `kimaki send` (without --notify-only)
+  // Uses embed marker instead of database to avoid race conditions
+  const AUTO_START_MARKER = 'kimaki:start'
   discordClient.on(Events.ThreadCreate, async (thread, newlyCreated) => {
     try {
       if (!newlyCreated) {
         return
       }
 
-      // Check if this thread is marked for auto-start in the database
-      const db = getDatabase()
-      const pendingRow = db
-        .prepare('SELECT thread_id FROM pending_auto_start WHERE thread_id = ?')
-        .get(thread.id) as { thread_id: string } | undefined
-
-      if (!pendingRow) {
-        return // Not a CLI-initiated auto-start thread
-      }
-
-      // Remove from pending table
-      db.prepare('DELETE FROM pending_auto_start WHERE thread_id = ?').run(thread.id)
-
-      discordLogger.log(`[BOT_SESSION] Detected bot-initiated thread: ${thread.name}`)
-
       // Only handle threads in text channels
       const parent = thread.parent as TextChannel | null
       if (!parent || parent.type !== ChannelType.GuildText) {
         return
       }
 
-      // Get the starter message for the prompt
+      // Get the starter message to check for auto-start marker
       const starterMessage = await thread.fetchStarterMessage().catch(() => null)
       if (!starterMessage) {
         discordLogger.log(`[THREAD_CREATE] Could not fetch starter message for thread ${thread.id}`)
         return
       }
 
+      // Check if starter message has the auto-start embed marker
+      const hasAutoStartMarker = starterMessage.embeds.some(
+        (embed) => embed.footer?.text === AUTO_START_MARKER,
+      )
+      if (!hasAutoStartMarker) {
+        return // Not a CLI-initiated auto-start thread
+      }
+
+      discordLogger.log(`[BOT_SESSION] Detected bot-initiated thread: ${thread.name}`)
+
       const prompt = starterMessage.content.trim()
       if (!prompt) {
         discordLogger.log(`[BOT_SESSION] No prompt found in starter message`)
         return
       }
 
-      // Extract directory from parent channel topic
-      if (!parent.topic) {
-        discordLogger.log(`[BOT_SESSION] Parent channel has no topic`)
-        return
-      }
-
-      const extracted = extractTagsArrays({
-        xml: parent.topic,
-        tags: ['kimaki.directory', 'kimaki.app'],
-      })
+      // Get directory from database
+      const channelConfig = getChannelDirectory(parent.id)
 
-      const projectDirectory = extracted['kimaki.directory']?.[0]?.trim()
-      const channelAppId = extracted['kimaki.app']?.[0]?.trim()
-
-      if (!projectDirectory) {
-        discordLogger.log(`[BOT_SESSION] No kimaki.directory in parent channel topic`)
+      if (!channelConfig) {
+        discordLogger.log(`[BOT_SESSION] No project directory configured for parent channel`)
         return
       }
 
+      const projectDirectory = channelConfig.directory
+      const channelAppId = channelConfig.appId || undefined
+
       if (channelAppId && channelAppId !== currentAppId) {
         discordLogger.log(`[BOT_SESSION] Channel belongs to different bot app`)
         return

package/src/discord-utils.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, test } from 'vitest'
+import { splitMarkdownForDiscord } from './discord-utils.js'
+
+describe('splitMarkdownForDiscord', () => {
+  test('never returns chunks over the max length with code fences', () => {
+    const maxLength = 2000
+    const header = '## Summary of Current Architecture\n\n'
+    const codeFenceStart = '```\n'
+    const codeFenceEnd = '\n```\n'
+    const codeLine = 'x'.repeat(180)
+    const codeBlock = Array.from({ length: 20 })
+      .map(() => codeLine)
+      .join('\n')
+    const markdown = `${header}${codeFenceStart}${codeBlock}${codeFenceEnd}`
+
+    const chunks = splitMarkdownForDiscord({ content: markdown, maxLength })
+
+    expect(chunks.length).toBeGreaterThan(1)
+    for (const chunk of chunks) {
+      expect(chunk.length).toBeLessThanOrEqual(maxLength)
+    }
+  })
+})

package/src/discord-utils.ts

@@ -4,8 +4,8 @@
 
 import { ChannelType, type Message, type TextChannel, type ThreadChannel } from 'discord.js'
 import { Lexer } from 'marked'
-import { extractTagsArrays } from './xml.js'
 import { formatMarkdownTables } from './format-tables.js'
+import { getChannelDirectory } from './database.js'
 import { limitHeadingDepth } from './limit-heading-depth.js'
 import { unnestCodeBlocksFromLists } from './unnest-code-blocks.js'
 import { createLogger } from './logger.js'
@@ -132,8 +132,18 @@ export function splitMarkdownForDiscord({
     return pieces
   }
 
+  const closingFence = '```\n'
+
   for (const line of lines) {
-    const wouldExceed = currentChunk.length + line.text.length > maxLength
+    const openingFenceSize =
+      currentChunk.length === 0 && (line.inCodeBlock || line.isOpeningFence)
+        ? ('```' + line.lang + '\n').length
+        : 0
+    const lineLength = line.isOpeningFence ? 0 : line.text.length
+    const activeFenceOverhead =
+      currentLang !== null || openingFenceSize > 0 ? closingFence.length : 0
+    const wouldExceed =
+      currentChunk.length + openingFenceSize + lineLength + activeFenceOverhead > maxLength
 
     if (wouldExceed) {
       // handle case where single line is longer than maxLength
@@ -195,9 +205,34 @@ export function splitMarkdownForDiscord({
         }
       } else {
         // currentChunk is empty but line still exceeds - shouldn't happen after above check
-        currentChunk = line.text
-        if (line.inCodeBlock || line.isOpeningFence) {
-          currentLang = line.lang
+        const openingFence = line.inCodeBlock || line.isOpeningFence
+        const openingFenceSize = openingFence ? ('```' + line.lang + '\n').length : 0
+        if (line.text.length + openingFenceSize + activeFenceOverhead > maxLength) {
+          const fencedOverhead = openingFence
+            ? ('```' + line.lang + '\n').length + closingFence.length
+            : 0
+          const availablePerChunk = Math.max(10, maxLength - fencedOverhead - 50)
+          const pieces = splitLongLine(line.text, availablePerChunk, line.inCodeBlock)
+          for (const piece of pieces) {
+            if (openingFence) {
+              chunks.push('```' + line.lang + '\n' + piece + closingFence)
+            } else {
+              chunks.push(piece)
+            }
+          }
+          currentChunk = ''
+          currentLang = null
+        } else {
+          if (openingFence) {
+            currentChunk = '```' + line.lang + '\n'
+            if (!line.isOpeningFence) {
+              currentChunk += line.text
+            }
+            currentLang = line.lang
+          } else {
+            currentChunk = line.text
+            currentLang = null
+          }
         }
       }
     } else {
@@ -211,6 +246,9 @@ export function splitMarkdownForDiscord({
   }
 
   if (currentChunk) {
+    if (currentLang !== null) {
+      currentChunk += closingFence
+    }
     chunks.push(currentChunk)
   }
 
@@ -291,19 +329,20 @@ export function getKimakiMetadata(textChannel: TextChannel | null): {
   projectDirectory?: string
   channelAppId?: string
 } {
-  if (!textChannel?.topic) {
+  if (!textChannel) {
     return {}
   }
 
-  const extracted = extractTagsArrays({
-    xml: textChannel.topic,
-    tags: ['kimaki.directory', 'kimaki.app'],
-  })
+  const channelConfig = getChannelDirectory(textChannel.id)
 
-  const projectDirectory = extracted['kimaki.directory']?.[0]?.trim()
-  const channelAppId = extracted['kimaki.app']?.[0]?.trim()
+  if (!channelConfig) {
+    return {}
+  }
 
-  return { projectDirectory, channelAppId }
+  return {
+    projectDirectory: channelConfig.directory,
+    channelAppId: channelConfig.appId || undefined,
+  }
 }
 
 /**

package/src/escape-backticks.test.ts

@@ -194,11 +194,17 @@ test('splitMarkdownForDiscord adds closing and opening fences when splitting cod
     [
       "\`\`\`js
     line1
+    \`\`\`
+    ",
+      "\`\`\`js
     line2
     \`\`\`
     ",
       "\`\`\`js
     line3
+    \`\`\`
+    ",
+      "\`\`\`js
     line4
     \`\`\`
     ",
@@ -234,10 +240,12 @@ test('splitMarkdownForDiscord handles mixed content with code blocks', () => {
     [
       "Text before
     \`\`\`js
-    code
     \`\`\`
     ",
-      "Text after",
+      "\`\`\`js
+    code
+    \`\`\`
+    Text after",
     ]
   `)
 })
@@ -250,6 +258,9 @@ test('splitMarkdownForDiscord handles code block without language', () => {
   expect(result).toMatchInlineSnapshot(`
     [
       "\`\`\`
+    \`\`\`
+    ",
+      "\`\`\`
     line1
     \`\`\`
     ",
@@ -437,10 +448,10 @@ And here is some text after the code block.`
 
     export function formatCurrency(amount: number): string {
       return new Intl.NumberFormat('en-US', {
-        style: 'currency',
     \`\`\`
     ",
       "\`\`\`typescript
+        style: 'currency',
         currency: 'USD',
       }).format(amount)
     }

package/src/interaction-handler.ts

@@ -5,6 +5,11 @@
 import { Events, type Client, type Interaction } from 'discord.js'
 import { handleSessionCommand, handleSessionAutocomplete } from './commands/session.js'
 import { handleNewWorktreeCommand } from './commands/worktree.js'
+import { handleMergeWorktreeCommand } from './commands/merge-worktree.js'
+import {
+  handleEnableWorktreesCommand,
+  handleDisableWorktreesCommand,
+} from './commands/worktree-settings.js'
 import { handleResumeCommand, handleResumeAutocomplete } from './commands/resume.js'
 import { handleAddProjectCommand, handleAddProjectAutocomplete } from './commands/add-project.js'
 import {
@@ -26,6 +31,7 @@ import { handleAskQuestionSelectMenu } from './commands/ask-question.js'
 import { handleQueueCommand, handleClearQueueCommand } from './commands/queue.js'
 import { handleUndoCommand, handleRedoCommand } from './commands/undo-redo.js'
 import { handleUserCommand } from './commands/user-command.js'
+import { handleVerbosityCommand } from './commands/verbosity.js'
 import { createLogger } from './logger.js'
 
 const interactionLogger = createLogger('INTERACTION')
@@ -87,6 +93,18 @@ export function registerInteractionHandler({
             await handleNewWorktreeCommand({ command: interaction, appId })
             return
 
+          case 'merge-worktree':
+            await handleMergeWorktreeCommand({ command: interaction, appId })
+            return
+
+          case 'enable-worktrees':
+            await handleEnableWorktreesCommand({ command: interaction, appId })
+            return
+
+          case 'disable-worktrees':
+            await handleDisableWorktreesCommand({ command: interaction, appId })
+            return
+
           case 'resume':
             await handleResumeCommand({ command: interaction, appId })
             return
@@ -139,6 +157,10 @@ export function registerInteractionHandler({
           case 'redo':
             await handleRedoCommand({ command: interaction, appId })
             return
+
+          case 'verbosity':
+            await handleVerbosityCommand({ command: interaction, appId })
+            return
         }
 
         // Handle quick agent commands (ending with -agent suffix, but not the base /agent command)