kimaki 0.4.35 → 0.4.37

package/src/genai-worker.ts

@@ -40,12 +40,7 @@ process.on('uncaughtException', (error) => {
 })
 
 process.on('unhandledRejection', (reason, promise) => {
-  workerLogger.error(
-    'Unhandled rejection in worker:',
-    reason,
-    'at promise:',
-    promise,
-  )
+  workerLogger.error('Unhandled rejection in worker:', reason, 'at promise:', promise)
   sendError(`Worker unhandled rejection: ${reason}`)
 })
 
@@ -130,12 +125,7 @@ async function createAssistantAudioLogStream(
   if (!process.env.DEBUG) return null
 
   const timestamp = new Date().toISOString().replace(/[:.]/g, '-')
-  const audioDir = path.join(
-    process.cwd(),
-    'discord-audio-logs',
-    guildId,
-    channelId,
-  )
+  const audioDir = path.join(process.cwd(), 'discord-audio-logs', guildId, channelId)
 
   try {
     await mkdir(audioDir, { recursive: true })
@@ -252,10 +242,7 @@ parentPort.on('message', async (message: WorkerInMessage) => {
         workerLogger.log(`Initializing with directory:`, message.directory)
 
         // Create audio log stream for assistant audio
-        audioLogStream = await createAssistantAudioLogStream(
-          message.guildId,
-          message.channelId,
-        )
+        audioLogStream = await createAssistantAudioLogStream(message.guildId, message.channelId)
 
         // Start packet sending interval
         startPacketSending()
@@ -359,8 +346,6 @@ parentPort.on('message', async (message: WorkerInMessage) => {
     }
   } catch (error) {
     workerLogger.error(`Error handling message:`, error)
-    sendError(
-      error instanceof Error ? error.message : 'Unknown error in worker',
-    )
+    sendError(error instanceof Error ? error.message : 'Unknown error in worker')
   }
 })

package/src/genai.ts

@@ -2,13 +2,7 @@
 // Establishes bidirectional audio streaming with Gemini, handles tool calls,
 // and manages the assistant's audio output for Discord voice channels.
 
-import {
-  GoogleGenAI,
-  LiveServerMessage,
-  MediaResolution,
-  Modality,
-  Session,
-} from '@google/genai'
+import { GoogleGenAI, LiveServerMessage, MediaResolution, Modality, Session } from '@google/genai'
 import type { CallableTool } from '@google/genai'
 import { writeFile } from 'fs'
 import type { Tool as AITool } from 'ai'
@@ -97,13 +91,7 @@ function createWavHeader(dataLength: number, options: WavConversionOptions) {
   return buffer
 }
 
-function defaultAudioChunkHandler({
-  data,
-  mimeType,
-}: {
-  data: Buffer
-  mimeType: string
-}) {
+function defaultAudioChunkHandler({ data, mimeType }: { data: Buffer; mimeType: string }) {
   audioParts.push(data)
   const fileName = 'audio.wav'
   const buffer = convertToWav(audioParts, mimeType)
@@ -147,9 +135,7 @@ export async function startGenAiSession({
       // Handle tool calls
       if (message.toolCall.functionCalls && callableTools.length > 0) {
         for (const tool of callableTools) {
-          if (
-            !message.toolCall.functionCalls.some((x) => x.name === tool.name)
-          ) {
+          if (!message.toolCall.functionCalls.some((x) => x.name === tool.name)) {
             continue
           }
           tool
@@ -158,20 +144,14 @@ export async function startGenAiSession({
               const functionResponses = parts
                 .filter((part) => part.functionResponse)
                 .map((part) => ({
-                  response: part.functionResponse!.response as Record<
-                    string,
-                    unknown
-                  >,
+                  response: part.functionResponse!.response as Record<string, unknown>,
                   id: part.functionResponse!.id,
                   name: part.functionResponse!.name,
                 }))
 
               if (functionResponses.length > 0 && session) {
                 session.sendToolResponse({ functionResponses })
-                genaiLogger.log(
-                  'client-toolResponse: ' +
-                    JSON.stringify({ functionResponses }),
-                )
+                genaiLogger.log('client-toolResponse: ' + JSON.stringify({ functionResponses }))
               }
             })
             .catch((error) => {
@@ -188,14 +168,8 @@ export async function startGenAiSession({
 
         if (part?.inlineData) {
           const inlineData = part.inlineData
-          if (
-            !inlineData.mimeType ||
-            !inlineData.mimeType.startsWith('audio/')
-          ) {
-            genaiLogger.log(
-              'Skipping non-audio inlineData:',
-              inlineData.mimeType,
-            )
+          if (!inlineData.mimeType || !inlineData.mimeType.startsWith('audio/')) {
+            genaiLogger.log('Skipping non-audio inlineData:', inlineData.mimeType)
             continue
           }
 
@@ -219,18 +193,12 @@ export async function startGenAiSession({
     }
     // Handle input transcription (user's audio transcription)
     if (message.serverContent?.inputTranscription?.text) {
-      genaiLogger.log(
-        '[user transcription]',
-        message.serverContent.inputTranscription.text,
-      )
+      genaiLogger.log('[user transcription]', message.serverContent.inputTranscription.text)
     }
 
     // Handle output transcription (model's audio transcription)
     if (message.serverContent?.outputTranscription?.text) {
-      genaiLogger.log(
-        '[assistant transcription]',
-        message.serverContent.outputTranscription.text,
-      )
+      genaiLogger.log('[assistant transcription]', message.serverContent.outputTranscription.text)
     }
     if (message.serverContent?.interrupted) {
       genaiLogger.log('Assistant was interrupted')
@@ -249,7 +217,7 @@ export async function startGenAiSession({
   }
 
   const apiKey = geminiApiKey || process.env.GEMINI_API_KEY
-  
+
   if (!apiKey) {
     genaiLogger.error('No Gemini API key provided')
     throw new Error('Gemini API key is required for voice interactions')

package/src/interaction-handler.ts

@@ -6,12 +6,20 @@ import { Events, type Client, type Interaction } from 'discord.js'
 import { handleSessionCommand, handleSessionAutocomplete } from './commands/session.js'
 import { handleResumeCommand, handleResumeAutocomplete } from './commands/resume.js'
 import { handleAddProjectCommand, handleAddProjectAutocomplete } from './commands/add-project.js'
+import {
+  handleRemoveProjectCommand,
+  handleRemoveProjectAutocomplete,
+} from './commands/remove-project.js'
 import { handleCreateNewProjectCommand } from './commands/create-new-project.js'
 import { handlePermissionSelectMenu } from './commands/permissions.js'
 import { handleAbortCommand } from './commands/abort.js'
 import { handleShareCommand } from './commands/share.js'
 import { handleForkCommand, handleForkSelectMenu } from './commands/fork.js'
-import { handleModelCommand, handleProviderSelectMenu, handleModelSelectMenu } from './commands/model.js'
+import {
+  handleModelCommand,
+  handleProviderSelectMenu,
+  handleModelSelectMenu,
+} from './commands/model.js'
 import { handleAgentCommand, handleAgentSelectMenu } from './commands/agent.js'
 import { handleAskQuestionSelectMenu } from './commands/ask-question.js'
 import { handleQueueCommand, handleClearQueueCommand } from './commands/queue.js'
@@ -21,7 +29,6 @@ import { createLogger } from './logger.js'
 
 const interactionLogger = createLogger('INTERACTION')
 
-
 export function registerInteractionHandler({
   discordClient,
   appId,
@@ -31,153 +38,158 @@ export function registerInteractionHandler({
 }) {
   interactionLogger.log('[REGISTER] Interaction handler registered')
 
-  discordClient.on(
-    Events.InteractionCreate,
-    async (interaction: Interaction) => {
-      try {
-        interactionLogger.log(
-          `[INTERACTION] Received: ${interaction.type} - ${
-            interaction.isChatInputCommand()
-              ? interaction.commandName
-              : interaction.isAutocomplete()
-                ? `autocomplete:${interaction.commandName}`
-                : 'other'
-          }`,
-        )
-
-        if (interaction.isAutocomplete()) {
-          switch (interaction.commandName) {
-            case 'session':
-              await handleSessionAutocomplete({ interaction, appId })
-              return
-
-            case 'resume':
-              await handleResumeAutocomplete({ interaction, appId })
-              return
-
-            case 'add-project':
-              await handleAddProjectAutocomplete({ interaction, appId })
-              return
-
-            default:
-              await interaction.respond([])
-              return
-          }
-        }
-
-        if (interaction.isChatInputCommand()) {
-          interactionLogger.log(`[COMMAND] Processing: ${interaction.commandName}`)
-
-          switch (interaction.commandName) {
-            case 'session':
-              await handleSessionCommand({ command: interaction, appId })
-              return
-
-            case 'resume':
-              await handleResumeCommand({ command: interaction, appId })
-              return
+  discordClient.on(Events.InteractionCreate, async (interaction: Interaction) => {
+    try {
+      interactionLogger.log(
+        `[INTERACTION] Received: ${interaction.type} - ${
+          interaction.isChatInputCommand()
+            ? interaction.commandName
+            : interaction.isAutocomplete()
+              ? `autocomplete:${interaction.commandName}`
+              : 'other'
+        }`,
+      )
+
+      if (interaction.isAutocomplete()) {
+        switch (interaction.commandName) {
+          case 'session':
+            await handleSessionAutocomplete({ interaction, appId })
+            return
 
-            case 'add-project':
-              await handleAddProjectCommand({ command: interaction, appId })
-              return
+          case 'resume':
+            await handleResumeAutocomplete({ interaction, appId })
+            return
 
-            case 'create-new-project':
-              await handleCreateNewProjectCommand({ command: interaction, appId })
-              return
+          case 'add-project':
+            await handleAddProjectAutocomplete({ interaction, appId })
+            return
 
-            case 'abort':
-            case 'stop':
-              await handleAbortCommand({ command: interaction, appId })
-              return
+          case 'remove-project':
+            await handleRemoveProjectAutocomplete({ interaction, appId })
+            return
 
-            case 'share':
-              await handleShareCommand({ command: interaction, appId })
-              return
+          default:
+            await interaction.respond([])
+            return
+        }
+      }
 
-            case 'fork':
-              await handleForkCommand(interaction)
-              return
+      if (interaction.isChatInputCommand()) {
+        interactionLogger.log(`[COMMAND] Processing: ${interaction.commandName}`)
 
-            case 'model':
-              await handleModelCommand({ interaction, appId })
-              return
+        switch (interaction.commandName) {
+          case 'session':
+            await handleSessionCommand({ command: interaction, appId })
+            return
 
-            case 'agent':
-              await handleAgentCommand({ interaction, appId })
-              return
+          case 'resume':
+            await handleResumeCommand({ command: interaction, appId })
+            return
 
-            case 'queue':
-              await handleQueueCommand({ command: interaction, appId })
-              return
+          case 'add-project':
+            await handleAddProjectCommand({ command: interaction, appId })
+            return
 
-            case 'clear-queue':
-              await handleClearQueueCommand({ command: interaction, appId })
-              return
+          case 'remove-project':
+            await handleRemoveProjectCommand({ command: interaction, appId })
+            return
 
-            case 'undo':
-              await handleUndoCommand({ command: interaction, appId })
-              return
+          case 'create-new-project':
+            await handleCreateNewProjectCommand({ command: interaction, appId })
+            return
 
-            case 'redo':
-              await handleRedoCommand({ command: interaction, appId })
-              return
-          }
+          case 'abort':
+          case 'stop':
+            await handleAbortCommand({ command: interaction, appId })
+            return
 
-          // Handle user-defined commands (ending with -cmd suffix)
-          if (interaction.commandName.endsWith('-cmd')) {
-            await handleUserCommand({ command: interaction, appId })
+          case 'share':
+            await handleShareCommand({ command: interaction, appId })
             return
-          }
-          return
-        }
 
-        if (interaction.isStringSelectMenu()) {
-          const customId = interaction.customId
+          case 'fork':
+            await handleForkCommand(interaction)
+            return
 
-          if (customId.startsWith('fork_select:')) {
-            await handleForkSelectMenu(interaction)
+          case 'model':
+            await handleModelCommand({ interaction, appId })
             return
-          }
 
-          if (customId.startsWith('model_provider:')) {
-            await handleProviderSelectMenu(interaction)
+          case 'agent':
+            await handleAgentCommand({ interaction, appId })
             return
-          }
 
-          if (customId.startsWith('model_select:')) {
-            await handleModelSelectMenu(interaction)
+          case 'queue':
+            await handleQueueCommand({ command: interaction, appId })
             return
-          }
 
-          if (customId.startsWith('agent_select:')) {
-            await handleAgentSelectMenu(interaction)
+          case 'clear-queue':
+            await handleClearQueueCommand({ command: interaction, appId })
             return
-          }
 
-          if (customId.startsWith('ask_question:')) {
-            await handleAskQuestionSelectMenu(interaction)
+          case 'undo':
+            await handleUndoCommand({ command: interaction, appId })
             return
-          }
 
-          if (customId.startsWith('permission:')) {
-            await handlePermissionSelectMenu(interaction)
+          case 'redo':
+            await handleRedoCommand({ command: interaction, appId })
             return
-          }
+        }
+
+        // Handle user-defined commands (ending with -cmd suffix)
+        if (interaction.commandName.endsWith('-cmd')) {
+          await handleUserCommand({ command: interaction, appId })
+          return
+        }
+        return
+      }
+
+      if (interaction.isStringSelectMenu()) {
+        const customId = interaction.customId
+
+        if (customId.startsWith('fork_select:')) {
+          await handleForkSelectMenu(interaction)
+          return
+        }
+
+        if (customId.startsWith('model_provider:')) {
+          await handleProviderSelectMenu(interaction)
+          return
+        }
+
+        if (customId.startsWith('model_select:')) {
+          await handleModelSelectMenu(interaction)
           return
         }
-      } catch (error) {
-        interactionLogger.error('[INTERACTION] Error handling interaction:', error)
-        try {
-          if (interaction.isRepliable() && !interaction.replied && !interaction.deferred) {
-            await interaction.reply({
-              content: 'An error occurred processing this command.',
-              ephemeral: true,
-            })
-          }
-        } catch (replyError) {
-          interactionLogger.error('[INTERACTION] Failed to send error reply:', replyError)
+
+        if (customId.startsWith('agent_select:')) {
+          await handleAgentSelectMenu(interaction)
+          return
+        }
+
+        if (customId.startsWith('ask_question:')) {
+          await handleAskQuestionSelectMenu(interaction)
+          return
+        }
+
+        if (customId.startsWith('permission:')) {
+          await handlePermissionSelectMenu(interaction)
+          return
+        }
+        return
+      }
+    } catch (error) {
+      interactionLogger.error('[INTERACTION] Error handling interaction:', error)
+      try {
+        if (interaction.isRepliable() && !interaction.replied && !interaction.deferred) {
+          await interaction.reply({
+            content: 'An error occurred processing this command.',
+            ephemeral: true,
+          })
         }
+      } catch (replyError) {
+        interactionLogger.error('[INTERACTION] Failed to send error reply:', replyError)
       }
-    },
-  )
+    }
+  })
 }

package/src/markdown.test.ts

@@ -35,9 +35,7 @@ const waitForServer = async (port: number, maxAttempts = 30) => {
     console.log(`Waiting for server... attempt ${i + 1}/${maxAttempts}`)
     await new Promise((resolve) => setTimeout(resolve, 1000))
   }
-  throw new Error(
-    `Server did not start on port ${port} after ${maxAttempts} seconds`,
-  )
+  throw new Error(`Server did not start on port ${port} after ${maxAttempts} seconds`)
 }
 
 beforeAll(async () => {
@@ -117,9 +115,7 @@ test('generate markdown from first available session', async () => {
   // Take the first kimaki session
   const firstSession = kimakiSessions[0]
   const sessionID = firstSession!.id
-  console.log(
-    `Using session ID: ${sessionID} (${firstSession!.title || 'Untitled'})`,
-  )
+  console.log(`Using session ID: ${sessionID} (${firstSession!.title || 'Untitled'})`)
 
   // Create markdown exporter
   const exporter = new ShareMarkdown(client)
@@ -139,9 +135,7 @@ test('generate markdown from first available session', async () => {
   expect(markdown).toContain('## Conversation')
 
   // Save snapshot to file
-  await expect(markdown).toMatchFileSnapshot(
-    './__snapshots__/first-session-with-info.md',
-  )
+  await expect(markdown).toMatchFileSnapshot('./__snapshots__/first-session-with-info.md')
 })
 
 test('generate markdown without system info', async () => {
@@ -184,9 +178,7 @@ test('generate markdown without system info', async () => {
   expect(markdown).toContain('## Conversation')
 
   // Save snapshot to file
-  await expect(markdown).toMatchFileSnapshot(
-    './__snapshots__/first-session-no-info.md',
-  )
+  await expect(markdown).toMatchFileSnapshot('./__snapshots__/first-session-no-info.md')
 })
 
 test('generate markdown from session with tools', async () => {
@@ -218,11 +210,7 @@ test('generate markdown from session with tools', async () => {
       const messages = await client.session.messages({
         path: { id: session.id },
       })
-      if (
-        messages.data?.some((msg) =>
-          msg.parts?.some((part) => part.type === 'tool'),
-        )
-      ) {
+      if (messages.data?.some((msg) => msg.parts?.some((part) => part.type === 'tool'))) {
         sessionWithTools = session
         console.log(`Found session with tools: ${session.id}`)
         break
@@ -233,9 +221,7 @@ test('generate markdown from session with tools', async () => {
   }
 
   if (!sessionWithTools) {
-    console.warn(
-      'No kimaki session with tool usage found, using first kimaki session',
-    )
+    console.warn('No kimaki session with tool usage found, using first kimaki session')
     sessionWithTools = kimakiSessions[0]
   }
 
@@ -245,9 +231,7 @@ test('generate markdown from session with tools', async () => {
   })
 
   expect(markdown).toBeTruthy()
-  await expect(markdown).toMatchFileSnapshot(
-    './__snapshots__/session-with-tools.md',
-  )
+  await expect(markdown).toMatchFileSnapshot('./__snapshots__/session-with-tools.md')
 })
 
 test('error handling for non-existent session', async () => {
@@ -303,9 +287,7 @@ test('generate markdown from multiple sessions', async () => {
       })
 
       expect(markdown).toBeTruthy()
-      await expect(markdown).toMatchFileSnapshot(
-        `./__snapshots__/session-${i + 1}.md`,
-      )
+      await expect(markdown).toMatchFileSnapshot(`./__snapshots__/session-${i + 1}.md`)
     } catch (e) {
       console.error(`Error generating markdown for session ${session!.id}:`, e)
       // Continue with other sessions
@@ -331,9 +313,7 @@ test.skipIf(process.env.CI)('getCompactSessionContext generates compact format',
   // should have tool calls or messages
   expect(context).toMatch(/\[Tool \w+\]:|\[User\]:|\[Assistant\]:/)
 
-  await expect(context).toMatchFileSnapshot(
-    './__snapshots__/compact-session-context.md',
-  )
+  await expect(context).toMatchFileSnapshot('./__snapshots__/compact-session-context.md')
 })
 
 test.skipIf(process.env.CI)('getCompactSessionContext without system prompt', async () => {
@@ -352,7 +332,5 @@ test.skipIf(process.env.CI)('getCompactSessionContext without system prompt', as
   // should NOT have system prompt
   expect(context).not.toContain('[System Prompt]')
 
-  await expect(context).toMatchFileSnapshot(
-    './__snapshots__/compact-session-context-no-system.md',
-  )
+  await expect(context).toMatchFileSnapshot('./__snapshots__/compact-session-context-no-system.md')
 })

package/src/markdown.ts

@@ -46,9 +46,7 @@ export class ShareMarkdown {
     // If lastAssistantOnly, filter to only the last assistant message
     const messagesToRender = lastAssistantOnly
       ? (() => {
-          const assistantMessages = messages.filter(
-            (m) => m.info.role === 'assistant',
-          )
+          const assistantMessages = messages.filter((m) => m.info.role === 'assistant')
           return assistantMessages.length > 0
             ? [assistantMessages[assistantMessages.length - 1]]
             : []
@@ -68,12 +66,8 @@ export class ShareMarkdown {
       if (includeSystemInfo === true) {
         lines.push('## Session Information')
         lines.push('')
-        lines.push(
-          `- **Created**: ${formatDateTime(new Date(session.time.created))}`,
-        )
-        lines.push(
-          `- **Updated**: ${formatDateTime(new Date(session.time.updated))}`,
-        )
+        lines.push(`- **Created**: ${formatDateTime(new Date(session.time.created))}`)
+        lines.push(`- **Updated**: ${formatDateTime(new Date(session.time.updated))}`)
         if (session.version) {
           lines.push(`- **OpenCode Version**: v${session.version}`)
         }
@@ -308,10 +302,7 @@ export async function getCompactSessionContext({
 
         // Get tool calls in compact form (name + params only)
         const toolParts = (msg.parts || []).filter(
-          (p) =>
-            p.type === 'tool' &&
-            'state' in p &&
-            p.state?.status === 'completed',
+          (p) => p.type === 'tool' && 'state' in p && p.state?.status === 'completed',
         )
         for (const part of toolParts) {
           if (part.type === 'tool' && 'tool' in part && 'state' in part) {
@@ -324,7 +315,8 @@ export async function getCompactSessionContext({
             // compact params: just key=value on one line
             const params = Object.entries(input)
               .map(([k, v]) => {
-                const val = typeof v === 'string' ? v.slice(0, 100) : JSON.stringify(v).slice(0, 100)
+                const val =
+                  typeof v === 'string' ? v.slice(0, 100) : JSON.stringify(v).slice(0, 100)
                 return `${k}=${val}`
               })
               .join(', ')