kimaki 0.4.43 → 0.4.44

package/dist/discord-bot.js

@@ -1,8 +1,11 @@
 // Core Discord bot module that handles message events and bot lifecycle.
 // 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, } 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, SILENT_MESSAGE_FLAGS, } from './discord-utils.js';
 import { getOpencodeSystemMessage } from './system-message.js';
 import { getFileAttachments, getTextAttachments } from './message-formatting.js';
@@ -39,7 +42,7 @@ export async function createDiscordClient() {
         partials: [Partials.Channel, Partials.Message, Partials.User, Partials.ThreadMember],
     });
 }
-export async function startDiscordBot({ token, appId, discordClient, }) {
+export async function startDiscordBot({ token, appId, discordClient, useWorktrees, }) {
     if (!discordClient) {
         discordClient = await createDiscordClient();
     }
@@ -299,20 +302,76 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                     return;
                 }
                 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,
                     reason: 'Start Claude session',
                 });
                 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,
                 });
@@ -327,7 +386,7 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                 await handleOpencodeSession({
                     prompt: promptWithAttachments,
                     thread,
-                    projectDirectory,
+                    projectDirectory: sessionDirectory,
                     originalMessage: message,
                     images: fileAttachments,
                     channelId: textChannel.id,
@@ -349,33 +408,30 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
         }
     });
     // 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);
-            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;
             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`);

package/dist/interaction-handler.js

@@ -4,6 +4,8 @@
 import { Events } 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 { handleRemoveProjectCommand, handleRemoveProjectAutocomplete, } from './commands/remove-project.js';
@@ -57,6 +59,15 @@ export function registerInteractionHandler({ discordClient, appId, }) {
                     case 'new-worktree':
                         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;

package/dist/session-handler.js

@@ -2,7 +2,7 @@
 // Creates, maintains, and sends prompts to OpenCode sessions from Discord threads.
 // Handles streaming events, permissions, abort signals, and message queuing.
 import prettyMilliseconds from 'pretty-ms';
-import { getDatabase, getSessionModel, getChannelModel, getSessionAgent, getChannelAgent, setSessionAgent, } from './database.js';
+import { getDatabase, getSessionModel, getChannelModel, getSessionAgent, getChannelAgent, setSessionAgent, getThreadWorktree, } from './database.js';
 import { initializeOpencodeForDirectory, getOpencodeServers, getOpencodeClientV2, } from './opencode.js';
 import { sendThreadMessage, NOTIFY_MESSAGE_FLAGS, SILENT_MESSAGE_FLAGS } from './discord-utils.js';
 import { formatPart } from './message-formatting.js';
@@ -755,6 +755,15 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
             sessionLogger.log(`[MODEL] Using model preference: ${modelPreference}`);
             return { providerID, modelID };
         })();
+        // Get worktree info if this thread is in a worktree
+        const worktreeInfo = getThreadWorktree(thread.id);
+        const worktree = worktreeInfo?.status === 'ready' && worktreeInfo.worktree_directory
+            ? {
+                worktreeDirectory: worktreeInfo.worktree_directory,
+                branch: worktreeInfo.worktree_name,
+                mainRepoDirectory: worktreeInfo.project_directory,
+            }
+            : undefined;
         // Use session.command API for slash commands, session.prompt for regular messages
         const response = command
             ? await getClient().session.command({
@@ -770,7 +779,7 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                 path: { id: session.id },
                 body: {
                     parts,
-                    system: getOpencodeSystemMessage({ sessionId: session.id, channelId }),
+                    system: getOpencodeSystemMessage({ sessionId: session.id, channelId, worktree }),
                     model: modelParam,
                     agent: agentPreference,
                 },

package/dist/system-message.js

@@ -1,7 +1,7 @@
 // OpenCode system prompt generator.
 // Creates the system message injected into every OpenCode session,
 // including Discord-specific formatting rules, diff commands, and permissions info.
-export function getOpencodeSystemMessage({ sessionId, channelId, }) {
+export function getOpencodeSystemMessage({ sessionId, channelId, worktree, }) {
     return `
 The user is reading your messages from inside Discord, via kimaki.xyz
 
@@ -50,6 +50,26 @@ Use this for handoff when:
 - User asks to "handoff", "continue in new thread", or "start fresh session"
 - You detect you're running low on context window space
 - A complex task would benefit from a clean slate with summarized context
+`
+        : ''}${worktree
+        ? `
+## worktree
+
+This session is running inside a git worktree.
+- **Worktree path:** \`${worktree.worktreeDirectory}\`
+- **Branch:** \`${worktree.branch}\`
+- **Main repo:** \`${worktree.mainRepoDirectory}\`
+
+Before finishing a task, ask the user if they want to merge changes back to the main branch.
+
+To merge (without leaving the worktree):
+\`\`\`bash
+# Get the default branch name
+DEFAULT_BRANCH=$(git -C ${worktree.mainRepoDirectory} symbolic-ref refs/remotes/origin/HEAD 2>/dev/null | sed 's@^refs/remotes/origin/@@' || echo "main")
+
+# Merge worktree branch into main
+git -C ${worktree.mainRepoDirectory} checkout $DEFAULT_BRANCH && git -C ${worktree.mainRepoDirectory} merge ${worktree.branch}
+\`\`\`
 `
         : ''}
 ## showing diffs
@@ -72,6 +92,10 @@ bunx critique HEAD~1 --web "Update dependencies"
 
 Do this in case you committed the changes yourself (only if the user asks so, never commit otherwise).
 
+To compare two branches:
+
+bunx critique main feature-branch --web "Compare branches"
+
 The command outputs a URL - share that URL with the user so they can see the diff.
 
 ## markdown

package/dist/worktree-utils.js

@@ -0,0 +1,50 @@
+// Worktree utility functions.
+// Wrapper for OpenCode worktree creation that also initializes git submodules.
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+import { createLogger } from './logger.js';
+export const execAsync = promisify(exec);
+const logger = createLogger('WORKTREE-UTILS');
+/**
+ * Create a worktree using OpenCode SDK and initialize git submodules.
+ * This wrapper ensures submodules are properly set up in new worktrees.
+ */
+export async function createWorktreeWithSubmodules({ clientV2, directory, name, }) {
+    // 1. Create worktree via OpenCode SDK
+    const response = await clientV2.worktree.create({
+        directory,
+        worktreeCreateInput: { name },
+    });
+    if (response.error) {
+        return new Error(`SDK error: ${JSON.stringify(response.error)}`);
+    }
+    if (!response.data) {
+        return new Error('No worktree data returned from SDK');
+    }
+    const worktreeDir = response.data.directory;
+    // 2. Init submodules in new worktree (don't block on failure)
+    try {
+        logger.log(`Initializing submodules in ${worktreeDir}`);
+        await execAsync('git submodule update --init --recursive', {
+            cwd: worktreeDir,
+        });
+        logger.log(`Submodules initialized in ${worktreeDir}`);
+    }
+    catch (e) {
+        // Log but don't fail - submodules might not exist
+        logger.warn(`Failed to init submodules in ${worktreeDir}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    // 3. Install dependencies using ni (detects package manager from lockfile)
+    try {
+        logger.log(`Installing dependencies in ${worktreeDir}`);
+        await execAsync('npx -y ni', {
+            cwd: worktreeDir,
+        });
+        logger.log(`Dependencies installed in ${worktreeDir}`);
+    }
+    catch (e) {
+        // Log but don't fail - might not be a JS project or might fail for various reasons
+        logger.warn(`Failed to install dependencies in ${worktreeDir}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    return response.data;
+}

package/package.json

@@ -2,7 +2,7 @@
   "name": "kimaki",
   "module": "index.ts",
   "type": "module",
-  "version": "0.4.43",
+  "version": "0.4.44",
   "repository": "https://github.com/remorses/kimaki",
   "bin": "bin.js",
   "files": [

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))
@@ -1386,6 +1402,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 +1430,7 @@ cli
             JSON.stringify({
               content: summaryContent,
               attachments: [{ id: 0, filename: 'prompt.md' }],
+              embeds: autoStartEmbed,
             }),
           )
           const buffer = fs.readFileSync(tmpFile)
@@ -1446,6 +1470,7 @@ cli
             },
             body: JSON.stringify({
               content: prompt,
+              embeds: autoStartEmbed,
             }),
           },
         )
@@ -1486,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}`
@@ -1518,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()