kimaki 0.4.39 → 0.4.41

package/src/commands/worktree.ts

@@ -0,0 +1,243 @@
+// Worktree management command: /new-worktree
+// Uses OpenCode SDK v2 to create worktrees with kimaki- prefix
+// Creates thread immediately, then worktree in background so user can type
+
+import { ChannelType, type TextChannel, type ThreadChannel, type Message } from 'discord.js'
+import fs from 'node:fs'
+import type { CommandContext } from './types.js'
+import {
+  createPendingWorktree,
+  setWorktreeReady,
+  setWorktreeError,
+} 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 * as errore from 'errore'
+
+const logger = createLogger('WORKTREE')
+
+class WorktreeError extends Error {
+  constructor(message: string, options?: { cause?: unknown }) {
+    super(message, options)
+    this.name = 'WorktreeError'
+  }
+}
+
+/**
+ * Format worktree name: lowercase, spaces to dashes, remove special chars, add kimaki- prefix.
+ * "My Feature" → "kimaki-my-feature"
+ */
+function formatWorktreeName(name: string): string {
+  const formatted = name
+    .toLowerCase()
+    .trim()
+    .replace(/\s+/g, '-')
+    .replace(/[^a-z0-9-]/g, '')
+
+  return `kimaki-${formatted}`
+}
+
+/**
+ * Get project directory from channel topic.
+ */
+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 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 (!projectDirectory) {
+    return new WorktreeError('This channel is not configured with a project directory')
+  }
+
+  if (!fs.existsSync(projectDirectory)) {
+    return new WorktreeError(`Directory does not exist: ${projectDirectory}`)
+  }
+
+  return projectDirectory
+}
+
+/**
+ * Create worktree in background and update starter message when done.
+ */
+async function createWorktreeInBackground({
+  thread,
+  starterMessage,
+  worktreeName,
+  projectDirectory,
+  clientV2,
+}: {
+  thread: ThreadChannel
+  starterMessage: Message
+  worktreeName: string
+  projectDirectory: string
+  clientV2: ReturnType<typeof getOpencodeClientV2> & {}
+}): Promise<void> {
+  // Create worktree using SDK v2
+  logger.log(`Creating worktree "${worktreeName}" for project ${projectDirectory}`)
+  const worktreeResult = await errore.tryAsync({
+    try: async () => {
+      const response = await clientV2.worktree.create({
+        directory: projectDirectory,
+        worktreeCreateInput: {
+          name: worktreeName,
+        },
+      })
+
+      if (response.error) {
+        throw new Error(`SDK error: ${JSON.stringify(response.error)}`)
+      }
+
+      if (!response.data) {
+        throw new Error('No worktree data returned from SDK')
+      }
+
+      return response.data
+    },
+    catch: (e) => new WorktreeError('Failed to create worktree', { cause: e }),
+  })
+
+  if (errore.isError(worktreeResult)) {
+    const errorMsg = worktreeResult.message
+    logger.error('[NEW-WORKTREE] Error:', worktreeResult.cause)
+    setWorktreeError({ threadId: thread.id, errorMessage: errorMsg })
+    await starterMessage.edit(`🌳 **Worktree: ${worktreeName}**\n❌ ${errorMsg}`)
+    return
+  }
+
+  // Success - update database and edit starter message
+  setWorktreeReady({ threadId: thread.id, worktreeDirectory: worktreeResult.directory })
+  await starterMessage.edit(
+    `🌳 **Worktree: ${worktreeName}**\n` +
+    `📁 \`${worktreeResult.directory}\`\n` +
+    `🌿 Branch: \`${worktreeResult.branch}\``
+  )
+}
+
+export async function handleNewWorktreeCommand({
+  command,
+  appId,
+}: CommandContext): Promise<void> {
+  await command.deferReply({ ephemeral: false })
+
+  const rawName = command.options.getString('name', true)
+  const worktreeName = formatWorktreeName(rawName)
+
+  if (worktreeName === 'kimaki-') {
+    await command.editReply('Invalid worktree name. Please use letters, numbers, and spaces.')
+    return
+  }
+
+  const channel = command.channel
+
+  if (!channel || channel.type !== ChannelType.GuildText) {
+    await command.editReply('This command can only be used in text channels')
+    return
+  }
+
+  const textChannel = channel as TextChannel
+
+  const projectDirectory = getProjectDirectoryFromChannel(textChannel, appId)
+  if (errore.isError(projectDirectory)) {
+    await command.editReply(projectDirectory.message)
+    return
+  }
+
+  // Initialize opencode and check if worktree already exists
+  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
+  // SDK returns array of directory paths like "~/.opencode/worktree/abc/kimaki-my-feature"
+  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
+  }
+
+  // Check if any worktree path ends with our name
+  const existingWorktree = listResult.find((dir) => dir.endsWith(`/${worktreeName}`))
+  if (existingWorktree) {
+    await command.editReply(`Worktree \`${worktreeName}\` already exists at \`${existingWorktree}\``)
+    return
+  }
+
+  // Create thread immediately so user can start typing
+  const result = await errore.tryAsync({
+    try: async () => {
+      const starterMessage = await textChannel.send({
+        content: `🌳 **Creating worktree: ${worktreeName}**\n⏳ Setting up...`,
+        flags: SILENT_MESSAGE_FLAGS,
+      })
+
+      const thread = await starterMessage.startThread({
+        name: `worktree: ${worktreeName}`,
+        autoArchiveDuration: 1440,
+        reason: 'Worktree session',
+      })
+
+      return { thread, starterMessage }
+    },
+    catch: (e) => new WorktreeError('Failed to create thread', { cause: e }),
+  })
+
+  if (errore.isError(result)) {
+    logger.error('[NEW-WORKTREE] Error:', result.cause)
+    await command.editReply(result.message)
+    return
+  }
+
+  const { thread, starterMessage } = result
+
+  // Store pending worktree in database
+  createPendingWorktree({
+    threadId: thread.id,
+    worktreeName,
+    projectDirectory,
+  })
+
+  await command.editReply(`Creating worktree in ${thread.toString()}`)
+
+  // Create worktree in background (don't await)
+  createWorktreeInBackground({
+    thread,
+    starterMessage,
+    worktreeName,
+    projectDirectory,
+    clientV2,
+  }).catch((e) => {
+    logger.error('[NEW-WORKTREE] Background error:', e)
+  })
+}

package/src/database.ts

@@ -23,7 +23,7 @@ export function getDatabase(): Database.Database {
       },
       catch: (e) => e as Error,
     })
-    if (errore.isError(mkdirError)) {
+    if (mkdirError instanceof Error) {
       dbLogger.error(`Failed to create data directory ${dataDir}:`, mkdirError.message)
     }
 
@@ -90,6 +90,20 @@ export function getDatabase(): Database.Database {
       )
     `)
 
+    // Track worktrees created for threads (for /new-worktree command)
+    // status: 'pending' while creating, 'ready' when done, 'error' if failed
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS thread_worktrees (
+        thread_id TEXT PRIMARY KEY,
+        worktree_name TEXT NOT NULL,
+        worktree_directory TEXT,
+        project_directory TEXT NOT NULL,
+        status TEXT DEFAULT 'pending',
+        error_message TEXT,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `)
+
     runModelMigrations(db)
   }
 
@@ -243,6 +257,87 @@ export function setSessionAgent(sessionId: string, agentName: string): void {
   )
 }
 
+// Worktree status types
+export type WorktreeStatus = 'pending' | 'ready' | 'error'
+
+export type ThreadWorktree = {
+  thread_id: string
+  worktree_name: string
+  worktree_directory: string | null
+  project_directory: string
+  status: WorktreeStatus
+  error_message: string | null
+}
+
+/**
+ * Get the worktree info for a thread.
+ */
+export function getThreadWorktree(threadId: string): ThreadWorktree | undefined {
+  const db = getDatabase()
+  return db.prepare('SELECT * FROM thread_worktrees WHERE thread_id = ?').get(threadId) as
+    | ThreadWorktree
+    | undefined
+}
+
+/**
+ * Create a pending worktree entry for a thread.
+ */
+export function createPendingWorktree({
+  threadId,
+  worktreeName,
+  projectDirectory,
+}: {
+  threadId: string
+  worktreeName: string
+  projectDirectory: string
+}): void {
+  const db = getDatabase()
+  db.prepare(
+    `INSERT OR REPLACE INTO thread_worktrees (thread_id, worktree_name, project_directory, status) VALUES (?, ?, ?, 'pending')`,
+  ).run(threadId, worktreeName, projectDirectory)
+}
+
+/**
+ * Mark a worktree as ready with its directory.
+ */
+export function setWorktreeReady({
+  threadId,
+  worktreeDirectory,
+}: {
+  threadId: string
+  worktreeDirectory: string
+}): void {
+  const db = getDatabase()
+  db.prepare(
+    `UPDATE thread_worktrees SET worktree_directory = ?, status = 'ready' WHERE thread_id = ?`,
+  ).run(worktreeDirectory, threadId)
+}
+
+/**
+ * Mark a worktree as failed with error message.
+ */
+export function setWorktreeError({
+  threadId,
+  errorMessage,
+}: {
+  threadId: string
+  errorMessage: string
+}): void {
+  const db = getDatabase()
+  db.prepare(`UPDATE thread_worktrees SET status = 'error', error_message = ? WHERE thread_id = ?`).run(
+    errorMessage,
+    threadId,
+  )
+}
+
+/**
+ * Delete the worktree info for a thread.
+ */
+export function deleteThreadWorktree(threadId: string): void {
+  const db = getDatabase()
+  db.prepare('DELETE FROM thread_worktrees WHERE thread_id = ?').run(threadId)
+}
+
 export function closeDatabase(): void {
   if (db) {
     db.close()

package/src/discord-bot.ts

@@ -2,7 +2,7 @@
 // Bridges Discord messages to OpenCode sessions, manages voice connections,
 // and orchestrates the main event loop for the Kimaki bot.
 
-import { getDatabase, closeDatabase } from './database.js'
+import { getDatabase, closeDatabase, getThreadWorktree } from './database.js'
 import { initializeOpencodeForDirectory, getOpencodeServers } from './opencode.js'
 import {
   escapeBackticksInCodeBlocks,
@@ -58,7 +58,10 @@ import { extractTagsArrays } from './xml.js'
 import { createLogger } from './logger.js'
 import { setGlobalDispatcher, Agent } from 'undici'
 
-setGlobalDispatcher(new Agent({ headersTimeout: 0, bodyTimeout: 0 }))
+// Increase connection pool to prevent deadlock when multiple sessions have open SSE streams.
+// Each session's event.subscribe() holds a connection; without enough connections,
+// regular HTTP requests (question.reply, session.prompt) get blocked → deadlock.
+setGlobalDispatcher(new Agent({ headersTimeout: 0, bodyTimeout: 0, connections: 500 }))
 
 const discordLogger = createLogger('DISCORD')
 const voiceLogger = createLogger('VOICE')
@@ -154,7 +157,7 @@ export async function startDiscordBot({
           try: () => message.fetch(),
           catch: (e) => e as Error,
         })
-        if (errore.isError(fetched)) {
+        if (fetched instanceof Error) {
           discordLogger.log(`Failed to fetch partial message ${message.id}:`, fetched.message)
           return
         }
@@ -204,6 +207,29 @@ export async function startDiscordBot({
           channelAppId = extracted['kimaki.app']?.[0]?.trim()
         }
 
+        // Check if this thread is a worktree thread
+        const worktreeInfo = getThreadWorktree(thread.id)
+        if (worktreeInfo) {
+          if (worktreeInfo.status === 'pending') {
+            await message.reply({
+              content: '⏳ Worktree is still being created. Please wait...',
+              flags: SILENT_MESSAGE_FLAGS,
+            })
+            return
+          }
+          if (worktreeInfo.status === 'error') {
+            await message.reply({
+              content: `❌ Worktree creation failed: ${worktreeInfo.error_message}`,
+              flags: SILENT_MESSAGE_FLAGS,
+            })
+            return
+          }
+          if (worktreeInfo.worktree_directory) {
+            projectDirectory = worktreeInfo.worktree_directory
+            discordLogger.log(`Using worktree directory: ${projectDirectory}`)
+          }
+        }
+
         if (channelAppId && channelAppId !== currentAppId) {
           voiceLogger.log(
             `[IGNORED] Thread belongs to different bot app (expected: ${currentAppId}, got: ${channelAppId})`,
@@ -259,7 +285,7 @@ export async function startDiscordBot({
         if (projectDirectory) {
           try {
             const getClient = await initializeOpencodeForDirectory(projectDirectory)
-            if (errore.isError(getClient)) {
+            if (getClient instanceof Error) {
               voiceLogger.error(`[SESSION] Failed to initialize OpenCode client:`, getClient.message)
               throw new Error(getClient.message)
             }

package/src/discord-utils.ts

@@ -9,6 +9,9 @@ import { formatMarkdownTables } from './format-tables.js'
 import { limitHeadingDepth } from './limit-heading-depth.js'
 import { unnestCodeBlocksFromLists } from './unnest-code-blocks.js'
 import { createLogger } from './logger.js'
+import mime from 'mime'
+import fs from 'node:fs'
+import path from 'node:path'
 
 const discordLogger = createLogger('DISCORD')
 
@@ -302,3 +305,50 @@ export function getKimakiMetadata(textChannel: TextChannel | null): {
 
   return { projectDirectory, channelAppId }
 }
+
+/**
+ * Upload files to a Discord thread/channel in a single message.
+ * Sending all files in one message causes Discord to display images in a grid layout.
+ */
+export async function uploadFilesToDiscord({
+  threadId,
+  botToken,
+  files,
+}: {
+  threadId: string
+  botToken: string
+  files: string[]
+}): Promise<void> {
+  if (files.length === 0) {
+    return
+  }
+
+  // Build attachments array for all files
+  const attachments = files.map((file, index) => ({
+    id: index,
+    filename: path.basename(file),
+  }))
+
+  const formData = new FormData()
+  formData.append('payload_json', JSON.stringify({ attachments }))
+
+  // Append each file with its array index, with correct MIME type for grid display
+  files.forEach((file, index) => {
+    const buffer = fs.readFileSync(file)
+    const mimeType = mime.getType(file) || 'application/octet-stream'
+    formData.append(`files[${index}]`, new Blob([buffer], { type: mimeType }), path.basename(file))
+  })
+
+  const response = await fetch(`https://discord.com/api/v10/channels/${threadId}/messages`, {
+    method: 'POST',
+    headers: {
+      Authorization: `Bot ${botToken}`,
+    },
+    body: formData,
+  })
+
+  if (!response.ok) {
+    const error = await response.text()
+    throw new Error(`Discord API error: ${response.status} - ${error}`)
+  }
+}