kimaki 0.4.43 → 0.4.45

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, getChannelDirectory, } 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';
@@ -11,7 +14,7 @@ import { voiceConnections, cleanupVoiceConnection, processVoiceAttachment, regis
 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';
@@ -19,7 +22,6 @@ export { ensureKimakiCategory, ensureKimakiAudioCategory, createProjectChannels,
 import { ChannelType, Client, Events, GatewayIntentBits, Partials, PermissionsBitField, ThreadAutoArchiveDuration, } 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';
 // Increase connection pool to prevent deadlock when multiple sessions have open SSE streams.
@@ -39,7 +41,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();
     }
@@ -127,13 +129,12 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                 const parent = thread.parent;
                 let projectDirectory;
                 let channelAppId;
-                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
                 const worktreeInfo = getThreadWorktree(thread.id);
@@ -152,9 +153,11 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                         });
                         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})`);
                     }
                 }
                 if (channelAppId && channelAppId !== currentAppId) {
@@ -268,20 +271,13 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
             if (channel.type === ChannelType.GuildText) {
                 const textChannel = channel;
                 voiceLogger.log(`[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();
-                if (!projectDirectory) {
-                    voiceLogger.log(`[IGNORED] Channel #${textChannel.name} has no kimaki.directory tag`);
+                const channelConfig = getChannelDirectory(textChannel.id);
+                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})`);
                     return;
@@ -299,20 +295,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 +379,7 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                 await handleOpencodeSession({
                     prompt: promptWithAttachments,
                     thread,
-                    projectDirectory,
+                    projectDirectory: sessionDirectory,
                     originalMessage: message,
                     images: fileAttachments,
                     channelId: textChannel.id,
@@ -349,53 +401,43 @@ 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`);
                 return;
             }
-            // Extract directory from parent channel topic
-            if (!parent.topic) {
-                discordLogger.log(`[BOT_SESSION] Parent channel has no topic`);
-                return;
-            }
-            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`);
+            // Get directory from database
+            const channelConfig = getChannelDirectory(parent.id);
+            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/dist/discord-utils.js

@@ -3,8 +3,8 @@
 // thread message sending, and channel metadata extraction from topic tags.
 import { ChannelType } 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';
@@ -106,8 +106,14 @@ export function splitMarkdownForDiscord({ content, maxLength, }) {
         }
         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
             if (line.text.length > maxLength) {
@@ -164,9 +170,37 @@ export function splitMarkdownForDiscord({ content, maxLength, }) {
             }
             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;
+                    }
                 }
             }
         }
@@ -181,6 +215,9 @@ export function splitMarkdownForDiscord({ content, maxLength, }) {
         }
     }
     if (currentChunk) {
+        if (currentLang !== null) {
+            currentChunk += closingFence;
+        }
         chunks.push(currentChunk);
     }
     return chunks;
@@ -236,16 +273,17 @@ export function escapeDiscordFormatting(text) {
     return text.replace(/```/g, '\\`\\`\\`').replace(/````/g, '\\`\\`\\`\\`');
 }
 export function getKimakiMetadata(textChannel) {
-    if (!textChannel?.topic) {
+    if (!textChannel) {
         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();
-    return { projectDirectory, channelAppId };
+    const channelConfig = getChannelDirectory(textChannel.id);
+    if (!channelConfig) {
+        return {};
+    }
+    return {
+        projectDirectory: channelConfig.directory,
+        channelAppId: channelConfig.appId || undefined,
+    };
 }
 /**
  * Upload files to a Discord thread/channel in a single message.

package/dist/discord-utils.test.js

@@ -0,0 +1,20 @@
+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/dist/escape-backticks.test.js

@@ -171,11 +171,17 @@ test('splitMarkdownForDiscord adds closing and opening fences when splitting cod
     [
       "\`\`\`js
     line1
+    \`\`\`
+    ",
+      "\`\`\`js
     line2
     \`\`\`
     ",
       "\`\`\`js
     line3
+    \`\`\`
+    ",
+      "\`\`\`js
     line4
     \`\`\`
     ",
@@ -209,10 +215,12 @@ test('splitMarkdownForDiscord handles mixed content with code blocks', () => {
     [
       "Text before
     \`\`\`js
-    code
     \`\`\`
     ",
-      "Text after",
+      "\`\`\`js
+    code
+    \`\`\`
+    Text after",
     ]
   `);
 });
@@ -224,6 +232,9 @@ test('splitMarkdownForDiscord handles code block without language', () => {
     expect(result).toMatchInlineSnapshot(`
     [
       "\`\`\`
+    \`\`\`
+    ",
+      "\`\`\`
     line1
     \`\`\`
     ",
@@ -402,10 +413,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/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';
@@ -18,6 +20,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');
 export function registerInteractionHandler({ discordClient, appId, }) {
@@ -57,6 +60,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;
@@ -97,6 +109,9 @@ export function registerInteractionHandler({ discordClient, appId, }) {
                     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)
                 if (interaction.commandName.endsWith('-agent') && interaction.commandName !== 'agent') {