kimaki 0.4.33 → 0.4.35

package/package.json

@@ -2,7 +2,7 @@
   "name": "kimaki",
   "module": "index.ts",
   "type": "module",
-  "version": "0.4.33",
+  "version": "0.4.35",
   "scripts": {
     "dev": "tsx --env-file .env src/cli.ts",
     "prepublishOnly": "pnpm tsc",
@@ -30,30 +30,29 @@
     "tsx": "^4.20.5"
   },
   "dependencies": {
-    "@ai-sdk/google": "^2.0.47",
     "@clack/prompts": "^0.11.0",
-    "@discordjs/opus": "^0.10.0",
     "@discordjs/voice": "^0.19.0",
     "@google/genai": "^1.34.0",
     "@opencode-ai/sdk": "^1.1.12",
     "@purinton/resampler": "^1.0.4",
-    "@snazzah/davey": "^0.1.6",
     "ai": "^5.0.114",
     "better-sqlite3": "^12.3.0",
     "cac": "^6.7.14",
     "discord.js": "^14.16.3",
     "domhandler": "^5.0.3",
     "glob": "^13.0.0",
-    "go-try": "^3.0.2",
     "htmlparser2": "^10.0.0",
     "js-yaml": "^4.1.0",
     "marked": "^16.3.0",
     "picocolors": "^1.1.1",
     "pretty-ms": "^9.3.0",
-    "prism-media": "^1.3.5",
     "ripgrep-js": "^3.0.0",
     "string-dedent": "^3.0.2",
     "undici": "^7.16.0",
     "zod": "^4.2.1"
+  },
+  "optionalDependencies": {
+    "@discordjs/opus": "^0.10.0",
+    "prism-media": "^1.3.5"
   }
 }

package/src/cli.ts

@@ -197,6 +197,14 @@ async function registerCommands(token: string, appId: string, userCommands: Open
 
         return option
       })
+      .addStringOption((option) => {
+        option
+          .setName('agent')
+          .setDescription('Agent to use for this session')
+          .setAutocomplete(true)
+
+        return option
+      })
       .toJSON(),
     new SlashCommandBuilder()
       .setName('add-project')
@@ -279,7 +287,9 @@ async function registerCommands(token: string, appId: string, userCommands: Open
       continue
     }
 
-    const commandName = `${cmd.name}-cmd`
+    // Sanitize command name: oh-my-opencode uses MCP commands with colons, which Discord doesn't allow
+    const sanitizedName = cmd.name.replace(/:/g, '-')
+    const commandName = `${sanitizedName}-cmd`
     const description = cmd.description || `Run /${cmd.name} command`
 
     commands.push(

package/src/commands/session.ts

@@ -21,6 +21,7 @@ export async function handleSessionCommand({
 
   const prompt = command.options.getString('prompt', true)
   const filesString = command.options.getString('files') || ''
+  const agent = command.options.getString('agent') || undefined
   const channel = command.channel
 
   if (!channel || channel.type !== ChannelType.GuildText) {
@@ -91,6 +92,7 @@ export async function handleSessionCommand({
       thread,
       projectDirectory,
       channelId: textChannel.id,
+      agent,
     })
   } catch (error) {
     logger.error('[SESSION] Error:', error)
@@ -100,12 +102,78 @@ export async function handleSessionCommand({
   }
 }
 
+async function handleAgentAutocomplete({
+  interaction,
+  appId,
+}: AutocompleteContext): Promise<void> {
+  const focusedValue = interaction.options.getFocused()
+
+  let projectDirectory: string | undefined
+
+  if (interaction.channel) {
+    const channel = interaction.channel
+    if (channel.type === ChannelType.GuildText) {
+      const textChannel = channel as TextChannel
+      if (textChannel.topic) {
+        const extracted = extractTagsArrays({
+          xml: textChannel.topic,
+          tags: ['kimaki.directory', 'kimaki.app'],
+        })
+        const channelAppId = extracted['kimaki.app']?.[0]?.trim()
+        if (channelAppId && channelAppId !== appId) {
+          await interaction.respond([])
+          return
+        }
+        projectDirectory = extracted['kimaki.directory']?.[0]?.trim()
+      }
+    }
+  }
+
+  if (!projectDirectory) {
+    await interaction.respond([])
+    return
+  }
+
+  try {
+    const getClient = await initializeOpencodeForDirectory(projectDirectory)
+
+    const agentsResponse = await getClient().app.agents({
+      query: { directory: projectDirectory },
+    })
+
+    if (!agentsResponse.data || agentsResponse.data.length === 0) {
+      await interaction.respond([])
+      return
+    }
+
+    const agents = agentsResponse.data
+      .filter((a) => a.mode === 'primary' || a.mode === 'all')
+      .filter((a) => a.name.toLowerCase().includes(focusedValue.toLowerCase()))
+      .slice(0, 25)
+
+    const choices = agents.map((agent) => ({
+      name: agent.name.slice(0, 100),
+      value: agent.name,
+    }))
+
+    await interaction.respond(choices)
+  } catch (error) {
+    logger.error('[AUTOCOMPLETE] Error fetching agents:', error)
+    await interaction.respond([])
+  }
+}
+
 export async function handleSessionAutocomplete({
   interaction,
   appId,
 }: AutocompleteContext): Promise<void> {
   const focusedOption = interaction.options.getFocused(true)
 
+  if (focusedOption.name === 'agent') {
+    await handleAgentAutocomplete({ interaction, appId })
+    return
+  }
+
   if (focusedOption.name !== 'files') {
     return
   }

package/src/logger.ts

@@ -6,6 +6,7 @@ import { log } from '@clack/prompts'
 import fs from 'node:fs'
 import path, { dirname } from 'node:path'
 import { fileURLToPath } from 'node:url'
+import util from 'node:util'
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = dirname(__filename)
@@ -22,36 +23,43 @@ if (isDev) {
   fs.writeFileSync(logFilePath, `--- kimaki log started at ${new Date().toISOString()} ---\n`)
 }
 
-function writeToFile(level: string, prefix: string, args: any[]) {
+function formatArg(arg: unknown): string {
+  if (typeof arg === 'string') {
+    return arg
+  }
+  return util.inspect(arg, { colors: true, depth: 4 })
+}
+
+function writeToFile(level: string, prefix: string, args: unknown[]) {
   if (!isDev) {
     return
   }
   const timestamp = new Date().toISOString()
-  const message = `[${timestamp}] [${level}] [${prefix}] ${args.map((arg) => String(arg)).join(' ')}\n`
+  const message = `[${timestamp}] [${level}] [${prefix}] ${args.map(formatArg).join(' ')}\n`
   fs.appendFileSync(logFilePath, message)
 }
 
 export function createLogger(prefix: string) {
   return {
-    log: (...args: any[]) => {
+    log: (...args: unknown[]) => {
       writeToFile('INFO', prefix, args)
-      log.info([`[${prefix}]`, ...args.map((arg) => String(arg))].join(' '))
+      log.info([`[${prefix}]`, ...args.map(formatArg)].join(' '))
     },
-    error: (...args: any[]) => {
+    error: (...args: unknown[]) => {
       writeToFile('ERROR', prefix, args)
-      log.error([`[${prefix}]`, ...args.map((arg) => String(arg))].join(' '))
+      log.error([`[${prefix}]`, ...args.map(formatArg)].join(' '))
     },
-    warn: (...args: any[]) => {
+    warn: (...args: unknown[]) => {
       writeToFile('WARN', prefix, args)
-      log.warn([`[${prefix}]`, ...args.map((arg) => String(arg))].join(' '))
+      log.warn([`[${prefix}]`, ...args.map(formatArg)].join(' '))
     },
-    info: (...args: any[]) => {
+    info: (...args: unknown[]) => {
       writeToFile('INFO', prefix, args)
-      log.info([`[${prefix}]`, ...args.map((arg) => String(arg))].join(' '))
+      log.info([`[${prefix}]`, ...args.map(formatArg)].join(' '))
     },
-    debug: (...args: any[]) => {
+    debug: (...args: unknown[]) => {
       writeToFile('DEBUG', prefix, args)
-      log.info([`[${prefix}]`, ...args.map((arg) => String(arg))].join(' '))
+      log.info([`[${prefix}]`, ...args.map(formatArg)].join(' '))
     },
   }
 }

package/src/opencode.ts

@@ -115,8 +115,7 @@ export async function initializeOpencodeForDirectory(directory: string) {
 
   const port = await getOpenPort()
 
-  const opencodeBinDir = `${process.env.HOME}/.opencode/bin`
-  const opencodeCommand = process.env.OPENCODE_PATH || `${opencodeBinDir}/opencode`
+  const opencodeCommand = process.env.OPENCODE_PATH || 'opencode'
 
   const serverProcess = spawn(
     opencodeCommand,

package/src/session-handler.ts

@@ -6,14 +6,14 @@ import type { Part, PermissionRequest } from '@opencode-ai/sdk/v2'
 import type { FilePartInput } from '@opencode-ai/sdk'
 import type { Message, ThreadChannel } from 'discord.js'
 import prettyMilliseconds from 'pretty-ms'
-import { getDatabase, getSessionModel, getChannelModel, getSessionAgent, getChannelAgent } from './database.js'
+import { getDatabase, getSessionModel, getChannelModel, getSessionAgent, getChannelAgent, setSessionAgent } from './database.js'
 import { initializeOpencodeForDirectory, getOpencodeServers, getOpencodeClientV2 } from './opencode.js'
 import { sendThreadMessage, NOTIFY_MESSAGE_FLAGS, SILENT_MESSAGE_FLAGS } from './discord-utils.js'
 import { formatPart } from './message-formatting.js'
 import { getOpencodeSystemMessage } from './system-message.js'
 import { createLogger } from './logger.js'
 import { isAbortError } from './utils.js'
-import { showAskUserQuestionDropdowns, cancelPendingQuestion } from './commands/ask-question.js'
+import { showAskUserQuestionDropdowns, cancelPendingQuestion, pendingQuestionContexts } from './commands/ask-question.js'
 import { showPermissionDropdown, cleanupPermissionContext } from './commands/permissions.js'
 
 const sessionLogger = createLogger('SESSION')
@@ -141,6 +141,7 @@ export async function handleOpencodeSession({
   images = [],
   channelId,
   command,
+  agent,
 }: {
   prompt: string
   thread: ThreadChannel
@@ -150,6 +151,8 @@ export async function handleOpencodeSession({
   channelId?: string
   /** If set, uses session.command API instead of session.prompt */
   command?: { name: string; arguments: string }
+  /** Agent to use for this session */
+  agent?: string
 }): Promise<{ sessionID: string; result: any; port?: number } | undefined> {
   voiceLogger.log(
     `[OPENCODE SESSION] Starting for thread ${thread.id} with prompt: "${prompt.slice(0, 50)}${prompt.length > 50 ? '...' : ''}"`,
@@ -209,6 +212,12 @@ export async function handleOpencodeSession({
     .run(thread.id, session.id)
   sessionLogger.log(`Stored session ${session.id} for thread ${thread.id}`)
 
+  // Store agent preference if provided
+  if (agent) {
+    setSessionAgent(session.id, agent)
+    sessionLogger.log(`Set agent preference for session ${session.id}: ${agent}`)
+  }
+
   const existingController = abortControllers.get(session.id)
   if (existingController) {
     voiceLogger.log(
@@ -239,11 +248,10 @@ export async function handleOpencodeSession({
     }
   }
 
-  // Cancel any pending question tool if user sends a new message
+  // Cancel any pending question tool if user sends a new message (silently, no thread message)
   const questionCancelled = await cancelPendingQuestion(thread.id)
   if (questionCancelled) {
     sessionLogger.log(`[QUESTION] Cancelled pending question due to new message`)
-    await sendThreadMessage(thread, `⚠️ Previous question cancelled - processing your new message`)
   }
 
   const abortController = new AbortController()
@@ -433,7 +441,14 @@ export async function handleOpencodeSession({
           }
 
           if (part.type === 'step-start') {
-            stopTyping = startTyping()
+            // Don't start typing if user needs to respond to a question or permission
+            const hasPendingQuestion = [...pendingQuestionContexts.values()].some(
+              (ctx) => ctx.thread.id === thread.id,
+            )
+            const hasPendingPermission = pendingPermissions.has(thread.id)
+            if (!hasPendingQuestion && !hasPendingPermission) {
+              stopTyping = startTyping()
+            }
           }
 
           if (part.type === 'tool' && part.state.status === 'running') {
@@ -475,6 +490,12 @@ export async function handleOpencodeSession({
             await sendPartMessage(part)
           }
 
+          // Send text parts when complete (time.end is set)
+          // Text parts stream incrementally; only send when finished to avoid partial text
+          if (part.type === 'text' && part.time?.end) {
+            await sendPartMessage(part)
+          }
+
           if (part.type === 'step-finish') {
             for (const p of currentParts) {
               if (p.type !== 'step-start' && p.type !== 'step-finish') {
@@ -483,6 +504,12 @@ export async function handleOpencodeSession({
             }
             setTimeout(() => {
               if (abortController.signal.aborted) return
+              // Don't restart typing if user needs to respond to a question or permission
+              const hasPendingQuestion = [...pendingQuestionContexts.values()].some(
+                (ctx) => ctx.thread.id === thread.id,
+              )
+              const hasPendingPermission = pendingPermissions.has(thread.id)
+              if (hasPendingQuestion || hasPendingPermission) return
               stopTyping = startTyping()
             }, 300)
           }
@@ -527,6 +554,12 @@ export async function handleOpencodeSession({
             `Permission requested: permission=${permission.permission}, patterns=${permission.patterns.join(', ')}`,
           )
 
+          // Stop typing - user needs to respond now, not the bot
+          if (stopTyping) {
+            stopTyping()
+            stopTyping = null
+          }
+
           // Show dropdown instead of text message
           const { messageId, contextHash } = await showPermissionDropdown({
             thread,
@@ -569,6 +602,12 @@ export async function handleOpencodeSession({
             `Question requested: id=${questionRequest.id}, questions=${questionRequest.questions.length}`,
           )
 
+          // Stop typing - user needs to respond now, not the bot
+          if (stopTyping) {
+            stopTyping()
+            stopTyping = null
+          }
+
           // Flush any pending text/reasoning parts before showing the dropdown
           // This ensures text the LLM generated before the question tool is shown first
           for (const p of currentParts) {
@@ -584,6 +623,12 @@ export async function handleOpencodeSession({
             requestId: questionRequest.id,
             input: { questions: questionRequest.questions },
           })
+        } else if (event.type === 'session.idle') {
+          // Session is done processing - abort to signal completion
+          if (event.properties.sessionID === session.id) {
+            sessionLogger.log(`[SESSION IDLE] Session ${session.id} is idle, aborting`)
+            abortController.abort('finished')
+          }
         }
       }
     } catch (e) {
@@ -789,20 +834,17 @@ export async function handleOpencodeSession({
           discordLogger.log(`Could not update reaction:`, e)
         }
       }
-      const errorName =
-        error &&
-        typeof error === 'object' &&
-        'constructor' in error &&
-        error.constructor &&
-        typeof error.constructor.name === 'string'
-          ? error.constructor.name
-          : typeof error
-      const errorMsg =
-        error instanceof Error ? error.stack || error.message : String(error)
-      await sendThreadMessage(
-        thread,
-        `✗ Unexpected bot Error: [${errorName}]\n${errorMsg}`,
-      )
+      const errorDisplay = (() => {
+        if (error instanceof Error) {
+          const name = error.constructor.name || 'Error'
+          return `[${name}]\n${error.stack || error.message}`
+        }
+        if (typeof error === 'string') {
+          return error
+        }
+        return String(error)
+      })()
+      await sendThreadMessage(thread, `✗ Unexpected bot Error: ${errorDisplay}`)
     }
   }
 }

package/src/system-message.ts

@@ -66,5 +66,18 @@ headings are discouraged anyway. instead try to use bold text for titles which r
 ## diagrams
 
 you can create diagrams wrapping them in code blocks.
+
+## ending conversations with options
+
+IMPORTANT: At the end of each response, especially after completing a task or presenting a plan, use the question tool to offer the user clear options for what to do next.
+
+Examples:
+- After showing a plan: offer "Start implementing?" with Yes/No options
+- After completing edits: offer "Commit changes?" with Yes/No options
+- After debugging: offer "How to proceed?" with options like "Apply fix", "Investigate further", "Try different approach"
+
+The user can always select "Other" to type a custom response if the provided options don't fit their needs, or if the plan needs updating.
+
+This makes the interaction more guided and reduces friction for the user.
 `
 }