kimaki 0.4.30 → 0.4.31

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Kimaki
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/cli.js

@@ -388,7 +388,12 @@ async function run({ restart, addChannels }) {
         }
     }
     const s = spinner();
-    s.start('Creating Discord client and connecting...');
+    // Start OpenCode server EARLY - let it initialize in parallel with Discord login.
+    // This is the biggest startup bottleneck (can take 1-30 seconds to spawn and wait for ready)
+    const currentDir = process.cwd();
+    s.start('Starting OpenCode server...');
+    const opencodePromise = initializeOpencodeForDirectory(currentDir);
+    s.message('Connecting to Discord...');
     const discordClient = await createDiscordClient();
     const guilds = [];
     const kimakiChannels = [];
@@ -397,11 +402,43 @@ async function run({ restart, addChannels }) {
         await new Promise((resolve, reject) => {
             discordClient.once(Events.ClientReady, async (c) => {
                 guilds.push(...Array.from(c.guilds.cache.values()));
-                for (const guild of guilds) {
+                // Process all guilds in parallel for faster startup
+                const guildResults = await Promise.all(guilds.map(async (guild) => {
+                    // Create Kimaki role if it doesn't exist, or fix its position (fire-and-forget)
+                    guild.roles
+                        .fetch()
+                        .then(async (roles) => {
+                        const existingRole = roles.find((role) => role.name.toLowerCase() === 'kimaki');
+                        if (existingRole) {
+                            // Move to bottom if not already there
+                            if (existingRole.position > 1) {
+                                await existingRole.setPosition(1);
+                                cliLogger.info(`Moved "Kimaki" role to bottom in ${guild.name}`);
+                            }
+                            return;
+                        }
+                        return guild.roles.create({
+                            name: 'Kimaki',
+                            position: 1, // Place at bottom so anyone with Manage Roles can assign it
+                            reason: 'Kimaki bot permission role - assign to users who can start sessions, send messages in threads, and use voice features',
+                        });
+                    })
+                        .then((role) => {
+                        if (role) {
+                            cliLogger.info(`Created "Kimaki" role in ${guild.name}`);
+                        }
+                    })
+                        .catch((error) => {
+                        cliLogger.warn(`Could not create Kimaki role in ${guild.name}: ${error instanceof Error ? error.message : String(error)}`);
+                    });
                     const channels = await getChannelsWithDescriptions(guild);
                     const kimakiChans = channels.filter((ch) => ch.kimakiDirectory && (!ch.kimakiApp || ch.kimakiApp === appId));
-                    if (kimakiChans.length > 0) {
-                        kimakiChannels.push({ guild, channels: kimakiChans });
+                    return { guild, channels: kimakiChans };
+                }));
+                // Collect results
+                for (const result of guildResults) {
+                    if (result.channels.length > 0) {
+                        kimakiChannels.push(result);
                     }
                 }
                 resolve(null);
@@ -441,26 +478,22 @@ async function run({ restart, addChannels }) {
             .join('\n');
         note(channelList, 'Existing Kimaki Channels');
     }
-    s.start('Starting OpenCode server...');
-    const currentDir = process.cwd();
-    let getClient = await initializeOpencodeForDirectory(currentDir);
-    s.stop('OpenCode server started!');
-    s.start('Fetching OpenCode projects...');
-    let projects = [];
-    try {
-        const projectsResponse = await getClient().project.list({});
-        if (!projectsResponse.data) {
-            throw new Error('Failed to fetch projects');
-        }
-        projects = projectsResponse.data;
-        s.stop(`Found ${projects.length} OpenCode project(s)`);
-    }
-    catch (error) {
-        s.stop('Failed to fetch projects');
-        cliLogger.error('Error:', error instanceof Error ? error.message : String(error));
-        discordClient.destroy();
-        process.exit(EXIT_NO_RESTART);
-    }
+    // Await the OpenCode server that was started in parallel with Discord login
+    s.start('Waiting for OpenCode server...');
+    const getClient = await opencodePromise;
+    s.stop('OpenCode server ready!');
+    s.start('Fetching OpenCode data...');
+    // Fetch projects and commands in parallel
+    const [projects, allUserCommands] = await Promise.all([
+        getClient().project.list({}).then((r) => r.data || []).catch((error) => {
+            s.stop('Failed to fetch projects');
+            cliLogger.error('Error:', error instanceof Error ? error.message : String(error));
+            discordClient.destroy();
+            process.exit(EXIT_NO_RESTART);
+        }),
+        getClient().command.list({ query: { directory: currentDir } }).then((r) => r.data || []).catch(() => []),
+    ]);
+    s.stop(`Found ${projects.length} OpenCode project(s)`);
     const existingDirs = kimakiChannels.flatMap(({ channels }) => channels
         .filter((ch) => ch.kimakiDirectory && ch.kimakiApp === appId)
         .map((ch) => ch.kimakiDirectory)
@@ -541,19 +574,6 @@ async function run({ restart, addChannels }) {
             }
         }
     }
-    // Fetch user-defined commands using the already-running server
-    const allUserCommands = [];
-    try {
-        const commandsResponse = await getClient().command.list({
-            query: { directory: currentDir },
-        });
-        if (commandsResponse.data) {
-            allUserCommands.push(...commandsResponse.data);
-        }
-    }
-    catch {
-        // Ignore errors fetching commands
-    }
     // Log available user commands
     const registrableCommands = allUserCommands.filter((cmd) => !SKIP_USER_COMMANDS.includes(cmd.name));
     if (registrableCommands.length > 0) {
@@ -598,6 +618,7 @@ cli
     .option('--restart', 'Prompt for new credentials even if saved')
     .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')
     .action(async (options) => {
     try {
         // Set data directory early, before any database access
@@ -605,6 +626,18 @@ cli
             setDataDir(options.dataDir);
             cliLogger.log(`Using data directory: ${getDataDir()}`);
         }
+        if (options.installUrl) {
+            const db = getDatabase();
+            const existingBot = db
+                .prepare('SELECT app_id FROM bot_tokens ORDER BY created_at DESC LIMIT 1')
+                .get();
+            if (!existingBot) {
+                cliLogger.error('No bot configured yet. Run `kimaki` first to set up.');
+                process.exit(EXIT_NO_RESTART);
+            }
+            console.log(generateBotInstallUrl({ clientId: existingBot.app_id }));
+            process.exit(0);
+        }
         await checkSingleInstance();
         await startLockServer();
         await run({

package/dist/commands/ask-question.js

@@ -4,7 +4,7 @@
 import { StringSelectMenuBuilder, StringSelectMenuInteraction, ActionRowBuilder, } from 'discord.js';
 import crypto from 'node:crypto';
 import { sendThreadMessage, NOTIFY_MESSAGE_FLAGS } from '../discord-utils.js';
-import { getOpencodeServerPort } from '../opencode.js';
+import { getOpencodeClientV2 } from '../opencode.js';
 import { createLogger } from '../logger.js';
 const logger = createLogger('ASK_QUESTION');
 // Store pending question contexts by hash
@@ -128,25 +128,18 @@ export async function handleAskQuestionSelectMenu(interaction) {
  */
 async function submitQuestionAnswers(context) {
     try {
+        const clientV2 = getOpencodeClientV2(context.directory);
+        if (!clientV2) {
+            throw new Error('OpenCode server not found for directory');
+        }
         // Build answers array: each element is an array of selected labels for that question
-        const answersPayload = context.questions.map((_, i) => {
+        const answers = context.questions.map((_, i) => {
             return context.answers[i] || [];
         });
-        // Reply to the question using direct HTTP call to OpenCode API
-        // (v1 SDK doesn't have question.reply, so we call it directly)
-        const port = getOpencodeServerPort(context.directory);
-        if (!port) {
-            throw new Error('OpenCode server not found for directory');
-        }
-        const response = await fetch(`http://127.0.0.1:${port}/question/${context.requestId}/reply`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ answers: answersPayload }),
+        await clientV2.question.reply({
+            requestID: context.requestId,
+            answers,
         });
-        if (!response.ok) {
-            const text = await response.text();
-            throw new Error(`Failed to reply to question: ${response.status} ${text}`);
-        }
         logger.log(`Submitted answers for question ${context.requestId} in session ${context.sessionId}`);
     }
     catch (error) {
@@ -182,3 +175,43 @@ export function parseAskUserQuestionTool(part) {
     }
     return input;
 }
+/**
+ * Cancel a pending question for a thread (e.g., when user sends a new message).
+ * Sends cancellation response to OpenCode so the session can continue.
+ */
+export async function cancelPendingQuestion(threadId) {
+    // Find pending question for this thread
+    let contextHash;
+    let context;
+    for (const [hash, ctx] of pendingQuestionContexts) {
+        if (ctx.thread.id === threadId) {
+            contextHash = hash;
+            context = ctx;
+            break;
+        }
+    }
+    if (!contextHash || !context) {
+        return false;
+    }
+    try {
+        const clientV2 = getOpencodeClientV2(context.directory);
+        if (!clientV2) {
+            throw new Error('OpenCode server not found for directory');
+        }
+        // Preserve already-answered questions, mark unanswered as cancelled
+        const answers = context.questions.map((_, i) => {
+            return context.answers[i] || ['(cancelled - user sent new message)'];
+        });
+        await clientV2.question.reply({
+            requestID: context.requestId,
+            answers,
+        });
+        logger.log(`Cancelled question ${context.requestId} due to new user message`);
+    }
+    catch (error) {
+        logger.error('Failed to cancel question:', error);
+    }
+    // Clean up regardless of whether the API call succeeded
+    pendingQuestionContexts.delete(contextHash);
+    return true;
+}

package/dist/discord-bot.js

@@ -109,7 +109,10 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                 const canManageServer = message.member.permissions.has(PermissionsBitField.Flags.ManageGuild);
                 const hasKimakiRole = message.member.roles.cache.some((role) => role.name.toLowerCase() === 'kimaki');
                 if (!isOwner && !isAdmin && !canManageServer && !hasKimakiRole) {
-                    await message.react('🔒');
+                    await message.reply({
+                        content: `You don't have permission to start sessions.\nTo use Kimaki, ask a server admin to give you the **Kimaki** role.`,
+                        flags: SILENT_MESSAGE_FLAGS,
+                    });
                     return;
                 }
             }

package/dist/discord-utils.js

@@ -5,6 +5,7 @@ import { ChannelType, } from 'discord.js';
 import { Lexer } from 'marked';
 import { extractTagsArrays } from './xml.js';
 import { formatMarkdownTables } from './format-tables.js';
+import { unnestCodeBlocksFromLists } from './unnest-code-blocks.js';
 import { createLogger } from './logger.js';
 const discordLogger = createLogger('DISCORD');
 export const SILENT_MESSAGE_FLAGS = 4 | 4096;
@@ -92,7 +93,8 @@ export function splitMarkdownForDiscord({ content, maxLength, }) {
                 }
                 // calculate overhead for code block markers
                 const codeBlockOverhead = line.inCodeBlock ? ('```' + line.lang + '\n').length + '```\n'.length : 0;
-                const availablePerChunk = maxLength - codeBlockOverhead - 50; // safety margin
+                // ensure at least 10 chars available, even if maxLength is very small
+                const availablePerChunk = Math.max(10, maxLength - codeBlockOverhead - 50);
                 const pieces = splitLongLine(line.text, availablePerChunk, line.inCodeBlock);
                 for (let i = 0; i < pieces.length; i++) {
                     const piece = pieces[i];
@@ -156,6 +158,7 @@ export function splitMarkdownForDiscord({ content, maxLength, }) {
 export async function sendThreadMessage(thread, content, options) {
     const MAX_LENGTH = 2000;
     content = formatMarkdownTables(content);
+    content = unnestCodeBlocksFromLists(content);
     content = escapeBackticksInCodeBlocks(content);
     // If custom flags provided, send as single message (no chunking)
     if (options?.flags !== undefined) {

package/dist/escape-backticks.test.js

@@ -341,11 +341,19 @@ test('splitMarkdownForDiscord handles very long line inside code block', () => {
     \`\`\`
     ",
       "\`\`\`js
-    veryverylonglinethatexceedsmaxlength
-    \`\`\`
+    veryverylo\`\`\`
     ",
       "\`\`\`js
-    short
+    nglinethat\`\`\`
+    ",
+      "\`\`\`js
+    exceedsmax\`\`\`
+    ",
+      "\`\`\`js
+    length
+    \`\`\`
+    ",
+      "short
     \`\`\`
     ",
     ]

package/dist/session-handler.js

@@ -4,12 +4,12 @@
 import prettyMilliseconds from 'pretty-ms';
 import { getDatabase, getSessionModel, getChannelModel, getSessionAgent, getChannelAgent } from './database.js';
 import { initializeOpencodeForDirectory, getOpencodeServers, getOpencodeClientV2 } from './opencode.js';
-import { sendThreadMessage, NOTIFY_MESSAGE_FLAGS } from './discord-utils.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 } from './commands/ask-question.js';
+import { showAskUserQuestionDropdowns, cancelPendingQuestion } from './commands/ask-question.js';
 import { showPermissionDropdown, cleanupPermissionContext } from './commands/permissions.js';
 const sessionLogger = createLogger('SESSION');
 const voiceLogger = createLogger('VOICE');
@@ -154,6 +154,12 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
             pendingPermissions.delete(thread.id);
         }
     }
+    // Cancel any pending question tool if user sends a new 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);
     if (existingController) {
@@ -281,7 +287,8 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                                 const thresholdCrossed = Math.floor(currentPercentage / 10) * 10;
                                 if (thresholdCrossed > lastDisplayedContextPercentage && thresholdCrossed >= 10) {
                                     lastDisplayedContextPercentage = thresholdCrossed;
-                                    await sendThreadMessage(thread, `⬥ context usage ${currentPercentage}%`);
+                                    const chunk = `⬦ context usage ${currentPercentage}%`;
+                                    await thread.send({ content: chunk, flags: SILENT_MESSAGE_FLAGS });
                                 }
                             }
                         }
@@ -386,6 +393,13 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                         continue;
                     }
                     sessionLogger.log(`Question requested: id=${questionRequest.id}, questions=${questionRequest.questions.length}`);
+                    // 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) {
+                        if (p.type !== 'step-start' && p.type !== 'step-finish') {
+                            await sendPartMessage(p);
+                        }
+                    }
                     await showAskUserQuestionDropdowns({
                         thread,
                         sessionId: session.id,

package/dist/system-message.js

@@ -37,17 +37,17 @@ IMPORTANT: After editing any files, you MUST execute the critique command using
 
 Execute this after making changes:
 
-bunx critique web
+bunx critique web --title "Add user authentication flow"
 
 If there are other unrelated changes in the working directory, filter to only show the files you edited:
 
-bunx critique web -- path/to/file1.ts path/to/file2.ts
+bunx critique web --title "Fix database connection retry" -- path/to/file1.ts path/to/file2.ts
 
 You can also show latest commit changes using:
 
-bunx critique web HEAD
+bunx critique web --title "Refactor API endpoints" HEAD
 
-bunx critique web HEAD~1 to get the one before last
+bunx critique web --title "Update dependencies" HEAD~1 to get the one before last
 
 Do this in case you committed the changes yourself (only if the user asks so, never commit otherwise).
 

package/dist/unnest-code-blocks.js

@@ -0,0 +1,110 @@
+// Unnest code blocks from list items for Discord.
+// Discord doesn't render code blocks inside lists, so this hoists them
+// to root level while preserving list structure.
+import { Lexer } from 'marked';
+export function unnestCodeBlocksFromLists(markdown) {
+    const lexer = new Lexer();
+    const tokens = lexer.lex(markdown);
+    const result = [];
+    for (const token of tokens) {
+        if (token.type === 'list') {
+            const segments = processListToken(token);
+            result.push(renderSegments(segments));
+        }
+        else {
+            result.push(token.raw);
+        }
+    }
+    return result.join('');
+}
+function processListToken(list) {
+    const segments = [];
+    const start = typeof list.start === 'number' ? list.start : parseInt(list.start, 10) || 1;
+    const prefix = list.ordered ? (i) => `${start + i}. ` : () => '- ';
+    for (let i = 0; i < list.items.length; i++) {
+        const item = list.items[i];
+        const itemSegments = processListItem(item, prefix(i));
+        segments.push(...itemSegments);
+    }
+    return segments;
+}
+function processListItem(item, prefix) {
+    const segments = [];
+    let currentText = [];
+    const flushText = () => {
+        const text = currentText.join('').trim();
+        if (text) {
+            segments.push({ type: 'list-item', prefix, content: text });
+        }
+        currentText = [];
+    };
+    for (const token of item.tokens) {
+        if (token.type === 'code') {
+            flushText();
+            const codeToken = token;
+            const lang = codeToken.lang || '';
+            segments.push({
+                type: 'code',
+                content: '```' + lang + '\n' + codeToken.text + '\n```\n',
+            });
+        }
+        else if (token.type === 'list') {
+            flushText();
+            // Recursively process nested list - segments bubble up
+            const nestedSegments = processListToken(token);
+            segments.push(...nestedSegments);
+        }
+        else {
+            currentText.push(extractText(token));
+        }
+    }
+    flushText();
+    // If no segments were created (empty item), return empty
+    if (segments.length === 0) {
+        return [];
+    }
+    // If item had no code blocks (all segments are list-items from this level),
+    // return original raw to preserve formatting
+    const hasCode = segments.some((s) => s.type === 'code');
+    if (!hasCode) {
+        return [{ type: 'list-item', prefix: '', content: item.raw }];
+    }
+    return segments;
+}
+function extractText(token) {
+    if (token.type === 'text') {
+        return token.text;
+    }
+    if (token.type === 'space') {
+        return '';
+    }
+    if ('raw' in token) {
+        return token.raw;
+    }
+    return '';
+}
+function renderSegments(segments) {
+    const result = [];
+    for (let i = 0; i < segments.length; i++) {
+        const segment = segments[i];
+        const prev = segments[i - 1];
+        if (segment.type === 'code') {
+            // Add newline before code if previous was a list item
+            if (prev && prev.type === 'list-item') {
+                result.push('\n');
+            }
+            result.push(segment.content);
+        }
+        else {
+            // list-item
+            if (segment.prefix) {
+                result.push(segment.prefix + segment.content + '\n');
+            }
+            else {
+                // Raw content (no prefix means it's original raw)
+                result.push(segment.content);
+            }
+        }
+    }
+    return result.join('');
+}