kimaki 0.0.3 → 0.1.0

package/src/markdown.ts

@@ -0,0 +1,225 @@
+import type { OpencodeClient } from '@opencode-ai/sdk'
+import { format } from 'date-fns'
+import * as yaml from 'js-yaml'
+
+export class ShareMarkdown {
+  constructor(private client: OpencodeClient) {}
+
+  /**
+   * Generate a markdown representation of a session
+   * @param options Configuration options
+   * @returns Markdown string representation of the session
+   */
+  async generate(options: {
+    sessionID: string
+    includeSystemInfo?: boolean
+    lastAssistantOnly?: boolean
+  }): Promise<string> {
+    const { sessionID, includeSystemInfo, lastAssistantOnly } = options
+
+    // Get session info
+    const sessionResponse = await this.client.session.get({
+      path: { id: sessionID },
+    })
+    if (!sessionResponse.data) {
+      throw new Error(`Session ${sessionID} not found`)
+    }
+    const session = sessionResponse.data
+
+    // Get all messages
+    const messagesResponse = await this.client.session.messages({
+      path: { id: sessionID },
+    })
+    if (!messagesResponse.data) {
+      throw new Error(`No messages found for session ${sessionID}`)
+    }
+    const messages = messagesResponse.data
+
+    // If lastAssistantOnly, filter to only the last assistant message
+    const messagesToRender = lastAssistantOnly
+      ? (() => {
+          const assistantMessages = messages.filter(
+            (m) => m.info.role === 'assistant',
+          )
+          return assistantMessages.length > 0
+            ? [assistantMessages[assistantMessages.length - 1]]
+            : []
+        })()
+      : messages
+
+    // Build markdown
+    const lines: string[] = []
+
+    // Only include header and session info if not lastAssistantOnly
+    if (!lastAssistantOnly) {
+      // Header
+      lines.push(`# ${session.title || 'Untitled Session'}`)
+      lines.push('')
+
+      // Session metadata
+      if (includeSystemInfo === true) {
+        lines.push('## Session Information')
+        lines.push('')
+        lines.push(
+          `- **Created**: ${format(new Date(session.time.created), 'MMM d, yyyy, h:mm a')}`,
+        )
+        lines.push(
+          `- **Updated**: ${format(new Date(session.time.updated), 'MMM d, yyyy, h:mm a')}`,
+        )
+        if (session.version) {
+          lines.push(`- **OpenCode Version**: v${session.version}`)
+        }
+        lines.push('')
+      }
+
+      // Process messages
+      lines.push('## Conversation')
+      lines.push('')
+    }
+
+    for (const message of messagesToRender) {
+      const messageLines = this.renderMessage(message!.info, message!.parts)
+      lines.push(...messageLines)
+      lines.push('')
+    }
+
+    return lines.join('\n')
+  }
+
+  private renderMessage(message: any, parts: any[]): string[] {
+    const lines: string[] = []
+
+    if (message.role === 'user') {
+      lines.push('### 👤 User')
+      lines.push('')
+
+      for (const part of parts) {
+        if (part.type === 'text' && part.text) {
+          lines.push(part.text)
+          lines.push('')
+        } else if (part.type === 'file') {
+          lines.push(`📎 **Attachment**: ${part.filename || 'unnamed file'}`)
+          if (part.url) {
+            lines.push(`   - URL: ${part.url}`)
+          }
+          lines.push('')
+        }
+      }
+    } else if (message.role === 'assistant') {
+      lines.push(`### 🤖 Assistant (${message.modelID || 'unknown model'})`)
+      lines.push('')
+
+      // Filter and process parts
+      const filteredParts = parts.filter((part) => {
+        if (part.type === 'step-start' && parts.indexOf(part) > 0) return false
+        if (part.type === 'snapshot') return false
+        if (part.type === 'patch') return false
+        if (part.type === 'step-finish') return false
+        if (part.type === 'text' && part.synthetic === true) return false
+        if (part.type === 'tool' && part.tool === 'todoread') return false
+        if (part.type === 'text' && !part.text) return false
+        if (
+          part.type === 'tool' &&
+          (part.state.status === 'pending' || part.state.status === 'running')
+        )
+          return false
+        return true
+      })
+
+      for (const part of filteredParts) {
+        const partLines = this.renderPart(part, message)
+        lines.push(...partLines)
+      }
+
+      // Add completion time if available
+      if (message.time?.completed) {
+        const duration = message.time.completed - message.time.created
+        lines.push('')
+        lines.push(`*Completed in ${this.formatDuration(duration)}*`)
+      }
+    }
+
+    return lines
+  }
+
+  private renderPart(part: any, message: any): string[] {
+    const lines: string[] = []
+
+    switch (part.type) {
+      case 'text':
+        if (part.text) {
+          lines.push(part.text)
+          lines.push('')
+        }
+        break
+
+      case 'reasoning':
+        if (part.text) {
+          lines.push('<details>')
+          lines.push('<summary>💭 Thinking</summary>')
+          lines.push('')
+          lines.push(part.text)
+          lines.push('')
+          lines.push('</details>')
+          lines.push('')
+        }
+        break
+
+      case 'tool':
+        if (part.state.status === 'completed') {
+          lines.push(`#### 🛠️ Tool: ${part.tool}`)
+          lines.push('')
+
+          // Render input parameters in YAML
+          if (part.state.input && Object.keys(part.state.input).length > 0) {
+            lines.push('**Input:**')
+            lines.push('```yaml')
+            lines.push(yaml.dump(part.state.input, { lineWidth: -1 }))
+            lines.push('```')
+            lines.push('')
+          }
+
+          // Render output
+          if (part.state.output) {
+            lines.push('**Output:**')
+            lines.push('```')
+            lines.push(part.state.output)
+            lines.push('```')
+            lines.push('')
+          }
+
+          // Add timing info if significant
+          if (part.state.time?.start && part.state.time?.end) {
+            const duration = part.state.time.end - part.state.time.start
+            if (duration > 2000) {
+              lines.push(`*Duration: ${this.formatDuration(duration)}*`)
+              lines.push('')
+            }
+          }
+        } else if (part.state.status === 'error') {
+          lines.push(`#### ❌ Tool Error: ${part.tool}`)
+          lines.push('')
+          lines.push('```')
+          lines.push(part.state.error || 'Unknown error')
+          lines.push('```')
+          lines.push('')
+        }
+        break
+
+      case 'step-start':
+        lines.push(`**Started using ${message.providerID}/${message.modelID}**`)
+        lines.push('')
+        break
+    }
+
+    return lines
+  }
+
+  private formatDuration(ms: number): string {
+    if (ms < 1000) return `${ms}ms`
+    if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`
+    const minutes = Math.floor(ms / 60000)
+    const seconds = Math.floor((ms % 60000) / 1000)
+    return `${minutes}m ${seconds}s`
+  }
+}

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
+}