kimaki 0.4.21 → 0.4.23

package/src/markdown.ts

@@ -1,6 +1,6 @@
 import type { OpencodeClient } from '@opencode-ai/sdk'
-import { format } from 'date-fns'
 import * as yaml from 'js-yaml'
+import { formatDateTime } from './utils.js'
 import { extractNonXmlContent } from './xml.js'
 
 export class ShareMarkdown {
@@ -62,10 +62,10 @@ export class ShareMarkdown {
         lines.push('## Session Information')
         lines.push('')
         lines.push(
-          `- **Created**: ${format(new Date(session.time.created), 'MMM d, yyyy, h:mm a')}`,
+          `- **Created**: ${formatDateTime(new Date(session.time.created))}`,
         )
         lines.push(
-          `- **Updated**: ${format(new Date(session.time.updated), 'MMM d, yyyy, h:mm a')}`,
+          `- **Updated**: ${formatDateTime(new Date(session.time.updated))}`,
         )
         if (session.version) {
           lines.push(`- **OpenCode Version**: v${session.version}`)

package/src/message-formatting.ts

@@ -0,0 +1,227 @@
+import type { Part, FilePartInput } from '@opencode-ai/sdk'
+import type { Message } from 'discord.js'
+import { createLogger } from './logger.js'
+
+const logger = createLogger('FORMATTING')
+
+export const TEXT_MIME_TYPES = [
+  'text/',
+  'application/json',
+  'application/xml',
+  'application/javascript',
+  'application/typescript',
+  'application/x-yaml',
+  'application/toml',
+]
+
+export function isTextMimeType(contentType: string | null): boolean {
+  if (!contentType) {
+    return false
+  }
+  return TEXT_MIME_TYPES.some((prefix) => contentType.startsWith(prefix))
+}
+
+export async function getTextAttachments(message: Message): Promise<string> {
+  const textAttachments = Array.from(message.attachments.values()).filter(
+    (attachment) => isTextMimeType(attachment.contentType),
+  )
+
+  if (textAttachments.length === 0) {
+    return ''
+  }
+
+  const textContents = await Promise.all(
+    textAttachments.map(async (attachment) => {
+      try {
+        const response = await fetch(attachment.url)
+        if (!response.ok) {
+          return `<attachment filename="${attachment.name}" error="Failed to fetch: ${response.status}" />`
+        }
+        const text = await response.text()
+        return `<attachment filename="${attachment.name}" mime="${attachment.contentType}">\n${text}\n</attachment>`
+      } catch (error) {
+        const errMsg = error instanceof Error ? error.message : String(error)
+        return `<attachment filename="${attachment.name}" error="${errMsg}" />`
+      }
+    }),
+  )
+
+  return textContents.join('\n\n')
+}
+
+export function getFileAttachments(message: Message): FilePartInput[] {
+  const fileAttachments = Array.from(message.attachments.values()).filter(
+    (attachment) => {
+      const contentType = attachment.contentType || ''
+      return (
+        contentType.startsWith('image/') || contentType === 'application/pdf'
+      )
+    },
+  )
+
+  return fileAttachments.map((attachment) => ({
+    type: 'file' as const,
+    mime: attachment.contentType || 'application/octet-stream',
+    filename: attachment.name,
+    url: attachment.url,
+  }))
+}
+
+export function getToolSummaryText(part: Part): string {
+  if (part.type !== 'tool') return ''
+
+  if (part.tool === 'edit') {
+    const filePath = (part.state.input?.filePath as string) || ''
+    const newString = (part.state.input?.newString as string) || ''
+    const oldString = (part.state.input?.oldString as string) || ''
+    const added = newString.split('\n').length
+    const removed = oldString.split('\n').length
+    const fileName = filePath.split('/').pop() || ''
+    return fileName ? `*${fileName}* (+${added}-${removed})` : `(+${added}-${removed})`
+  }
+
+  if (part.tool === 'write') {
+    const filePath = (part.state.input?.filePath as string) || ''
+    const content = (part.state.input?.content as string) || ''
+    const lines = content.split('\n').length
+    const fileName = filePath.split('/').pop() || ''
+    return fileName ? `*${fileName}* (${lines} line${lines === 1 ? '' : 's'})` : `(${lines} line${lines === 1 ? '' : 's'})`
+  }
+
+  if (part.tool === 'webfetch') {
+    const url = (part.state.input?.url as string) || ''
+    const urlWithoutProtocol = url.replace(/^https?:\/\//, '')
+    return urlWithoutProtocol ? `*${urlWithoutProtocol}*` : ''
+  }
+
+  if (part.tool === 'read') {
+    const filePath = (part.state.input?.filePath as string) || ''
+    const fileName = filePath.split('/').pop() || ''
+    return fileName ? `*${fileName}*` : ''
+  }
+
+  if (part.tool === 'list') {
+    const path = (part.state.input?.path as string) || ''
+    const dirName = path.split('/').pop() || path
+    return dirName ? `*${dirName}*` : ''
+  }
+
+  if (part.tool === 'glob') {
+    const pattern = (part.state.input?.pattern as string) || ''
+    return pattern ? `*${pattern}*` : ''
+  }
+
+  if (part.tool === 'grep') {
+    const pattern = (part.state.input?.pattern as string) || ''
+    return pattern ? `*${pattern}*` : ''
+  }
+
+  if (part.tool === 'bash' || part.tool === 'todoread' || part.tool === 'todowrite') {
+    return ''
+  }
+
+  if (part.tool === 'task') {
+    const description = (part.state.input?.description as string) || ''
+    return description ? `_${description}_` : ''
+  }
+
+  if (part.tool === 'skill') {
+    const name = (part.state.input?.name as string) || ''
+    return name ? `_${name}_` : ''
+  }
+
+  if (!part.state.input) return ''
+
+  const inputFields = Object.entries(part.state.input)
+    .map(([key, value]) => {
+      if (value === null || value === undefined) return null
+      const stringValue = typeof value === 'string' ? value : JSON.stringify(value)
+      const truncatedValue = stringValue.length > 300 ? stringValue.slice(0, 300) + '…' : stringValue
+      return `${key}: ${truncatedValue}`
+    })
+    .filter(Boolean)
+
+  if (inputFields.length === 0) return ''
+
+  return `(${inputFields.join(', ')})`
+}
+
+export function formatTodoList(part: Part): string {
+  if (part.type !== 'tool' || part.tool !== 'todowrite') return ''
+  const todos =
+    (part.state.input?.todos as {
+      content: string
+      status: 'pending' | 'in_progress' | 'completed' | 'cancelled'
+    }[]) || []
+  const activeIndex = todos.findIndex((todo) => {
+    return todo.status === 'in_progress'
+  })
+  const activeTodo = todos[activeIndex]
+  if (activeIndex === -1 || !activeTodo) return ''
+  return `${activeIndex + 1}. **${activeTodo.content}**`
+}
+
+export function formatPart(part: Part): string {
+  if (part.type === 'text') {
+    return part.text || ''
+  }
+
+  if (part.type === 'reasoning') {
+    if (!part.text?.trim()) return ''
+    return `◼︎ thinking`
+  }
+
+  if (part.type === 'file') {
+    return `📄 ${part.filename || 'File'}`
+  }
+
+  if (part.type === 'step-start' || part.type === 'step-finish' || part.type === 'patch') {
+    return ''
+  }
+
+  if (part.type === 'agent') {
+    return `◼︎ agent ${part.id}`
+  }
+
+  if (part.type === 'snapshot') {
+    return `◼︎ snapshot ${part.snapshot}`
+  }
+
+  if (part.type === 'tool') {
+    if (part.tool === 'todowrite') {
+      return formatTodoList(part)
+    }
+
+    if (part.state.status === 'pending') {
+      return ''
+    }
+
+    const summaryText = getToolSummaryText(part)
+    const stateTitle = 'title' in part.state ? part.state.title : undefined
+
+    let toolTitle = ''
+    if (part.state.status === 'error') {
+      toolTitle = part.state.error || 'error'
+    } else if (part.tool === 'bash') {
+      const command = (part.state.input?.command as string) || ''
+      const description = (part.state.input?.description as string) || ''
+      const isSingleLine = !command.includes('\n')
+      const hasUnderscores = command.includes('_')
+      if (isSingleLine && !hasUnderscores && command.length <= 50) {
+        toolTitle = `_${command}_`
+      } else if (description) {
+        toolTitle = `_${description}_`
+      } else if (stateTitle) {
+        toolTitle = `_${stateTitle}_`
+      }
+    } else if (stateTitle) {
+      toolTitle = `_${stateTitle}_`
+    }
+
+    const icon = part.state.status === 'error' ? '⨯' : '◼︎'
+    return `${icon} ${part.tool} ${toolTitle} ${summaryText}`
+  }
+
+  logger.warn('Unknown part type:', part)
+  return ''
+}

package/src/model-command.ts

@@ -0,0 +1,380 @@
+import {
+  ChatInputCommandInteraction,
+  StringSelectMenuInteraction,
+  StringSelectMenuBuilder,
+  ActionRowBuilder,
+  ChannelType,
+  type ThreadChannel,
+  type TextChannel,
+} from 'discord.js'
+import crypto from 'node:crypto'
+import { getDatabase, setChannelModel, setSessionModel, runModelMigrations } from './database.js'
+import { initializeOpencodeForDirectory } from './opencode.js'
+import { resolveTextChannel, getKimakiMetadata } from './discord-utils.js'
+import { createLogger } from './logger.js'
+
+const modelLogger = createLogger('MODEL')
+
+// Store context by hash to avoid customId length limits (Discord max: 100 chars)
+const pendingModelContexts = new Map<string, {
+  dir: string
+  channelId: string
+  sessionId?: string
+  isThread: boolean
+  providerId?: string
+  providerName?: string
+}>()
+
+type ProviderInfo = {
+  id: string
+  name: string
+  models: Record<
+    string,
+    {
+      id: string
+      name: string
+      release_date: string
+    }
+  >
+}
+
+/**
+ * Handle the /model slash command.
+ * Shows a select menu with available providers.
+ */
+export async function handleModelCommand({
+  interaction,
+  appId,
+}: {
+  interaction: ChatInputCommandInteraction
+  appId: string
+}): Promise<void> {
+  modelLogger.log('[MODEL] handleModelCommand called')
+
+  // Defer reply immediately to avoid 3-second timeout
+  await interaction.deferReply({ ephemeral: true })
+  modelLogger.log('[MODEL] Deferred reply')
+
+  // Ensure migrations are run
+  runModelMigrations()
+
+  const channel = interaction.channel
+
+  if (!channel) {
+    await interaction.editReply({
+      content: 'This command can only be used in a channel',
+    })
+    return
+  }
+
+  // Determine if we're in a thread or text channel
+  const isThread = [
+    ChannelType.PublicThread,
+    ChannelType.PrivateThread,
+    ChannelType.AnnouncementThread,
+  ].includes(channel.type)
+
+  let projectDirectory: string | undefined
+  let channelAppId: string | undefined
+  let targetChannelId: string
+  let sessionId: string | undefined
+
+  if (isThread) {
+    const thread = channel as ThreadChannel
+    const textChannel = await resolveTextChannel(thread)
+    const metadata = getKimakiMetadata(textChannel)
+    projectDirectory = metadata.projectDirectory
+    channelAppId = metadata.channelAppId
+    targetChannelId = textChannel?.id || channel.id
+
+    // Get session ID for this thread
+    const row = getDatabase()
+      .prepare('SELECT session_id FROM thread_sessions WHERE thread_id = ?')
+      .get(thread.id) as { session_id: string } | undefined
+    sessionId = row?.session_id
+  } else if (channel.type === ChannelType.GuildText) {
+    const textChannel = channel as TextChannel
+    const metadata = getKimakiMetadata(textChannel)
+    projectDirectory = metadata.projectDirectory
+    channelAppId = metadata.channelAppId
+    targetChannelId = channel.id
+  } else {
+    await interaction.editReply({
+      content: 'This command can only be used in text channels or threads',
+    })
+    return
+  }
+
+  if (channelAppId && channelAppId !== appId) {
+    await interaction.editReply({
+      content: 'This channel is not configured for this bot',
+    })
+    return
+  }
+
+  if (!projectDirectory) {
+    await interaction.editReply({
+      content: 'This channel is not configured with a project directory',
+    })
+    return
+  }
+
+  try {
+    const getClient = await initializeOpencodeForDirectory(projectDirectory)
+
+    const providersResponse = await getClient().provider.list({
+      query: { directory: projectDirectory },
+    })
+
+    if (!providersResponse.data) {
+      await interaction.editReply({
+        content: 'Failed to fetch providers',
+      })
+      return
+    }
+
+    const { all: allProviders, connected } = providersResponse.data
+
+    // Filter to only connected providers (have credentials)
+    const availableProviders = allProviders.filter((p) => {
+      return connected.includes(p.id)
+    })
+
+    if (availableProviders.length === 0) {
+      await interaction.editReply({
+        content:
+          'No providers with credentials found. Use `/connect` in OpenCode TUI to add provider credentials.',
+      })
+      return
+    }
+
+    // Store context with a short hash key to avoid customId length limits
+    const context = {
+      dir: projectDirectory,
+      channelId: targetChannelId,
+      sessionId: sessionId,
+      isThread: isThread,
+    }
+    const contextHash = crypto.randomBytes(8).toString('hex')
+    pendingModelContexts.set(contextHash, context)
+
+    const options = availableProviders.slice(0, 25).map((provider) => {
+      const modelCount = Object.keys(provider.models || {}).length
+      return {
+        label: provider.name.slice(0, 100),
+        value: provider.id,
+        description: `${modelCount} model${modelCount !== 1 ? 's' : ''} available`.slice(0, 100),
+      }
+    })
+
+    const selectMenu = new StringSelectMenuBuilder()
+      .setCustomId(`model_provider:${contextHash}`)
+      .setPlaceholder('Select a provider')
+      .addOptions(options)
+
+    const actionRow = new ActionRowBuilder<StringSelectMenuBuilder>().addComponents(selectMenu)
+
+    await interaction.editReply({
+      content: '**Set Model Preference**\nSelect a provider:',
+      components: [actionRow],
+    })
+  } catch (error) {
+    modelLogger.error('Error loading providers:', error)
+    await interaction.editReply({
+      content: `Failed to load providers: ${error instanceof Error ? error.message : 'Unknown error'}`,
+    })
+  }
+}
+
+/**
+ * Handle the provider select menu interaction.
+ * Shows a second select menu with models for the chosen provider.
+ */
+export async function handleProviderSelectMenu(
+  interaction: StringSelectMenuInteraction
+): Promise<void> {
+  const customId = interaction.customId
+
+  if (!customId.startsWith('model_provider:')) {
+    return
+  }
+
+  // Defer update immediately to avoid timeout
+  await interaction.deferUpdate()
+
+  const contextHash = customId.replace('model_provider:', '')
+  const context = pendingModelContexts.get(contextHash)
+
+  if (!context) {
+    await interaction.editReply({
+      content: 'Selection expired. Please run /model again.',
+      components: [],
+    })
+    return
+  }
+
+  const selectedProviderId = interaction.values[0]
+  if (!selectedProviderId) {
+    await interaction.editReply({
+      content: 'No provider selected',
+      components: [],
+    })
+    return
+  }
+
+  try {
+    const getClient = await initializeOpencodeForDirectory(context.dir)
+
+    const providersResponse = await getClient().provider.list({
+      query: { directory: context.dir },
+    })
+
+    if (!providersResponse.data) {
+      await interaction.editReply({
+        content: 'Failed to fetch providers',
+        components: [],
+      })
+      return
+    }
+
+    const provider = providersResponse.data.all.find((p) => p.id === selectedProviderId)
+
+    if (!provider) {
+      await interaction.editReply({
+        content: 'Provider not found',
+        components: [],
+      })
+      return
+    }
+
+    const models = Object.entries(provider.models || {})
+      .map(([modelId, model]) => ({
+        id: modelId,
+        name: model.name,
+        releaseDate: model.release_date,
+      }))
+      // Sort by release date descending (most recent first)
+      .sort((a, b) => {
+        const dateA = a.releaseDate ? new Date(a.releaseDate).getTime() : 0
+        const dateB = b.releaseDate ? new Date(b.releaseDate).getTime() : 0
+        return dateB - dateA
+      })
+
+    if (models.length === 0) {
+      await interaction.editReply({
+        content: `No models available for ${provider.name}`,
+        components: [],
+      })
+      return
+    }
+
+    // Take first 25 models (most recent since sorted descending)
+    const recentModels = models.slice(0, 25)
+
+    // Update context with provider info and reuse the same hash
+    context.providerId = selectedProviderId
+    context.providerName = provider.name
+    pendingModelContexts.set(contextHash, context)
+
+    const options = recentModels.map((model) => {
+      const dateStr = model.releaseDate
+        ? new Date(model.releaseDate).toLocaleDateString()
+        : 'Unknown date'
+      return {
+        label: model.name.slice(0, 100),
+        value: model.id,
+        description: dateStr.slice(0, 100),
+      }
+    })
+
+    const selectMenu = new StringSelectMenuBuilder()
+      .setCustomId(`model_select:${contextHash}`)
+      .setPlaceholder('Select a model')
+      .addOptions(options)
+
+    const actionRow = new ActionRowBuilder<StringSelectMenuBuilder>().addComponents(selectMenu)
+
+    await interaction.editReply({
+      content: `**Set Model Preference**\nProvider: **${provider.name}**\nSelect a model:`,
+      components: [actionRow],
+    })
+  } catch (error) {
+    modelLogger.error('Error loading models:', error)
+    await interaction.editReply({
+      content: `Failed to load models: ${error instanceof Error ? error.message : 'Unknown error'}`,
+      components: [],
+    })
+  }
+}
+
+/**
+ * Handle the model select menu interaction.
+ * Stores the model preference in the database.
+ */
+export async function handleModelSelectMenu(
+  interaction: StringSelectMenuInteraction
+): Promise<void> {
+  const customId = interaction.customId
+
+  if (!customId.startsWith('model_select:')) {
+    return
+  }
+
+  // Defer update immediately
+  await interaction.deferUpdate()
+
+  const contextHash = customId.replace('model_select:', '')
+  const context = pendingModelContexts.get(contextHash)
+
+  if (!context || !context.providerId || !context.providerName) {
+    await interaction.editReply({
+      content: 'Selection expired. Please run /model again.',
+      components: [],
+    })
+    return
+  }
+
+  const selectedModelId = interaction.values[0]
+  if (!selectedModelId) {
+    await interaction.editReply({
+      content: 'No model selected',
+      components: [],
+    })
+    return
+  }
+
+  // Build full model ID: provider_id/model_id
+  const fullModelId = `${context.providerId}/${selectedModelId}`
+
+  try {
+    // Store in appropriate table based on context
+    if (context.isThread && context.sessionId) {
+      // Store for session
+      setSessionModel(context.sessionId, fullModelId)
+      modelLogger.log(`Set model ${fullModelId} for session ${context.sessionId}`)
+
+      await interaction.editReply({
+        content: `Model preference set for this session:\n**${context.providerName}** / **${selectedModelId}**\n\n\`${fullModelId}\``,
+        components: [],
+      })
+    } else {
+      // Store for channel
+      setChannelModel(context.channelId, fullModelId)
+      modelLogger.log(`Set model ${fullModelId} for channel ${context.channelId}`)
+
+      await interaction.editReply({
+        content: `Model preference set for this channel:\n**${context.providerName}** / **${selectedModelId}**\n\n\`${fullModelId}\`\n\nAll new sessions in this channel will use this model.`,
+        components: [],
+      })
+    }
+
+    // Clean up the context from memory
+    pendingModelContexts.delete(contextHash)
+  } catch (error) {
+    modelLogger.error('Error saving model preference:', error)
+    await interaction.editReply({
+      content: `Failed to save model preference: ${error instanceof Error ? error.message : 'Unknown error'}`,
+      components: [],
+    })
+  }
+}