kimaki 0.4.10 → 0.4.13

package/dist/discordBot.js

@@ -22,6 +22,50 @@ import { isAbortError } from './utils.js';
 import { setGlobalDispatcher, Agent } from 'undici';
 // disables the automatic 5 minutes abort after no body
 setGlobalDispatcher(new Agent({ headersTimeout: 0, bodyTimeout: 0 }));
+export const OPENCODE_SYSTEM_MESSAGE = `
+The user is reading your messages from inside Discord, via kimaki.xyz
+
+After each message, if you implemented changes, you can show the user a diff via an url running the command, to show the changes in working directory:
+
+bunx critique web
+
+you can also show latest commit changes using
+
+bunx critique web HEAD~1
+
+do this in case you committed the changes yourself (only if the user asks so, never commit otherwise).
+
+## markdown
+
+discord does support basic markdown features like code blocks, code blocks languages, inline code, bold, italic, quotes, etc.
+
+the max heading level is 3, so do not use ####
+
+headings are discouraged anyway. instead try to use bold text for titles which renders more nicely in Discord
+
+## tables
+
+discord does NOT support markdown gfm tables.
+
+so instead of using full markdown tables ALWAYS show code snippets with space aligned cells:
+
+\`\`\`
+Item        Qty   Price
+----------  ---   -----
+Apples      10    $5
+Oranges     3     $2
+\`\`\`
+
+Using code blocks will make the content use monospaced font so that space will be aligned correctly
+
+IMPORTANT: add enough space characters to align the table! otherwise the content will not look good and will be difficult to understand for the user
+
+code blocks for tables and diagrams MUST have Max length of 85 characters. otherwise the content will wrap
+
+## diagrams
+
+you can create diagrams wrapping them in code blocks too.
+`;
 const discordLogger = createLogger('DISCORD');
 const voiceLogger = createLogger('VOICE');
 const opencodeLogger = createLogger('OPENCODE');
@@ -85,7 +129,7 @@ async function createUserAudioLogStream(guildId, channelId) {
     }
 }
 // Set up voice handling for a connection (called once per connection)
-async function setupVoiceHandling({ connection, guildId, channelId, appId, }) {
+async function setupVoiceHandling({ connection, guildId, channelId, appId, discordClient, }) {
     voiceLogger.log(`Setting up voice handling for guild ${guildId}, channel ${channelId}`);
     // Check if this voice channel has an associated directory
     const channelDirRow = getDatabase()
@@ -183,8 +227,24 @@ async function setupVoiceHandling({ connection, guildId, channelId, appId, }) {
                 : `<systemMessage>\nThe coding agent finished working on session ${params.sessionId}\n\nHere's what the assistant wrote:\n${params.markdown}\n</systemMessage>`;
             genAiWorker.sendTextInput(text);
         },
-        onError(error) {
+        async onError(error) {
             voiceLogger.error('GenAI worker error:', error);
+            const textChannelRow = getDatabase()
+                .prepare(`SELECT cd2.channel_id FROM channel_directories cd1
+           JOIN channel_directories cd2 ON cd1.directory = cd2.directory
+           WHERE cd1.channel_id = ? AND cd1.channel_type = 'voice' AND cd2.channel_type = 'text'`)
+                .get(channelId);
+            if (textChannelRow) {
+                try {
+                    const textChannel = await discordClient.channels.fetch(textChannelRow.channel_id);
+                    if (textChannel?.isTextBased() && 'send' in textChannel) {
+                        await textChannel.send(`⚠️ Voice session error: ${error}`);
+                    }
+                }
+                catch (e) {
+                    voiceLogger.error('Failed to send error to text channel:', e);
+                }
+            }
         },
     });
     // Stop any existing GenAI worker before storing new one
@@ -451,60 +511,20 @@ 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);
+    const chunks = splitMarkdownForDiscord({ content, maxLength: MAX_LENGTH });
+    if (chunks.length > 1) {
+        discordLogger.log(`MESSAGE: Splitting ${content.length} chars into ${chunks.length} messages`);
     }
-    // Use marked's lexer to tokenize markdown content
-    const lexer = new Lexer();
-    const tokens = lexer.lex(content);
-    const chunks = [];
-    let currentChunk = '';
-    // Process each token and add to chunks
-    for (const token of tokens) {
-        const tokenText = token.raw || '';
-        // If adding this token would exceed limit and we have content, flush current chunk
-        if (currentChunk && currentChunk.length + tokenText.length > MAX_LENGTH) {
-            chunks.push(currentChunk);
-            currentChunk = '';
-        }
-        // If this single token is longer than MAX_LENGTH, split it
-        if (tokenText.length > MAX_LENGTH) {
-            if (currentChunk) {
-                chunks.push(currentChunk);
-                currentChunk = '';
-            }
-            let remainingText = tokenText;
-            while (remainingText.length > MAX_LENGTH) {
-                // Try to split at a newline if possible
-                let splitIndex = MAX_LENGTH;
-                const newlineIndex = remainingText.lastIndexOf('\n', MAX_LENGTH - 1);
-                if (newlineIndex > MAX_LENGTH * 0.7) {
-                    splitIndex = newlineIndex + 1;
-                }
-                chunks.push(remainingText.slice(0, splitIndex));
-                remainingText = remainingText.slice(splitIndex);
-            }
-            currentChunk = remainingText;
-        }
-        else {
-            currentChunk += tokenText;
-        }
-    }
-    // Add any remaining content
-    if (currentChunk) {
-        chunks.push(currentChunk);
-    }
-    // Send all chunks
-    discordLogger.log(`MESSAGE: Splitting ${content.length} chars into ${chunks.length} messages`);
     let firstMessage;
     for (let i = 0; i < chunks.length; i++) {
         const chunk = chunks[i];
-        if (!chunk)
+        if (!chunk) {
             continue;
+        }
         const message = await thread.send(chunk);
-        if (i === 0)
+        if (i === 0) {
             firstMessage = message;
+        }
     }
     return firstMessage;
 }
@@ -621,6 +641,77 @@ export function escapeBackticksInCodeBlocks(markdown) {
     }
     return result;
 }
+export function splitMarkdownForDiscord({ content, maxLength, }) {
+    if (content.length <= maxLength) {
+        return [content];
+    }
+    const lexer = new Lexer();
+    const tokens = lexer.lex(content);
+    const lines = [];
+    for (const token of tokens) {
+        if (token.type === 'code') {
+            const lang = token.lang || '';
+            lines.push({ text: '```' + lang + '\n', inCodeBlock: false, lang, isOpeningFence: true, isClosingFence: false });
+            const codeLines = token.text.split('\n');
+            for (const codeLine of codeLines) {
+                lines.push({ text: codeLine + '\n', inCodeBlock: true, lang, isOpeningFence: false, isClosingFence: false });
+            }
+            lines.push({ text: '```\n', inCodeBlock: false, lang: '', isOpeningFence: false, isClosingFence: true });
+        }
+        else {
+            const rawLines = token.raw.split('\n');
+            for (let i = 0; i < rawLines.length; i++) {
+                const isLast = i === rawLines.length - 1;
+                const text = isLast ? rawLines[i] : rawLines[i] + '\n';
+                if (text) {
+                    lines.push({ text, inCodeBlock: false, lang: '', isOpeningFence: false, isClosingFence: false });
+                }
+            }
+        }
+    }
+    const chunks = [];
+    let currentChunk = '';
+    let currentLang = null;
+    for (const line of lines) {
+        const wouldExceed = currentChunk.length + line.text.length > maxLength;
+        if (wouldExceed && currentChunk) {
+            if (currentLang !== null) {
+                currentChunk += '```\n';
+            }
+            chunks.push(currentChunk);
+            if (line.isClosingFence && currentLang !== null) {
+                currentChunk = '';
+                currentLang = null;
+                continue;
+            }
+            if (line.inCodeBlock || line.isOpeningFence) {
+                const lang = line.lang;
+                currentChunk = '```' + lang + '\n';
+                if (!line.isOpeningFence) {
+                    currentChunk += line.text;
+                }
+                currentLang = lang;
+            }
+            else {
+                currentChunk = line.text;
+                currentLang = null;
+            }
+        }
+        else {
+            currentChunk += line.text;
+            if (line.inCodeBlock || line.isOpeningFence) {
+                currentLang = line.lang;
+            }
+            else if (line.isClosingFence) {
+                currentLang = null;
+            }
+        }
+    }
+    if (currentChunk) {
+        chunks.push(currentChunk);
+    }
+    return chunks;
+}
 /**
  * Escape Discord formatting characters to prevent breaking code blocks and inline code
  */
@@ -837,24 +928,27 @@ function getToolOutputToDisplay(part) {
     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 formatTodoList(part) {
+    if (part.type !== 'tool' || part.tool !== 'todowrite')
+        return '';
+    const todos = part.state.input?.todos || [];
+    if (todos.length === 0)
+        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');
+}
 function formatPart(part) {
     if (part.type === 'text') {
         return part.text || '';
@@ -877,14 +971,31 @@ function formatPart(part) {
         return `◼︎ snapshot ${part.snapshot}`;
     }
     if (part.type === 'tool') {
+        if (part.tool === 'todowrite') {
+            return formatTodoList(part);
+        }
         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}*`;
+        let toolTitle = '';
+        if (part.state.status === 'error') {
+            toolTitle = 'error';
+        }
+        else if (part.tool === 'bash') {
+            const command = part.state.input?.command || '';
+            const isSingleLine = !command.includes('\n');
+            const hasBackticks = command.includes('`');
+            if (isSingleLine && command.length <= 120 && !hasBackticks) {
+                toolTitle = `\`${command}\``;
+            }
+            else {
+                toolTitle = part.state.title ? `*${part.state.title}*` : '';
+            }
+        }
+        else if (part.state.title) {
+            toolTitle = `*${part.state.title}*`;
         }
         const icon = part.state.status === 'completed' ? '◼︎' : part.state.status === 'error' ? '⨯' : '';
         const title = `${icon} ${part.tool} ${toolTitle} ${summaryText}`;
@@ -1265,6 +1376,7 @@ async function handleOpencodeSession({ prompt, thread, projectDirectory, origina
             path: { id: session.id },
             body: {
                 parts,
+                system: OPENCODE_SYSTEM_MESSAGE,
             },
             signal: abortController.signal,
         });
@@ -1861,52 +1973,37 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                         await command.editReply(`Resumed session "${sessionTitle}" in ${thread.toString()}`);
                         // Send initial message to thread
                         await sendThreadMessage(thread, `📂 **Resumed session:** ${sessionTitle}\n📅 **Created:** ${new Date(sessionResponse.data.time.created).toLocaleString()}\n\n*Loading ${messages.length} messages...*`);
-                        // Render all existing messages
-                        let messageCount = 0;
+                        // Collect all assistant parts first, then only render the last 30
+                        const allAssistantParts = [];
                         for (const message of messages) {
-                            if (message.info.role === 'user') {
-                                // Render user messages
-                                const userParts = message.parts.filter((p) => p.type === 'text' && !p.synthetic);
-                                const userTexts = userParts
-                                    .map((p) => {
-                                    if (p.type === 'text') {
-                                        return p.text;
-                                    }
-                                    return '';
-                                })
-                                    .filter((t) => t.trim());
-                                const userText = userTexts.join('\n\n');
-                                if (userText) {
-                                    // Escape backticks in user messages to prevent formatting issues
-                                    const escapedText = escapeDiscordFormatting(userText);
-                                    await sendThreadMessage(thread, `**User:**\n${escapedText}`);
-                                }
-                            }
-                            else if (message.info.role === 'assistant') {
-                                // Render assistant parts
-                                const partsToRender = [];
+                            if (message.info.role === 'assistant') {
                                 for (const part of message.parts) {
                                     const content = formatPart(part);
                                     if (content.trim()) {
-                                        partsToRender.push({ id: part.id, content });
+                                        allAssistantParts.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++;
                         }
+                        const partsToRender = allAssistantParts.slice(-30);
+                        const skippedCount = allAssistantParts.length - partsToRender.length;
+                        if (skippedCount > 0) {
+                            await sendThreadMessage(thread, `*Skipped ${skippedCount} older assistant parts...*`);
+                        }
+                        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);
+                        }
+                        const messageCount = messages.length;
                         await sendThreadMessage(thread, `✅ **Session resumed!** Loaded ${messageCount} messages.\n\nYou can now continue the conversation by sending messages in this thread.`);
                     }
                     catch (error) {
@@ -2245,6 +2342,7 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                     guildId: newState.guild.id,
                     channelId: voiceChannel.id,
                     appId: currentAppId,
+                    discordClient,
                 });
                 // Handle connection state changes
                 connection.on(VoiceConnectionStatus.Disconnected, async () => {

package/dist/escape-backticks.test.js

@@ -1,6 +1,6 @@
 import { test, expect } from 'vitest';
 import { Lexer } from 'marked';
-import { escapeBackticksInCodeBlocks } from './discordBot.js';
+import { escapeBackticksInCodeBlocks, splitMarkdownForDiscord } from './discordBot.js';
 test('escapes single backticks in code blocks', () => {
     const input = '```js\nconst x = `hello`\n```';
     const result = escapeBackticksInCodeBlocks(input);
@@ -123,3 +123,288 @@ const x = \\\`hello\\\`
 "
 `);
 });
+test('splitMarkdownForDiscord returns single chunk for short content', () => {
+    const result = splitMarkdownForDiscord({
+        content: 'Hello world',
+        maxLength: 100,
+    });
+    expect(result).toMatchInlineSnapshot(`
+    [
+      "Hello world",
+    ]
+  `);
+});
+test('splitMarkdownForDiscord splits at line boundaries', () => {
+    const result = splitMarkdownForDiscord({
+        content: 'Line 1\nLine 2\nLine 3\nLine 4',
+        maxLength: 15,
+    });
+    expect(result).toMatchInlineSnapshot(`
+    [
+      "Line 1
+    Line 2
+    ",
+      "Line 3
+    Line 4",
+    ]
+  `);
+});
+test('splitMarkdownForDiscord preserves code blocks when not split', () => {
+    const result = splitMarkdownForDiscord({
+        content: '```js\nconst x = 1\n```',
+        maxLength: 100,
+    });
+    expect(result).toMatchInlineSnapshot(`
+    [
+      "\`\`\`js
+    const x = 1
+    \`\`\`",
+    ]
+  `);
+});
+test('splitMarkdownForDiscord adds closing and opening fences when splitting code block', () => {
+    const result = splitMarkdownForDiscord({
+        content: '```js\nline1\nline2\nline3\nline4\n```',
+        maxLength: 20,
+    });
+    expect(result).toMatchInlineSnapshot(`
+    [
+      "\`\`\`js
+    line1
+    line2
+    \`\`\`
+    ",
+      "\`\`\`js
+    line3
+    line4
+    \`\`\`
+    ",
+    ]
+  `);
+});
+test('splitMarkdownForDiscord handles code block with language', () => {
+    const result = splitMarkdownForDiscord({
+        content: '```typescript\nconst a = 1\nconst b = 2\n```',
+        maxLength: 30,
+    });
+    expect(result).toMatchInlineSnapshot(`
+    [
+      "\`\`\`typescript
+    const a = 1
+    \`\`\`
+    ",
+      "\`\`\`typescript
+    const b = 2
+    \`\`\`
+    ",
+    ]
+  `);
+});
+test('splitMarkdownForDiscord handles mixed content with code blocks', () => {
+    const result = splitMarkdownForDiscord({
+        content: 'Text before\n```js\ncode\n```\nText after',
+        maxLength: 25,
+    });
+    expect(result).toMatchInlineSnapshot(`
+    [
+      "Text before
+    \`\`\`js
+    code
+    \`\`\`
+    ",
+      "Text after",
+    ]
+  `);
+});
+test('splitMarkdownForDiscord handles code block without language', () => {
+    const result = splitMarkdownForDiscord({
+        content: '```\nline1\nline2\n```',
+        maxLength: 12,
+    });
+    expect(result).toMatchInlineSnapshot(`
+    [
+      "\`\`\`
+    line1
+    \`\`\`
+    ",
+      "\`\`\`
+    line2
+    \`\`\`
+    ",
+    ]
+  `);
+});
+test('splitMarkdownForDiscord handles multiple consecutive code blocks', () => {
+    const result = splitMarkdownForDiscord({
+        content: '```js\nfoo\n```\n```py\nbar\n```',
+        maxLength: 20,
+    });
+    expect(result).toMatchInlineSnapshot(`
+    [
+      "\`\`\`js
+    foo
+    \`\`\`
+    \`\`\`py
+    \`\`\`
+    ",
+      "\`\`\`py
+    bar
+    \`\`\`
+    ",
+    ]
+  `);
+});
+test('splitMarkdownForDiscord handles empty code block', () => {
+    const result = splitMarkdownForDiscord({
+        content: 'before\n```\n```\nafter',
+        maxLength: 50,
+    });
+    expect(result).toMatchInlineSnapshot(`
+    [
+      "before
+    \`\`\`
+    \`\`\`
+    after",
+    ]
+  `);
+});
+test('splitMarkdownForDiscord handles content exactly at maxLength', () => {
+    const result = splitMarkdownForDiscord({
+        content: '12345678901234567890',
+        maxLength: 20,
+    });
+    expect(result).toMatchInlineSnapshot(`
+    [
+      "12345678901234567890",
+    ]
+  `);
+});
+test('splitMarkdownForDiscord handles code block only', () => {
+    const result = splitMarkdownForDiscord({
+        content: '```ts\nconst x = 1\n```',
+        maxLength: 15,
+    });
+    expect(result).toMatchInlineSnapshot(`
+    [
+      "\`\`\`ts
+    \`\`\`
+    ",
+      "\`\`\`ts
+    const x = 1
+    \`\`\`
+    ",
+    ]
+  `);
+});
+test('splitMarkdownForDiscord handles code block at start with text after', () => {
+    const result = splitMarkdownForDiscord({
+        content: '```js\ncode\n```\nSome text after',
+        maxLength: 20,
+    });
+    expect(result).toMatchInlineSnapshot(`
+    [
+      "\`\`\`js
+    code
+    \`\`\`
+    ",
+      "Some text after",
+    ]
+  `);
+});
+test('splitMarkdownForDiscord handles text before code block at end', () => {
+    const result = splitMarkdownForDiscord({
+        content: 'Some text before\n```js\ncode\n```',
+        maxLength: 25,
+    });
+    expect(result).toMatchInlineSnapshot(`
+    [
+      "Some text before
+    \`\`\`js
+    \`\`\`
+    ",
+      "\`\`\`js
+    code
+    \`\`\`
+    ",
+    ]
+  `);
+});
+test('splitMarkdownForDiscord handles very long line inside code block', () => {
+    const result = splitMarkdownForDiscord({
+        content: '```js\nshort\nveryverylonglinethatexceedsmaxlength\nshort\n```',
+        maxLength: 25,
+    });
+    expect(result).toMatchInlineSnapshot(`
+    [
+      "\`\`\`js
+    short
+    \`\`\`
+    ",
+      "\`\`\`js
+    veryverylonglinethatexceedsmaxlength
+    \`\`\`
+    ",
+      "\`\`\`js
+    short
+    \`\`\`
+    ",
+    ]
+  `);
+});
+test('splitMarkdownForDiscord handles realistic long markdown with code block', () => {
+    const content = `Here is some explanation text before the code.
+
+\`\`\`typescript
+export function calculateTotal(items: Item[]): number {
+  let total = 0
+  for (const item of items) {
+    total += item.price * item.quantity
+  }
+  return total
+}
+
+export function formatCurrency(amount: number): string {
+  return new Intl.NumberFormat('en-US', {
+    style: 'currency',
+    currency: 'USD',
+  }).format(amount)
+}
+\`\`\`
+
+And here is some text after the code block.`;
+    const result = splitMarkdownForDiscord({
+        content,
+        maxLength: 200,
+    });
+    expect(result).toMatchInlineSnapshot(`
+    [
+      "Here is some explanation text before the code.
+
+    \`\`\`typescript
+    export function calculateTotal(items: Item[]): number {
+      let total = 0
+      for (const item of items) {
+    \`\`\`
+    ",
+      "\`\`\`typescript
+        total += item.price * item.quantity
+      }
+      return total
+    }
+
+    export function formatCurrency(amount: number): string {
+      return new Intl.NumberFormat('en-US', {
+        style: 'currency',
+    \`\`\`
+    ",
+      "\`\`\`typescript
+        currency: 'USD',
+      }).format(amount)
+    }
+    \`\`\`
+
+
+    And here is some text after the code block.",
+    ]
+  `);
+});