kimaki 0.4.23 → 0.4.25

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/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'

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 {

package/src/discord-utils.ts

@@ -1,3 +1,7 @@
+// Discord-specific utility functions.
+// Handles markdown splitting for Discord's 2000-char limit, code block escaping,
+// thread message sending, and channel metadata extraction from topic tags.
+
 import {
   ChannelType,
   type Message,
@@ -12,6 +16,8 @@ import { createLogger } from './logger.js'
 const discordLogger = createLogger('DISCORD')
 
 export const SILENT_MESSAGE_FLAGS = 4 | 4096
+// Same as SILENT but without SuppressNotifications - triggers badge/notification
+export const NOTIFY_MESSAGE_FLAGS = 4
 
 export function escapeBackticksInCodeBlocks(markdown: string): string {
   const lexer = new Lexer()
@@ -125,12 +131,18 @@ export function splitMarkdownForDiscord({
 export async function sendThreadMessage(
   thread: ThreadChannel,
   content: string,
+  options?: { flags?: number }
 ): Promise<Message> {
   const MAX_LENGTH = 2000
 
   content = formatMarkdownTables(content)
   content = escapeBackticksInCodeBlocks(content)
 
+  // If custom flags provided, send as single message (no chunking)
+  if (options?.flags !== undefined) {
+    return thread.send({ content, flags: options.flags })
+  }
+
   const chunks = splitMarkdownForDiscord({ content, maxLength: MAX_LENGTH })
 
   if (chunks.length > 1) {

package/src/format-tables.ts

@@ -1,3 +1,7 @@
+// Markdown table to code block converter.
+// Discord doesn't render GFM tables, so this converts them to
+// space-aligned code blocks for proper monospace display.
+
 import { Lexer, type Token, type Tokens } from 'marked'
 
 export function formatMarkdownTables(markdown: string): string {

package/src/genai-worker-wrapper.ts

@@ -1,3 +1,7 @@
+// Main thread interface for the GenAI worker.
+// Spawns and manages the worker thread, handling message passing for
+// audio input/output, tool call completions, and graceful shutdown.
+
 import { Worker } from 'node:worker_threads'
 import type { WorkerInMessage, WorkerOutMessage } from './worker-types.js'
 import type { Tool as AITool } from 'ai'

package/src/genai-worker.ts

@@ -1,3 +1,7 @@
+// Worker thread for GenAI voice processing.
+// Runs in a separate thread to handle audio encoding/decoding without blocking.
+// Resamples 24kHz GenAI output to 48kHz stereo Opus packets for Discord.
+
 import { parentPort, threadId } from 'node:worker_threads'
 import { createWriteStream, type WriteStream } from 'node:fs'
 import { mkdir } from 'node:fs/promises'

package/src/genai.ts

@@ -1,3 +1,7 @@
+// Google GenAI Live session manager for real-time voice interactions.
+// Establishes bidirectional audio streaming with Gemini, handles tool calls,
+// and manages the assistant's audio output for Discord voice channels.
+
 import {
   GoogleGenAI,
   LiveServerMessage,