kimaki 0.4.34 → 0.4.36

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(', ')

package/src/message-formatting.ts

@@ -77,8 +77,8 @@ export function isTextMimeType(contentType: string | null): boolean {
 }
 
 export async function getTextAttachments(message: Message): Promise<string> {
-  const textAttachments = Array.from(message.attachments.values()).filter(
-    (attachment) => isTextMimeType(attachment.contentType),
+  const textAttachments = Array.from(message.attachments.values()).filter((attachment) =>
+    isTextMimeType(attachment.contentType),
   )
 
   if (textAttachments.length === 0) {
@@ -105,14 +105,10 @@ export async function getTextAttachments(message: Message): Promise<string> {
 }
 
 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'
-      )
-    },
-  )
+  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 []
@@ -164,7 +160,9 @@ export function getToolSummaryText(part: Part): 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})`
+    return fileName
+      ? `*${escapeInlineMarkdown(fileName)}* (+${added}-${removed})`
+      : `(+${added}-${removed})`
   }
 
   if (part.tool === 'write') {
@@ -172,7 +170,9 @@ export function getToolSummaryText(part: Part): 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'})`
+    return fileName
+      ? `*${escapeInlineMarkdown(fileName)}* (${lines} line${lines === 1 ? '' : 's'})`
+      : `(${lines} line${lines === 1 ? '' : 's'})`
   }
 
   if (part.tool === 'webfetch') {
@@ -259,8 +259,7 @@ export function formatPart(part: Part): string {
     const trimmed = part.text.trimStart()
     const firstChar = trimmed[0] || ''
     const markdownStarters = ['#', '*', '_', '-', '>', '`', '[', '|']
-    const startsWithMarkdown =
-      markdownStarters.includes(firstChar) || /^\d+\./.test(trimmed)
+    const startsWithMarkdown = markdownStarters.includes(firstChar) || /^\d+\./.test(trimmed)
     if (startsWithMarkdown) {
       return `\n${part.text}`
     }