kimaki 0.4.10 → 0.4.13

package/dist/tools.js

@@ -8,7 +8,7 @@ const toolsLogger = createLogger('TOOLS');
 import { formatDistanceToNow } from 'date-fns';
 import { ShareMarkdown } from './markdown.js';
 import pc from 'picocolors';
-import { initializeOpencodeForDirectory } from './discordBot.js';
+import { initializeOpencodeForDirectory, OPENCODE_SYSTEM_MESSAGE, } from './discordBot.js';
 export async function getTools({ onMessageCompleted, directory, }) {
     const getClient = await initializeOpencodeForDirectory(directory);
     const client = getClient();
@@ -48,6 +48,7 @@ export async function getTools({ onMessageCompleted, directory, }) {
                     body: {
                         parts: [{ type: 'text', text: message }],
                         model: sessionModel,
+                        system: OPENCODE_SYSTEM_MESSAGE,
                     },
                 })
                     .then(async (response) => {
@@ -114,7 +115,7 @@ export async function getTools({ onMessageCompleted, directory, }) {
                         path: { id: session.data.id },
                         body: {
                             parts: [{ type: 'text', text: message }],
-                            // model,
+                            system: OPENCODE_SYSTEM_MESSAGE,
                         },
                     })
                         .then(async (response) => {

package/package.json

@@ -2,7 +2,7 @@
   "name": "kimaki",
   "module": "index.ts",
   "type": "module",
-  "version": "0.4.10",
+  "version": "0.4.13",
   "scripts": {
     "dev": "tsx --env-file .env src/cli.ts",
     "prepublishOnly": "pnpm tsc",

package/src/discordBot.ts

@@ -54,6 +54,51 @@ 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')
@@ -168,11 +213,13 @@ async function setupVoiceHandling({
   guildId,
   channelId,
   appId,
+  discordClient,
 }: {
   connection: VoiceConnection
   guildId: string
   channelId: string
   appId: string
+  discordClient: Client
 }) {
   voiceLogger.log(
     `Setting up voice handling for guild ${guildId}, channel ${channelId}`,
@@ -285,8 +332,28 @@ async function setupVoiceHandling({
 
       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) as { channel_id: string } | undefined
+
+      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)
+        }
+      }
     },
   })
 
@@ -629,69 +696,24 @@ async function sendThreadMessage(
 
   content = escapeBackticksInCodeBlocks(content)
 
-  // Simple case: content fits in one message
-  if (content.length <= MAX_LENGTH) {
-    return await thread.send(content)
-  }
-
-  // Use marked's lexer to tokenize markdown content
-  const lexer = new Lexer()
-  const tokens = lexer.lex(content)
-
-  const chunks: string[] = []
-  let currentChunk = ''
-
-  // Process each token and add to chunks
-  for (const token of tokens) {
-    const tokenText = token.raw || ''
+  const chunks = splitMarkdownForDiscord({ content, maxLength: MAX_LENGTH })
 
-    // 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)
+  if (chunks.length > 1) {
+    discordLogger.log(
+      `MESSAGE: Splitting ${content.length} chars into ${chunks.length} messages`,
+    )
   }
 
-  // Send all chunks
-  discordLogger.log(
-    `MESSAGE: Splitting ${content.length} chars into ${chunks.length} messages`,
-  )
-
   let firstMessage: Message | undefined
   for (let i = 0; i < chunks.length; i++) {
     const chunk = chunks[i]
-    if (!chunk) continue
+    if (!chunk) {
+      continue
+    }
     const message = await thread.send(chunk)
-    if (i === 0) firstMessage = message
+    if (i === 0) {
+      firstMessage = message
+    }
   }
 
   return firstMessage!
@@ -852,6 +874,97 @@ export function escapeBackticksInCodeBlocks(markdown: string): string {
   return result
 }
 
+type LineInfo = {
+  text: string
+  inCodeBlock: boolean
+  lang: string
+  isOpeningFence: boolean
+  isClosingFence: boolean
+}
+
+export function splitMarkdownForDiscord({
+  content,
+  maxLength,
+}: {
+  content: string
+  maxLength: number
+}): string[] {
+  if (content.length <= maxLength) {
+    return [content]
+  }
+
+  const lexer = new Lexer()
+  const tokens = lexer.lex(content)
+
+  const lines: LineInfo[] = []
+  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: string[] = []
+  let currentChunk = ''
+  let currentLang: string | null = 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
  */
@@ -1121,30 +1234,31 @@ function getToolOutputToDisplay(part: Part): string {
     return part.state.error || 'Unknown error'
   }
 
-  if (part.tool === 'todowrite') {
-    const todos =
-      (part.state.input?.todos as {
-        content: string
-        status: 'pending' | 'in_progress' | 'completed' | 'cancelled'
-      }[]) || []
-    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: Part): string {
+  if (part.type !== 'tool' || part.tool !== 'todowrite') return ''
+  const todos =
+    (part.state.input?.todos as {
+      content: string
+      status: 'pending' | 'in_progress' | 'completed' | 'cancelled'
+    }[]) || []
+  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: Part): string {
   if (part.type === 'text') {
     return part.text || ''
@@ -1172,6 +1286,10 @@ function formatPart(part: Part): string {
   }
 
   if (part.type === 'tool') {
+    if (part.tool === 'todowrite') {
+      return formatTodoList(part)
+    }
+
     if (part.state.status !== 'completed' && part.state.status !== 'error') {
       return ''
     }
@@ -1179,9 +1297,20 @@ function formatPart(part: Part): string {
     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 as string) || ''
+      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' ? '⨯' : ''
@@ -1687,6 +1816,7 @@ async function handleOpencodeSession({
       path: { id: session.id },
       body: {
         parts,
+        system: OPENCODE_SYSTEM_MESSAGE,
       },
       signal: abortController.signal,
     })
@@ -2508,68 +2638,56 @@ export async function startDiscordBot({
                 `📂 **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: { id: string; content: string }[] = []
               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: { id: string; content: string }[] = []
-
+                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 partsToRender = allAssistantParts.slice(-30)
+              const skippedCount = allAssistantParts.length - partsToRender.length
 
-                    const discordMessage = await sendThreadMessage(
-                      thread,
-                      combinedContent,
-                    )
+              if (skippedCount > 0) {
+                await sendThreadMessage(
+                  thread,
+                  `*Skipped ${skippedCount} older assistant parts...*`,
+                )
+              }
 
-                    const stmt = getDatabase().prepare(
-                      'INSERT OR REPLACE INTO part_messages (part_id, message_id, thread_id) VALUES (?, ?, ?)',
-                    )
+              if (partsToRender.length > 0) {
+                const combinedContent = partsToRender
+                  .map((p) => p.content)
+                  .join('\n\n')
 
-                    const transaction = getDatabase().transaction(
-                      (parts: { id: string }[]) => {
-                        for (const part of parts) {
-                          stmt.run(part.id, discordMessage.id, thread.id)
-                        }
-                      },
-                    )
+                const discordMessage = await sendThreadMessage(
+                  thread,
+                  combinedContent,
+                )
 
-                    transaction(partsToRender)
-                  }
-                }
-                messageCount++
+                const stmt = getDatabase().prepare(
+                  'INSERT OR REPLACE INTO part_messages (part_id, message_id, thread_id) VALUES (?, ?, ?)',
+                )
+
+                const transaction = getDatabase().transaction(
+                  (parts: { id: string }[]) => {
+                    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.`,
@@ -3009,6 +3127,7 @@ export async function startDiscordBot({
           guildId: newState.guild.id,
           channelId: voiceChannel.id,
           appId: currentAppId!,
+          discordClient,
         })
 
         // Handle connection state changes