shuvmaki 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

@@ -0,0 +1,220 @@
+// 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'
+import path from 'node:path'
+import { createLogger } from './logger.js'
+
+const dbLogger = createLogger('DB')
+
+let db: Database.Database | null = null
+
+export function getDatabase(): Database.Database {
+  if (!db) {
+    const kimakiDir = path.join(os.homedir(), '.kimaki')
+
+    try {
+      fs.mkdirSync(kimakiDir, { recursive: true })
+    } catch (error) {
+      dbLogger.error('Failed to create ~/.kimaki directory:', error)
+    }
+
+    const dbPath = path.join(kimakiDir, 'discord-sessions.db')
+
+    dbLogger.log(`Opening database at: ${dbPath}`)
+    db = new Database(dbPath)
+
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS thread_sessions (
+        thread_id TEXT PRIMARY KEY,
+        session_id TEXT NOT NULL,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `)
+
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS part_messages (
+        part_id TEXT PRIMARY KEY,
+        message_id TEXT NOT NULL,
+        thread_id TEXT NOT NULL,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `)
+
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS bot_tokens (
+        app_id TEXT PRIMARY KEY,
+        token TEXT NOT NULL,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `)
+
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS channel_directories (
+        channel_id TEXT PRIMARY KEY,
+        directory TEXT NOT NULL,
+        channel_type TEXT NOT NULL,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `)
+
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS bot_api_keys (
+        app_id TEXT PRIMARY KEY,
+        gemini_api_key TEXT,
+        xai_api_key TEXT,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `)
+
+    runModelMigrations(db)
+  }
+
+  return db
+}
+
+/**
+ * Run migrations for model preferences tables.
+ * Called on startup and can be called on-demand.
+ */
+export function runModelMigrations(database?: Database.Database): void {
+  const targetDb = database || getDatabase()
+
+  targetDb.exec(`
+    CREATE TABLE IF NOT EXISTS channel_models (
+      channel_id TEXT PRIMARY KEY,
+      model_id TEXT NOT NULL,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+      updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    )
+  `)
+
+  targetDb.exec(`
+    CREATE TABLE IF NOT EXISTS session_models (
+      session_id TEXT PRIMARY KEY,
+      model_id TEXT NOT NULL,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    )
+  `)
+
+  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')
+}
+
+/**
+ * Get the model preference for a channel.
+ * @returns Model ID in format "provider_id/model_id" or undefined
+ */
+export function getChannelModel(channelId: string): string | undefined {
+  const db = getDatabase()
+  const row = db
+    .prepare('SELECT model_id FROM channel_models WHERE channel_id = ?')
+    .get(channelId) as { model_id: string } | undefined
+  return row?.model_id
+}
+
+/**
+ * Set the model preference for a channel.
+ * @param modelId Model ID in format "provider_id/model_id"
+ */
+export function setChannelModel(channelId: string, modelId: string): void {
+  const db = getDatabase()
+  db.prepare(
+    `INSERT INTO channel_models (channel_id, model_id, updated_at) 
+     VALUES (?, ?, CURRENT_TIMESTAMP)
+     ON CONFLICT(channel_id) DO UPDATE SET model_id = ?, updated_at = CURRENT_TIMESTAMP`
+  ).run(channelId, modelId, modelId)
+}
+
+/**
+ * Get the model preference for a session.
+ * @returns Model ID in format "provider_id/model_id" or undefined
+ */
+export function getSessionModel(sessionId: string): string | undefined {
+  const db = getDatabase()
+  const row = db
+    .prepare('SELECT model_id FROM session_models WHERE session_id = ?')
+    .get(sessionId) as { model_id: string } | undefined
+  return row?.model_id
+}
+
+/**
+ * Set the model preference for a session.
+ * @param modelId Model ID in format "provider_id/model_id"
+ */
+export function setSessionModel(sessionId: string, modelId: string): void {
+  const db = getDatabase()
+  db.prepare(
+    `INSERT OR REPLACE INTO session_models (session_id, model_id) VALUES (?, ?)`
+  ).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()
+    db = null
+  }
+}