kimaki 0.4.24 → 0.4.26

package/src/commands/undo-redo.ts

@@ -0,0 +1,213 @@
+// Undo/Redo commands - /undo, /redo
+
+import { ChannelType, type ThreadChannel } from 'discord.js'
+import type { CommandContext } from './types.js'
+import { getDatabase } from '../database.js'
+import { initializeOpencodeForDirectory } from '../opencode.js'
+import { resolveTextChannel, getKimakiMetadata, SILENT_MESSAGE_FLAGS } from '../discord-utils.js'
+import { createLogger } from '../logger.js'
+
+const logger = createLogger('UNDO-REDO')
+
+export async function handleUndoCommand({
+  command,
+}: CommandContext): Promise<void> {
+  const channel = command.channel
+
+  if (!channel) {
+    await command.reply({
+      content: 'This command can only be used in a channel',
+      ephemeral: true,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  const isThread = [
+    ChannelType.PublicThread,
+    ChannelType.PrivateThread,
+    ChannelType.AnnouncementThread,
+  ].includes(channel.type)
+
+  if (!isThread) {
+    await command.reply({
+      content: 'This command can only be used in a thread with an active session',
+      ephemeral: true,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  const textChannel = await resolveTextChannel(channel as ThreadChannel)
+  const { projectDirectory: directory } = getKimakiMetadata(textChannel)
+
+  if (!directory) {
+    await command.reply({
+      content: 'Could not determine project directory for this channel',
+      ephemeral: true,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  const row = getDatabase()
+    .prepare('SELECT session_id FROM thread_sessions WHERE thread_id = ?')
+    .get(channel.id) as { session_id: string } | undefined
+
+  if (!row?.session_id) {
+    await command.reply({
+      content: 'No active session in this thread',
+      ephemeral: true,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  const sessionId = row.session_id
+
+  try {
+    await command.deferReply({ flags: SILENT_MESSAGE_FLAGS })
+
+    const getClient = await initializeOpencodeForDirectory(directory)
+
+    // Fetch messages to find the last assistant message
+    const messagesResponse = await getClient().session.messages({
+      path: { id: sessionId },
+    })
+
+    if (!messagesResponse.data || messagesResponse.data.length === 0) {
+      await command.editReply('No messages to undo')
+      return
+    }
+
+    // Find the last assistant message
+    const lastAssistantMessage = [...messagesResponse.data]
+      .reverse()
+      .find((m) => m.info.role === 'assistant')
+
+    if (!lastAssistantMessage) {
+      await command.editReply('No assistant message to undo')
+      return
+    }
+
+    const response = await getClient().session.revert({
+      path: { id: sessionId },
+      body: { messageID: lastAssistantMessage.info.id },
+    })
+
+    if (response.error) {
+      await command.editReply(
+        `Failed to undo: ${JSON.stringify(response.error)}`,
+      )
+      return
+    }
+
+    const diffInfo = response.data?.revert?.diff
+      ? `\n\`\`\`diff\n${response.data.revert.diff.slice(0, 1500)}\n\`\`\``
+      : ''
+
+    await command.editReply(
+      `⏪ **Undone** - reverted last assistant message${diffInfo}`,
+    )
+    logger.log(
+      `Session ${sessionId} reverted message ${lastAssistantMessage.info.id}`,
+    )
+  } catch (error) {
+    logger.error('[UNDO] Error:', error)
+    await command.editReply(
+      `Failed to undo: ${error instanceof Error ? error.message : 'Unknown error'}`,
+    )
+  }
+}
+
+export async function handleRedoCommand({
+  command,
+}: CommandContext): Promise<void> {
+  const channel = command.channel
+
+  if (!channel) {
+    await command.reply({
+      content: 'This command can only be used in a channel',
+      ephemeral: true,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  const isThread = [
+    ChannelType.PublicThread,
+    ChannelType.PrivateThread,
+    ChannelType.AnnouncementThread,
+  ].includes(channel.type)
+
+  if (!isThread) {
+    await command.reply({
+      content: 'This command can only be used in a thread with an active session',
+      ephemeral: true,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  const textChannel = await resolveTextChannel(channel as ThreadChannel)
+  const { projectDirectory: directory } = getKimakiMetadata(textChannel)
+
+  if (!directory) {
+    await command.reply({
+      content: 'Could not determine project directory for this channel',
+      ephemeral: true,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  const row = getDatabase()
+    .prepare('SELECT session_id FROM thread_sessions WHERE thread_id = ?')
+    .get(channel.id) as { session_id: string } | undefined
+
+  if (!row?.session_id) {
+    await command.reply({
+      content: 'No active session in this thread',
+      ephemeral: true,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  const sessionId = row.session_id
+
+  try {
+    await command.deferReply({ flags: SILENT_MESSAGE_FLAGS })
+
+    const getClient = await initializeOpencodeForDirectory(directory)
+
+    // Check if session has reverted state
+    const sessionResponse = await getClient().session.get({
+      path: { id: sessionId },
+    })
+
+    if (!sessionResponse.data?.revert) {
+      await command.editReply('Nothing to redo - no previous undo found')
+      return
+    }
+
+    const response = await getClient().session.unrevert({
+      path: { id: sessionId },
+    })
+
+    if (response.error) {
+      await command.editReply(
+        `Failed to redo: ${JSON.stringify(response.error)}`,
+      )
+      return
+    }
+
+    await command.editReply(`⏩ **Restored** - session back to previous state`)
+    logger.log(`Session ${sessionId} unrevert completed`)
+  } catch (error) {
+    logger.error('[REDO] Error:', error)
+    await command.editReply(
+      `Failed to redo: ${error instanceof Error ? error.message : 'Unknown error'}`,
+    )
+  }
+}

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

@@ -1,3 +1,7 @@
+// SQLite database manager for persistent bot state.
+// Stores thread-session mappings, bot tokens, channel directories,
+// API keys, and model preferences in ~/.kimaki/discord-sessions.db.
+
 import Database from 'better-sqlite3'
 import fs from 'node:fs'
 import os from 'node:os'
@@ -96,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')
 }
 
@@ -147,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

@@ -1,3 +1,7 @@
+// Core Discord bot module that handles message events and bot lifecycle.
+// Bridges Discord messages to OpenCode sessions, manages voice connections,
+// and orchestrates the main event loop for the Kimaki bot.
+
 import { getDatabase, closeDatabase } from './database.js'
 import { initializeOpencodeForDirectory, getOpencodeServers } from './opencode.js'
 import {
@@ -21,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'
@@ -236,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)
           }
         }
 
@@ -272,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
@@ -376,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 {