kimaki 0.4.33 → 0.4.35

package/dist/cli.js

@@ -135,6 +135,13 @@ async function registerCommands(token, appId, userCommands = []) {
                 .setAutocomplete(true)
                 .setMaxLength(6000);
             return option;
+        })
+            .addStringOption((option) => {
+            option
+                .setName('agent')
+                .setDescription('Agent to use for this session')
+                .setAutocomplete(true);
+            return option;
         })
             .toJSON(),
         new SlashCommandBuilder()
@@ -213,7 +220,9 @@ async function registerCommands(token, appId, userCommands = []) {
         if (SKIP_USER_COMMANDS.includes(cmd.name)) {
             continue;
         }
-        const commandName = `${cmd.name}-cmd`;
+        // Sanitize command name: oh-my-opencode uses MCP commands with colons, which Discord doesn't allow
+        const sanitizedName = cmd.name.replace(/:/g, '-');
+        const commandName = `${sanitizedName}-cmd`;
         const description = cmd.description || `Run /${cmd.name} command`;
         commands.push(new SlashCommandBuilder()
             .setName(commandName)

package/dist/commands/session.js

@@ -13,6 +13,7 @@ export async function handleSessionCommand({ command, appId, }) {
     await command.deferReply({ ephemeral: false });
     const prompt = command.options.getString('prompt', true);
     const filesString = command.options.getString('files') || '';
+    const agent = command.options.getString('agent') || undefined;
     const channel = command.channel;
     if (!channel || channel.type !== ChannelType.GuildText) {
         await command.editReply('This command can only be used in text channels');
@@ -66,6 +67,7 @@ export async function handleSessionCommand({ command, appId, }) {
             thread,
             projectDirectory,
             channelId: textChannel.id,
+            agent,
         });
     }
     catch (error) {
@@ -73,8 +75,61 @@ export async function handleSessionCommand({ command, appId, }) {
         await command.editReply(`Failed to create session: ${error instanceof Error ? error.message : 'Unknown error'}`);
     }
 }
+async function handleAgentAutocomplete({ interaction, appId, }) {
+    const focusedValue = interaction.options.getFocused();
+    let projectDirectory;
+    if (interaction.channel) {
+        const channel = interaction.channel;
+        if (channel.type === ChannelType.GuildText) {
+            const textChannel = channel;
+            if (textChannel.topic) {
+                const extracted = extractTagsArrays({
+                    xml: textChannel.topic,
+                    tags: ['kimaki.directory', 'kimaki.app'],
+                });
+                const channelAppId = extracted['kimaki.app']?.[0]?.trim();
+                if (channelAppId && channelAppId !== appId) {
+                    await interaction.respond([]);
+                    return;
+                }
+                projectDirectory = extracted['kimaki.directory']?.[0]?.trim();
+            }
+        }
+    }
+    if (!projectDirectory) {
+        await interaction.respond([]);
+        return;
+    }
+    try {
+        const getClient = await initializeOpencodeForDirectory(projectDirectory);
+        const agentsResponse = await getClient().app.agents({
+            query: { directory: projectDirectory },
+        });
+        if (!agentsResponse.data || agentsResponse.data.length === 0) {
+            await interaction.respond([]);
+            return;
+        }
+        const agents = agentsResponse.data
+            .filter((a) => a.mode === 'primary' || a.mode === 'all')
+            .filter((a) => a.name.toLowerCase().includes(focusedValue.toLowerCase()))
+            .slice(0, 25);
+        const choices = agents.map((agent) => ({
+            name: agent.name.slice(0, 100),
+            value: agent.name,
+        }));
+        await interaction.respond(choices);
+    }
+    catch (error) {
+        logger.error('[AUTOCOMPLETE] Error fetching agents:', error);
+        await interaction.respond([]);
+    }
+}
 export async function handleSessionAutocomplete({ interaction, appId, }) {
     const focusedOption = interaction.options.getFocused(true);
+    if (focusedOption.name === 'agent') {
+        await handleAgentAutocomplete({ interaction, appId });
+        return;
+    }
     if (focusedOption.name !== 'files') {
         return;
     }

package/dist/logger.js

@@ -5,6 +5,7 @@ import { log } from '@clack/prompts';
 import fs from 'node:fs';
 import path, { dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import util from 'node:util';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const isDev = !__dirname.includes('node_modules');
@@ -17,35 +18,41 @@ if (isDev) {
     }
     fs.writeFileSync(logFilePath, `--- kimaki log started at ${new Date().toISOString()} ---\n`);
 }
+function formatArg(arg) {
+    if (typeof arg === 'string') {
+        return arg;
+    }
+    return util.inspect(arg, { colors: true, depth: 4 });
+}
 function writeToFile(level, prefix, args) {
     if (!isDev) {
         return;
     }
     const timestamp = new Date().toISOString();
-    const message = `[${timestamp}] [${level}] [${prefix}] ${args.map((arg) => String(arg)).join(' ')}\n`;
+    const message = `[${timestamp}] [${level}] [${prefix}] ${args.map(formatArg).join(' ')}\n`;
     fs.appendFileSync(logFilePath, message);
 }
 export function createLogger(prefix) {
     return {
         log: (...args) => {
             writeToFile('INFO', prefix, args);
-            log.info([`[${prefix}]`, ...args.map((arg) => String(arg))].join(' '));
+            log.info([`[${prefix}]`, ...args.map(formatArg)].join(' '));
         },
         error: (...args) => {
             writeToFile('ERROR', prefix, args);
-            log.error([`[${prefix}]`, ...args.map((arg) => String(arg))].join(' '));
+            log.error([`[${prefix}]`, ...args.map(formatArg)].join(' '));
         },
         warn: (...args) => {
             writeToFile('WARN', prefix, args);
-            log.warn([`[${prefix}]`, ...args.map((arg) => String(arg))].join(' '));
+            log.warn([`[${prefix}]`, ...args.map(formatArg)].join(' '));
         },
         info: (...args) => {
             writeToFile('INFO', prefix, args);
-            log.info([`[${prefix}]`, ...args.map((arg) => String(arg))].join(' '));
+            log.info([`[${prefix}]`, ...args.map(formatArg)].join(' '));
         },
         debug: (...args) => {
             writeToFile('DEBUG', prefix, args);
-            log.info([`[${prefix}]`, ...args.map((arg) => String(arg))].join(' '));
+            log.info([`[${prefix}]`, ...args.map(formatArg)].join(' '));
         },
     };
 }

package/dist/opencode.js

@@ -87,8 +87,7 @@ export async function initializeOpencodeForDirectory(directory) {
         throw new Error(`Directory does not exist or is not accessible: ${directory}`);
     }
     const port = await getOpenPort();
-    const opencodeBinDir = `${process.env.HOME}/.opencode/bin`;
-    const opencodeCommand = process.env.OPENCODE_PATH || `${opencodeBinDir}/opencode`;
+    const opencodeCommand = process.env.OPENCODE_PATH || 'opencode';
     const serverProcess = spawn(opencodeCommand, ['serve', '--port', port.toString()], {
         stdio: 'pipe',
         detached: false,

package/dist/session-handler.js

@@ -2,14 +2,14 @@
 // 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 } from './database.js';
+import { getDatabase, getSessionModel, getChannelModel, getSessionAgent, getChannelAgent, setSessionAgent } 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';
 import { getOpencodeSystemMessage } from './system-message.js';
 import { createLogger } from './logger.js';
 import { isAbortError } from './utils.js';
-import { showAskUserQuestionDropdowns, cancelPendingQuestion } from './commands/ask-question.js';
+import { showAskUserQuestionDropdowns, cancelPendingQuestion, pendingQuestionContexts } from './commands/ask-question.js';
 import { showPermissionDropdown, cleanupPermissionContext } from './commands/permissions.js';
 const sessionLogger = createLogger('SESSION');
 const voiceLogger = createLogger('VOICE');
@@ -85,7 +85,7 @@ export async function abortAndRetrySession({ sessionId, thread, projectDirectory
     });
     return true;
 }
-export async function handleOpencodeSession({ prompt, thread, projectDirectory, originalMessage, images = [], channelId, command, }) {
+export async function handleOpencodeSession({ prompt, thread, projectDirectory, originalMessage, images = [], channelId, command, agent, }) {
     voiceLogger.log(`[OPENCODE SESSION] Starting for thread ${thread.id} with prompt: "${prompt.slice(0, 50)}${prompt.length > 50 ? '...' : ''}"`);
     const sessionStartTime = Date.now();
     const directory = projectDirectory || process.cwd();
@@ -127,6 +127,11 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
         .prepare('INSERT OR REPLACE INTO thread_sessions (thread_id, session_id) VALUES (?, ?)')
         .run(thread.id, session.id);
     sessionLogger.log(`Stored session ${session.id} for thread ${thread.id}`);
+    // Store agent preference if provided
+    if (agent) {
+        setSessionAgent(session.id, agent);
+        sessionLogger.log(`Set agent preference for session ${session.id}: ${agent}`);
+    }
     const existingController = abortControllers.get(session.id);
     if (existingController) {
         voiceLogger.log(`[ABORT] Cancelling existing request for session: ${session.id}`);
@@ -154,11 +159,10 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
             pendingPermissions.delete(thread.id);
         }
     }
-    // Cancel any pending question tool if user sends a new message
+    // Cancel any pending question tool if user sends a new message (silently, no thread message)
     const questionCancelled = await cancelPendingQuestion(thread.id);
     if (questionCancelled) {
         sessionLogger.log(`[QUESTION] Cancelled pending question due to new message`);
-        await sendThreadMessage(thread, `⚠️ Previous question cancelled - processing your new message`);
     }
     const abortController = new AbortController();
     abortControllers.set(session.id, abortController);
@@ -310,7 +314,12 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                         currentParts.push(part);
                     }
                     if (part.type === 'step-start') {
-                        stopTyping = startTyping();
+                        // Don't start typing if user needs to respond to a question or permission
+                        const hasPendingQuestion = [...pendingQuestionContexts.values()].some((ctx) => ctx.thread.id === thread.id);
+                        const hasPendingPermission = pendingPermissions.has(thread.id);
+                        if (!hasPendingQuestion && !hasPendingPermission) {
+                            stopTyping = startTyping();
+                        }
                     }
                     if (part.type === 'tool' && part.state.status === 'running') {
                         // Flush any pending text/reasoning parts before showing the tool
@@ -348,6 +357,11 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                     if (part.type === 'reasoning') {
                         await sendPartMessage(part);
                     }
+                    // Send text parts when complete (time.end is set)
+                    // Text parts stream incrementally; only send when finished to avoid partial text
+                    if (part.type === 'text' && part.time?.end) {
+                        await sendPartMessage(part);
+                    }
                     if (part.type === 'step-finish') {
                         for (const p of currentParts) {
                             if (p.type !== 'step-start' && p.type !== 'step-finish') {
@@ -357,6 +371,11 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                         setTimeout(() => {
                             if (abortController.signal.aborted)
                                 return;
+                            // Don't restart typing if user needs to respond to a question or permission
+                            const hasPendingQuestion = [...pendingQuestionContexts.values()].some((ctx) => ctx.thread.id === thread.id);
+                            const hasPendingPermission = pendingPermissions.has(thread.id);
+                            if (hasPendingQuestion || hasPendingPermission)
+                                return;
                             stopTyping = startTyping();
                         }, 300);
                     }
@@ -391,6 +410,11 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                         continue;
                     }
                     sessionLogger.log(`Permission requested: permission=${permission.permission}, patterns=${permission.patterns.join(', ')}`);
+                    // Stop typing - user needs to respond now, not the bot
+                    if (stopTyping) {
+                        stopTyping();
+                        stopTyping = null;
+                    }
                     // Show dropdown instead of text message
                     const { messageId, contextHash } = await showPermissionDropdown({
                         thread,
@@ -423,6 +447,11 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                         continue;
                     }
                     sessionLogger.log(`Question requested: id=${questionRequest.id}, questions=${questionRequest.questions.length}`);
+                    // Stop typing - user needs to respond now, not the bot
+                    if (stopTyping) {
+                        stopTyping();
+                        stopTyping = null;
+                    }
                     // Flush any pending text/reasoning parts before showing the dropdown
                     // This ensures text the LLM generated before the question tool is shown first
                     for (const p of currentParts) {
@@ -438,6 +467,13 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                         input: { questions: questionRequest.questions },
                     });
                 }
+                else if (event.type === 'session.idle') {
+                    // Session is done processing - abort to signal completion
+                    if (event.properties.sessionID === session.id) {
+                        sessionLogger.log(`[SESSION IDLE] Session ${session.id} is idle, aborting`);
+                        abortController.abort('finished');
+                    }
+                }
             }
         }
         catch (e) {
@@ -617,15 +653,17 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                     discordLogger.log(`Could not update reaction:`, e);
                 }
             }
-            const errorName = error &&
-                typeof error === 'object' &&
-                'constructor' in error &&
-                error.constructor &&
-                typeof error.constructor.name === 'string'
-                ? error.constructor.name
-                : typeof error;
-            const errorMsg = error instanceof Error ? error.stack || error.message : String(error);
-            await sendThreadMessage(thread, `✗ Unexpected bot Error: [${errorName}]\n${errorMsg}`);
+            const errorDisplay = (() => {
+                if (error instanceof Error) {
+                    const name = error.constructor.name || 'Error';
+                    return `[${name}]\n${error.stack || error.message}`;
+                }
+                if (typeof error === 'string') {
+                    return error;
+                }
+                return String(error);
+            })();
+            await sendThreadMessage(thread, `✗ Unexpected bot Error: ${errorDisplay}`);
         }
     }
 }

package/dist/system-message.js

@@ -65,5 +65,18 @@ headings are discouraged anyway. instead try to use bold text for titles which r
 ## diagrams
 
 you can create diagrams wrapping them in code blocks.
+
+## ending conversations with options
+
+IMPORTANT: At the end of each response, especially after completing a task or presenting a plan, use the question tool to offer the user clear options for what to do next.
+
+Examples:
+- After showing a plan: offer "Start implementing?" with Yes/No options
+- After completing edits: offer "Commit changes?" with Yes/No options
+- After debugging: offer "How to proceed?" with options like "Apply fix", "Investigate further", "Try different approach"
+
+The user can always select "Other" to type a custom response if the provided options don't fit their needs, or if the plan needs updating.
+
+This makes the interaction more guided and reduces friction for the user.
 `;
 }

package/dist/unnest-code-blocks.js

@@ -31,10 +31,14 @@ function processListToken(list) {
 function processListItem(item, prefix) {
     const segments = [];
     let currentText = [];
+    // Track if we've seen a code block - text after code uses continuation prefix
+    let seenCodeBlock = false;
     const flushText = () => {
         const text = currentText.join('').trim();
         if (text) {
-            segments.push({ type: 'list-item', prefix, content: text });
+            // After a code block, use '-' as continuation prefix to avoid repeating numbers
+            const effectivePrefix = seenCodeBlock ? '- ' : prefix;
+            segments.push({ type: 'list-item', prefix: effectivePrefix, content: text });
         }
         currentText = [];
     };
@@ -47,6 +51,7 @@ function processListItem(item, prefix) {
                 type: 'code',
                 content: '```' + lang + '\n' + codeToken.text + '\n```\n',
             });
+            seenCodeBlock = true;
         }
         else if (token.type === 'list') {
             flushText();
@@ -102,9 +107,11 @@ function renderSegments(segments) {
             }
             else {
                 // Raw content (no prefix means it's original raw)
-                result.push(segment.content);
+                // Ensure raw ends with newline for proper separation from next segment
+                const raw = segment.content.trimEnd();
+                result.push(raw + '\n');
             }
         }
     }
-    return result.join('');
+    return result.join('').trimEnd();
 }

package/dist/unnest-code-blocks.test.js

@@ -11,8 +11,7 @@ test('basic - single item with code block', () => {
 
     \`\`\`js
     const x = 1
-    \`\`\`
-    "
+    \`\`\`"
   `);
 });
 test('multiple items - code in middle item only', () => {
@@ -50,8 +49,7 @@ test('multiple code blocks in one item', () => {
     \`\`\`
     \`\`\`python
     b = 2
-    \`\`\`
-    "
+    \`\`\`"
   `);
 });
 test('nested list with code', () => {
@@ -125,8 +123,7 @@ test('mixed - some items have code, some dont', () => {
 
     \`\`\`python
     y = 2
-    \`\`\`
-    "
+    \`\`\`"
   `);
 });
 test('text before and after code in same item', () => {
@@ -142,8 +139,7 @@ test('text before and after code in same item', () => {
     \`\`\`js
     const x = 1
     \`\`\`
-    - End text
-    "
+    - End text"
   `);
 });
 test('preserves content outside lists', () => {
@@ -169,7 +165,6 @@ More text after.`;
     const x = 1
     \`\`\`
 
-
     More text after."
   `);
 });
@@ -195,8 +190,7 @@ test('handles code block without language', () => {
 
     \`\`\`
     plain code
-    \`\`\`
-    "
+    \`\`\`"
   `);
 });
 test('handles empty list item with code', () => {
@@ -207,7 +201,232 @@ test('handles empty list item with code', () => {
     expect(result).toMatchInlineSnapshot(`
     "\`\`\`js
     const x = 1
+    \`\`\`"
+  `);
+});
+test('numbered list with text after code block', () => {
+    const input = `1. First item
+   \`\`\`js
+   const a = 1
+   \`\`\`
+   Text after the code
+2. Second item`;
+    const result = unnestCodeBlocksFromLists(input);
+    expect(result).toMatchInlineSnapshot(`
+    "1. First item
+
+    \`\`\`js
+    const a = 1
+    \`\`\`
+    - Text after the code
+    2. Second item"
+  `);
+});
+test('numbered list with multiple code blocks and text between', () => {
+    const input = `1. First item
+   \`\`\`js
+   const a = 1
+   \`\`\`
+   Middle text
+   \`\`\`python
+   b = 2
+   \`\`\`
+   Final text
+2. Second item`;
+    const result = unnestCodeBlocksFromLists(input);
+    expect(result).toMatchInlineSnapshot(`
+    "1. First item
+
+    \`\`\`js
+    const a = 1
+    \`\`\`
+    - Middle text
+
+    \`\`\`python
+    b = 2
+    \`\`\`
+    - Final text
+    2. Second item"
+  `);
+});
+test('unordered list with multiple code blocks and text between', () => {
+    const input = `- First item
+  \`\`\`js
+  const a = 1
+  \`\`\`
+  Middle text
+  \`\`\`python
+  b = 2
+  \`\`\`
+  Final text
+- Second item`;
+    const result = unnestCodeBlocksFromLists(input);
+    expect(result).toMatchInlineSnapshot(`
+    "- First item
+
+    \`\`\`js
+    const a = 1
+    \`\`\`
+    - Middle text
+
+    \`\`\`python
+    b = 2
+    \`\`\`
+    - Final text
+    - Second item"
+  `);
+});
+test('numbered list starting from 5', () => {
+    const input = `5. Fifth item
+   \`\`\`js
+   code
+   \`\`\`
+   Text after
+6. Sixth item`;
+    const result = unnestCodeBlocksFromLists(input);
+    expect(result).toMatchInlineSnapshot(`
+    "5. Fifth item
+
+    \`\`\`js
+    code
+    \`\`\`
+    - Text after
+    6. Sixth item"
+  `);
+});
+test('deeply nested list with code', () => {
+    const input = `- Level 1
+  - Level 2
+    - Level 3
+      \`\`\`js
+      deep code
+      \`\`\`
+      Text after deep code
+    - Another level 3
+  - Back to level 2`;
+    const result = unnestCodeBlocksFromLists(input);
+    expect(result).toMatchInlineSnapshot(`
+    "- Level 1
+    - Level 2
+    - Level 3
+
+    \`\`\`js
+    deep code
+    \`\`\`
+    - Text after deep code
+    - Another level 3
+    - Back to level 2"
+  `);
+});
+test('nested numbered list inside unordered with code', () => {
+    const input = `- Unordered item
+  1. Nested numbered
+     \`\`\`js
+     code
+     \`\`\`
+     Text after
+  2. Second nested
+- Another unordered`;
+    const result = unnestCodeBlocksFromLists(input);
+    expect(result).toMatchInlineSnapshot(`
+    "- Unordered item
+    1. Nested numbered
+
+    \`\`\`js
+    code
+    \`\`\`
+    - Text after
+    2. Second nested
+    - Another unordered"
+  `);
+});
+test('code block at end of numbered item no text after', () => {
+    const input = `1. First with text
+   \`\`\`js
+   code here
+   \`\`\`
+2. Second item
+3. Third item`;
+    const result = unnestCodeBlocksFromLists(input);
+    expect(result).toMatchInlineSnapshot(`
+    "1. First with text
+
+    \`\`\`js
+    code here
+    \`\`\`
+    2. Second item
+    3. Third item"
+  `);
+});
+test('multiple items each with code and text after', () => {
+    const input = `1. First
+   \`\`\`js
+   code1
+   \`\`\`
+   After first
+2. Second
+   \`\`\`python
+   code2
+   \`\`\`
+   After second
+3. Third no code`;
+    const result = unnestCodeBlocksFromLists(input);
+    expect(result).toMatchInlineSnapshot(`
+    "1. First
+
+    \`\`\`js
+    code1
+    \`\`\`
+    - After first
+    2. Second
+
+    \`\`\`python
+    code2
+    \`\`\`
+    - After second
+    3. Third no code"
+  `);
+});
+test('code block immediately after list marker', () => {
+    const input = `1. \`\`\`js
+   immediate code
+   \`\`\`
+2. Normal item`;
+    const result = unnestCodeBlocksFromLists(input);
+    expect(result).toMatchInlineSnapshot(`
+    "\`\`\`js
+    immediate code
+    \`\`\`
+    2. Normal item"
+  `);
+});
+test('code block with filename metadata', () => {
+    const input = `- Item with code
+  \`\`\`tsx filename=example.tsx
+  const x = 1
+  \`\`\``;
+    const result = unnestCodeBlocksFromLists(input);
+    expect(result).toMatchInlineSnapshot(`
+    "- Item with code
+
+    \`\`\`tsx filename=example.tsx
+    const x = 1
+    \`\`\`"
+  `);
+});
+test('numbered list with filename metadata code block', () => {
+    const input = `1. First item
+   \`\`\`tsx filename=app.tsx
+   export default function App() {}
+   \`\`\`
+2. Second item`;
+    const result = unnestCodeBlocksFromLists(input);
+    expect(result).toMatchInlineSnapshot(`
+    "1. First item
+
+    \`\`\`tsx filename=app.tsx
+    export default function App() {}
     \`\`\`
-    "
+    2. Second item"
   `);
 });