kimaki 0.4.25 → 0.4.26

package/src/discord-bot.ts

@@ -25,9 +25,10 @@ import {
   registerVoiceStateHandler,
 } from './voice-handler.js'
 import {
-  handleOpencodeSession,
-  parseSlashCommand,
-} from './session-handler.js'
+  getCompactSessionContext,
+  getLastSessionId,
+} from './markdown.js'
+import { handleOpencodeSession } from './session-handler.js'
 import { registerInteractionHandler } from './interaction-handler.js'
 
 export { getDatabase, closeDatabase } from './database.js'
@@ -240,34 +241,39 @@ export async function startDiscordBot({
 
         let messageContent = message.content || ''
 
-        let sessionMessagesText: string | undefined
-        if (projectDirectory && row.session_id) {
+        let currentSessionContext: string | undefined
+        let lastSessionContext: string | undefined
+
+        if (projectDirectory) {
           try {
             const getClient = await initializeOpencodeForDirectory(projectDirectory)
-            const messagesResponse = await getClient().session.messages({
-              path: { id: row.session_id },
+            const client = getClient()
+
+            // get current session context (without system prompt, it would be duplicated)
+            if (row.session_id) {
+              currentSessionContext = await getCompactSessionContext({
+                client,
+                sessionId: row.session_id,
+                includeSystemPrompt: false,
+                maxMessages: 15,
+              })
+            }
+
+            // get last session context (with system prompt for project context)
+            const lastSessionId = await getLastSessionId({
+              client,
+              excludeSessionId: row.session_id,
             })
-            const messages = messagesResponse.data || []
-            const recentMessages = messages.slice(-10)
-            sessionMessagesText = recentMessages
-              .map((m) => {
-                const role = m.info.role === 'user' ? 'User' : 'Assistant'
-                const text = (() => {
-                  if (m.info.role === 'user') {
-                    const textParts = (m.parts || []).filter((p) => p.type === 'text')
-                    return textParts
-                      .map((p) => ('text' in p ? p.text : ''))
-                      .filter(Boolean)
-                      .join('\n')
-                  }
-                  const assistantInfo = m.info as { text?: string }
-                  return assistantInfo.text?.slice(0, 500)
-                })()
-                return `[${role}]: ${text || '(no text)'}`
+            if (lastSessionId) {
+              lastSessionContext = await getCompactSessionContext({
+                client,
+                sessionId: lastSessionId,
+                includeSystemPrompt: true,
+                maxMessages: 10,
               })
-              .join('\n\n')
+            }
           } catch (e) {
-            voiceLogger.log(`Could not get session messages:`, e)
+            voiceLogger.error(`Could not get session context:`, e)
           }
         }
 
@@ -276,25 +282,24 @@ export async function startDiscordBot({
           thread,
           projectDirectory,
           appId: currentAppId,
-          sessionMessages: sessionMessagesText,
+          currentSessionContext,
+          lastSessionContext,
         })
         if (transcription) {
           messageContent = transcription
         }
 
-        const fileAttachments = getFileAttachments(message)
+        const fileAttachments = await getFileAttachments(message)
         const textAttachmentsContent = await getTextAttachments(message)
         const promptWithAttachments = textAttachmentsContent
           ? `${messageContent}\n\n${textAttachmentsContent}`
           : messageContent
-        const parsedCommand = parseSlashCommand(messageContent)
         await handleOpencodeSession({
           prompt: promptWithAttachments,
           thread,
           projectDirectory,
           originalMessage: message,
           images: fileAttachments,
-          parsedCommand,
           channelId: parent?.id,
         })
         return
@@ -380,19 +385,17 @@ export async function startDiscordBot({
           messageContent = transcription
         }
 
-        const fileAttachments = getFileAttachments(message)
+        const fileAttachments = await getFileAttachments(message)
         const textAttachmentsContent = await getTextAttachments(message)
         const promptWithAttachments = textAttachmentsContent
           ? `${messageContent}\n\n${textAttachmentsContent}`
           : messageContent
-        const parsedCommand = parseSlashCommand(messageContent)
         await handleOpencodeSession({
           prompt: promptWithAttachments,
           thread,
           projectDirectory,
           originalMessage: message,
           images: fileAttachments,
-          parsedCommand,
           channelId: textChannel.id,
         })
       } else {

package/src/discord-utils.ts

@@ -85,31 +85,93 @@ export function splitMarkdownForDiscord({
   let currentChunk = ''
   let currentLang: string | null = null
 
+  // helper to split a long line into smaller pieces at word boundaries or hard breaks
+  const splitLongLine = (text: string, available: number, inCode: boolean): string[] => {
+    const pieces: string[] = []
+    let remaining = text
+
+    while (remaining.length > available) {
+      let splitAt = available
+      // for non-code, try to split at word boundary
+      if (!inCode) {
+        const lastSpace = remaining.lastIndexOf(' ', available)
+        if (lastSpace > available * 0.5) {
+          splitAt = lastSpace + 1
+        }
+      }
+      pieces.push(remaining.slice(0, splitAt))
+      remaining = remaining.slice(splitAt)
+    }
+    if (remaining) {
+      pieces.push(remaining)
+    }
+    return pieces
+  }
+
   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 (wouldExceed) {
+      // handle case where single line is longer than maxLength
+      if (line.text.length > maxLength) {
+        // first, flush current chunk if any
+        if (currentChunk) {
+          if (currentLang !== null) {
+            currentChunk += '```\n'
+          }
+          chunks.push(currentChunk)
+          currentChunk = ''
+        }
+
+        // calculate overhead for code block markers
+        const codeBlockOverhead = line.inCodeBlock ? ('```' + line.lang + '\n').length + '```\n'.length : 0
+        const availablePerChunk = maxLength - codeBlockOverhead - 50 // safety margin
+
+        const pieces = splitLongLine(line.text, availablePerChunk, line.inCodeBlock)
+
+        for (let i = 0; i < pieces.length; i++) {
+          const piece = pieces[i]!
+          if (line.inCodeBlock) {
+            chunks.push('```' + line.lang + '\n' + piece + '```\n')
+          } else {
+            chunks.push(piece)
+          }
+        }
 
-      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
+      // normal case: line fits in a chunk but current chunk would overflow
+      if (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
         }
-        currentLang = lang
       } else {
+        // currentChunk is empty but line still exceeds - shouldn't happen after above check
         currentChunk = line.text
-        currentLang = null
+        if (line.inCodeBlock || line.isOpeningFence) {
+          currentLang = line.lang
+        }
       }
     } else {
       currentChunk += line.text

package/src/interaction-handler.ts

@@ -12,12 +12,16 @@ import { handleAbortCommand } from './commands/abort.js'
 import { handleShareCommand } from './commands/share.js'
 import { handleForkCommand, handleForkSelectMenu } from './commands/fork.js'
 import { handleModelCommand, handleProviderSelectMenu, handleModelSelectMenu } from './commands/model.js'
+import { handleAgentCommand, handleAgentSelectMenu } from './commands/agent.js'
+import { handleAskQuestionSelectMenu } from './commands/ask-question.js'
 import { handleQueueCommand, handleClearQueueCommand } from './commands/queue.js'
 import { handleUndoCommand, handleRedoCommand } from './commands/undo-redo.js'
+import { handleUserCommand } from './commands/user-command.js'
 import { createLogger } from './logger.js'
 
 const interactionLogger = createLogger('INTERACTION')
 
+
 export function registerInteractionHandler({
   discordClient,
   appId,
@@ -91,6 +95,7 @@ export function registerInteractionHandler({
               return
 
             case 'abort':
+            case 'stop':
               await handleAbortCommand({ command: interaction, appId })
               return
 
@@ -106,6 +111,10 @@ export function registerInteractionHandler({
               await handleModelCommand({ interaction, appId })
               return
 
+            case 'agent':
+              await handleAgentCommand({ interaction, appId })
+              return
+
             case 'queue':
               await handleQueueCommand({ command: interaction, appId })
               return
@@ -122,6 +131,12 @@ export function registerInteractionHandler({
               await handleRedoCommand({ command: interaction, appId })
               return
           }
+
+          // Handle user-defined commands (ending with -cmd suffix)
+          if (interaction.commandName.endsWith('-cmd')) {
+            await handleUserCommand({ command: interaction, appId })
+            return
+          }
           return
         }
 
@@ -142,6 +157,16 @@ export function registerInteractionHandler({
             await handleModelSelectMenu(interaction)
             return
           }
+
+          if (customId.startsWith('agent_select:')) {
+            await handleAgentSelectMenu(interaction)
+            return
+          }
+
+          if (customId.startsWith('ask_question:')) {
+            await handleAskQuestionSelectMenu(interaction)
+            return
+          }
           return
         }
       } catch (error) {

package/src/logger.ts

@@ -3,18 +3,55 @@
 // (DISCORD, VOICE, SESSION, etc.) for easier debugging.
 
 import { log } from '@clack/prompts'
+import fs from 'node:fs'
+import path, { dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+const isDev = !__dirname.includes('node_modules')
+
+const logFilePath = path.join(__dirname, '..', 'tmp', 'kimaki.log')
+
+// reset log file on startup in dev mode
+if (isDev) {
+  const logDir = path.dirname(logFilePath)
+  if (!fs.existsSync(logDir)) {
+    fs.mkdirSync(logDir, { recursive: true })
+  }
+  fs.writeFileSync(logFilePath, `--- kimaki log started at ${new Date().toISOString()} ---\n`)
+}
+
+function writeToFile(level: string, prefix: string, args: any[]) {
+  if (!isDev) {
+    return
+  }
+  const timestamp = new Date().toISOString()
+  const message = `[${timestamp}] [${level}] [${prefix}] ${args.map((arg) => String(arg)).join(' ')}\n`
+  fs.appendFileSync(logFilePath, message)
+}
 
 export function createLogger(prefix: string) {
   return {
-    log: (...args: any[]) =>
-      log.info([`[${prefix}]`, ...args.map((arg) => String(arg))].join(' ')),
-    error: (...args: any[]) =>
-      log.error([`[${prefix}]`, ...args.map((arg) => String(arg))].join(' ')),
-    warn: (...args: any[]) =>
-      log.warn([`[${prefix}]`, ...args.map((arg) => String(arg))].join(' ')),
-    info: (...args: any[]) =>
-      log.info([`[${prefix}]`, ...args.map((arg) => String(arg))].join(' ')),
-    debug: (...args: any[]) =>
-      log.info([`[${prefix}]`, ...args.map((arg) => String(arg))].join(' ')),
+    log: (...args: any[]) => {
+      writeToFile('INFO', prefix, args)
+      log.info([`[${prefix}]`, ...args.map((arg) => String(arg))].join(' '))
+    },
+    error: (...args: any[]) => {
+      writeToFile('ERROR', prefix, args)
+      log.error([`[${prefix}]`, ...args.map((arg) => String(arg))].join(' '))
+    },
+    warn: (...args: any[]) => {
+      writeToFile('WARN', prefix, args)
+      log.warn([`[${prefix}]`, ...args.map((arg) => String(arg))].join(' '))
+    },
+    info: (...args: any[]) => {
+      writeToFile('INFO', prefix, args)
+      log.info([`[${prefix}]`, ...args.map((arg) => String(arg))].join(' '))
+    },
+    debug: (...args: any[]) => {
+      writeToFile('DEBUG', prefix, args)
+      log.info([`[${prefix}]`, ...args.map((arg) => String(arg))].join(' '))
+    },
   }
 }

package/src/markdown.test.ts

@@ -1,7 +1,7 @@
 import { test, expect, beforeAll, afterAll } from 'vitest'
 import { spawn, type ChildProcess } from 'child_process'
 import { OpencodeClient } from '@opencode-ai/sdk'
-import { ShareMarkdown } from './markdown.js'
+import { ShareMarkdown, getCompactSessionContext } from './markdown.js'
 
 let serverProcess: ChildProcess
 let client: OpencodeClient
@@ -312,3 +312,47 @@ test('generate markdown from multiple sessions', async () => {
     }
   }
 })
+
+// test for getCompactSessionContext - disabled in CI since it requires a specific session
+test.skipIf(process.env.CI)('getCompactSessionContext generates compact format', async () => {
+  const sessionId = 'ses_46c2205e8ffeOll1JUSuYChSAM'
+
+  const context = await getCompactSessionContext({
+    client,
+    sessionId,
+    includeSystemPrompt: true,
+    maxMessages: 15,
+  })
+
+  console.log(`Generated compact context length: ${context.length} characters`)
+
+  expect(context).toBeTruthy()
+  expect(context.length).toBeGreaterThan(0)
+  // should have tool calls or messages
+  expect(context).toMatch(/\[Tool \w+\]:|\[User\]:|\[Assistant\]:/)
+
+  await expect(context).toMatchFileSnapshot(
+    './__snapshots__/compact-session-context.md',
+  )
+})
+
+test.skipIf(process.env.CI)('getCompactSessionContext without system prompt', async () => {
+  const sessionId = 'ses_46c2205e8ffeOll1JUSuYChSAM'
+
+  const context = await getCompactSessionContext({
+    client,
+    sessionId,
+    includeSystemPrompt: false,
+    maxMessages: 10,
+  })
+
+  console.log(`Generated compact context (no system) length: ${context.length} characters`)
+
+  expect(context).toBeTruthy()
+  // should NOT have system prompt
+  expect(context).not.toContain('[System Prompt]')
+
+  await expect(context).toMatchFileSnapshot(
+    './__snapshots__/compact-session-context-no-system.md',
+  )
+})

package/src/markdown.ts

@@ -6,6 +6,9 @@ import type { OpencodeClient } from '@opencode-ai/sdk'
 import * as yaml from 'js-yaml'
 import { formatDateTime } from './utils.js'
 import { extractNonXmlContent } from './xml.js'
+import { createLogger } from './logger.js'
+
+const markdownLogger = createLogger('MARKDOWN')
 
 export class ShareMarkdown {
   constructor(private client: OpencodeClient) {}
@@ -231,3 +234,132 @@ export class ShareMarkdown {
     return `${minutes}m ${seconds}s`
   }
 }
+
+/**
+ * Generate compact session context for voice transcription.
+ * Includes system prompt (optional), user messages, assistant text,
+ * and tool calls in compact form (name + params only, no output).
+ */
+export async function getCompactSessionContext({
+  client,
+  sessionId,
+  includeSystemPrompt = false,
+  maxMessages = 20,
+}: {
+  client: OpencodeClient
+  sessionId: string
+  includeSystemPrompt?: boolean
+  maxMessages?: number
+}): Promise<string> {
+  try {
+    const messagesResponse = await client.session.messages({
+      path: { id: sessionId },
+    })
+    const messages = messagesResponse.data || []
+
+    const lines: string[] = []
+
+    // Get system prompt if requested
+    // Note: OpenCode SDK doesn't expose system prompt directly. We try multiple approaches:
+    // 1. session.system field (if available in future SDK versions)
+    // 2. synthetic text part in first assistant message (current approach)
+    if (includeSystemPrompt && messages.length > 0) {
+      const firstAssistant = messages.find((m) => m.info.role === 'assistant')
+      if (firstAssistant) {
+        // look for text part marked as synthetic (system prompt)
+        const systemPart = (firstAssistant.parts || []).find(
+          (p) => p.type === 'text' && (p as any).synthetic === true,
+        )
+        if (systemPart && 'text' in systemPart && systemPart.text) {
+          lines.push('[System Prompt]')
+          const truncated = systemPart.text.slice(0, 3000)
+          lines.push(truncated)
+          if (systemPart.text.length > 3000) {
+            lines.push('...(truncated)')
+          }
+          lines.push('')
+        }
+      }
+    }
+
+    // Process recent messages
+    const recentMessages = messages.slice(-maxMessages)
+
+    for (const msg of recentMessages) {
+      if (msg.info.role === 'user') {
+        const textParts = (msg.parts || [])
+          .filter((p) => p.type === 'text' && 'text' in p)
+          .map((p) => ('text' in p ? extractNonXmlContent(p.text || '') : ''))
+          .filter(Boolean)
+        if (textParts.length > 0) {
+          lines.push(`[User]: ${textParts.join(' ').slice(0, 1000)}`)
+          lines.push('')
+        }
+      } else if (msg.info.role === 'assistant') {
+        // Get assistant text parts (non-synthetic, non-empty)
+        const textParts = (msg.parts || [])
+          .filter((p) => p.type === 'text' && 'text' in p && !p.synthetic && p.text)
+          .map((p) => ('text' in p ? p.text : ''))
+          .filter(Boolean)
+        if (textParts.length > 0) {
+          lines.push(`[Assistant]: ${textParts.join(' ').slice(0, 1000)}`)
+          lines.push('')
+        }
+
+        // Get tool calls in compact form (name + params only)
+        const toolParts = (msg.parts || []).filter(
+          (p) =>
+            p.type === 'tool' &&
+            'state' in p &&
+            p.state?.status === 'completed',
+        )
+        for (const part of toolParts) {
+          if (part.type === 'tool' && 'tool' in part && 'state' in part) {
+            const toolName = part.tool
+            // skip noisy tools
+            if (toolName === 'todoread' || toolName === 'todowrite') {
+              continue
+            }
+            const input = part.state?.input || {}
+            // compact params: just key=value on one line
+            const params = Object.entries(input)
+              .map(([k, v]) => {
+                const val = typeof v === 'string' ? v.slice(0, 100) : JSON.stringify(v).slice(0, 100)
+                return `${k}=${val}`
+              })
+              .join(', ')
+            lines.push(`[Tool ${toolName}]: ${params}`)
+          }
+        }
+      }
+    }
+
+    return lines.join('\n').slice(0, 8000)
+  } catch (e) {
+    markdownLogger.error('Failed to get compact session context:', e)
+    return ''
+  }
+}
+
+/**
+ * Get the last session for a directory (excluding the current one).
+ */
+export async function getLastSessionId({
+  client,
+  excludeSessionId,
+}: {
+  client: OpencodeClient
+  excludeSessionId?: string
+}): Promise<string | null> {
+  try {
+    const sessionsResponse = await client.session.list()
+    const sessions = sessionsResponse.data || []
+
+    // Sessions are sorted by time, get the most recent one that isn't the current
+    const lastSession = sessions.find((s) => s.id !== excludeSessionId)
+    return lastSession?.id || null
+  } catch (e) {
+    markdownLogger.error('Failed to get last session:', e)
+    return null
+  }
+}

package/src/message-formatting.test.ts

@@ -0,0 +1,81 @@
+import { describe, test, expect } from 'vitest'
+import { formatTodoList } from './message-formatting.js'
+import type { Part } from '@opencode-ai/sdk'
+
+describe('formatTodoList', () => {
+  test('formats active todo with monospace numbers', () => {
+    const part: Part = {
+      id: 'test',
+      type: 'tool',
+      tool: 'todowrite',
+      sessionID: 'ses_test',
+      messageID: 'msg_test',
+      callID: 'call_test',
+      state: {
+        status: 'completed',
+        input: {
+          todos: [
+            { content: 'First task', status: 'completed' },
+            { content: 'Second task', status: 'in_progress' },
+            { content: 'Third task', status: 'pending' },
+          ],
+        },
+        output: '',
+        title: 'todowrite',
+        metadata: {},
+        time: { start: 0, end: 0 },
+      },
+    }
+
+    expect(formatTodoList(part)).toMatchInlineSnapshot(`"⑵ **second task**"`)
+  })
+
+  test('formats double digit todo numbers', () => {
+    const todos = Array.from({ length: 12 }, (_, i) => ({
+      content: `Task ${i + 1}`,
+      status: i === 11 ? 'in_progress' : 'completed',
+    }))
+
+    const part: Part = {
+      id: 'test',
+      type: 'tool',
+      tool: 'todowrite',
+      sessionID: 'ses_test',
+      messageID: 'msg_test',
+      callID: 'call_test',
+      state: {
+        status: 'completed',
+        input: { todos },
+        output: '',
+        title: 'todowrite',
+        metadata: {},
+        time: { start: 0, end: 0 },
+      },
+    }
+
+    expect(formatTodoList(part)).toMatchInlineSnapshot(`"⑿ **task 12**"`)
+  })
+
+  test('lowercases first letter of content', () => {
+    const part: Part = {
+      id: 'test',
+      type: 'tool',
+      tool: 'todowrite',
+      sessionID: 'ses_test',
+      messageID: 'msg_test',
+      callID: 'call_test',
+      state: {
+        status: 'completed',
+        input: {
+          todos: [{ content: 'Fix the bug', status: 'in_progress' }],
+        },
+        output: '',
+        title: 'todowrite',
+        metadata: {},
+        time: { start: 0, end: 0 },
+      },
+    }
+
+    expect(formatTodoList(part)).toMatchInlineSnapshot(`"⑴ **fix the bug**"`)
+  })
+})