shuvmaki 0.4.26

package/src/message-formatting.ts

@@ -0,0 +1,340 @@
+// OpenCode message part formatting for Discord.
+// Converts SDK message parts (text, tools, reasoning) to Discord-friendly format,
+// handles file attachments, and provides tool summary generation.
+
+import type { Part } from '@opencode-ai/sdk/v2'
+import type { FilePartInput } from '@opencode-ai/sdk'
+import type { Message } from 'discord.js'
+import fs from 'node:fs'
+import path from 'node:path'
+import { createLogger } from './logger.js'
+
+// Generic message type compatible with both v1 and v2 SDK
+type GenericSessionMessage = {
+  info: { role: string; id?: string }
+  parts: Part[]
+}
+
+const ATTACHMENTS_DIR = path.join(process.cwd(), 'tmp', 'discord-attachments')
+
+const logger = createLogger('FORMATTING')
+
+/**
+ * Escapes Discord inline markdown characters so dynamic content
+ * doesn't break formatting when wrapped in *, _, **, etc.
+ */
+function escapeInlineMarkdown(text: string): string {
+  return text.replace(/([*_~|`\\])/g, '\\$1')
+}
+
+/**
+ * Collects and formats the last N assistant parts from session messages.
+ * Used by both /resume and /fork to show recent assistant context.
+ */
+export function collectLastAssistantParts({
+  messages,
+  limit = 30,
+}: {
+  messages: GenericSessionMessage[]
+  limit?: number
+}): { partIds: string[]; content: string; skippedCount: number } {
+  const allAssistantParts: { id: string; content: string }[] = []
+
+  for (const message of messages) {
+    if (message.info.role === 'assistant') {
+      for (const part of message.parts) {
+        const content = formatPart(part)
+        if (content.trim()) {
+          allAssistantParts.push({ id: part.id, content: content.trimEnd() })
+        }
+      }
+    }
+  }
+
+  const partsToRender = allAssistantParts.slice(-limit)
+  const partIds = partsToRender.map((p) => p.id)
+  const content = partsToRender.map((p) => p.content).join('\n')
+  const skippedCount = allAssistantParts.length - partsToRender.length
+
+  return { partIds, content, skippedCount }
+}
+
+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 async function getFileAttachments(message: Message): Promise<FilePartInput[]> {
+  const fileAttachments = Array.from(message.attachments.values()).filter(
+    (attachment) => {
+      const contentType = attachment.contentType || ''
+      return (
+        contentType.startsWith('image/') || contentType === 'application/pdf'
+      )
+    },
+  )
+
+  if (fileAttachments.length === 0) {
+    return []
+  }
+
+  // ensure tmp directory exists
+  if (!fs.existsSync(ATTACHMENTS_DIR)) {
+    fs.mkdirSync(ATTACHMENTS_DIR, { recursive: true })
+  }
+
+  const results = await Promise.all(
+    fileAttachments.map(async (attachment) => {
+      try {
+        const response = await fetch(attachment.url)
+        if (!response.ok) {
+          logger.error(`Failed to fetch attachment ${attachment.name}: ${response.status}`)
+          return null
+        }
+
+        const buffer = Buffer.from(await response.arrayBuffer())
+        const localPath = path.join(ATTACHMENTS_DIR, `${message.id}-${attachment.name}`)
+        fs.writeFileSync(localPath, buffer)
+
+        logger.log(`Downloaded attachment to ${localPath}`)
+
+        return {
+          type: 'file' as const,
+          mime: attachment.contentType || 'application/octet-stream',
+          filename: attachment.name,
+          url: localPath,
+        }
+      } catch (error) {
+        logger.error(`Error downloading attachment ${attachment.name}:`, error)
+        return null
+      }
+    }),
+  )
+
+  return results.filter((r) => r !== null) as FilePartInput[]
+}
+
+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 ? `*${escapeInlineMarkdown(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 ? `*${escapeInlineMarkdown(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 ? `*${escapeInlineMarkdown(urlWithoutProtocol)}*` : ''
+  }
+
+  if (part.tool === 'read') {
+    const filePath = (part.state.input?.filePath as string) || ''
+    const fileName = filePath.split('/').pop() || ''
+    return fileName ? `*${escapeInlineMarkdown(fileName)}*` : ''
+  }
+
+  if (part.tool === 'list') {
+    const path = (part.state.input?.path as string) || ''
+    const dirName = path.split('/').pop() || path
+    return dirName ? `*${escapeInlineMarkdown(dirName)}*` : ''
+  }
+
+  if (part.tool === 'glob') {
+    const pattern = (part.state.input?.pattern as string) || ''
+    return pattern ? `*${escapeInlineMarkdown(pattern)}*` : ''
+  }
+
+  if (part.tool === 'grep') {
+    const pattern = (part.state.input?.pattern as string) || ''
+    return pattern ? `*${escapeInlineMarkdown(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 ? `_${escapeInlineMarkdown(description)}_` : ''
+  }
+
+  if (part.tool === 'skill') {
+    const name = (part.state.input?.name as string) || ''
+    return name ? `_${escapeInlineMarkdown(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 > 50 ? stringValue.slice(0, 50) + '…' : 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 ''
+  // parenthesized digits ⑴-⒇ for 1-20, fallback to regular number for 21+
+  const parenthesizedDigits = '⑴⑵⑶⑷⑸⑹⑺⑻⑼⑽⑾⑿⒀⒁⒂⒃⒄⒅⒆⒇'
+  const todoNumber = activeIndex + 1
+  const num = todoNumber <= 20 ? parenthesizedDigits[todoNumber - 1] : `(${todoNumber})`
+  const content = activeTodo.content.charAt(0).toLowerCase() + activeTodo.content.slice(1)
+  return `${num} **${escapeInlineMarkdown(content)}**`
+}
+
+export function formatPart(part: Part): string {
+  if (part.type === 'text') {
+    if (!part.text?.trim()) return ''
+    const trimmed = part.text.trimStart()
+    const firstChar = trimmed[0] || ''
+    const markdownStarters = ['#', '*', '_', '-', '>', '`', '[', '|']
+    const startsWithMarkdown =
+      markdownStarters.includes(firstChar) || /^\d+\./.test(trimmed)
+    if (startsWithMarkdown) {
+      return `\n${part.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)
+    }
+
+    // Question tool is handled via Discord dropdowns, not text
+    if (part.tool === 'question') {
+      return ''
+    }
+
+    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')
+      if (isSingleLine && command.length <= 50) {
+        toolTitle = `_${escapeInlineMarkdown(command)}_`
+      } else if (description) {
+        toolTitle = `_${escapeInlineMarkdown(description)}_`
+      } else if (stateTitle) {
+        toolTitle = `_${escapeInlineMarkdown(stateTitle)}_`
+      }
+    } else if (stateTitle) {
+      toolTitle = `_${escapeInlineMarkdown(stateTitle)}_`
+    }
+
+    const icon = (() => {
+      if (part.state.status === 'error') {
+        return '⨯'
+      }
+      if (part.tool === 'edit' || part.tool === 'write') {
+        return '◼︎'
+      }
+      return '┣'
+    })()
+    return `${icon} ${part.tool} ${toolTitle} ${summaryText}`
+  }
+
+  logger.warn('Unknown part type:', part)
+  return ''
+}

package/src/openai-realtime.ts

@@ -0,0 +1,363 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+/* istanbul ignore file */
+// @ts-nocheck
+
+import { RealtimeClient } from '@openai/realtime-api-beta'
+import { writeFile } from 'fs'
+import type { Tool } from 'ai'
+import { createLogger } from './logger.js'
+
+const openaiLogger = createLogger('OPENAI')
+
+// Export the session type for reuse
+export interface OpenAIRealtimeSession {
+  send: (audioData: ArrayBuffer) => void
+  sendText: (text: string) => void
+  close: () => void
+}
+
+// Type definitions based on @openai/realtime-api-beta
+interface ConversationItem {
+  id: string
+  object: string
+  type: 'message' | 'function_call' | 'function_call_output'
+  status: 'in_progress' | 'completed' | 'incomplete'
+  role?: 'user' | 'assistant' | 'system'
+  content?: Array<{
+    type: string
+    text?: string
+    audio?: string
+    transcript?: string | null
+  }>
+  formatted: {
+    audio?: Int16Array
+    text?: string
+    transcript?: string
+    tool?: {
+      type: 'function'
+      name: string
+      call_id: string
+      arguments: string
+    }
+    output?: string
+  }
+}
+
+interface ConversationEventDelta {
+  audio?: Int16Array
+  text?: string
+  transcript?: string
+  arguments?: string
+}
+
+const audioParts: Buffer[] = []
+
+function saveBinaryFile(fileName: string, content: Buffer) {
+  writeFile(fileName, content, 'utf8', (err) => {
+    if (err) {
+      openaiLogger.error(`Error writing file ${fileName}:`, err)
+      return
+    }
+    openaiLogger.log(`Appending stream content to file ${fileName}.`)
+  })
+}
+
+interface WavConversionOptions {
+  numChannels: number
+  sampleRate: number
+  bitsPerSample: number
+}
+
+function convertToWav(rawData: Buffer[], mimeType: string) {
+  const options = parseMimeType(mimeType)
+  const dataLength = rawData.reduce((a, b) => a + b.length, 0)
+  const wavHeader = createWavHeader(dataLength, options)
+  const buffer = Buffer.concat(rawData)
+
+  return Buffer.concat([wavHeader, buffer])
+}
+
+function parseMimeType(mimeType: string) {
+  const [fileType, ...params] = mimeType.split(';').map((s) => s.trim())
+  const [_, format] = fileType?.split('/') || []
+
+  const options: Partial<WavConversionOptions> = {
+    numChannels: 1,
+    bitsPerSample: 16,
+  }
+
+  if (format && format.startsWith('L')) {
+    const bits = parseInt(format.slice(1), 10)
+    if (!isNaN(bits)) {
+      options.bitsPerSample = bits
+    }
+  }
+
+  for (const param of params) {
+    const [key, value] = param.split('=').map((s) => s.trim())
+    if (key === 'rate') {
+      options.sampleRate = parseInt(value || '', 10)
+    }
+  }
+
+  return options as WavConversionOptions
+}
+
+function createWavHeader(dataLength: number, options: WavConversionOptions) {
+  const { numChannels, sampleRate, bitsPerSample } = options
+
+  // http://soundfile.sapp.org/doc/WaveFormat
+
+  const byteRate = (sampleRate * numChannels * bitsPerSample) / 8
+  const blockAlign = (numChannels * bitsPerSample) / 8
+  const buffer = Buffer.alloc(44)
+
+  buffer.write('RIFF', 0) // ChunkID
+  buffer.writeUInt32LE(36 + dataLength, 4) // ChunkSize
+  buffer.write('WAVE', 8) // Format
+  buffer.write('fmt ', 12) // Subchunk1ID
+  buffer.writeUInt32LE(16, 16) // Subchunk1Size (PCM)
+  buffer.writeUInt16LE(1, 20) // AudioFormat (1 = PCM)
+  buffer.writeUInt16LE(numChannels, 22) // NumChannels
+  buffer.writeUInt32LE(sampleRate, 24) // SampleRate
+  buffer.writeUInt32LE(byteRate, 28) // ByteRate
+  buffer.writeUInt16LE(blockAlign, 32) // BlockAlign
+  buffer.writeUInt16LE(bitsPerSample, 34) // BitsPerSample
+  buffer.write('data', 36) // Subchunk2ID
+  buffer.writeUInt32LE(dataLength, 40) // Subchunk2Size
+
+  return buffer
+}
+
+function defaultAudioChunkHandler({
+  data,
+  mimeType,
+}: {
+  data: Buffer
+  mimeType: string
+}) {
+  audioParts.push(data)
+  const fileName = 'audio.wav'
+  const buffer = convertToWav(audioParts, mimeType)
+  saveBinaryFile(fileName, buffer)
+}
+
+export interface GenAISessionResult {
+  session: OpenAIRealtimeSession
+  stop: () => void
+}
+
+export async function startGenAiSession({
+  onAssistantAudioChunk,
+  onAssistantStartSpeaking,
+  onAssistantStopSpeaking,
+  onAssistantInterruptSpeaking,
+  systemMessage,
+  tools,
+}: {
+  onAssistantAudioChunk?: (args: { data: Buffer; mimeType: string }) => void
+  onAssistantStartSpeaking?: () => void
+  onAssistantStopSpeaking?: () => void
+  onAssistantInterruptSpeaking?: () => void
+  systemMessage?: string
+  // Accept tools but use structural typing to avoid variance issues
+  tools?: Record<
+    string,
+    {
+      description?: string
+      inputSchema?: unknown
+      execute?: Function
+    }
+  >
+} = {}): Promise<GenAISessionResult> {
+  if (!process.env.OPENAI_API_KEY) {
+    throw new Error('OPENAI_API_KEY environment variable is required')
+  }
+
+  const client = new RealtimeClient({
+    apiKey: process.env.OPENAI_API_KEY,
+  })
+
+  const audioChunkHandler = onAssistantAudioChunk || defaultAudioChunkHandler
+  let isAssistantSpeaking = false
+
+  // Configure session with 24kHz sample rate
+  client.updateSession({
+    instructions: systemMessage || '',
+    voice: 'alloy',
+    input_audio_format: 'pcm16',
+    output_audio_format: 'pcm16',
+    input_audio_transcription: { model: 'whisper-1' },
+    turn_detection: { type: 'server_vad' },
+    modalities: ['text', 'audio'],
+    temperature: 0.8,
+  })
+
+  // Add tools if provided
+  if (tools) {
+    for (const [name, tool] of Object.entries(tools)) {
+      // Convert AI SDK tool to OpenAI Realtime format
+      // The tool.inputSchema is a Zod schema, we need to convert it to JSON Schema
+      let parameters: Record<string, unknown> = {
+        type: 'object',
+        properties: {},
+        required: [],
+      }
+
+      // If the tool has a Zod schema, we can try to extract basic structure
+      // For now, we'll use a simple placeholder
+      if (tool.description?.includes('session')) {
+        parameters = {
+          type: 'object',
+          properties: {
+            sessionId: { type: 'string', description: 'The session ID' },
+            message: { type: 'string', description: 'The message text' },
+          },
+          required: ['sessionId'],
+        }
+      }
+
+      client.addTool(
+        {
+          type: 'function',
+          name,
+          description: tool.description || '',
+          parameters,
+        },
+        async (params: Record<string, unknown>) => {
+          try {
+            if (!tool.execute || typeof tool.execute !== 'function') {
+              return { error: 'Tool execute function not found' }
+            }
+            // Call the execute function with params
+            // The Tool type from 'ai' expects (input, options) but we need to handle this safely
+            const result = await tool.execute(params, {
+              abortSignal: new AbortController().signal,
+              toolCallId: '',
+              messages: [],
+            })
+            return result
+          } catch (error) {
+            openaiLogger.error(`Tool ${name} execution error:`, error)
+            return { error: String(error) }
+          }
+        },
+      )
+    }
+  }
+
+  // Set up event handlers
+  client.on(
+    'conversation.item.created',
+    ({ item }: { item: ConversationItem }) => {
+      if (
+        'role' in item &&
+        item.role === 'assistant' &&
+        item.type === 'message'
+      ) {
+        // Check if this is the first audio content
+        const hasAudio =
+          'content' in item &&
+          Array.isArray(item.content) &&
+          item.content.some((c) => 'type' in c && c.type === 'audio')
+        if (hasAudio && !isAssistantSpeaking && onAssistantStartSpeaking) {
+          isAssistantSpeaking = true
+          onAssistantStartSpeaking()
+        }
+      }
+    },
+  )
+
+  client.on(
+    'conversation.updated',
+    ({
+      item,
+      delta,
+    }: {
+      item: ConversationItem
+      delta: ConversationEventDelta | null
+    }) => {
+      // Handle audio chunks
+      if (delta?.audio && 'role' in item && item.role === 'assistant') {
+        if (!isAssistantSpeaking && onAssistantStartSpeaking) {
+          isAssistantSpeaking = true
+          onAssistantStartSpeaking()
+        }
+
+        // OpenAI provides audio as Int16Array or base64
+        let audioBuffer: Buffer
+        if (delta.audio instanceof Int16Array) {
+          audioBuffer = Buffer.from(delta.audio.buffer)
+        } else {
+          // Assume base64 string
+          audioBuffer = Buffer.from(delta.audio, 'base64')
+        }
+
+        // OpenAI uses 24kHz PCM16 format
+        audioChunkHandler({
+          data: audioBuffer,
+          mimeType: 'audio/pcm;rate=24000',
+        })
+      }
+
+      // Handle transcriptions
+      if (delta?.transcript) {
+        if ('role' in item) {
+          if (item.role === 'user') {
+            openaiLogger.log('User transcription:', delta.transcript)
+          } else if (item.role === 'assistant') {
+            openaiLogger.log('Assistant transcription:', delta.transcript)
+          }
+        }
+      }
+    },
+  )
+
+  client.on(
+    'conversation.item.completed',
+    ({ item }: { item: ConversationItem }) => {
+      if (
+        'role' in item &&
+        item.role === 'assistant' &&
+        isAssistantSpeaking &&
+        onAssistantStopSpeaking
+      ) {
+        isAssistantSpeaking = false
+        onAssistantStopSpeaking()
+      }
+    },
+  )
+
+  client.on('conversation.interrupted', () => {
+    openaiLogger.log('Assistant was interrupted')
+    if (isAssistantSpeaking && onAssistantInterruptSpeaking) {
+      isAssistantSpeaking = false
+      onAssistantInterruptSpeaking()
+    }
+  })
+
+  // Connect to the Realtime API
+  await client.connect()
+
+  const sessionResult: GenAISessionResult = {
+    session: {
+      send: (audioData: ArrayBuffer) => {
+        // Convert ArrayBuffer to Int16Array for OpenAI
+        const int16Data = new Int16Array(audioData)
+        client.appendInputAudio(int16Data)
+      },
+      sendText: (text: string) => {
+        // Send text message to OpenAI
+        client.sendUserMessageContent([{ type: 'input_text', text }])
+      },
+      close: () => {
+        client.disconnect()
+      },
+    },
+    stop: () => {
+      client.disconnect()
+    },
+  }
+
+  return sessionResult
+}