shuvmaki 0.4.26

package/src/commands/queue.ts

@@ -0,0 +1,181 @@
+// Queue commands - /queue, /clear-queue
+
+import { ChannelType, type ThreadChannel } from 'discord.js'
+import type { CommandContext } from './types.js'
+import { getDatabase } from '../database.js'
+import {
+  resolveTextChannel,
+  getKimakiMetadata,
+  sendThreadMessage,
+  SILENT_MESSAGE_FLAGS,
+} from '../discord-utils.js'
+import {
+  handleOpencodeSession,
+  abortControllers,
+  addToQueue,
+  getQueueLength,
+  clearQueue,
+} from '../session-handler.js'
+import { createLogger } from '../logger.js'
+
+const logger = createLogger('QUEUE')
+
+export async function handleQueueCommand({
+  command,
+}: CommandContext): Promise<void> {
+  const message = command.options.getString('message', true)
+  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 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. Send a message directly instead.',
+      ephemeral: true,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  // Check if there's an active request running
+  const hasActiveRequest = abortControllers.has(row.session_id)
+
+  if (!hasActiveRequest) {
+    // No active request, send immediately
+    const textChannel = await resolveTextChannel(channel as ThreadChannel)
+    const { projectDirectory } = getKimakiMetadata(textChannel)
+
+    if (!projectDirectory) {
+      await command.reply({
+        content: 'Could not determine project directory',
+        ephemeral: true,
+        flags: SILENT_MESSAGE_FLAGS,
+      })
+      return
+    }
+
+    await command.reply({
+      content: `» **${command.user.displayName}:** ${message.slice(0, 100)}${message.length > 100 ? '...' : ''}`,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+
+    logger.log(
+      `[QUEUE] No active request, sending immediately in thread ${channel.id}`,
+    )
+
+    handleOpencodeSession({
+      prompt: message,
+      thread: channel as ThreadChannel,
+      projectDirectory,
+      channelId: textChannel?.id || channel.id,
+    }).catch(async (e) => {
+      logger.error(`[QUEUE] Failed to send message:`, e)
+      const errorMsg = e instanceof Error ? e.message : String(e)
+      await sendThreadMessage(
+        channel as ThreadChannel,
+        `✗ Failed: ${errorMsg.slice(0, 200)}`,
+      )
+    })
+
+    return
+  }
+
+  // Add to queue
+  const queuePosition = addToQueue({
+    threadId: channel.id,
+    message: {
+      prompt: message,
+      userId: command.user.id,
+      username: command.user.displayName,
+      queuedAt: Date.now(),
+    },
+  })
+
+  await command.reply({
+    content: `✅ Message queued (position: ${queuePosition}). Will be sent after current response.`,
+    ephemeral: true,
+    flags: SILENT_MESSAGE_FLAGS,
+  })
+
+  logger.log(
+    `[QUEUE] User ${command.user.displayName} queued message in thread ${channel.id}`,
+  )
+}
+
+export async function handleClearQueueCommand({
+  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',
+      ephemeral: true,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  const queueLength = getQueueLength(channel.id)
+
+  if (queueLength === 0) {
+    await command.reply({
+      content: 'No messages in queue',
+      ephemeral: true,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
+  clearQueue(channel.id)
+
+  await command.reply({
+    content: `🗑 Cleared ${queueLength} queued message${queueLength > 1 ? 's' : ''}`,
+    flags: SILENT_MESSAGE_FLAGS,
+  })
+
+  logger.log(
+    `[QUEUE] User ${command.user.displayName} cleared queue in thread ${channel.id}`,
+  )
+}

package/src/commands/resume.ts

@@ -0,0 +1,230 @@
+// /resume command - Resume an existing OpenCode session.
+
+import {
+  ChannelType,
+  ThreadAutoArchiveDuration,
+  type TextChannel,
+  type ThreadChannel,
+} from 'discord.js'
+import fs from 'node:fs'
+import type { CommandContext, AutocompleteContext } from './types.js'
+import { getDatabase } from '../database.js'
+import { initializeOpencodeForDirectory } from '../opencode.js'
+import {
+  sendThreadMessage,
+  resolveTextChannel,
+  getKimakiMetadata,
+} from '../discord-utils.js'
+import { extractTagsArrays } from '../xml.js'
+import { collectLastAssistantParts } from '../message-formatting.js'
+import { createLogger } from '../logger.js'
+
+const logger = createLogger('RESUME')
+
+export async function handleResumeCommand({
+  command,
+  appId,
+}: CommandContext): Promise<void> {
+  await command.deferReply({ ephemeral: false })
+
+  const sessionId = command.options.getString('session', true)
+  const channel = command.channel
+
+  if (!channel || channel.type !== ChannelType.GuildText) {
+    await command.editReply('This command can only be used in text channels')
+    return
+  }
+
+  const textChannel = channel as TextChannel
+
+  let projectDirectory: string | undefined
+  let channelAppId: string | undefined
+
+  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.editReply('This channel is not configured for this bot')
+    return
+  }
+
+  if (!projectDirectory) {
+    await command.editReply(
+      'This channel is not configured with a project directory',
+    )
+    return
+  }
+
+  if (!fs.existsSync(projectDirectory)) {
+    await command.editReply(`Directory does not exist: ${projectDirectory}`)
+    return
+  }
+
+  try {
+    const getClient = await initializeOpencodeForDirectory(projectDirectory)
+
+    const sessionResponse = await getClient().session.get({
+      path: { id: sessionId },
+    })
+
+    if (!sessionResponse.data) {
+      await command.editReply('Session not found')
+      return
+    }
+
+    const sessionTitle = sessionResponse.data.title
+
+    const thread = await textChannel.threads.create({
+      name: `Resume: ${sessionTitle}`.slice(0, 100),
+      autoArchiveDuration: ThreadAutoArchiveDuration.OneDay,
+      reason: `Resuming session ${sessionId}`,
+    })
+
+    getDatabase()
+      .prepare(
+        'INSERT OR REPLACE INTO thread_sessions (thread_id, session_id) VALUES (?, ?)',
+      )
+      .run(thread.id, sessionId)
+
+    logger.log(`[RESUME] Created thread ${thread.id} for session ${sessionId}`)
+
+    const messagesResponse = await getClient().session.messages({
+      path: { id: sessionId },
+    })
+
+    if (!messagesResponse.data) {
+      throw new Error('Failed to fetch session messages')
+    }
+
+    const messages = messagesResponse.data
+
+    await command.editReply(
+      `Resumed session "${sessionTitle}" in ${thread.toString()}`,
+    )
+
+    await sendThreadMessage(
+      thread,
+      `📂 **Resumed session:** ${sessionTitle}\n📅 **Created:** ${new Date(sessionResponse.data.time.created).toLocaleString()}\n\n*Loading ${messages.length} messages...*`,
+    )
+
+    const { partIds, content, skippedCount } = collectLastAssistantParts({
+      messages,
+    })
+
+    if (skippedCount > 0) {
+      await sendThreadMessage(
+        thread,
+        `*Skipped ${skippedCount} older assistant parts...*`,
+      )
+    }
+
+    if (content.trim()) {
+      const discordMessage = await sendThreadMessage(thread, content)
+
+      const stmt = getDatabase().prepare(
+        'INSERT OR REPLACE INTO part_messages (part_id, message_id, thread_id) VALUES (?, ?, ?)',
+      )
+
+      const transaction = getDatabase().transaction((ids: string[]) => {
+        for (const partId of ids) {
+          stmt.run(partId, discordMessage.id, thread.id)
+        }
+      })
+
+      transaction(partIds)
+    }
+
+    const messageCount = messages.length
+
+    await sendThreadMessage(
+      thread,
+      `✅ **Session resumed!** Loaded ${messageCount} messages.\n\nYou can now continue the conversation by sending messages in this thread.`,
+    )
+  } catch (error) {
+    logger.error('[RESUME] Error:', error)
+    await command.editReply(
+      `Failed to resume session: ${error instanceof Error ? error.message : 'Unknown error'}`,
+    )
+  }
+}
+
+export async function handleResumeAutocomplete({
+  interaction,
+  appId,
+}: AutocompleteContext): Promise<void> {
+  const focusedValue = interaction.options.getFocused()
+
+  let projectDirectory: string | undefined
+
+  if (interaction.channel) {
+    const textChannel = await resolveTextChannel(
+      interaction.channel as TextChannel | ThreadChannel | null,
+    )
+    if (textChannel) {
+      const { projectDirectory: directory, channelAppId } =
+        getKimakiMetadata(textChannel)
+      if (channelAppId && channelAppId !== appId) {
+        await interaction.respond([])
+        return
+      }
+      projectDirectory = directory
+    }
+  }
+
+  if (!projectDirectory) {
+    await interaction.respond([])
+    return
+  }
+
+  try {
+    const getClient = await initializeOpencodeForDirectory(projectDirectory)
+
+    const sessionsResponse = await getClient().session.list()
+    if (!sessionsResponse.data) {
+      await interaction.respond([])
+      return
+    }
+
+    const existingSessionIds = new Set(
+      (
+        getDatabase()
+          .prepare('SELECT session_id FROM thread_sessions')
+          .all() as { session_id: string }[]
+      ).map((row) => row.session_id),
+    )
+
+    const sessions = sessionsResponse.data
+      .filter((session) => !existingSessionIds.has(session.id))
+      .filter((session) =>
+        session.title.toLowerCase().includes(focusedValue.toLowerCase()),
+      )
+      .slice(0, 25)
+      .map((session) => {
+        const dateStr = new Date(session.time.updated).toLocaleString()
+        const suffix = ` (${dateStr})`
+        const maxTitleLength = 100 - suffix.length
+
+        let title = session.title
+        if (title.length > maxTitleLength) {
+          title = title.slice(0, Math.max(0, maxTitleLength - 1)) + '…'
+        }
+
+        return {
+          name: `${title}${suffix}`,
+          value: session.id,
+        }
+      })
+
+    await interaction.respond(sessions)
+  } catch (error) {
+    logger.error('[AUTOCOMPLETE] Error fetching sessions:', error)
+    await interaction.respond([])
+  }
+}

package/src/commands/session.ts

@@ -0,0 +1,184 @@
+// /session command - Start a new OpenCode session.
+
+import { ChannelType, type TextChannel } from 'discord.js'
+import fs from 'node:fs'
+import path from 'node:path'
+import type { CommandContext, AutocompleteContext } from './types.js'
+import { getDatabase } from '../database.js'
+import { initializeOpencodeForDirectory } from '../opencode.js'
+import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js'
+import { extractTagsArrays } from '../xml.js'
+import { handleOpencodeSession } from '../session-handler.js'
+import { createLogger } from '../logger.js'
+
+const logger = createLogger('SESSION')
+
+export async function handleSessionCommand({
+  command,
+  appId,
+}: CommandContext): Promise<void> {
+  await command.deferReply({ ephemeral: false })
+
+  const prompt = command.options.getString('prompt', true)
+  const filesString = command.options.getString('files') || ''
+  const channel = command.channel
+
+  if (!channel || channel.type !== ChannelType.GuildText) {
+    await command.editReply('This command can only be used in text channels')
+    return
+  }
+
+  const textChannel = channel as TextChannel
+
+  let projectDirectory: string | undefined
+  let channelAppId: string | undefined
+
+  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.editReply('This channel is not configured for this bot')
+    return
+  }
+
+  if (!projectDirectory) {
+    await command.editReply(
+      'This channel is not configured with a project directory',
+    )
+    return
+  }
+
+  if (!fs.existsSync(projectDirectory)) {
+    await command.editReply(`Directory does not exist: ${projectDirectory}`)
+    return
+  }
+
+  try {
+    const getClient = await initializeOpencodeForDirectory(projectDirectory)
+
+    const files = filesString
+      .split(',')
+      .map((f) => f.trim())
+      .filter((f) => f)
+
+    let fullPrompt = prompt
+    if (files.length > 0) {
+      fullPrompt = `${prompt}\n\n@${files.join(' @')}`
+    }
+
+    const starterMessage = await textChannel.send({
+      content: `🚀 **Starting OpenCode session**\n📝 ${prompt.slice(0, 200)}${prompt.length > 200 ? '…' : ''}${files.length > 0 ? `\n📎 Files: ${files.join(', ')}` : ''}`,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+
+    const thread = await starterMessage.startThread({
+      name: prompt.slice(0, 100),
+      autoArchiveDuration: 1440,
+      reason: 'OpenCode session',
+    })
+
+    await command.editReply(`Created new session in ${thread.toString()}`)
+
+    await handleOpencodeSession({
+      prompt: fullPrompt,
+      thread,
+      projectDirectory,
+      channelId: textChannel.id,
+    })
+  } catch (error) {
+    logger.error('[SESSION] Error:', error)
+    await command.editReply(
+      `Failed to create session: ${error instanceof Error ? error.message : 'Unknown error'}`,
+    )
+  }
+}
+
+export async function handleSessionAutocomplete({
+  interaction,
+  appId,
+}: AutocompleteContext): Promise<void> {
+  const focusedOption = interaction.options.getFocused(true)
+
+  if (focusedOption.name !== 'files') {
+    return
+  }
+
+  const focusedValue = focusedOption.value
+
+  const parts = focusedValue.split(',')
+  const previousFiles = parts
+    .slice(0, -1)
+    .map((f) => f.trim())
+    .filter((f) => f)
+  const currentQuery = (parts[parts.length - 1] || '').trim()
+
+  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 response = await getClient().find.files({
+      query: {
+        query: currentQuery || '',
+      },
+    })
+
+    const files = response.data || []
+
+    const prefix =
+      previousFiles.length > 0 ? previousFiles.join(', ') + ', ' : ''
+
+    const choices = files
+      .map((file: string) => {
+        const fullValue = prefix + file
+        const allFiles = [...previousFiles, file]
+        const allBasenames = allFiles.map((f) => f.split('/').pop() || f)
+        let displayName = allBasenames.join(', ')
+        if (displayName.length > 100) {
+          displayName = '…' + displayName.slice(-97)
+        }
+        return {
+          name: displayName,
+          value: fullValue,
+        }
+      })
+      .filter((choice) => choice.value.length <= 100)
+      .slice(0, 25)
+
+    await interaction.respond(choices)
+  } catch (error) {
+    logger.error('[AUTOCOMPLETE] Error fetching files:', error)
+    await interaction.respond([])
+  }
+}

package/src/commands/share.ts

@@ -0,0 +1,96 @@
+// /share command - Share the current session as a public URL.
+
+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('SHARE')
+
+export async function handleShareCommand({
+  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 {
+    const getClient = await initializeOpencodeForDirectory(directory)
+    const response = await getClient().session.share({
+      path: { id: sessionId },
+    })
+
+    if (!response.data?.share?.url) {
+      await command.reply({
+        content: 'Failed to generate share URL',
+        ephemeral: true,
+        flags: SILENT_MESSAGE_FLAGS,
+      })
+      return
+    }
+
+    await command.reply({
+      content: `🔗 **Session shared:** ${response.data.share.url}`,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+    logger.log(`Session ${sessionId} shared: ${response.data.share.url}`)
+  } catch (error) {
+    logger.error('[SHARE] Error:', error)
+    await command.reply({
+      content: `Failed to share session: ${error instanceof Error ? error.message : 'Unknown error'}`,
+      ephemeral: true,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+  }
+}

package/src/commands/types.ts

@@ -0,0 +1,25 @@
+// Shared types for command handlers.
+
+import type {
+  AutocompleteInteraction,
+  ChatInputCommandInteraction,
+  StringSelectMenuInteraction,
+} from 'discord.js'
+
+export type CommandContext = {
+  command: ChatInputCommandInteraction
+  appId: string
+}
+
+export type CommandHandler = (ctx: CommandContext) => Promise<void>
+
+export type AutocompleteContext = {
+  interaction: AutocompleteInteraction
+  appId: string
+}
+
+export type AutocompleteHandler = (ctx: AutocompleteContext) => Promise<void>
+
+export type SelectMenuHandler = (
+  interaction: StringSelectMenuInteraction,
+) => Promise<void>