kimaki 0.4.42 → 0.4.44

package/src/cli.ts

@@ -174,6 +174,7 @@ type CliOptions = {
   restart?: boolean
   addChannels?: boolean
   dataDir?: string
+  useWorktrees?: boolean
 }
 
 // Commands to skip when registering user commands (reserved names)
@@ -249,6 +250,18 @@ async function registerCommands({
         return option
       })
       .toJSON(),
+    new SlashCommandBuilder()
+      .setName('merge-worktree')
+      .setDescription('Merge the worktree branch into the default branch')
+      .toJSON(),
+    new SlashCommandBuilder()
+      .setName('enable-worktrees')
+      .setDescription('Enable automatic git worktree creation for new sessions in this channel')
+      .toJSON(),
+    new SlashCommandBuilder()
+      .setName('disable-worktrees')
+      .setDescription('Disable automatic git worktree creation for new sessions in this channel')
+      .toJSON(),
     new SlashCommandBuilder()
       .setName('add-project')
       .setDescription('Create Discord channels for a new OpenCode project')
@@ -516,7 +529,7 @@ async function backgroundInit({
   }
 }
 
-async function run({ restart, addChannels }: CliOptions) {
+async function run({ restart, addChannels, useWorktrees }: CliOptions) {
   const forceSetup = Boolean(restart)
 
   intro('🤖 Discord Bot Setup')
@@ -827,7 +840,7 @@ async function run({ restart, addChannels }: CliOptions) {
   const isQuickStart = existingBot && !forceSetup && !addChannels
   if (isQuickStart) {
     s.start('Starting Discord bot...')
-    await startDiscordBot({ token, appId, discordClient })
+    await startDiscordBot({ token, appId, discordClient, useWorktrees })
     s.stop('Discord bot is running!')
 
     // Background: OpenCode init + slash command registration (non-blocking)
@@ -998,7 +1011,7 @@ async function run({ restart, addChannels }: CliOptions) {
     })
 
   s.start('Starting Discord bot...')
-  await startDiscordBot({ token, appId, discordClient })
+  await startDiscordBot({ token, appId, discordClient, useWorktrees })
   s.stop('Discord bot is running!')
 
   showReadyMessage({ kimakiChannels, createdChannels, appId })
@@ -1011,12 +1024,14 @@ cli
   .option('--add-channels', 'Select OpenCode projects to create Discord channels before starting')
   .option('--data-dir <path>', 'Data directory for config and database (default: ~/.kimaki)')
   .option('--install-url', 'Print the bot install URL and exit')
+  .option('--use-worktrees', 'Create git worktrees for all new sessions started from channel messages')
   .action(
     async (options: {
       restart?: boolean
       addChannels?: boolean
       dataDir?: string
       installUrl?: boolean
+      useWorktrees?: boolean
     }) => {
       try {
         // Set data directory early, before any database access
@@ -1046,6 +1061,7 @@ cli
           restart: options.restart,
           addChannels: options.addChannels,
           dataDir: options.dataDir,
+          useWorktrees: options.useWorktrees,
         })
       } catch (error) {
         cliLogger.error('Unhandled error:', error instanceof Error ? error.message : String(error))
@@ -1381,28 +1397,92 @@ cli
 
       s.message('Creating starter message...')
 
-      // Create starter message with just the prompt (no prefix)
-      const starterMessageResponse = await fetch(
-        `https://discord.com/api/v10/channels/${channelId}/messages`,
-        {
-          method: 'POST',
-          headers: {
-            Authorization: `Bot ${botToken}`,
-            'Content-Type': 'application/json',
+      // Discord has a 2000 character limit for messages.
+      // If prompt exceeds this, send it as a file attachment instead.
+      const DISCORD_MAX_LENGTH = 2000
+      let starterMessage: { id: string }
+
+      // Embed marker for auto-start sessions (unless --notify-only)
+      // Bot checks for this embed footer to know it should start a session
+      const AUTO_START_MARKER = 'kimaki:start'
+      const autoStartEmbed = notifyOnly
+        ? undefined
+        : [{ color: 0x2b2d31, footer: { text: AUTO_START_MARKER } }]
+
+      if (prompt.length > DISCORD_MAX_LENGTH) {
+        // Send as file attachment with a short summary
+        const preview = prompt.slice(0, 100).replace(/\n/g, ' ')
+        const summaryContent = `📄 **Prompt attached as file** (${prompt.length} chars)\n\n> ${preview}...`
+
+        // Write prompt to a temp file
+        const tmpDir = path.join(process.cwd(), 'tmp')
+        if (!fs.existsSync(tmpDir)) {
+          fs.mkdirSync(tmpDir, { recursive: true })
+        }
+        const tmpFile = path.join(tmpDir, `prompt-${Date.now()}.md`)
+        fs.writeFileSync(tmpFile, prompt)
+
+        try {
+          // Create message with file attachment
+          const formData = new FormData()
+          formData.append(
+            'payload_json',
+            JSON.stringify({
+              content: summaryContent,
+              attachments: [{ id: 0, filename: 'prompt.md' }],
+              embeds: autoStartEmbed,
+            }),
+          )
+          const buffer = fs.readFileSync(tmpFile)
+          formData.append('files[0]', new Blob([buffer], { type: 'text/markdown' }), 'prompt.md')
+
+          const starterMessageResponse = await fetch(
+            `https://discord.com/api/v10/channels/${channelId}/messages`,
+            {
+              method: 'POST',
+              headers: {
+                Authorization: `Bot ${botToken}`,
+              },
+              body: formData,
+            },
+          )
+
+          if (!starterMessageResponse.ok) {
+            const error = await starterMessageResponse.text()
+            s.stop('Failed to create message')
+            throw new Error(`Discord API error: ${starterMessageResponse.status} - ${error}`)
+          }
+
+          starterMessage = (await starterMessageResponse.json()) as { id: string }
+        } finally {
+          // Clean up temp file
+          fs.unlinkSync(tmpFile)
+        }
+      } else {
+        // Normal case: send prompt inline
+        const starterMessageResponse = await fetch(
+          `https://discord.com/api/v10/channels/${channelId}/messages`,
+          {
+            method: 'POST',
+            headers: {
+              Authorization: `Bot ${botToken}`,
+              'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+              content: prompt,
+              embeds: autoStartEmbed,
+            }),
           },
-          body: JSON.stringify({
-            content: prompt,
-          }),
-        },
-      )
+        )
 
-      if (!starterMessageResponse.ok) {
-        const error = await starterMessageResponse.text()
-        s.stop('Failed to create message')
-        throw new Error(`Discord API error: ${starterMessageResponse.status} - ${error}`)
-      }
+        if (!starterMessageResponse.ok) {
+          const error = await starterMessageResponse.text()
+          s.stop('Failed to create message')
+          throw new Error(`Discord API error: ${starterMessageResponse.status} - ${error}`)
+        }
 
-      const starterMessage = (await starterMessageResponse.json()) as { id: string }
+        starterMessage = (await starterMessageResponse.json()) as { id: string }
+      }
 
       s.message('Creating thread...')
 
@@ -1431,19 +1511,6 @@ cli
 
       const threadData = (await threadResponse.json()) as { id: string; name: string }
 
-      // Mark thread for auto-start if not notify-only
-      // This is optional - only works if local database exists (for local bot auto-start)
-      if (!notifyOnly) {
-        try {
-          const db = getDatabase()
-          db.prepare('INSERT OR REPLACE INTO pending_auto_start (thread_id) VALUES (?)').run(
-            threadData.id,
-          )
-        } catch {
-          // Database not available (e.g., CI environment) - skip auto-start marking
-        }
-      }
-
       s.stop('Thread created!')
 
       const threadUrl = `https://discord.com/channels/${channelData.guild_id}/${threadData.id}`
@@ -1463,5 +1530,190 @@ cli
     }
   })
 
+cli
+  .command('add-project [directory]', 'Create Discord channels for a project directory')
+  .option('-g, --guild <guildId>', 'Discord guild/server ID (auto-detects if bot is in only one server)')
+  .option('-a, --app-id <appId>', 'Bot application ID (reads from database if available)')
+  .action(
+    async (
+      directory: string | undefined,
+      options: {
+        guild?: string
+        appId?: string
+      },
+    ) => {
+      try {
+        const absolutePath = path.resolve(directory || '.')
+
+        if (!fs.existsSync(absolutePath)) {
+          cliLogger.error(`Directory does not exist: ${absolutePath}`)
+          process.exit(EXIT_NO_RESTART)
+        }
+
+        // Get bot token from env var or database
+        const envToken = process.env.KIMAKI_BOT_TOKEN
+        let botToken: string | undefined
+        let appId: string | undefined = options.appId
+
+        if (envToken) {
+          botToken = envToken
+          if (!appId) {
+            try {
+              const db = getDatabase()
+              const botRow = db
+                .prepare('SELECT app_id FROM bot_tokens ORDER BY created_at DESC LIMIT 1')
+                .get() as { app_id: string } | undefined
+              appId = botRow?.app_id
+            } catch {
+              // Database might not exist in CI
+            }
+          }
+        } else {
+          try {
+            const db = getDatabase()
+            const botRow = db
+              .prepare('SELECT app_id, token FROM bot_tokens ORDER BY created_at DESC LIMIT 1')
+              .get() as { app_id: string; token: string } | undefined
+
+            if (botRow) {
+              botToken = botRow.token
+              appId = appId || botRow.app_id
+            }
+          } catch (e) {
+            cliLogger.error('Database error:', e instanceof Error ? e.message : String(e))
+          }
+        }
+
+        if (!botToken) {
+          cliLogger.error(
+            'No bot token found. Set KIMAKI_BOT_TOKEN env var or run `kimaki` first to set up.',
+          )
+          process.exit(EXIT_NO_RESTART)
+        }
+
+        if (!appId) {
+          cliLogger.error(
+            'App ID is required to create channels. Use --app-id or run `kimaki` first.',
+          )
+          process.exit(EXIT_NO_RESTART)
+        }
+
+        const s = spinner()
+        s.start('Checking for existing channel...')
+
+        // Check if channel already exists
+        try {
+          const db = getDatabase()
+          const existingChannel = db
+            .prepare(
+              'SELECT channel_id FROM channel_directories WHERE directory = ? AND channel_type = ? AND app_id = ?',
+            )
+            .get(absolutePath, 'text', appId) as { channel_id: string } | undefined
+
+          if (existingChannel) {
+            s.stop('Channel already exists')
+            note(
+              `Channel already exists for this directory.\n\nChannel: <#${existingChannel.channel_id}>\nDirectory: ${absolutePath}`,
+              '⚠️  Already Exists',
+            )
+            process.exit(0)
+          }
+        } catch {
+          // Database might not exist, continue to create
+        }
+
+        s.message('Connecting to Discord...')
+        const client = await createDiscordClient()
+
+        await new Promise<void>((resolve, reject) => {
+          client.once(Events.ClientReady, () => {
+            resolve()
+          })
+          client.once(Events.Error, reject)
+          client.login(botToken)
+        })
+
+        s.message('Finding guild...')
+
+        // Find guild
+        let guild: Guild
+        if (options.guild) {
+          const foundGuild = client.guilds.cache.get(options.guild)
+          if (!foundGuild) {
+            s.stop('Guild not found')
+            cliLogger.error(`Guild not found: ${options.guild}`)
+            client.destroy()
+            process.exit(EXIT_NO_RESTART)
+          }
+          guild = foundGuild
+        } else {
+          // Auto-detect: prefer guild with existing channels for this bot, else first guild
+          const db = getDatabase()
+          const existingChannelRow = db
+            .prepare(
+              'SELECT channel_id FROM channel_directories WHERE app_id = ? ORDER BY created_at DESC LIMIT 1',
+            )
+            .get(appId) as { channel_id: string } | undefined
+
+          if (existingChannelRow) {
+            try {
+              const ch = await client.channels.fetch(existingChannelRow.channel_id)
+              if (ch && 'guild' in ch && ch.guild) {
+                guild = ch.guild
+              } else {
+                throw new Error('Channel has no guild')
+              }
+            } catch {
+              // Channel might be deleted, fall back to first guild
+              const firstGuild = client.guilds.cache.first()
+              if (!firstGuild) {
+                s.stop('No guild found')
+                cliLogger.error('No guild found. Add the bot to a server first.')
+                client.destroy()
+                process.exit(EXIT_NO_RESTART)
+              }
+              guild = firstGuild
+            }
+          } else {
+            const firstGuild = client.guilds.cache.first()
+            if (!firstGuild) {
+              s.stop('No guild found')
+              cliLogger.error('No guild found. Add the bot to a server first.')
+              client.destroy()
+              process.exit(EXIT_NO_RESTART)
+            }
+            guild = firstGuild
+          }
+        }
+
+        s.message(`Creating channels in ${guild.name}...`)
+
+        const { textChannelId, voiceChannelId, channelName } = await createProjectChannels({
+          guild,
+          projectDirectory: absolutePath,
+          appId,
+          botName: client.user?.username,
+        })
+
+        client.destroy()
+
+        s.stop('Channels created!')
+
+        const channelUrl = `https://discord.com/channels/${guild.id}/${textChannelId}`
+
+        note(
+          `Created channels for project:\n\n📝 Text: #${channelName}\n🔊 Voice: #${channelName}\n📁 Directory: ${absolutePath}\n\nURL: ${channelUrl}`,
+          '✅ Success',
+        )
+
+        console.log(channelUrl)
+        process.exit(0)
+      } catch (error) {
+        cliLogger.error('Error:', error instanceof Error ? error.message : String(error))
+        process.exit(EXIT_NO_RESTART)
+      }
+    },
+  )
+
 cli.help()
 cli.parse()

package/src/commands/merge-worktree.ts

@@ -0,0 +1,186 @@
+// /merge-worktree command - Merge worktree commits into main/default branch.
+// Handles both branch-based worktrees and detached HEAD state.
+// After merge, switches to detached HEAD at main so user can keep working.
+
+import { type ThreadChannel } from 'discord.js'
+import type { CommandContext } from './types.js'
+import { getThreadWorktree } from '../database.js'
+import { createLogger } from '../logger.js'
+import { execAsync } from '../worktree-utils.js'
+
+const logger = createLogger('MERGE-WORKTREE')
+
+/** Worktree thread title prefix - indicates unmerged worktree */
+export const WORKTREE_PREFIX = '⬦ '
+
+/**
+ * Remove the worktree prefix from a thread title.
+ * Uses Promise.race with timeout since Discord thread title updates can hang.
+ */
+async function removeWorktreePrefixFromTitle(thread: ThreadChannel): Promise<void> {
+  if (!thread.name.startsWith(WORKTREE_PREFIX)) {
+    return
+  }
+
+  const newName = thread.name.slice(WORKTREE_PREFIX.length)
+
+  // Race between the edit and a timeout - thread title updates are heavily rate-limited
+  const timeoutMs = 5000
+  const editPromise = thread.setName(newName).catch((e) => {
+    logger.warn(`Failed to update thread title: ${e instanceof Error ? e.message : String(e)}`)
+  })
+
+  const timeoutPromise = new Promise<void>((resolve) => {
+    setTimeout(() => {
+      logger.warn(`Thread title update timed out after ${timeoutMs}ms`)
+      resolve()
+    }, timeoutMs)
+  })
+
+  await Promise.race([editPromise, timeoutPromise])
+}
+
+/**
+ * Check if worktree is in detached HEAD state.
+ */
+async function isDetachedHead(worktreeDir: string): Promise<boolean> {
+  try {
+    await execAsync(`git -C "${worktreeDir}" symbolic-ref HEAD`)
+    return false
+  } catch {
+    return true
+  }
+}
+
+/**
+ * Get current branch name (returns null if detached).
+ */
+async function getCurrentBranch(worktreeDir: string): Promise<string | null> {
+  try {
+    const { stdout } = await execAsync(`git -C "${worktreeDir}" symbolic-ref --short HEAD`)
+    return stdout.trim() || null
+  } catch {
+    return null
+  }
+}
+
+export async function handleMergeWorktreeCommand({ command, appId }: CommandContext): Promise<void> {
+  await command.deferReply({ ephemeral: false })
+
+  const channel = command.channel
+
+  // Must be in a thread
+  if (!channel || !channel.isThread()) {
+    await command.editReply('This command can only be used in a thread')
+    return
+  }
+
+  const thread = channel as ThreadChannel
+
+  // Get worktree info from database
+  const worktreeInfo = getThreadWorktree(thread.id)
+  if (!worktreeInfo) {
+    await command.editReply('This thread is not associated with a worktree')
+    return
+  }
+
+  if (worktreeInfo.status !== 'ready' || !worktreeInfo.worktree_directory) {
+    await command.editReply(
+      `Worktree is not ready (status: ${worktreeInfo.status})${worktreeInfo.error_message ? `: ${worktreeInfo.error_message}` : ''}`,
+    )
+    return
+  }
+
+  const mainRepoDir = worktreeInfo.project_directory
+  const worktreeDir = worktreeInfo.worktree_directory
+
+  try {
+    // 1. Check for uncommitted changes
+    const { stdout: status } = await execAsync(`git -C "${worktreeDir}" status --porcelain`)
+    if (status.trim()) {
+      await command.editReply(
+        `❌ Uncommitted changes detected in worktree.\n\nPlease commit your changes first, then retry \`/merge-worktree\`.`,
+      )
+      return
+    }
+
+    // 2. Get the default branch name
+    logger.log(`Getting default branch for ${mainRepoDir}`)
+    let defaultBranch: string
+
+    try {
+      const { stdout } = await execAsync(
+        `git -C "${mainRepoDir}" symbolic-ref refs/remotes/origin/HEAD 2>/dev/null | sed 's@^refs/remotes/origin/@@'`,
+      )
+      defaultBranch = stdout.trim() || 'main'
+    } catch {
+      defaultBranch = 'main'
+    }
+
+    // 3. Determine if we're on a branch or detached HEAD
+    const isDetached = await isDetachedHead(worktreeDir)
+    const currentBranch = await getCurrentBranch(worktreeDir)
+    let branchToMerge: string
+    let tempBranch: string | null = null
+
+    if (isDetached) {
+      // Create a temporary branch from detached HEAD
+      tempBranch = `temp-merge-${Date.now()}`
+      logger.log(`Detached HEAD detected, creating temp branch: ${tempBranch}`)
+      await execAsync(`git -C "${worktreeDir}" checkout -b ${tempBranch}`)
+      branchToMerge = tempBranch
+    } else {
+      branchToMerge = currentBranch || worktreeInfo.worktree_name
+    }
+
+    logger.log(`Default branch: ${defaultBranch}, branch to merge: ${branchToMerge}`)
+
+    // 4. Merge default branch INTO worktree (handles diverged branches)
+    logger.log(`Merging ${defaultBranch} into worktree at ${worktreeDir}`)
+    try {
+      await execAsync(`git -C "${worktreeDir}" merge ${defaultBranch} --no-edit`)
+    } catch (e) {
+      // If merge fails (conflicts), abort and report
+      await execAsync(`git -C "${worktreeDir}" merge --abort`).catch(() => {})
+      // Clean up temp branch if we created one
+      if (tempBranch) {
+        await execAsync(`git -C "${worktreeDir}" checkout --detach`).catch(() => {})
+        await execAsync(`git -C "${worktreeDir}" branch -D ${tempBranch}`).catch(() => {})
+      }
+      throw new Error(`Merge conflict - resolve manually in worktree then retry`)
+    }
+
+    // 5. Update default branch ref to point to current HEAD
+    // Use update-ref instead of fetch because fetch refuses if branch is checked out
+    logger.log(`Updating ${defaultBranch} to point to current HEAD`)
+    const { stdout: commitHash } = await execAsync(`git -C "${worktreeDir}" rev-parse HEAD`)
+    await execAsync(`git -C "${mainRepoDir}" update-ref refs/heads/${defaultBranch} ${commitHash.trim()}`)
+
+    // 6. Switch to detached HEAD at default branch (allows main to be checked out elsewhere)
+    logger.log(`Switching to detached HEAD at ${defaultBranch}`)
+    await execAsync(`git -C "${worktreeDir}" checkout --detach ${defaultBranch}`)
+
+    // 7. Delete the merged branch (temp or original)
+    logger.log(`Deleting merged branch ${branchToMerge}`)
+    await execAsync(`git -C "${worktreeDir}" branch -D ${branchToMerge}`).catch(() => {})
+
+    // Also delete the original worktree branch if different from what we merged
+    if (!isDetached && branchToMerge !== worktreeInfo.worktree_name) {
+      await execAsync(`git -C "${worktreeDir}" branch -D ${worktreeInfo.worktree_name}`).catch(() => {})
+    }
+
+    // 8. Remove worktree prefix from thread title (fire and forget with timeout)
+    void removeWorktreePrefixFromTitle(thread)
+
+    const sourceDesc = isDetached ? 'detached commits' : `\`${branchToMerge}\``
+    await command.editReply(
+      `✅ Merged ${sourceDesc} into \`${defaultBranch}\`\n\nWorktree now at detached HEAD - you can keep working here.`,
+    )
+
+    logger.log(`Successfully merged ${branchToMerge} into ${defaultBranch}`)
+  } catch (e) {
+    const errorMsg = e instanceof Error ? e.message : String(e)
+    logger.error(`Merge failed: ${errorMsg}`)
+    await command.editReply(`❌ Merge failed:\n\`\`\`\n${errorMsg}\n\`\`\``)
+  }
+}