kimaki 0.4.2 → 0.4.6

package/dist/discordBot.js

@@ -327,7 +327,6 @@ function frameMono16khz() {
 }
 export function getDatabase() {
     if (!db) {
-        // Create ~/.kimaki directory if it doesn't exist
         const kimakiDir = path.join(os.homedir(), '.kimaki');
         try {
             fs.mkdirSync(kimakiDir, { recursive: true });
@@ -338,7 +337,6 @@ export function getDatabase() {
         const dbPath = path.join(kimakiDir, 'discord-sessions.db');
         dbLogger.log(`Opening database at: ${dbPath}`);
         db = new Database(dbPath);
-        // Initialize tables
         db.exec(`
       CREATE TABLE IF NOT EXISTS thread_sessions (
         thread_id TEXT PRIMARY KEY,
@@ -379,6 +377,51 @@ export function getDatabase() {
     }
     return db;
 }
+export async function ensureKimakiCategory(guild) {
+    const existingCategory = guild.channels.cache.find((channel) => {
+        if (channel.type !== ChannelType.GuildCategory) {
+            return false;
+        }
+        return channel.name.toLowerCase() === 'kimaki';
+    });
+    if (existingCategory) {
+        return existingCategory;
+    }
+    return guild.channels.create({
+        name: 'Kimaki',
+        type: ChannelType.GuildCategory,
+    });
+}
+export async function createProjectChannels({ guild, projectDirectory, appId, }) {
+    const baseName = path.basename(projectDirectory);
+    const channelName = `${baseName}`
+        .toLowerCase()
+        .replace(/[^a-z0-9-]/g, '-')
+        .slice(0, 100);
+    const kimakiCategory = await ensureKimakiCategory(guild);
+    const textChannel = await guild.channels.create({
+        name: channelName,
+        type: ChannelType.GuildText,
+        parent: kimakiCategory,
+        topic: `<kimaki><directory>${projectDirectory}</directory><app>${appId}</app></kimaki>`,
+    });
+    const voiceChannel = await guild.channels.create({
+        name: channelName,
+        type: ChannelType.GuildVoice,
+        parent: kimakiCategory,
+    });
+    getDatabase()
+        .prepare('INSERT OR REPLACE INTO channel_directories (channel_id, directory, channel_type) VALUES (?, ?, ?)')
+        .run(textChannel.id, projectDirectory, 'text');
+    getDatabase()
+        .prepare('INSERT OR REPLACE INTO channel_directories (channel_id, directory, channel_type) VALUES (?, ?, ?)')
+        .run(voiceChannel.id, projectDirectory, 'voice');
+    return {
+        textChannelId: textChannel.id,
+        voiceChannelId: voiceChannel.id,
+        channelName,
+    };
+}
 async function getOpenPort() {
     return new Promise((resolve, reject) => {
         const server = net.createServer();
@@ -405,6 +448,7 @@ async function getOpenPort() {
  */
 async function sendThreadMessage(thread, content) {
     const MAX_LENGTH = 2000;
+    content = escapeBackticksInCodeBlocks(content);
     // Simple case: content fits in one message
     if (content.length <= MAX_LENGTH) {
         return await thread.send(content);
@@ -551,6 +595,30 @@ async function processVoiceAttachment({ message, thread, projectDirectory, isNew
     await sendThreadMessage(thread, `📝 **Transcribed message:** ${escapeDiscordFormatting(transcription)}`);
     return transcription;
 }
+function getImageAttachments(message) {
+    const imageAttachments = Array.from(message.attachments.values()).filter((attachment) => attachment.contentType?.startsWith('image/'));
+    return imageAttachments.map((attachment) => ({
+        type: 'file',
+        mime: attachment.contentType || 'image/png',
+        filename: attachment.name,
+        url: attachment.url,
+    }));
+}
+export function escapeBackticksInCodeBlocks(markdown) {
+    const lexer = new Lexer();
+    const tokens = lexer.lex(markdown);
+    let result = '';
+    for (const token of tokens) {
+        if (token.type === 'code') {
+            const escapedCode = token.text.replace(/`/g, '\\`');
+            result += '```' + (token.lang || '') + '\n' + escapedCode + '\n```\n';
+        }
+        else {
+            result += token.raw;
+        }
+    }
+    return result;
+}
 /**
  * Escape Discord formatting characters to prevent breaking code blocks and inline code
  */
@@ -708,130 +776,123 @@ export async function initializeOpencodeForDirectory(directory) {
         return entry.client;
     };
 }
+function getToolSummaryText(part) {
+    if (part.type !== 'tool')
+        return '';
+    if (part.state.status !== 'completed' && part.state.status !== 'error')
+        return '';
+    if (part.tool === 'bash') {
+        const output = part.state.status === 'completed' ? part.state.output : part.state.error;
+        const lines = (output || '').split('\n').filter((l) => l.trim());
+        return `(${lines.length} line${lines.length === 1 ? '' : 's'})`;
+    }
+    if (part.tool === 'edit') {
+        const newString = part.state.input?.newString || '';
+        const oldString = part.state.input?.oldString || '';
+        const added = newString.split('\n').length;
+        const removed = oldString.split('\n').length;
+        return `(+${added}-${removed})`;
+    }
+    if (part.tool === 'write') {
+        const content = part.state.input?.content || '';
+        const lines = content.split('\n').length;
+        return `(${lines} line${lines === 1 ? '' : 's'})`;
+    }
+    if (part.tool === 'webfetch') {
+        const url = part.state.input?.url || '';
+        const urlWithoutProtocol = url.replace(/^https?:\/\//, '');
+        return urlWithoutProtocol ? `(${urlWithoutProtocol})` : '';
+    }
+    if (part.tool === 'read' ||
+        part.tool === 'list' ||
+        part.tool === 'glob' ||
+        part.tool === 'grep' ||
+        part.tool === 'task' ||
+        part.tool === 'todoread' ||
+        part.tool === 'todowrite') {
+        return '';
+    }
+    if (!part.state.input)
+        return '';
+    const inputFields = Object.entries(part.state.input)
+        .map(([key, value]) => {
+        if (value === null || value === undefined)
+            return null;
+        const stringValue = typeof value === 'string' ? value : JSON.stringify(value);
+        const truncatedValue = stringValue.length > 100 ? stringValue.slice(0, 100) + '…' : stringValue;
+        return `${key}: ${truncatedValue}`;
+    })
+        .filter(Boolean);
+    if (inputFields.length === 0)
+        return '';
+    return `(${inputFields.join(', ')})`;
+}
+function getToolOutputToDisplay(part) {
+    if (part.type !== 'tool')
+        return '';
+    if (part.state.status !== 'completed' && part.state.status !== 'error')
+        return '';
+    if (part.state.status === 'error') {
+        return part.state.error || 'Unknown error';
+    }
+    if (part.tool === 'todowrite') {
+        const todos = part.state.input?.todos || [];
+        return todos
+            .map((todo) => {
+            let statusIcon = '▢';
+            if (todo.status === 'in_progress') {
+                statusIcon = '●';
+            }
+            if (todo.status === 'completed' || todo.status === 'cancelled') {
+                statusIcon = '■';
+            }
+            return `\`${statusIcon}\` ${todo.content}`;
+        })
+            .filter(Boolean)
+            .join('\n');
+    }
+    return '';
+}
 function formatPart(part) {
-    switch (part.type) {
-        case 'text':
-            return escapeDiscordFormatting(part.text || '');
-        case 'reasoning':
-            if (!part.text?.trim())
-                return '';
-            return `▪︎ thinking: ${escapeDiscordFormatting(part.text || '')}`;
-        case 'tool':
-            if (part.state.status === 'completed' || part.state.status === 'error') {
-                let outputToDisplay = '';
-                let summaryText = '';
-                if (part.tool === 'bash') {
-                    const output = part.state.status === 'completed'
-                        ? part.state.output
-                        : part.state.error;
-                    const lines = (output || '').split('\n').filter((l) => l.trim());
-                    summaryText = `(${lines.length} line${lines.length === 1 ? '' : 's'})`;
-                }
-                else if (part.tool === 'edit') {
-                    const newString = part.state.input?.newString || '';
-                    const oldString = part.state.input?.oldString || '';
-                    const added = newString.split('\n').length;
-                    const removed = oldString.split('\n').length;
-                    summaryText = `(+${added}-${removed})`;
-                }
-                else if (part.tool === 'write') {
-                    const content = part.state.input?.content || '';
-                    const lines = content.split('\n').length;
-                    summaryText = `(${lines} line${lines === 1 ? '' : 's'})`;
-                }
-                else if (part.tool === 'read') {
-                }
-                else if (part.tool === 'write') {
-                }
-                else if (part.tool === 'edit') {
-                }
-                else if (part.tool === 'list') {
-                }
-                else if (part.tool === 'glob') {
-                }
-                else if (part.tool === 'grep') {
-                }
-                else if (part.tool === 'task') {
-                }
-                else if (part.tool === 'todoread') {
-                    // Special handling for read - don't show arguments
-                }
-                else if (part.tool === 'todowrite') {
-                    const todos = part.state.input?.todos || [];
-                    outputToDisplay = todos
-                        .map((todo) => {
-                        let statusIcon = '▢';
-                        switch (todo.status) {
-                            case 'pending':
-                                statusIcon = '▢';
-                                break;
-                            case 'in_progress':
-                                statusIcon = '●';
-                                break;
-                            case 'completed':
-                                statusIcon = '■';
-                                break;
-                            case 'cancelled':
-                                statusIcon = '■';
-                                break;
-                        }
-                        return `\`${statusIcon}\` ${todo.content}`;
-                    })
-                        .filter(Boolean)
-                        .join('\n');
-                }
-                else if (part.tool === 'webfetch') {
-                    const url = part.state.input?.url || '';
-                    const urlWithoutProtocol = url.replace(/^https?:\/\//, '');
-                    summaryText = urlWithoutProtocol ? `(${urlWithoutProtocol})` : '';
-                }
-                else if (part.state.input) {
-                    const inputFields = Object.entries(part.state.input)
-                        .map(([key, value]) => {
-                        if (value === null || value === undefined)
-                            return null;
-                        const stringValue = typeof value === 'string' ? value : JSON.stringify(value);
-                        const truncatedValue = stringValue.length > 100
-                            ? stringValue.slice(0, 100) + '…'
-                            : stringValue;
-                        return `${key}: ${truncatedValue}`;
-                    })
-                        .filter(Boolean);
-                    if (inputFields.length > 0) {
-                        outputToDisplay = inputFields.join(', ');
-                    }
-                }
-                let toolTitle = part.state.status === 'completed' ? part.state.title || '' : 'error';
-                if (toolTitle) {
-                    toolTitle = `\`${escapeInlineCode(toolTitle)}\``;
-                }
-                const icon = part.state.status === 'completed'
-                    ? '◼︎'
-                    : part.state.status === 'error'
-                        ? '⨯'
-                        : '';
-                const title = `${icon} ${part.tool} ${toolTitle} ${summaryText}`;
-                let text = title;
-                if (outputToDisplay) {
-                    text += '\n\n' + outputToDisplay;
-                }
-                return text;
-            }
-            return '';
-        case 'file':
-            return `📄 ${part.filename || 'File'}`;
-        case 'step-start':
-        case 'step-finish':
-        case 'patch':
+    if (part.type === 'text') {
+        return part.text || '';
+    }
+    if (part.type === 'reasoning') {
+        if (!part.text?.trim())
             return '';
-        case 'agent':
-            return `◼︎ agent ${part.id}`;
-        case 'snapshot':
-            return `◼︎ snapshot ${part.snapshot}`;
-        default:
-            discordLogger.warn('Unknown part type:', part);
+        return `◼︎ thinking`;
+    }
+    if (part.type === 'file') {
+        return `📄 ${part.filename || 'File'}`;
+    }
+    if (part.type === 'step-start' || part.type === 'step-finish' || part.type === 'patch') {
+        return '';
+    }
+    if (part.type === 'agent') {
+        return `◼︎ agent ${part.id}`;
+    }
+    if (part.type === 'snapshot') {
+        return `◼︎ snapshot ${part.snapshot}`;
+    }
+    if (part.type === 'tool') {
+        if (part.state.status !== 'completed' && part.state.status !== 'error') {
             return '';
+        }
+        const summaryText = getToolSummaryText(part);
+        const outputToDisplay = getToolOutputToDisplay(part);
+        let toolTitle = part.state.status === 'completed' ? part.state.title || '' : 'error';
+        if (toolTitle) {
+            toolTitle = `*${toolTitle}*`;
+        }
+        const icon = part.state.status === 'completed' ? '◼︎' : part.state.status === 'error' ? '⨯' : '';
+        const title = `${icon} ${part.tool} ${toolTitle} ${summaryText}`;
+        if (outputToDisplay) {
+            return title + '\n\n' + outputToDisplay;
+        }
+        return title;
     }
+    discordLogger.warn('Unknown part type:', part);
+    return '';
 }
 export async function createDiscordClient() {
     return new Client({
@@ -849,7 +910,7 @@ export async function createDiscordClient() {
         ],
     });
 }
-async function handleOpencodeSession(prompt, thread, projectDirectory, originalMessage) {
+async function handleOpencodeSession({ prompt, thread, projectDirectory, originalMessage, images = [], }) {
     voiceLogger.log(`[OPENCODE SESSION] Starting for thread ${thread.id} with prompt: "${prompt.slice(0, 50)}${prompt.length > 50 ? '...' : ''}"`);
     // Track session start time
     const sessionStartTime = Date.now();
@@ -868,6 +929,9 @@ async function handleOpencodeSession(prompt, thread, projectDirectory, originalM
     sessionLogger.log(`Using directory: ${directory}`);
     // Note: We'll cancel the existing request after we have the session ID
     const getClient = await initializeOpencodeForDirectory(directory);
+    // Get the port for this directory
+    const serverEntry = opencodeServers.get(directory);
+    const port = serverEntry?.port;
     // Get session ID from database
     const row = getDatabase()
         .prepare('SELECT session_id FROM thread_sessions WHERE thread_id = ?')
@@ -939,6 +1003,7 @@ async function handleOpencodeSession(prompt, thread, projectDirectory, originalM
     }
     let currentParts = [];
     let stopTyping = null;
+    let usedModel;
     const sendPartMessage = async (part) => {
         const content = formatPart(part) + '\n\n';
         if (!content.trim() || content.length === 0) {
@@ -1023,6 +1088,7 @@ async function handleOpencodeSession(prompt, thread, projectDirectory, originalM
                     // Track assistant message ID
                     if (msg.role === 'assistant') {
                         assistantMessageId = msg.id;
+                        usedModel = msg.modelID;
                         voiceLogger.log(`[EVENT] Tracking assistant message ${assistantMessageId}`);
                     }
                     else {
@@ -1142,8 +1208,10 @@ async function handleOpencodeSession(prompt, thread, projectDirectory, originalM
             if (!abortController.signal.aborted ||
                 abortController.signal.reason === 'finished') {
                 const sessionDuration = prettyMilliseconds(Date.now() - sessionStartTime);
-                await sendThreadMessage(thread, `_Completed in ${sessionDuration}_`);
-                sessionLogger.log(`DURATION: Session completed in ${sessionDuration}`);
+                const attachCommand = port ? ` ⋅ ${session.id}` : '';
+                const modelInfo = usedModel ? ` ⋅ ${usedModel}` : '';
+                await sendThreadMessage(thread, `_Completed in ${sessionDuration}_${attachCommand}${modelInfo}`);
+                sessionLogger.log(`DURATION: Session completed in ${sessionDuration}, port ${port}, model ${usedModel}`);
             }
             else {
                 sessionLogger.log(`Session was aborted (reason: ${abortController.signal.reason}), skipping duration message`);
@@ -1152,18 +1220,22 @@ async function handleOpencodeSession(prompt, thread, projectDirectory, originalM
     };
     try {
         voiceLogger.log(`[PROMPT] Sending prompt to session ${session.id}: "${prompt.slice(0, 100)}${prompt.length > 100 ? '...' : ''}"`);
+        if (images.length > 0) {
+            sessionLogger.log(`[PROMPT] Sending ${images.length} image(s):`, images.map((img) => ({ mime: img.mime, filename: img.filename, url: img.url.slice(0, 100) })));
+        }
         // Start the event handler
         const eventHandlerPromise = eventHandler();
+        const parts = [{ type: 'text', text: prompt }, ...images];
+        sessionLogger.log(`[PROMPT] Parts to send:`, parts.length);
         const response = await getClient().session.prompt({
             path: { id: session.id },
             body: {
-                parts: [{ type: 'text', text: prompt }],
+                parts,
             },
             signal: abortController.signal,
         });
-        abortController.abort(new Error('finished'));
+        abortController.abort('finished');
         sessionLogger.log(`Successfully sent prompt, got response`);
-        abortControllers.delete(session.id);
         // Update reaction to success
         if (originalMessage) {
             try {
@@ -1175,12 +1247,12 @@ async function handleOpencodeSession(prompt, thread, projectDirectory, originalM
                 discordLogger.log(`Could not update reaction:`, e);
             }
         }
-        return { sessionID: session.id, result: response.data };
+        return { sessionID: session.id, result: response.data, port };
     }
     catch (error) {
         sessionLogger.error(`ERROR: Failed to send prompt:`, error);
         if (!isAbortError(error, abortController.signal)) {
-            abortController.abort(new Error('error'));
+            abortController.abort('error');
             if (originalMessage) {
                 try {
                     await originalMessage.reactions.removeAll();
@@ -1191,7 +1263,6 @@ async function handleOpencodeSession(prompt, thread, projectDirectory, originalM
                     discordLogger.log(`Could not update reaction:`, e);
                 }
             }
-            // Always log the error's constructor name (if any) and make error reporting more readable
             const errorName = error &&
                 typeof error === 'object' &&
                 'constructor' in error &&
@@ -1350,7 +1421,14 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                 if (transcription) {
                     messageContent = transcription;
                 }
-                await handleOpencodeSession(messageContent, thread, projectDirectory, message);
+                const images = getImageAttachments(message);
+                await handleOpencodeSession({
+                    prompt: messageContent,
+                    thread,
+                    projectDirectory,
+                    originalMessage: message,
+                    images,
+                });
                 return;
             }
             // For text channels, start new sessions with kimaki.directory tag
@@ -1409,7 +1487,14 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                 if (transcription) {
                     messageContent = transcription;
                 }
-                await handleOpencodeSession(messageContent, thread, projectDirectory, message);
+                const images = getImageAttachments(message);
+                await handleOpencodeSession({
+                    prompt: messageContent,
+                    thread,
+                    projectDirectory,
+                    originalMessage: message,
+                    images,
+                });
             }
             else {
                 discordLogger.log(`Channel type ${channel.type} is not supported`);
@@ -1466,10 +1551,20 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                             .toLowerCase()
                             .includes(focusedValue.toLowerCase()))
                             .slice(0, 25) // Discord limit
-                            .map((session) => ({
-                            name: `${session.title} (${new Date(session.time.updated).toLocaleString()})`,
-                            value: session.id,
-                        }));
+                            .map((session) => {
+                            const dateStr = new Date(session.time.updated).toLocaleString();
+                            const suffix = ` (${dateStr})`;
+                            // Discord limit is 100 chars. Reserve space for suffix.
+                            const maxTitleLength = 100 - suffix.length;
+                            let title = session.title;
+                            if (title.length > maxTitleLength) {
+                                title = title.slice(0, Math.max(0, maxTitleLength - 1)) + '…';
+                            }
+                            return {
+                                name: `${title}${suffix}`,
+                                value: session.id,
+                            };
+                        });
                         await interaction.respond(sessions);
                     }
                     catch (error) {
@@ -1523,7 +1618,6 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                                 : '';
                             // Map to Discord autocomplete format
                             const choices = files
-                                .slice(0, 25) // Discord limit
                                 .map((file) => {
                                 const fullValue = prefix + file;
                                 // Get all basenames for display
@@ -1538,7 +1632,10 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                                     name: displayName,
                                     value: fullValue,
                                 };
-                            });
+                            })
+                                // Discord API limits choice value to 100 characters
+                                .filter((choice) => choice.value.length <= 100)
+                                .slice(0, 25); // Discord limit
                             await interaction.respond(choices);
                         }
                         catch (error) {
@@ -1547,6 +1644,48 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                         }
                     }
                 }
+                else if (interaction.commandName === 'add-project') {
+                    const focusedValue = interaction.options.getFocused();
+                    try {
+                        const currentDir = process.cwd();
+                        const getClient = await initializeOpencodeForDirectory(currentDir);
+                        const projectsResponse = await getClient().project.list({});
+                        if (!projectsResponse.data) {
+                            await interaction.respond([]);
+                            return;
+                        }
+                        const db = getDatabase();
+                        const existingDirs = db
+                            .prepare('SELECT DISTINCT directory FROM channel_directories WHERE channel_type = ?')
+                            .all('text');
+                        const existingDirSet = new Set(existingDirs.map((row) => row.directory));
+                        const availableProjects = projectsResponse.data.filter((project) => !existingDirSet.has(project.worktree));
+                        const projects = availableProjects
+                            .filter((project) => {
+                            const baseName = path.basename(project.worktree);
+                            const searchText = `${baseName} ${project.worktree}`.toLowerCase();
+                            return searchText.includes(focusedValue.toLowerCase());
+                        })
+                            .sort((a, b) => {
+                            const aTime = a.time.initialized || a.time.created;
+                            const bTime = b.time.initialized || b.time.created;
+                            return bTime - aTime;
+                        })
+                            .slice(0, 25)
+                            .map((project) => {
+                            const name = `${path.basename(project.worktree)} (${project.worktree})`;
+                            return {
+                                name: name.length > 100 ? name.slice(0, 99) + '…' : name,
+                                value: project.id,
+                            };
+                        });
+                        await interaction.respond(projects);
+                    }
+                    catch (error) {
+                        voiceLogger.error('[AUTOCOMPLETE] Error fetching projects:', error);
+                        await interaction.respond([]);
+                    }
+                }
             }
             // Handle slash commands
             if (interaction.isChatInputCommand()) {
@@ -1610,7 +1749,11 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                         });
                         await command.editReply(`Created new session in ${thread.toString()}`);
                         // Start the OpenCode session
-                        await handleOpencodeSession(fullPrompt, thread, projectDirectory);
+                        await handleOpencodeSession({
+                            prompt: fullPrompt,
+                            thread,
+                            projectDirectory,
+                        });
                     }
                     catch (error) {
                         voiceLogger.error('[SESSION] Error:', error);
@@ -1707,16 +1850,26 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                             }
                             else if (message.info.role === 'assistant') {
                                 // Render assistant parts
+                                const partsToRender = [];
                                 for (const part of message.parts) {
                                     const content = formatPart(part);
                                     if (content.trim()) {
-                                        const discordMessage = await sendThreadMessage(thread, content);
-                                        // Store part-message mapping in database
-                                        getDatabase()
-                                            .prepare('INSERT OR REPLACE INTO part_messages (part_id, message_id, thread_id) VALUES (?, ?, ?)')
-                                            .run(part.id, discordMessage.id, thread.id);
+                                        partsToRender.push({ id: part.id, content });
                                     }
                                 }
+                                if (partsToRender.length > 0) {
+                                    const combinedContent = partsToRender
+                                        .map((p) => p.content)
+                                        .join('\n\n');
+                                    const discordMessage = await sendThreadMessage(thread, combinedContent);
+                                    const stmt = getDatabase().prepare('INSERT OR REPLACE INTO part_messages (part_id, message_id, thread_id) VALUES (?, ?, ?)');
+                                    const transaction = getDatabase().transaction((parts) => {
+                                        for (const part of parts) {
+                                            stmt.run(part.id, discordMessage.id, thread.id);
+                                        }
+                                    });
+                                    transaction(partsToRender);
+                                }
                             }
                             messageCount++;
                         }
@@ -1727,6 +1880,53 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                         await command.editReply(`Failed to resume session: ${error instanceof Error ? error.message : 'Unknown error'}`);
                     }
                 }
+                else if (command.commandName === 'add-project') {
+                    await command.deferReply({ ephemeral: false });
+                    const projectId = command.options.getString('project', true);
+                    const guild = command.guild;
+                    if (!guild) {
+                        await command.editReply('This command can only be used in a guild');
+                        return;
+                    }
+                    try {
+                        const currentDir = process.cwd();
+                        const getClient = await initializeOpencodeForDirectory(currentDir);
+                        const projectsResponse = await getClient().project.list({});
+                        if (!projectsResponse.data) {
+                            await command.editReply('Failed to fetch projects');
+                            return;
+                        }
+                        const project = projectsResponse.data.find((p) => p.id === projectId);
+                        if (!project) {
+                            await command.editReply('Project not found');
+                            return;
+                        }
+                        const directory = project.worktree;
+                        if (!fs.existsSync(directory)) {
+                            await command.editReply(`Directory does not exist: ${directory}`);
+                            return;
+                        }
+                        const db = getDatabase();
+                        const existingChannel = db
+                            .prepare('SELECT channel_id FROM channel_directories WHERE directory = ? AND channel_type = ?')
+                            .get(directory, 'text');
+                        if (existingChannel) {
+                            await command.editReply(`A channel already exists for this directory: <#${existingChannel.channel_id}>`);
+                            return;
+                        }
+                        const { textChannelId, voiceChannelId, channelName } = await createProjectChannels({
+                            guild,
+                            projectDirectory: directory,
+                            appId: currentAppId,
+                        });
+                        await command.editReply(`✅ Created channels for project:\n📝 Text: <#${textChannelId}>\n🔊 Voice: <#${voiceChannelId}>\n📁 Directory: \`${directory}\``);
+                        discordLogger.log(`Created channels for project ${channelName} at ${directory}`);
+                    }
+                    catch (error) {
+                        voiceLogger.error('[ADD-PROJECT] Error:', error);
+                        await command.editReply(`Failed to create channels: ${error instanceof Error ? error.message : 'Unknown error'}`);
+                    }
+                }
             }
         }
         catch (error) {