@brianli/kimaki 0.4.72-brianli.1

package/src/openai-realtime.ts

@@ -0,0 +1,362 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+/* istanbul ignore file */
+// @ts-nocheck
+
+import { RealtimeClient } from '@openai/realtime-api-beta'
+import { writeFile } from 'fs'
+import { createLogger, LogPrefix } from './logger.js'
+
+const openaiLogger = createLogger(LogPrefix.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
+}

package/src/opencode-plugin-loading.e2e.test.ts

@@ -0,0 +1,112 @@
+// E2e test for OpenCode plugin loading.
+// Spawns `opencode serve` directly with our plugin in OPENCODE_CONFIG_CONTENT,
+// waits for the health endpoint, then checks stderr for plugin errors.
+// No Discord infrastructure needed — just the OpenCode server process.
+
+import { spawn, type ChildProcess } from 'node:child_process'
+import fs from 'node:fs'
+import net from 'node:net'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { test, expect } from 'vitest'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+
+async function getOpenPort(): Promise<number> {
+  return new Promise((resolve, reject) => {
+    const server = net.createServer()
+    server.listen(0, () => {
+      const address = server.address()
+      if (address && typeof address === 'object') {
+        server.close(() => {
+          resolve(address.port)
+        })
+      } else {
+        reject(new Error('Failed to get port'))
+      }
+    })
+    server.on('error', reject)
+  })
+}
+
+async function waitForHealth({
+  port,
+  maxAttempts = 30,
+}: {
+  port: number
+  maxAttempts?: number
+}): Promise<boolean> {
+  for (let i = 0; i < maxAttempts; i++) {
+    try {
+      const response = await fetch(`http://127.0.0.1:${port}/api/health`)
+      if (response.status < 500) {
+        return true
+      }
+    } catch {
+      // connection refused, retry
+    }
+    await new Promise((resolve) => {
+      setTimeout(resolve, 1000)
+    })
+  }
+  return false
+}
+
+test(
+  'opencode server loads plugin without errors',
+  async () => {
+    const projectDir = path.resolve(process.cwd(), 'tmp', 'plugin-loading-e2e')
+    fs.mkdirSync(projectDir, { recursive: true })
+
+    const port = await getOpenPort()
+    const pluginPath = new URL('../src/opencode-plugin.ts', import.meta.url).href
+    const stderrLines: string[] = []
+
+    const serverProcess: ChildProcess = spawn(
+      process.env.OPENCODE_PATH || 'opencode',
+      ['serve', '--port', port.toString(), '--print-logs', '--log-level', 'DEBUG'],
+      {
+        stdio: 'pipe',
+        cwd: projectDir,
+        shell: true,
+        env: {
+          ...process.env,
+          OPENCODE_CONFIG_CONTENT: JSON.stringify({
+            $schema: 'https://opencode.ai/config.json',
+            lsp: false,
+            formatter: false,
+            plugin: [pluginPath],
+          }),
+        },
+      },
+    )
+
+    serverProcess.stderr?.on('data', (data) => {
+      stderrLines.push(...data.toString().split('\n').filter(Boolean))
+    })
+
+    try {
+      const healthy = await waitForHealth({ port })
+      expect(healthy).toBe(true)
+
+      // Check no plugin-related errors in stderr
+      const pluginErrorPatterns = [
+        /plugin.*error/i,
+        /failed to load plugin/i,
+        /cannot find module/i,
+        /ERR_MODULE_NOT_FOUND/i,
+        /plugin.*failed/i,
+        /plugin.*crash/i,
+      ]
+      const errorLines = stderrLines.filter((line) => {
+        return pluginErrorPatterns.some((pattern) => {
+          return pattern.test(line)
+        })
+      })
+      expect(errorLines).toEqual([])
+    } finally {
+      serverProcess.kill('SIGTERM')
+    }
+  },
+  60_000,
+)

package/src/opencode-plugin.test.ts

@@ -0,0 +1,108 @@
+import { test, expect, describe } from 'vitest'
+import { condenseMemoryMd } from './condense-memory.js'
+
+describe('condenseMemoryMd', () => {
+  test('multiple headings with body content', () => {
+    const content = [
+      '# Project Overview',
+      '',
+      'This is a big project with many things.',
+      'It does X, Y, and Z.',
+      '',
+      '## Auth Architecture',
+      '',
+      'JWT tokens with 15min expiry.',
+      'Refresh tokens in httpOnly cookies.',
+      'Session stored in Redis.',
+      '',
+      '## User Preferences',
+      '',
+      '- kebab-case filenames',
+      '- errore-style errors',
+      '- no emojis',
+      '',
+      '### API Conventions',
+      '',
+      'All routes return { data, error }.',
+      'Use spiceflow for the server.',
+      '',
+    ].join('\n')
+
+    expect(condenseMemoryMd(content)).toMatchInlineSnapshot(`
+      "1: # Project Overview
+      ...
+      6: ## Auth Architecture
+      ...
+      12: ## User Preferences
+      ...
+      18: ### API Conventions
+      ..."
+    `)
+  })
+
+  test('body text before first heading', () => {
+    const content = [
+      'Some preamble notes.',
+      '',
+      '# First Heading',
+      '',
+      'Content here.',
+      '',
+    ].join('\n')
+
+    expect(condenseMemoryMd(content)).toMatchInlineSnapshot(`
+      "...
+      3: # First Heading
+      ..."
+    `)
+  })
+
+  test('no headings at all', () => {
+    const content = 'Just some notes.\nMore notes.\n'
+    expect(condenseMemoryMd(content)).toMatchInlineSnapshot(`"..."`)
+  })
+
+  test('empty content', () => {
+    expect(condenseMemoryMd('')).toMatchInlineSnapshot(`""`)
+  })
+
+  test('consecutive headings without body', () => {
+    const content = [
+      '# H1',
+      '## H2',
+      '### H3',
+      '',
+      'Some body.',
+      '',
+    ].join('\n')
+
+    expect(condenseMemoryMd(content)).toMatchInlineSnapshot(`
+      "1: # H1
+      2: ## H2
+      3: ### H3
+      ..."
+    `)
+  })
+
+  test('heading with code block body', () => {
+    const content = [
+      '# Config',
+      '',
+      '```json',
+      '{ "key": "value" }',
+      '```',
+      '',
+      '## Notes',
+      '',
+      'Some text.',
+      '',
+    ].join('\n')
+
+    expect(condenseMemoryMd(content)).toMatchInlineSnapshot(`
+      "1: # Config
+      ...
+      7: ## Notes
+      ..."
+    `)
+  })
+})