kimaki 0.4.43 → 0.4.45

package/src/channel-management.ts

@@ -4,8 +4,7 @@
 
 import { ChannelType, type CategoryChannel, type Guild, type TextChannel } from 'discord.js'
 import path from 'node:path'
-import { getDatabase } from './database.js'
-import { extractTagsArrays } from './xml.js'
+import { getDatabase, getChannelDirectory } from './database.js'
 
 export async function ensureKimakiCategory(
   guild: Guild,
@@ -83,7 +82,7 @@ export async function createProjectChannels({
     name: channelName,
     type: ChannelType.GuildText,
     parent: kimakiCategory,
-    topic: `<kimaki><directory>${projectDirectory}</directory><app>${appId}</app></kimaki>`,
+    // Channel configuration is stored in SQLite, not in the topic
   })
 
   const voiceChannel = await guild.channels.create({
@@ -128,25 +127,15 @@ export async function getChannelsWithDescriptions(guild: Guild): Promise<Channel
       const textChannel = channel as TextChannel
       const description = textChannel.topic || null
 
-      let kimakiDirectory: string | undefined
-      let kimakiApp: string | undefined
-
-      if (description) {
-        const extracted = extractTagsArrays({
-          xml: description,
-          tags: ['kimaki.directory', 'kimaki.app'],
-        })
-
-        kimakiDirectory = extracted['kimaki.directory']?.[0]?.trim()
-        kimakiApp = extracted['kimaki.app']?.[0]?.trim()
-      }
+      // Get channel config from database instead of parsing XML from topic
+      const channelConfig = getChannelDirectory(textChannel.id)
 
       channels.push({
         id: textChannel.id,
         name: textChannel.name,
         description,
-        kimakiDirectory,
-        kimakiApp,
+        kimakiDirectory: channelConfig?.directory,
+        kimakiApp: channelConfig?.appId || undefined,
       })
     })
 

package/src/cli.ts

@@ -21,6 +21,7 @@ import {
   getChannelsWithDescriptions,
   createDiscordClient,
   getDatabase,
+  getChannelDirectory,
   startDiscordBot,
   initializeOpencodeForDirectory,
   ensureKimakiCategory,
@@ -47,7 +48,6 @@ import { uploadFilesToDiscord } from './discord-utils.js'
 import { spawn, spawnSync, execSync, type ExecSyncOptions } from 'node:child_process'
 import http from 'node:http'
 import { setDataDir, getDataDir, getLockPort } from './config.js'
-import { extractTagsArrays } from './xml.js'
 import { sanitizeAgentName } from './commands/agent.js'
 
 const cliLogger = createLogger('CLI')
@@ -174,6 +174,7 @@ type CliOptions = {
   restart?: boolean
   addChannels?: boolean
   dataDir?: string
+  useWorktrees?: boolean
 }
 
 // Commands to skip when registering user commands (reserved names)
@@ -239,16 +240,28 @@ async function registerCommands({
       .toJSON(),
     new SlashCommandBuilder()
       .setName('new-worktree')
-      .setDescription('Create a new git worktree and start a session thread')
+      .setDescription('Create a new git worktree (in thread: uses thread name if no name given)')
       .addStringOption((option) => {
         option
           .setName('name')
-          .setDescription('Name for the worktree (will be formatted: lowercase, spaces to dashes)')
-          .setRequired(true)
+          .setDescription('Name for worktree (optional in threads - uses thread name)')
+          .setRequired(false)
 
         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')
@@ -329,6 +342,21 @@ async function registerCommands({
       .setName('redo')
       .setDescription('Redo previously undone changes')
       .toJSON(),
+    new SlashCommandBuilder()
+      .setName('verbosity')
+      .setDescription('Set output verbosity for new sessions in this channel')
+      .addStringOption((option) => {
+        option
+          .setName('level')
+          .setDescription('Verbosity level')
+          .setRequired(true)
+          .addChoices(
+            { name: 'tools-and-text (default)', value: 'tools-and-text' },
+            { name: 'text-only', value: 'text-only' },
+          )
+        return option
+      })
+      .toJSON(),
   ]
 
   // Add user-defined commands with -cmd suffix
@@ -516,7 +544,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 +855,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 +1026,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 +1039,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 +1076,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))
@@ -1351,25 +1382,17 @@ cli
         guild_id: string
       }
 
-      if (!channelData.topic) {
-        s.stop('Channel has no topic')
+      const channelConfig = getChannelDirectory(channelData.id)
+
+      if (!channelConfig) {
+        s.stop('Channel not configured')
         throw new Error(
-          `Channel #${channelData.name} has no topic. It must have a <kimaki.directory> tag.`,
+          `Channel #${channelData.name} is not configured with a project directory. Run the bot first to sync channel data.`,
         )
       }
 
-      const extracted = extractTagsArrays({
-        xml: channelData.topic,
-        tags: ['kimaki.directory', 'kimaki.app'],
-      })
-
-      const projectDirectory = extracted['kimaki.directory']?.[0]?.trim()
-      const channelAppId = extracted['kimaki.app']?.[0]?.trim()
-
-      if (!projectDirectory) {
-        s.stop('No kimaki.directory tag found')
-        throw new Error(`Channel #${channelData.name} has no <kimaki.directory> tag in topic.`)
-      }
+      const projectDirectory = channelConfig.directory
+      const channelAppId = channelConfig.appId || undefined
 
       // Verify app ID matches if both are present
       if (channelAppId && appId && channelAppId !== appId) {
@@ -1386,6 +1409,13 @@ cli
       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, ' ')
@@ -1407,6 +1437,7 @@ cli
             JSON.stringify({
               content: summaryContent,
               attachments: [{ id: 0, filename: 'prompt.md' }],
+              embeds: autoStartEmbed,
             }),
           )
           const buffer = fs.readFileSync(tmpFile)
@@ -1446,6 +1477,7 @@ cli
             },
             body: JSON.stringify({
               content: prompt,
+              embeds: autoStartEmbed,
             }),
           },
         )
@@ -1486,19 +1518,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}`
@@ -1518,5 +1537,201 @@ 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('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) {
+          // Get raw guild ID from argv to avoid cac's number coercion losing precision on large IDs
+          const guildArgIndex = process.argv.findIndex((arg) => arg === '-g' || arg === '--guild')
+          const rawGuildArg = guildArgIndex >= 0 ? process.argv[guildArgIndex + 1] : undefined
+          const guildId = rawGuildArg || String(options.guild)
+          const foundGuild = client.guilds.cache.get(guildId)
+          if (!foundGuild) {
+            s.stop('Guild not found')
+            cliLogger.error(`Guild not found: ${guildId}`)
+            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
+          }
+        }
+
+        // Check if channel already exists in this guild
+        s.message('Checking for existing channel...')
+        try {
+          const db = getDatabase()
+          const existingChannels = db
+            .prepare(
+              'SELECT channel_id FROM channel_directories WHERE directory = ? AND channel_type = ? AND app_id = ?',
+            )
+            .all(absolutePath, 'text', appId) as { channel_id: string }[]
+
+          for (const existingChannel of existingChannels) {
+            try {
+              const ch = await client.channels.fetch(existingChannel.channel_id)
+              if (ch && 'guild' in ch && ch.guild?.id === guild.id) {
+                s.stop('Channel already exists')
+                note(
+                  `Channel already exists for this directory in ${guild.name}.\n\nChannel: <#${existingChannel.channel_id}>\nDirectory: ${absolutePath}`,
+                  '⚠️  Already Exists',
+                )
+                client.destroy()
+                process.exit(0)
+              }
+            } catch {
+              // Channel might be deleted, continue checking
+            }
+          }
+        } catch {
+          // Database might not exist, continue to create
+        }
+
+        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\`\`\``)
+  }
+}