kimaki 0.4.25 → 0.4.27

package/src/commands/user-command.ts

@@ -0,0 +1,178 @@
+// User-defined OpenCode command handler.
+// Handles slash commands that map to user-configured commands in opencode.json.
+
+import type { CommandContext, CommandHandler } from './types.js'
+import { ChannelType, type TextChannel, type ThreadChannel } from 'discord.js'
+import { extractTagsArrays } from '../xml.js'
+import { handleOpencodeSession } from '../session-handler.js'
+import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js'
+import { createLogger } from '../logger.js'
+import { getDatabase } from '../database.js'
+import fs from 'node:fs'
+
+const userCommandLogger = createLogger('USER_CMD')
+
+export const handleUserCommand: CommandHandler = async ({
+  command,
+  appId,
+}: CommandContext) => {
+  const discordCommandName = command.commandName
+  // Strip the -cmd suffix to get the actual OpenCode command name
+  const commandName = discordCommandName.replace(/-cmd$/, '')
+  const args = command.options.getString('arguments') || ''
+
+  userCommandLogger.log(
+    `Executing /${commandName} (from /${discordCommandName}) with args: ${args}`,
+  )
+
+  const channel = command.channel
+
+  userCommandLogger.log(
+    `Channel info: type=${channel?.type}, id=${channel?.id}, isNull=${channel === null}`,
+  )
+
+  const isThread = channel && [
+    ChannelType.PublicThread,
+    ChannelType.PrivateThread,
+    ChannelType.AnnouncementThread,
+  ].includes(channel.type)
+
+  const isTextChannel = channel?.type === ChannelType.GuildText
+
+  if (!channel || (!isTextChannel && !isThread)) {
+    await command.reply({
+      content: 'This command can only be used in text channels or threads',
+      ephemeral: true,
+    })
+    return
+  }
+
+  let projectDirectory: string | undefined
+  let channelAppId: string | undefined
+  let textChannel: TextChannel | null = null
+  let thread: ThreadChannel | null = null
+
+  if (isThread) {
+    // Running in an existing thread - get project directory from parent channel
+    thread = channel as ThreadChannel
+    textChannel = thread.parent as TextChannel | null
+
+    // Verify this thread has an existing session
+    const row = getDatabase()
+      .prepare('SELECT session_id FROM thread_sessions WHERE thread_id = ?')
+      .get(thread.id) as { session_id: string } | undefined
+
+    if (!row) {
+      await command.reply({
+        content: 'This thread does not have an active session. Use this command in a project channel to create a new thread.',
+        ephemeral: true,
+      })
+      return
+    }
+
+    if (textChannel?.topic) {
+      const extracted = extractTagsArrays({
+        xml: textChannel.topic,
+        tags: ['kimaki.directory', 'kimaki.app'],
+      })
+
+      projectDirectory = extracted['kimaki.directory']?.[0]?.trim()
+      channelAppId = extracted['kimaki.app']?.[0]?.trim()
+    }
+  } else {
+    // Running in a text channel - will create a new thread
+    textChannel = channel as TextChannel
+
+    if (textChannel.topic) {
+      const extracted = extractTagsArrays({
+        xml: textChannel.topic,
+        tags: ['kimaki.directory', 'kimaki.app'],
+      })
+
+      projectDirectory = extracted['kimaki.directory']?.[0]?.trim()
+      channelAppId = extracted['kimaki.app']?.[0]?.trim()
+    }
+  }
+
+  if (channelAppId && channelAppId !== appId) {
+    await command.reply({
+      content: 'This channel is not configured for this bot',
+      ephemeral: true,
+    })
+    return
+  }
+
+  if (!projectDirectory) {
+    await command.reply({
+      content: 'This channel is not configured with a project directory',
+      ephemeral: true,
+    })
+    return
+  }
+
+  if (!fs.existsSync(projectDirectory)) {
+    await command.reply({
+      content: `Directory does not exist: ${projectDirectory}`,
+      ephemeral: true,
+    })
+    return
+  }
+
+  await command.deferReply({ ephemeral: false })
+
+  try {
+    // Use the dedicated session.command API instead of formatting as text prompt
+    const commandPayload = { name: commandName, arguments: args }
+
+    if (isThread && thread) {
+      // Running in existing thread - just send the command
+      await command.editReply(`Running /${commandName}...`)
+
+      await handleOpencodeSession({
+        prompt: '', // Not used when command is set
+        thread,
+        projectDirectory,
+        channelId: textChannel?.id,
+        command: commandPayload,
+      })
+    } else if (textChannel) {
+      // Running in text channel - create a new thread
+      const starterMessage = await textChannel.send({
+        content: `**/${commandName}**${args ? ` ${args.slice(0, 200)}${args.length > 200 ? '…' : ''}` : ''}`,
+        flags: SILENT_MESSAGE_FLAGS,
+      })
+
+      const threadName = `/${commandName} ${args.slice(0, 80)}${args.length > 80 ? '…' : ''}`
+      const newThread = await starterMessage.startThread({
+        name: threadName.slice(0, 100),
+        autoArchiveDuration: 1440,
+        reason: `OpenCode command: ${commandName}`,
+      })
+
+      await command.editReply(`Started /${commandName} in ${newThread.toString()}`)
+
+      await handleOpencodeSession({
+        prompt: '', // Not used when command is set
+        thread: newThread,
+        projectDirectory,
+        channelId: textChannel.id,
+        command: commandPayload,
+      })
+    }
+  } catch (error) {
+    userCommandLogger.error(`Error executing /${commandName}:`, error)
+
+    const errorMessage = error instanceof Error ? error.message : String(error)
+
+    if (command.deferred) {
+      await command.editReply({
+        content: `Failed to execute /${commandName}: ${errorMessage}`,
+      })
+    } else {
+      await command.reply({
+        content: `Failed to execute /${commandName}: ${errorMessage}`,
+        ephemeral: true,
+      })
+    }
+  }
+}

package/src/database.ts

@@ -100,6 +100,23 @@ export function runModelMigrations(database?: Database.Database): void {
     )
   `)
 
+  targetDb.exec(`
+    CREATE TABLE IF NOT EXISTS channel_agents (
+      channel_id TEXT PRIMARY KEY,
+      agent_name TEXT NOT NULL,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+      updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    )
+  `)
+
+  targetDb.exec(`
+    CREATE TABLE IF NOT EXISTS session_agents (
+      session_id TEXT PRIMARY KEY,
+      agent_name TEXT NOT NULL,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    )
+  `)
+
   dbLogger.log('Model preferences migrations complete')
 }
 
@@ -151,6 +168,50 @@ export function setSessionModel(sessionId: string, modelId: string): void {
   ).run(sessionId, modelId)
 }
 
+/**
+ * Get the agent preference for a channel.
+ */
+export function getChannelAgent(channelId: string): string | undefined {
+  const db = getDatabase()
+  const row = db
+    .prepare('SELECT agent_name FROM channel_agents WHERE channel_id = ?')
+    .get(channelId) as { agent_name: string } | undefined
+  return row?.agent_name
+}
+
+/**
+ * Set the agent preference for a channel.
+ */
+export function setChannelAgent(channelId: string, agentName: string): void {
+  const db = getDatabase()
+  db.prepare(
+    `INSERT INTO channel_agents (channel_id, agent_name, updated_at) 
+     VALUES (?, ?, CURRENT_TIMESTAMP)
+     ON CONFLICT(channel_id) DO UPDATE SET agent_name = ?, updated_at = CURRENT_TIMESTAMP`
+  ).run(channelId, agentName, agentName)
+}
+
+/**
+ * Get the agent preference for a session.
+ */
+export function getSessionAgent(sessionId: string): string | undefined {
+  const db = getDatabase()
+  const row = db
+    .prepare('SELECT agent_name FROM session_agents WHERE session_id = ?')
+    .get(sessionId) as { agent_name: string } | undefined
+  return row?.agent_name
+}
+
+/**
+ * Set the agent preference for a session.
+ */
+export function setSessionAgent(sessionId: string, agentName: string): void {
+  const db = getDatabase()
+  db.prepare(
+    `INSERT OR REPLACE INTO session_agents (session_id, agent_name) VALUES (?, ?)`
+  ).run(sessionId, agentName)
+}
+
 export function closeDatabase(): void {
   if (db) {
     db.close()

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

@@ -7,17 +7,21 @@ import { handleSessionCommand, handleSessionAutocomplete } from './commands/sess
 import { handleResumeCommand, handleResumeAutocomplete } from './commands/resume.js'
 import { handleAddProjectCommand, handleAddProjectAutocomplete } from './commands/add-project.js'
 import { handleCreateNewProjectCommand } from './commands/create-new-project.js'
-import { handleAcceptCommand, handleRejectCommand } from './commands/permissions.js'
+import { handlePermissionSelectMenu } from './commands/permissions.js'
 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,
@@ -81,16 +85,8 @@ export function registerInteractionHandler({
               await handleCreateNewProjectCommand({ command: interaction, appId })
               return
 
-            case 'accept':
-            case 'accept-always':
-              await handleAcceptCommand({ command: interaction, appId })
-              return
-
-            case 'reject':
-              await handleRejectCommand({ command: interaction, appId })
-              return
-
             case 'abort':
+            case 'stop':
               await handleAbortCommand({ command: interaction, appId })
               return
 
@@ -106,6 +102,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 +122,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 +148,21 @@ 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
+          }
+
+          if (customId.startsWith('permission:')) {
+            await handlePermissionSelectMenu(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(' '))
+    },
   }
 }