kimaki 0.4.44 → 0.4.45

package/src/commands/worktree.ts

@@ -9,10 +9,11 @@ import {
   createPendingWorktree,
   setWorktreeReady,
   setWorktreeError,
+  getChannelDirectory,
+  getThreadWorktree,
 } from '../database.js'
 import { initializeOpencodeForDirectory, getOpencodeClientV2 } from '../opencode.js'
 import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js'
-import { extractTagsArrays } from '../xml.js'
 import { createLogger } from '../logger.js'
 import { createWorktreeWithSubmodules } from '../worktree-utils.js'
 import { WORKTREE_PREFIX } from './merge-worktree.js'
@@ -30,6 +31,7 @@ class WorktreeError extends Error {
 /**
  * Format worktree name: lowercase, spaces to dashes, remove special chars, add opencode/kimaki- prefix.
  * "My Feature" → "opencode/kimaki-my-feature"
+ * Returns empty string if no valid name can be extracted.
  */
 export function formatWorktreeName(name: string): string {
   const formatted = name
@@ -38,41 +40,53 @@ export function formatWorktreeName(name: string): string {
     .replace(/\s+/g, '-')
     .replace(/[^a-z0-9-]/g, '')
 
+  if (!formatted) {
+    return ''
+  }
   return `opencode/kimaki-${formatted}`
 }
 
 /**
- * Get project directory from channel topic.
+ * Derive worktree name from thread name.
+ * Handles existing "⬦ worktree: opencode/kimaki-name" format or uses thread name directly.
+ */
+function deriveWorktreeNameFromThread(threadName: string): string {
+  // Handle existing "⬦ worktree: opencode/kimaki-name" format
+  const worktreeMatch = threadName.match(/worktree:\s*(.+)$/i)
+  const extractedName = worktreeMatch?.[1]?.trim()
+  if (extractedName) {
+    // If already has opencode/kimaki- prefix, return as is
+    if (extractedName.startsWith('opencode/kimaki-')) {
+      return extractedName
+    }
+    return formatWorktreeName(extractedName)
+  }
+  // Use thread name directly
+  return formatWorktreeName(threadName)
+}
+
+/**
+ * Get project directory from database.
  */
 function getProjectDirectoryFromChannel(
   channel: TextChannel,
   appId: string,
 ): string | WorktreeError {
-  if (!channel.topic) {
-    return new WorktreeError('This channel has no topic configured')
-  }
-
-  const extracted = extractTagsArrays({
-    xml: channel.topic,
-    tags: ['kimaki.directory', 'kimaki.app'],
-  })
+  const channelConfig = getChannelDirectory(channel.id)
 
-  const projectDirectory = extracted['kimaki.directory']?.[0]?.trim()
-  const channelAppId = extracted['kimaki.app']?.[0]?.trim()
-
-  if (channelAppId && channelAppId !== appId) {
-    return new WorktreeError('This channel is not configured for this bot')
+  if (!channelConfig) {
+    return new WorktreeError('This channel is not configured with a project directory')
   }
 
-  if (!projectDirectory) {
-    return new WorktreeError('This channel is not configured with a project directory')
+  if (channelConfig.appId && channelConfig.appId !== appId) {
+    return new WorktreeError('This channel is not configured for this bot')
   }
 
-  if (!fs.existsSync(projectDirectory)) {
-    return new WorktreeError(`Directory does not exist: ${projectDirectory}`)
+  if (!fs.existsSync(channelConfig.directory)) {
+    return new WorktreeError(`Directory does not exist: ${channelConfig.directory}`)
   }
 
-  return projectDirectory
+  return channelConfig.directory
 }
 
 /**
@@ -122,18 +136,38 @@ export async function handleNewWorktreeCommand({
 }: CommandContext): Promise<void> {
   await command.deferReply({ ephemeral: false })
 
-  const rawName = command.options.getString('name', true)
-  const worktreeName = formatWorktreeName(rawName)
+  const channel = command.channel
+  if (!channel) {
+    await command.editReply('Cannot determine channel')
+    return
+  }
 
-  if (worktreeName === 'kimaki-') {
-    await command.editReply('Invalid worktree name. Please use letters, numbers, and spaces.')
+  const isThread =
+    channel.type === ChannelType.PublicThread || channel.type === ChannelType.PrivateThread
+
+  // Handle command in existing thread - attach worktree to this thread
+  if (isThread) {
+    await handleWorktreeInThread({ command, appId, thread: channel as ThreadChannel })
     return
   }
 
-  const channel = command.channel
+  // Handle command in text channel - create new thread with worktree (existing behavior)
+  if (channel.type !== ChannelType.GuildText) {
+    await command.editReply('This command can only be used in text channels or threads')
+    return
+  }
+
+  const rawName = command.options.getString('name')
+  if (!rawName) {
+    await command.editReply(
+      'Name is required when creating a worktree from a text channel. Use `/new-worktree name:my-feature`',
+    )
+    return
+  }
 
-  if (!channel || channel.type !== ChannelType.GuildText) {
-    await command.editReply('This command can only be used in text channels')
+  const worktreeName = formatWorktreeName(rawName)
+  if (!worktreeName) {
+    await command.editReply('Invalid worktree name. Please use letters, numbers, and spaces.')
     return
   }
 
@@ -227,3 +261,102 @@ export async function handleNewWorktreeCommand({
     logger.error('[NEW-WORKTREE] Background error:', e)
   })
 }
+
+/**
+ * Handle /new-worktree when called inside an existing thread.
+ * Attaches a worktree to the current thread, using thread name if no name provided.
+ */
+async function handleWorktreeInThread({
+  command,
+  appId,
+  thread,
+}: CommandContext & { thread: ThreadChannel }): Promise<void> {
+  // Error if thread already has a worktree
+  if (getThreadWorktree(thread.id)) {
+    await command.editReply('This thread already has a worktree attached.')
+    return
+  }
+
+  // Get worktree name from parameter or derive from thread name
+  const rawName = command.options.getString('name')
+  const worktreeName = rawName ? formatWorktreeName(rawName) : deriveWorktreeNameFromThread(thread.name)
+
+  if (!worktreeName) {
+    await command.editReply('Invalid worktree name. Please provide a name or rename the thread.')
+    return
+  }
+
+  // Get parent channel for project directory
+  const parent = thread.parent
+  if (!parent || parent.type !== ChannelType.GuildText) {
+    await command.editReply('Cannot determine parent channel')
+    return
+  }
+
+  const projectDirectory = getProjectDirectoryFromChannel(parent as TextChannel, appId)
+  if (errore.isError(projectDirectory)) {
+    await command.editReply(projectDirectory.message)
+    return
+  }
+
+  // Initialize opencode
+  const getClient = await initializeOpencodeForDirectory(projectDirectory)
+  if (errore.isError(getClient)) {
+    await command.editReply(`Failed to initialize OpenCode: ${getClient.message}`)
+    return
+  }
+
+  const clientV2 = getOpencodeClientV2(projectDirectory)
+  if (!clientV2) {
+    await command.editReply('Failed to get OpenCode client')
+    return
+  }
+
+  // Check if worktree with this name already exists
+  const listResult = await errore.tryAsync({
+    try: async () => {
+      const response = await clientV2.worktree.list({ directory: projectDirectory })
+      return response.data || []
+    },
+    catch: (e) => new WorktreeError('Failed to list worktrees', { cause: e }),
+  })
+
+  if (errore.isError(listResult)) {
+    await command.editReply(listResult.message)
+    return
+  }
+
+  const existingWorktreePath = listResult.find((dir) => dir.endsWith(`/${worktreeName}`))
+  if (existingWorktreePath) {
+    await command.editReply(
+      `Worktree \`${worktreeName}\` already exists at \`${existingWorktreePath}\``,
+    )
+    return
+  }
+
+  // Store pending worktree in database for this existing thread
+  createPendingWorktree({
+    threadId: thread.id,
+    worktreeName,
+    projectDirectory,
+  })
+
+  // Send status message in thread
+  const statusMessage = await thread.send({
+    content: `🌳 **Creating worktree: ${worktreeName}**\n⏳ Setting up...`,
+    flags: SILENT_MESSAGE_FLAGS,
+  })
+
+  await command.editReply(`Creating worktree \`${worktreeName}\` for this thread...`)
+
+  // Create worktree in background
+  createWorktreeInBackground({
+    thread,
+    starterMessage: statusMessage,
+    worktreeName,
+    projectDirectory,
+    clientV2,
+  }).catch((e) => {
+    logger.error('[NEW-WORKTREE] Background error:', e)
+  })
+}

package/src/database.ts

@@ -106,6 +106,7 @@ export function getDatabase(): Database.Database {
 
     runModelMigrations(db)
     runWorktreeSettingsMigrations(db)
+    runVerbosityMigrations(db)
   }
 
   return db
@@ -358,6 +359,47 @@ export function runWorktreeSettingsMigrations(database?: Database.Database): voi
   dbLogger.log('Channel worktree settings migrations complete')
 }
 
+// Verbosity levels for controlling output detail
+export type VerbosityLevel = 'tools-and-text' | 'text-only'
+
+export function runVerbosityMigrations(database?: Database.Database): void {
+  const targetDb = database || getDatabase()
+
+  targetDb.exec(`
+    CREATE TABLE IF NOT EXISTS channel_verbosity (
+      channel_id TEXT PRIMARY KEY,
+      verbosity TEXT NOT NULL DEFAULT 'tools-and-text',
+      updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    )
+  `)
+
+  dbLogger.log('Channel verbosity settings migrations complete')
+}
+
+/**
+ * Get the verbosity setting for a channel.
+ * @returns 'tools-and-text' (default) or 'text-only'
+ */
+export function getChannelVerbosity(channelId: string): VerbosityLevel {
+  const db = getDatabase()
+  const row = db
+    .prepare('SELECT verbosity FROM channel_verbosity WHERE channel_id = ?')
+    .get(channelId) as { verbosity: string } | undefined
+  return (row?.verbosity as VerbosityLevel) || 'tools-and-text'
+}
+
+/**
+ * Set the verbosity setting for a channel.
+ */
+export function setChannelVerbosity(channelId: string, verbosity: VerbosityLevel): void {
+  const db = getDatabase()
+  db.prepare(
+    `INSERT INTO channel_verbosity (channel_id, verbosity, updated_at) 
+     VALUES (?, ?, CURRENT_TIMESTAMP)
+     ON CONFLICT(channel_id) DO UPDATE SET verbosity = ?, updated_at = CURRENT_TIMESTAMP`,
+  ).run(channelId, verbosity, verbosity)
+}
+
 /**
  * Check if automatic worktree creation is enabled for a channel.
  */
@@ -381,6 +423,29 @@ export function setChannelWorktreesEnabled(channelId: string, enabled: boolean):
   ).run(channelId, enabled ? 1 : 0, enabled ? 1 : 0)
 }
 
+/**
+ * Get the directory and app_id for a channel from the database.
+ * This is the single source of truth for channel-project mappings.
+ */
+export function getChannelDirectory(channelId: string): {
+  directory: string
+  appId: string | null
+} | undefined {
+  const db = getDatabase()
+  const row = db
+    .prepare('SELECT directory, app_id FROM channel_directories WHERE channel_id = ?')
+    .get(channelId) as { directory: string; app_id: string | null } | undefined
+
+  if (!row) {
+    return undefined
+  }
+
+  return {
+    directory: row.directory,
+    appId: row.app_id,
+  }
+}
+
 export function closeDatabase(): void {
   if (db) {
     db.close()

package/src/discord-bot.ts

@@ -10,6 +10,7 @@ import {
   setWorktreeReady,
   setWorktreeError,
   getChannelWorktreesEnabled,
+  getChannelDirectory,
 } from './database.js'
 import { initializeOpencodeForDirectory, getOpencodeServers, getOpencodeClientV2 } from './opencode.js'
 import { formatWorktreeName } from './commands/worktree.js'
@@ -39,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'
@@ -65,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'
 
@@ -211,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
@@ -238,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})`)
           }
         }
 
@@ -374,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})`,
@@ -566,25 +558,17 @@ export async function startDiscordBot({
         return
       }
 
-      // Extract directory from parent channel topic
-      if (!parent.topic) {
-        discordLogger.log(`[BOT_SESSION] Parent channel has no topic`)
-        return
-      }
+      // Get directory from database
+      const channelConfig = getChannelDirectory(parent.id)
 
-      const extracted = extractTagsArrays({
-        xml: parent.topic,
-        tags: ['kimaki.directory', 'kimaki.app'],
-      })
-
-      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

@@ -31,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')
@@ -156,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)