kimaki 0.31.0 → 1.0.0

package/src/tools.ts

@@ -1,430 +0,0 @@
-// Voice assistant tool definitions for the GenAI worker.
-// Provides tools for managing OpenCode sessions (create, submit, abort),
-// listing chats, searching files, and reading session messages.
-
-import { tool } from './ai-tool.js'
-import { z } from 'zod'
-import { spawn, type ChildProcess } from 'node:child_process'
-import net from 'node:net'
-import {
-  type OpencodeClient,
-  type AssistantMessage,
-  type Provider,
-} from '@opencode-ai/sdk/v2'
-import { createLogger, LogPrefix } from './logger.js'
-import * as errore from 'errore'
-
-const toolsLogger = createLogger(LogPrefix.TOOLS)
-
-import { ShareMarkdown } from './markdown.js'
-import { formatDistanceToNow } from './utils.js'
-import pc from 'picocolors'
-import {
-  initializeOpencodeForDirectory,
-  getOpencodeSystemMessage,
-} from './discord-bot.js'
-
-export async function getTools({
-  onMessageCompleted,
-  directory,
-}: {
-  directory: string
-  onMessageCompleted?: (params: {
-    sessionId: string
-    messageId: string
-    data?: { info: AssistantMessage }
-    error?: unknown
-    markdown?: string
-  }) => void
-}) {
-  const getClient = await initializeOpencodeForDirectory(directory)
-  if (getClient instanceof Error) {
-    throw new Error(getClient.message)
-  }
-  const client = getClient()
-
-  const markdownRenderer = new ShareMarkdown(client)
-
-  const providersResponse = await client.config.providers()
-  const providers: Provider[] = providersResponse.data?.providers || []
-
-  // Helper: get last assistant model for a session (non-summary)
-  const getSessionModel = async (
-    sessionId: string,
-  ): Promise<{ providerID: string; modelID: string } | undefined> => {
-    const res = await getClient().session.messages({ sessionID: sessionId })
-    const data = res.data
-    if (!data || data.length === 0) return undefined
-    for (let i = data.length - 1; i >= 0; i--) {
-      const info = data?.[i]?.info
-      if (info?.role === 'assistant') {
-        const ai = info
-        if (!ai.summary && ai.providerID && ai.modelID) {
-          return { providerID: ai.providerID, modelID: ai.modelID }
-        }
-      }
-    }
-    return undefined
-  }
-
-  const tools = {
-    submitMessage: tool({
-      description:
-        'Submit a message to an existing chat session. Does not wait for the message to complete',
-      inputSchema: z.object({
-        sessionId: z.string().describe('The session ID to send message to'),
-        message: z.string().describe('The message text to send'),
-      }),
-      execute: async ({ sessionId, message }) => {
-        const sessionModel = await getSessionModel(sessionId)
-
-        // do not await
-        getClient()
-          .session.promptAsync({
-            sessionID: sessionId,
-            parts: [{ type: 'text', text: message }],
-            model: sessionModel,
-            system: getOpencodeSystemMessage({ sessionId }),
-          })
-          .then(async (response) => {
-            const markdownResult = await markdownRenderer.generate({
-              sessionID: sessionId,
-              lastAssistantOnly: true,
-            })
-            onMessageCompleted?.({
-              sessionId,
-              messageId: '',
-              markdown: errore.unwrapOr(markdownResult, ''),
-            })
-          })
-          .catch((error) => {
-            onMessageCompleted?.({
-              sessionId,
-              messageId: '',
-              error,
-            })
-          })
-        return {
-          success: true,
-          sessionId,
-          directive: 'Tell user that message has been sent successfully',
-        }
-      },
-    }),
-
-    createNewChat: tool({
-      description:
-        'Start a new chat session with an initial message. Does not wait for the message to complete',
-      inputSchema: z.object({
-        message: z
-          .string()
-          .describe('The initial message to start the chat with'),
-        title: z.string().optional().describe('Optional title for the session'),
-        model: z
-          .object({
-            providerId: z
-              .string()
-              .describe('The provider ID (e.g., "anthropic", "openai")'),
-            modelId: z
-              .string()
-              .describe(
-                'The model ID (e.g., "claude-opus-4-20250514", "gpt-5")',
-              ),
-          })
-          .optional()
-          .describe('Optional model to use for this session'),
-      }),
-      execute: async ({ message, title }) => {
-        if (!message.trim()) {
-          throw new Error(`message must be a non empty string`)
-        }
-
-        try {
-          const session = await getClient().session.create({
-            ...(title ? { title } : {}),
-          })
-
-          if (!session.data) {
-            throw new Error('Failed to create session')
-          }
-
-          // do not await
-          getClient()
-            .session.promptAsync({
-              sessionID: session.data.id,
-              parts: [{ type: 'text', text: message }],
-              system: getOpencodeSystemMessage({ sessionId: session.data.id }),
-            })
-            .then(async (response) => {
-              const markdownResult = await markdownRenderer.generate({
-                sessionID: session.data.id,
-                lastAssistantOnly: true,
-              })
-              onMessageCompleted?.({
-                sessionId: session.data.id,
-                messageId: '',
-                markdown: errore.unwrapOr(markdownResult, ''),
-              })
-            })
-            .catch((error) => {
-              onMessageCompleted?.({
-                sessionId: session.data.id,
-                messageId: '',
-                error,
-              })
-            })
-
-          return {
-            success: true,
-            sessionId: session.data.id,
-            title: session.data.title,
-          }
-        } catch (error) {
-          return {
-            success: false,
-            error:
-              error instanceof Error
-                ? error.message
-                : 'Failed to create chat session',
-          }
-        }
-      },
-    }),
-
-    listChats: tool({
-      description:
-        'Get a list of available chat sessions sorted by most recent',
-      inputSchema: z.object({}),
-      execute: async () => {
-        toolsLogger.log(`Listing opencode sessions`)
-        const sessions = await getClient().session.list()
-
-        if (!sessions.data) {
-          return { success: false, error: 'No sessions found' }
-        }
-
-        const sortedSessions = [...sessions.data]
-          .sort((a, b) => {
-            return b.time.updated - a.time.updated
-          })
-          .slice(0, 20)
-
-        const sessionList = sortedSessions.map(async (session) => {
-          const finishedAt = session.time.updated
-          const status = await (async () => {
-            if (session.revert) return 'error'
-            const messagesResponse = await getClient().session.messages({
-              sessionID: session.id,
-            })
-            const messages = messagesResponse.data || []
-            const lastMessage = messages[messages.length - 1]
-            if (
-              lastMessage?.info.role === 'assistant' &&
-              !lastMessage.info.time.completed
-            ) {
-              return 'in_progress'
-            }
-            return 'finished'
-          })()
-
-          return {
-            id: session.id,
-            folder: session.directory,
-            status,
-            finishedAt: formatDistanceToNow(new Date(finishedAt)),
-            title: session.title,
-            prompt: session.title,
-          }
-        })
-
-        const resolvedList = await Promise.all(sessionList)
-
-        return {
-          success: true,
-          sessions: resolvedList,
-        }
-      },
-    }),
-
-    searchFiles: tool({
-      description: 'Search for files in a folder',
-      inputSchema: z.object({
-        folder: z
-          .string()
-          .optional()
-          .describe(
-            'The folder path to search in, optional. only use if user specifically asks for it',
-          ),
-        query: z.string().describe('The search query for files'),
-      }),
-      execute: async ({ folder, query }) => {
-        const results = await getClient().find.files({
-          query,
-          directory: folder,
-        })
-
-        return {
-          success: true,
-          files: results.data || [],
-        }
-      },
-    }),
-
-    readSessionMessages: tool({
-      description: 'Read messages from a chat session',
-      inputSchema: z.object({
-        sessionId: z.string().describe('The session ID to read messages from'),
-        lastAssistantOnly: z
-          .boolean()
-          .optional()
-          .describe('Only read the last assistant message'),
-      }),
-      execute: async ({ sessionId, lastAssistantOnly = false }) => {
-        if (lastAssistantOnly) {
-          const messages = await getClient().session.messages({
-            sessionID: sessionId,
-          })
-
-          if (!messages.data) {
-            return { success: false, error: 'No messages found' }
-          }
-
-          const assistantMessages = messages.data.filter(
-            (m) => m.info.role === 'assistant',
-          )
-
-          if (assistantMessages.length === 0) {
-            return {
-              success: false,
-              error: 'No assistant messages found',
-            }
-          }
-
-          const lastMessage = assistantMessages[assistantMessages.length - 1]
-          const status =
-            'completed' in lastMessage!.info.time &&
-            lastMessage!.info.time.completed
-              ? 'completed'
-              : 'in_progress'
-
-          const markdownResult = await markdownRenderer.generate({
-            sessionID: sessionId,
-            lastAssistantOnly: true,
-          })
-          if (markdownResult instanceof Error) {
-            throw new Error(markdownResult.message)
-          }
-
-          return {
-            success: true,
-            markdown: markdownResult,
-            status,
-          }
-        } else {
-          const markdownResult = await markdownRenderer.generate({
-            sessionID: sessionId,
-          })
-          if (markdownResult instanceof Error) {
-            throw new Error(markdownResult.message)
-          }
-
-          const messages = await getClient().session.messages({
-            sessionID: sessionId,
-          })
-          const lastMessage = messages.data?.[messages.data.length - 1]
-          const status =
-            lastMessage?.info.role === 'assistant' &&
-            lastMessage?.info.time &&
-            'completed' in lastMessage.info.time &&
-            !lastMessage.info.time.completed
-              ? 'in_progress'
-              : 'completed'
-
-          return {
-            success: true,
-            markdown: markdownResult,
-            status,
-          }
-        }
-      },
-    }),
-
-    abortChat: tool({
-      description: 'Abort/stop an in-progress chat session',
-      inputSchema: z.object({
-        sessionId: z.string().describe('The session ID to abort'),
-      }),
-      execute: async ({ sessionId }) => {
-        try {
-          toolsLogger.log(
-            `[ABORT] reason=voice-tool sessionId=${sessionId} - user requested abort via voice assistant tool`,
-          )
-          const result = await getClient().session.abort({
-            sessionID: sessionId,
-          })
-
-          if (!result.data) {
-            return {
-              success: false,
-              error: 'Failed to abort session',
-            }
-          }
-
-          return {
-            success: true,
-            sessionId,
-            message: 'Session aborted successfully',
-          }
-        } catch (error) {
-          return {
-            success: false,
-            error:
-              error instanceof Error ? error.message : 'Unknown error occurred',
-          }
-        }
-      },
-    }),
-
-    getModels: tool({
-      description: 'Get all available AI models from all providers',
-      inputSchema: z.object({}),
-      execute: async () => {
-        try {
-          const providersResponse = await getClient().config.providers()
-          const providers: Provider[] = providersResponse.data?.providers || []
-
-          const models: Array<{ providerId: string; modelId: string }> = []
-
-          providers.forEach((provider) => {
-            if (provider.models && typeof provider.models === 'object') {
-              Object.entries(provider.models).forEach(([modelId, model]) => {
-                models.push({
-                  providerId: provider.id,
-                  modelId: modelId,
-                })
-              })
-            }
-          })
-
-          return {
-            success: true,
-            models,
-            totalCount: models.length,
-          }
-        } catch (error) {
-          return {
-            success: false,
-            error:
-              error instanceof Error ? error.message : 'Failed to fetch models',
-            models: [],
-          }
-        }
-      },
-    }),
-  }
-
-  return {
-    tools,
-    providers,
-  }
-}

package/src/undici.d.ts

@@ -1,12 +0,0 @@
-// Minimal type declarations for undici (transitive dep from discord.js).
-// We don't list undici in package.json — discord.js bundles it.
-declare module 'undici' {
-  export class Agent {
-    constructor(opts?: {
-      headersTimeout?: number
-      bodyTimeout?: number
-      connections?: number
-    })
-  }
-  export function setGlobalDispatcher(dispatcher: Agent): void
-}

package/src/undo-redo.e2e.test.ts

@@ -1,219 +0,0 @@
-// E2e test for /undo command.
-// Validates that:
-// 1. After /undo, session.revert state is set (files reverted, revert boundary marked)
-// 2. Messages are NOT deleted yet (they stay until next prompt cleans them up)
-// 3. On the next user message, reverted messages are cleaned up by OpenCode's
-//    SessionRevert.cleanup() and the model only sees pre-revert messages
-//
-// This matches the OpenCode TUI behavior (use-session-commands.tsx):
-// - Pass the user message ID (not assistant ID)
-// - Don't delete messages — just mark session as reverted
-// - Cleanup happens automatically on next promptAsync()
-//
-// Uses opencode-deterministic-provider (no real LLM calls).
-// Poll timeouts: 4s max, 100ms interval.
-
-import { describe, test, expect } from 'vitest'
-import fs from 'node:fs'
-import path from 'node:path'
-import {
-  setupQueueAdvancedSuite,
-  TEST_USER_ID,
-} from './queue-advanced-e2e-setup.js'
-import {
-  waitForBotMessageContaining,
-  waitForFooterMessage,
-} from './test-utils.js'
-import { getThreadSession } from './database.js'
-import { initializeOpencodeForDirectory } from './opencode.js'
-
-const TEXT_CHANNEL_ID = '200000000000003205'
-
-const e2eTest = describe
-
-e2eTest('/undo sets revert state and cleans up on next prompt', () => {
-  const ctx = setupQueueAdvancedSuite({
-    channelId: TEXT_CHANNEL_ID,
-    channelName: 'qa-undo-e2e',
-    dirName: 'qa-undo-e2e',
-    username: 'undo-tester',
-  })
-
-  test(
-    'undo sets revert state, next message cleans up reverted messages',
-    async () => {
-      const markerPath = path.join(
-        ctx.directories.projectDirectory,
-        'tmp',
-        'undo-marker.txt',
-      )
-
-      // 1. Send a message and wait for complete session (footer)
-      await ctx.discord
-        .channel(TEXT_CHANNEL_ID)
-        .user(TEST_USER_ID)
-        .sendMessage({
-          content: 'UNDO_FILE_MARKER',
-        })
-
-      const thread = await ctx.discord
-        .channel(TEXT_CHANNEL_ID)
-        .waitForThread({
-          timeout: 8_000,
-          predicate: (t) => {
-            return t.name === 'UNDO_FILE_MARKER'
-          },
-        })
-
-      const th = ctx.discord.thread(thread.id)
-      await waitForBotMessageContaining({
-        discord: ctx.discord,
-        threadId: thread.id,
-        userId: TEST_USER_ID,
-        text: 'creating undo file',
-        timeout: 8_000,
-      })
-
-      await waitForFooterMessage({
-        discord: ctx.discord,
-        threadId: thread.id,
-        timeout: 4_000,
-      })
-
-      // 2. Get session ID and verify it has messages
-      const sessionId = await getThreadSession(thread.id)
-      expect(sessionId).toBeTruthy()
-
-      const getClient = await initializeOpencodeForDirectory(
-        ctx.directories.projectDirectory,
-      )
-      if (getClient instanceof Error) {
-        throw getClient
-      }
-
-      const beforeMessages = await getClient().session.messages({
-        sessionID: sessionId!,
-        directory: ctx.directories.projectDirectory,
-      })
-      const beforeCount = (beforeMessages.data || []).length
-      expect(beforeCount).toBeGreaterThan(0)
-
-      const beforeUserMessages = (beforeMessages.data || []).filter((m) => {
-        return m.info.role === 'user'
-      })
-      const beforeAssistantMessages = (beforeMessages.data || []).filter(
-        (m) => {
-          return m.info.role === 'assistant'
-        },
-      )
-      expect(beforeUserMessages.length).toBeGreaterThan(0)
-      expect(beforeAssistantMessages.length).toBeGreaterThan(0)
-      expect(fs.existsSync(markerPath)).toBe(true)
-
-      // Verify no revert state yet
-      const beforeSession = await getClient().session.get({
-        sessionID: sessionId!,
-      })
-      expect(beforeSession.data?.revert).toBeFalsy()
-
-      // 3. Run /undo command
-      const { id: undoInteractionId } = await th
-        .user(TEST_USER_ID)
-        .runSlashCommand({ name: 'undo' })
-
-      const undoAck = await th.waitForInteractionAck({
-        interactionId: undoInteractionId,
-        timeout: 4_000,
-      })
-      expect(undoAck).toBeDefined()
-
-      await waitForBotMessageContaining({
-        discord: ctx.discord,
-        threadId: thread.id,
-        text: 'Undone - reverted last assistant message',
-        timeout: 8_000,
-      })
-      // 4. Verify session now has revert state set
-      const afterSession = await getClient().session.get({
-        sessionID: sessionId!,
-      })
-      expect(afterSession.data?.revert).toBeTruthy()
-      expect(afterSession.data?.revert?.messageID).toBeTruthy()
-
-      // Messages should still exist (not deleted — cleanup happens on next prompt)
-      const afterMessages = await getClient().session.messages({
-        sessionID: sessionId!,
-        directory: ctx.directories.projectDirectory,
-      })
-      expect((afterMessages.data || []).length).toBe(beforeCount)
-
-      // 5. Send a new message — this triggers SessionRevert.cleanup()
-      // which removes reverted messages before processing the new prompt
-      await th.user(TEST_USER_ID).sendMessage({
-        content: 'Reply with exactly: after-undo-message',
-      })
-
-      await waitForFooterMessage({
-        discord: ctx.discord,
-        threadId: thread.id,
-        timeout: 8_000,
-        afterMessageIncludes: 'after-undo-message',
-      })
-
-      // 6. Verify reverted messages were cleaned up
-      const finalMessages = await getClient().session.messages({
-        sessionID: sessionId!,
-        directory: ctx.directories.projectDirectory,
-      })
-      const finalAssistantMessages = (finalMessages.data || []).filter(
-        (m) => {
-          return m.info.role === 'assistant'
-        },
-      )
-
-      // The original assistant message should have been cleaned up,
-      // only the new one (from after-undo-message) should remain
-      const originalAssistantStillExists = finalAssistantMessages.some(
-        (m) => {
-          return m.parts.some((p) => {
-            return p.type === 'text' && p.text === 'ok'
-          })
-        },
-      )
-      // The first "ok" response was reverted and should be cleaned up.
-      // The new response for "after-undo-message" should produce a fresh "ok".
-      // We verify the total count dropped: the original user+assistant pair
-      // was removed, and replaced by just the new user+assistant pair.
-      expect(finalAssistantMessages.length).toBeLessThanOrEqual(
-        beforeAssistantMessages.length,
-      )
-
-      // Revert state should be cleared after cleanup
-      const finalSession = await getClient().session.get({
-        sessionID: sessionId!,
-      })
-      expect(finalSession.data?.revert).toBeFalsy()
-
-      // 7. Snapshot the Discord thread
-      expect(await th.text()).toMatchInlineSnapshot(`
-        "--- from: user (undo-tester)
-        UNDO_FILE_MARKER
-        --- from: assistant (TestBot)
-        -# *using deterministic-provider/deterministic-v2*
-        > creating undo file
-
-        -# ┣ bash _Create undo marker file_
-
-        undo file created
-        -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
-        Undone - reverted last assistant message
-        --- from: user (undo-tester)
-        Reply with exactly: after-undo-message
-        --- from: assistant (TestBot)
-        ok
-        -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
-      `)
-    },
-    20_000,
-  )
-})