kimaki 0.4.20 → 0.4.22

package/dist/cli.js

@@ -87,7 +87,7 @@ async function registerCommands(token, appId) {
         })
             .toJSON(),
         new SlashCommandBuilder()
-            .setName('add-new-project')
+            .setName('create-new-project')
             .setDescription('Create a new project folder, initialize git, and start a session')
             .addStringOption((option) => {
             option

package/dist/discordBot.js

@@ -16,6 +16,7 @@ import * as prism from 'prism-media';
 import dedent from 'string-dedent';
 import { transcribeAudio } from './voice.js';
 import { extractTagsArrays, extractNonXmlContent } from './xml.js';
+import { formatMarkdownTables } from './format-tables.js';
 import prettyMilliseconds from 'pretty-ms';
 import { createLogger } from './logger.js';
 import { isAbortError } from './utils.js';
@@ -43,6 +44,32 @@ The user cannot see bash tool outputs. If there is important information in bash
 
 Your current OpenCode session ID is: ${sessionId}
 
+## permissions
+
+Only users with these Discord permissions can send messages to the bot:
+- Server Owner
+- Administrator permission
+- Manage Server permission
+- "Kimaki" role (case-insensitive)
+
+## changing the model
+
+To change the model used by OpenCode, edit the project's \`opencode.json\` config file and set the \`model\` field:
+
+\`\`\`json
+{
+  "model": "anthropic/claude-sonnet-4-20250514"
+}
+\`\`\`
+
+Examples:
+- \`"anthropic/claude-sonnet-4-20250514"\` - Claude Sonnet 4
+- \`"anthropic/claude-opus-4-20250514"\` - Claude Opus 4
+- \`"openai/gpt-4o"\` - GPT-4o
+- \`"google/gemini-2.5-pro"\` - Gemini 2.5 Pro
+
+Format is \`provider/model-name\`. You can also set \`small_model\` for tasks like title generation.
+
 ## uploading files to discord
 
 To upload files to the Discord thread (images, screenshots, long files that would clutter the chat), run:
@@ -538,6 +565,7 @@ async function getOpenPort() {
  */
 async function sendThreadMessage(thread, content) {
     const MAX_LENGTH = 2000;
+    content = formatMarkdownTables(content);
     content = escapeBackticksInCodeBlocks(content);
     const chunks = splitMarkdownForDiscord({ content, maxLength: MAX_LENGTH });
     if (chunks.length > 1) {
@@ -585,7 +613,6 @@ async function processVoiceAttachment({ message, thread, projectDirectory, isNew
     if (!audioAttachment)
         return null;
     voiceLogger.log(`Detected audio attachment: ${audioAttachment.name} (${audioAttachment.contentType})`);
-    await message.react('⏳');
     await sendThreadMessage(thread, '🎤 Transcribing voice message...');
     const audioResponse = await fetch(audioAttachment.url);
     const audioBuffer = Buffer.from(await audioResponse.arrayBuffer());
@@ -793,7 +820,7 @@ function escapeInlineCode(text) {
         .replace(/(?<!\\)`(?!`)/g, '\\`') // Single backticks (not already escaped or part of double/triple)
         .replace(/\|\|/g, '\\|\\|'); // Double pipes (spoiler syntax)
 }
-function resolveTextChannel(channel) {
+async function resolveTextChannel(channel) {
     if (!channel) {
         return null;
     }
@@ -803,9 +830,12 @@ function resolveTextChannel(channel) {
     if (channel.type === ChannelType.PublicThread ||
         channel.type === ChannelType.PrivateThread ||
         channel.type === ChannelType.AnnouncementThread) {
-        const parent = channel.parent;
-        if (parent?.type === ChannelType.GuildText) {
-            return parent;
+        const parentId = channel.parentId;
+        if (parentId) {
+            const parent = await channel.guild.channels.fetch(parentId);
+            if (parent?.type === ChannelType.GuildText) {
+                return parent;
+            }
         }
     }
     return null;
@@ -940,32 +970,55 @@ function getToolSummaryText(part) {
     if (part.type !== 'tool')
         return '';
     if (part.tool === 'edit') {
+        const filePath = part.state.input?.filePath || '';
         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})`;
+        const fileName = filePath.split('/').pop() || '';
+        return fileName ? `*${fileName}* (+${added}-${removed})` : `(+${added}-${removed})`;
     }
     if (part.tool === 'write') {
+        const filePath = part.state.input?.filePath || '';
         const content = part.state.input?.content || '';
         const lines = content.split('\n').length;
-        return `(${lines} line${lines === 1 ? '' : 's'})`;
+        const fileName = filePath.split('/').pop() || '';
+        return fileName ? `*${fileName}* (${lines} line${lines === 1 ? '' : 's'})` : `(${lines} line${lines === 1 ? '' : 's'})`;
     }
     if (part.tool === 'webfetch') {
         const url = part.state.input?.url || '';
         const urlWithoutProtocol = url.replace(/^https?:\/\//, '');
-        return urlWithoutProtocol ? `(${urlWithoutProtocol})` : '';
+        return urlWithoutProtocol ? `*${urlWithoutProtocol}*` : '';
+    }
+    if (part.tool === 'read') {
+        const filePath = part.state.input?.filePath || '';
+        const fileName = filePath.split('/').pop() || '';
+        return fileName ? `*${fileName}*` : '';
+    }
+    if (part.tool === 'list') {
+        const path = part.state.input?.path || '';
+        const dirName = path.split('/').pop() || path;
+        return dirName ? `*${dirName}*` : '';
+    }
+    if (part.tool === 'glob') {
+        const pattern = part.state.input?.pattern || '';
+        return pattern ? `*${pattern}*` : '';
     }
-    if (part.tool === 'bash' ||
-        part.tool === 'read' ||
-        part.tool === 'list' ||
-        part.tool === 'glob' ||
-        part.tool === 'grep' ||
-        part.tool === 'task' ||
-        part.tool === 'todoread' ||
-        part.tool === 'todowrite') {
+    if (part.tool === 'grep') {
+        const pattern = part.state.input?.pattern || '';
+        return pattern ? `*${pattern}*` : '';
+    }
+    if (part.tool === 'bash' || part.tool === 'todoread' || part.tool === 'todowrite') {
         return '';
     }
+    if (part.tool === 'task') {
+        const description = part.state.input?.description || '';
+        return description ? `_${description}_` : '';
+    }
+    if (part.tool === 'skill') {
+        const name = part.state.input?.name || '';
+        return name ? `_${name}_` : '';
+    }
     if (!part.state.input)
         return '';
     const inputFields = Object.entries(part.state.input)
@@ -985,20 +1038,13 @@ function formatTodoList(part) {
     if (part.type !== 'tool' || part.tool !== 'todowrite')
         return '';
     const todos = part.state.input?.todos || [];
-    if (todos.length === 0)
+    const activeIndex = todos.findIndex((todo) => {
+        return todo.status === 'in_progress';
+    });
+    const activeTodo = todos[activeIndex];
+    if (activeIndex === -1 || !activeTodo)
         return '';
-    return todos
-        .map((todo, i) => {
-        const num = `${i + 1}.`;
-        if (todo.status === 'in_progress') {
-            return `${num} **${todo.content}**`;
-        }
-        if (todo.status === 'completed' || todo.status === 'cancelled') {
-            return `${num} ~~${todo.content}~~`;
-        }
-        return `${num} ${todo.content}`;
-    })
-        .join('\n');
+    return `${activeIndex + 1}. **${activeTodo.content}**`;
 }
 function formatPart(part) {
     if (part.type === 'text') {
@@ -1036,19 +1082,18 @@ function formatPart(part) {
         }
         else if (part.tool === 'bash') {
             const command = part.state.input?.command || '';
+            const description = part.state.input?.description || '';
             const isSingleLine = !command.includes('\n');
-            const hasBackticks = command.includes('`');
-            if (isSingleLine && command.length <= 120 && !hasBackticks) {
+            const hasUnderscores = command.includes('_');
+            if (isSingleLine && !hasUnderscores && command.length <= 50) {
                 toolTitle = `_${command}_`;
             }
-            else {
-                toolTitle = stateTitle ? `_${stateTitle}_` : '';
+            else if (description) {
+                toolTitle = `_${description}_`;
+            }
+            else if (stateTitle) {
+                toolTitle = `_${stateTitle}_`;
             }
-        }
-        else if (part.tool === 'edit' || part.tool === 'write') {
-            const filePath = part.state.input?.filePath || '';
-            const fileName = filePath.split('/').pop() || filePath;
-            toolTitle = fileName ? `_${fileName}_` : '';
         }
         else if (stateTitle) {
             toolTitle = `_${stateTitle}_`;
@@ -1160,6 +1205,41 @@ async function handleOpencodeSession({ prompt, thread, projectDirectory, origina
     let usedModel;
     let usedProviderID;
     let tokensUsedInSession = 0;
+    let lastDisplayedContextPercentage = 0;
+    let modelContextLimit;
+    let typingInterval = null;
+    function startTyping() {
+        if (abortController.signal.aborted) {
+            discordLogger.log(`Not starting typing, already aborted`);
+            return () => { };
+        }
+        if (typingInterval) {
+            clearInterval(typingInterval);
+            typingInterval = null;
+        }
+        thread.sendTyping().catch((e) => {
+            discordLogger.log(`Failed to send initial typing: ${e}`);
+        });
+        typingInterval = setInterval(() => {
+            thread.sendTyping().catch((e) => {
+                discordLogger.log(`Failed to send periodic typing: ${e}`);
+            });
+        }, 8000);
+        if (!abortController.signal.aborted) {
+            abortController.signal.addEventListener('abort', () => {
+                if (typingInterval) {
+                    clearInterval(typingInterval);
+                    typingInterval = null;
+                }
+            }, { once: true });
+        }
+        return () => {
+            if (typingInterval) {
+                clearInterval(typingInterval);
+                typingInterval = null;
+            }
+        };
+    }
     const sendPartMessage = async (part) => {
         const content = formatPart(part) + '\n\n';
         if (!content.trim() || content.length === 0) {
@@ -1183,48 +1263,6 @@ async function handleOpencodeSession({ prompt, thread, projectDirectory, origina
         }
     };
     const eventHandler = async () => {
-        // Local typing function for this session
-        // Outer-scoped interval for typing notifications. Only one at a time.
-        let typingInterval = null;
-        function startTyping(thread) {
-            if (abortController.signal.aborted) {
-                discordLogger.log(`Not starting typing, already aborted`);
-                return () => { };
-            }
-            // Clear any previous typing interval
-            if (typingInterval) {
-                clearInterval(typingInterval);
-                typingInterval = null;
-            }
-            // Send initial typing
-            thread.sendTyping().catch((e) => {
-                discordLogger.log(`Failed to send initial typing: ${e}`);
-            });
-            // Set up interval to send typing every 8 seconds
-            typingInterval = setInterval(() => {
-                thread.sendTyping().catch((e) => {
-                    discordLogger.log(`Failed to send periodic typing: ${e}`);
-                });
-            }, 8000);
-            // Only add listener if not already aborted
-            if (!abortController.signal.aborted) {
-                abortController.signal.addEventListener('abort', () => {
-                    if (typingInterval) {
-                        clearInterval(typingInterval);
-                        typingInterval = null;
-                    }
-                }, {
-                    once: true,
-                });
-            }
-            // Return stop function
-            return () => {
-                if (typingInterval) {
-                    clearInterval(typingInterval);
-                    typingInterval = null;
-                }
-            };
-        }
         try {
             let assistantMessageId;
             for await (const event of events) {
@@ -1242,6 +1280,29 @@ async function handleOpencodeSession({ prompt, thread, projectDirectory, origina
                         assistantMessageId = msg.id;
                         usedModel = msg.modelID;
                         usedProviderID = msg.providerID;
+                        if (tokensUsedInSession > 0 && usedProviderID && usedModel) {
+                            if (!modelContextLimit) {
+                                try {
+                                    const providersResponse = await getClient().provider.list({ query: { directory } });
+                                    const provider = providersResponse.data?.all?.find((p) => p.id === usedProviderID);
+                                    const model = provider?.models?.[usedModel];
+                                    if (model?.limit?.context) {
+                                        modelContextLimit = model.limit.context;
+                                    }
+                                }
+                                catch (e) {
+                                    sessionLogger.error('Failed to fetch provider info for context limit:', e);
+                                }
+                            }
+                            if (modelContextLimit) {
+                                const currentPercentage = Math.floor((tokensUsedInSession / modelContextLimit) * 100);
+                                const thresholdCrossed = Math.floor(currentPercentage / 10) * 10;
+                                if (thresholdCrossed > lastDisplayedContextPercentage && thresholdCrossed >= 10) {
+                                    lastDisplayedContextPercentage = thresholdCrossed;
+                                    await sendThreadMessage(thread, `◼︎ context usage ${currentPercentage}%`);
+                                }
+                            }
+                        }
                     }
                 }
                 else if (event.type === 'message.part.updated') {
@@ -1262,7 +1323,7 @@ async function handleOpencodeSession({ prompt, thread, projectDirectory, origina
                     }
                     // Start typing on step-start
                     if (part.type === 'step-start') {
-                        stopTyping = startTyping(thread);
+                        stopTyping = startTyping();
                     }
                     // Send tool parts immediately when they start running
                     if (part.type === 'tool' && part.state.status === 'running') {
@@ -1285,7 +1346,7 @@ async function handleOpencodeSession({ prompt, thread, projectDirectory, origina
                         setTimeout(() => {
                             if (abortController.signal.aborted)
                                 return;
-                            stopTyping = startTyping(thread);
+                            stopTyping = startTyping();
                         }, 300);
                     }
                 }
@@ -1405,14 +1466,7 @@ async function handleOpencodeSession({ prompt, thread, projectDirectory, origina
             sessionLogger.log(`[DEBOUNCE] Aborted before prompt, exiting`);
             return;
         }
-        if (originalMessage) {
-            try {
-                await originalMessage.react('⏳');
-            }
-            catch (e) {
-                discordLogger.log(`Could not add processing reaction:`, e);
-            }
-        }
+        stopTyping = startTyping();
         let response;
         if (parsedCommand?.isCommand) {
             sessionLogger.log(`[COMMAND] Sending command /${parsedCommand.command} to session ${session.id} with args: "${parsedCommand.arguments.slice(0, 100)}${parsedCommand.arguments.length > 100 ? '...' : ''}"`);
@@ -1579,11 +1633,13 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                     return;
                 }
             }
-            // Check if user is authoritative (server owner or has admin permissions)
+            // Check if user is authoritative (server owner, admin, manage server, or has Kimaki role)
             if (message.guild && message.member) {
                 const isOwner = message.member.id === message.guild.ownerId;
                 const isAdmin = message.member.permissions.has(PermissionsBitField.Flags.Administrator);
-                if (!isOwner && !isAdmin) {
+                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) {
                     return;
                 }
             }
@@ -1749,9 +1805,8 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                     const focusedValue = interaction.options.getFocused();
                     // Get the channel's project directory from its topic
                     let projectDirectory;
-                    if (interaction.channel &&
-                        interaction.channel.type === ChannelType.GuildText) {
-                        const textChannel = resolveTextChannel(interaction.channel);
+                    if (interaction.channel) {
+                        const textChannel = await resolveTextChannel(interaction.channel);
                         if (textChannel) {
                             const { projectDirectory: directory, channelAppId } = getKimakiMetadata(textChannel);
                             if (channelAppId && channelAppId !== currentAppId) {
@@ -1814,9 +1869,8 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                         const currentQuery = (parts[parts.length - 1] || '').trim();
                         // Get the channel's project directory from its topic
                         let projectDirectory;
-                        if (interaction.channel &&
-                            interaction.channel.type === ChannelType.GuildText) {
-                            const textChannel = resolveTextChannel(interaction.channel);
+                        if (interaction.channel) {
+                            const textChannel = await resolveTextChannel(interaction.channel);
                             if (textChannel) {
                                 const { projectDirectory: directory, channelAppId } = getKimakiMetadata(textChannel);
                                 if (channelAppId && channelAppId !== currentAppId) {
@@ -2078,7 +2132,7 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                         if (partsToRender.length > 0) {
                             const combinedContent = partsToRender
                                 .map((p) => p.content)
-                                .join('\n\n');
+                                .join('\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) => {
@@ -2143,7 +2197,7 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                         await command.editReply(`Failed to create channels: ${error instanceof Error ? error.message : 'Unknown error'}`);
                     }
                 }
-                else if (command.commandName === 'add-new-project') {
+                else if (command.commandName === 'create-new-project') {
                     await command.deferReply({ ephemeral: false });
                     const projectName = command.options.getString('name', true);
                     const guild = command.guild;
@@ -2339,7 +2393,7 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                         });
                         return;
                     }
-                    const textChannel = resolveTextChannel(channel);
+                    const textChannel = await resolveTextChannel(channel);
                     const { projectDirectory: directory } = getKimakiMetadata(textChannel);
                     if (!directory) {
                         await command.reply({
@@ -2401,7 +2455,7 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                         });
                         return;
                     }
-                    const textChannel = resolveTextChannel(channel);
+                    const textChannel = await resolveTextChannel(channel);
                     const { projectDirectory: directory } = getKimakiMetadata(textChannel);
                     if (!directory) {
                         await command.reply({
@@ -2496,12 +2550,13 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
             const member = newState.member || oldState.member;
             if (!member)
                 return;
-            // Check if user is admin or server owner
+            // Check if user is admin, server owner, can manage server, or has Kimaki role
             const guild = newState.guild || oldState.guild;
             const isOwner = member.id === guild.ownerId;
             const isAdmin = member.permissions.has(PermissionsBitField.Flags.Administrator);
-            if (!isOwner && !isAdmin) {
-                // Not an admin user, ignore
+            const canManageServer = member.permissions.has(PermissionsBitField.Flags.ManageGuild);
+            const hasKimakiRole = member.roles.cache.some((role) => role.name.toLowerCase() === 'kimaki');
+            if (!isOwner && !isAdmin && !canManageServer && !hasKimakiRole) {
                 return;
             }
             // Handle admin leaving voice channel
@@ -2520,7 +2575,9 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                         if (m.id === member.id || m.user.bot)
                             return false;
                         return (m.id === guild.ownerId ||
-                            m.permissions.has(PermissionsBitField.Flags.Administrator));
+                            m.permissions.has(PermissionsBitField.Flags.Administrator) ||
+                            m.permissions.has(PermissionsBitField.Flags.ManageGuild) ||
+                            m.roles.cache.some((role) => role.name.toLowerCase() === 'kimaki'));
                     });
                     if (!hasOtherAdmins) {
                         voiceLogger.log(`No other admins in channel, bot leaving voice channel in guild: ${guild.name}`);
@@ -2550,7 +2607,9 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                             if (m.id === member.id || m.user.bot)
                                 return false;
                             return (m.id === guild.ownerId ||
-                                m.permissions.has(PermissionsBitField.Flags.Administrator));
+                                m.permissions.has(PermissionsBitField.Flags.Administrator) ||
+                                m.permissions.has(PermissionsBitField.Flags.ManageGuild) ||
+                                m.roles.cache.some((role) => role.name.toLowerCase() === 'kimaki'));
                         });
                         if (!hasOtherAdmins) {
                             voiceLogger.log(`Following admin to new channel: ${newState.channel?.name}`);

package/dist/format-tables.js

@@ -0,0 +1,93 @@
+import { Lexer } from 'marked';
+export function formatMarkdownTables(markdown) {
+    const lexer = new Lexer();
+    const tokens = lexer.lex(markdown);
+    let result = '';
+    for (const token of tokens) {
+        if (token.type === 'table') {
+            result += formatTableToken(token);
+        }
+        else {
+            result += token.raw;
+        }
+    }
+    return result;
+}
+function formatTableToken(table) {
+    const headers = table.header.map((cell) => {
+        return extractCellText(cell.tokens);
+    });
+    const rows = table.rows.map((row) => {
+        return row.map((cell) => {
+            return extractCellText(cell.tokens);
+        });
+    });
+    const columnWidths = calculateColumnWidths(headers, rows);
+    const lines = [];
+    lines.push(formatRow(headers, columnWidths));
+    lines.push(formatSeparator(columnWidths));
+    for (const row of rows) {
+        lines.push(formatRow(row, columnWidths));
+    }
+    return '```\n' + lines.join('\n') + '\n```\n';
+}
+function extractCellText(tokens) {
+    const parts = [];
+    for (const token of tokens) {
+        parts.push(extractTokenText(token));
+    }
+    return parts.join('').trim();
+}
+function extractTokenText(token) {
+    switch (token.type) {
+        case 'text':
+        case 'codespan':
+        case 'escape':
+            return token.text;
+        case 'link':
+            return token.href;
+        case 'image':
+            return token.href;
+        case 'strong':
+        case 'em':
+        case 'del':
+            return token.tokens ? extractCellText(token.tokens) : token.text;
+        case 'br':
+            return ' ';
+        default: {
+            const tokenAny = token;
+            if (tokenAny.tokens && Array.isArray(tokenAny.tokens)) {
+                return extractCellText(tokenAny.tokens);
+            }
+            if (typeof tokenAny.text === 'string') {
+                return tokenAny.text;
+            }
+            return '';
+        }
+    }
+}
+function calculateColumnWidths(headers, rows) {
+    const widths = headers.map((h) => {
+        return h.length;
+    });
+    for (const row of rows) {
+        for (let i = 0; i < row.length; i++) {
+            const cell = row[i] ?? '';
+            widths[i] = Math.max(widths[i] ?? 0, cell.length);
+        }
+    }
+    return widths;
+}
+function formatRow(cells, widths) {
+    const paddedCells = cells.map((cell, i) => {
+        return cell.padEnd(widths[i] ?? 0);
+    });
+    return paddedCells.join(' ');
+}
+function formatSeparator(widths) {
+    return widths
+        .map((w) => {
+        return '-'.repeat(w);
+    })
+        .join(' ');
+}