shuvmaki 0.4.26

package/src/system-message.ts

@@ -0,0 +1,62 @@
+// OpenCode system prompt generator.
+// Creates the system message injected into every OpenCode session,
+// including Discord-specific formatting rules, diff commands, and permissions info.
+
+export function getOpencodeSystemMessage({ sessionId }: { sessionId: string }) {
+  return `
+The user is reading your messages from inside Discord, via kimaki.xyz
+
+The user cannot see bash tool outputs. If there is important information in bash output, include it in your text response.
+
+Your current OpenCode session ID is: ${sessionId}
+
+## permissions
+
+Only users with these Discord permissions can send messages to the bot:
+- Server Owner
+- Administrator permission
+- Manage Server permission
+- "Kimaki" role (case-insensitive)
+
+## uploading files to discord
+
+To upload files to the Discord thread (images, screenshots, long files that would clutter the chat), run:
+
+npx -y kimaki upload-to-discord --session ${sessionId} <file1> [file2] ...
+
+## showing diffs
+
+IMPORTANT: After editing any files, you MUST execute the critique command using the Bash tool to get a diff URL, then share that URL with the user.
+
+Execute this after making changes:
+
+bunx critique web
+
+If there are other unrelated changes in the working directory, filter to only show the files you edited:
+
+bunx critique web -- path/to/file1.ts path/to/file2.ts
+
+You can also show latest commit changes using:
+
+bunx critique web HEAD
+
+bunx critique web HEAD~1 to get the one before last
+
+Do this in case you committed the changes yourself (only if the user asks so, never commit otherwise).
+
+The command outputs a URL - share that URL with the user so they can see the diff.
+
+## markdown
+
+discord does support basic markdown features like code blocks, code blocks languages, inline code, bold, italic, quotes, etc.
+
+the max heading level is 3, so do not use ####
+
+headings are discouraged anyway. instead try to use bold text for titles which renders more nicely in Discord
+
+
+## diagrams
+
+you can create diagrams wrapping them in code blocks.
+`
+}

package/src/tools.ts

@@ -0,0 +1,428 @@
+// 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'
+import { z } from 'zod'
+import { spawn, type ChildProcess } from 'node:child_process'
+import net from 'node:net'
+import {
+  createOpencodeClient,
+  type OpencodeClient,
+  type AssistantMessage,
+  type Provider,
+} from '@opencode-ai/sdk'
+import { createLogger } from './logger.js'
+
+const toolsLogger = createLogger('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)
+  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({ path: { id: 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 as AssistantMessage
+        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.prompt({
+            path: { id: sessionId },
+            body: {
+              parts: [{ type: 'text', text: message }],
+              model: sessionModel,
+              system: getOpencodeSystemMessage({ sessionId }),
+            },
+          })
+          .then(async (response) => {
+            const markdown = await markdownRenderer.generate({
+              sessionID: sessionId,
+              lastAssistantOnly: true,
+            })
+            onMessageCompleted?.({
+              sessionId,
+              messageId: '',
+              data: response.data,
+              markdown,
+            })
+          })
+          .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({
+            body: {
+              title: title || message.slice(0, 50),
+            },
+          })
+
+          if (!session.data) {
+            throw new Error('Failed to create session')
+          }
+
+          // do not await
+          getClient()
+            .session.prompt({
+              path: { id: session.data.id },
+              body: {
+                parts: [{ type: 'text', text: message }],
+                system: getOpencodeSystemMessage({ sessionId: session.data.id }),
+              },
+            })
+            .then(async (response) => {
+              const markdown = await markdownRenderer.generate({
+                sessionID: session.data.id,
+                lastAssistantOnly: true,
+              })
+              onMessageCompleted?.({
+                sessionId: session.data.id,
+                messageId: '',
+                data: response.data,
+                markdown,
+              })
+            })
+            .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({
+              path: { id: 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: {
+            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({
+            path: { id: 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 markdown = await markdownRenderer.generate({
+            sessionID: sessionId,
+            lastAssistantOnly: true,
+          })
+
+          return {
+            success: true,
+            markdown,
+            status,
+          }
+        } else {
+          const markdown = await markdownRenderer.generate({
+            sessionID: sessionId,
+          })
+
+          const messages = await getClient().session.messages({
+            path: { id: 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,
+            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 {
+          const result = await getClient().session.abort({
+            path: { id: 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/utils.ts

@@ -0,0 +1,118 @@
+// General utility functions for the bot.
+// Includes Discord OAuth URL generation, array deduplication,
+// abort error detection, and date/time formatting helpers.
+
+import { PermissionsBitField } from 'discord.js'
+
+type GenerateInstallUrlOptions = {
+  clientId: string
+  permissions?: bigint[]
+  scopes?: string[]
+  guildId?: string
+  disableGuildSelect?: boolean
+}
+
+export function generateBotInstallUrl({
+  clientId,
+  permissions = [
+    PermissionsBitField.Flags.ViewChannel,
+    PermissionsBitField.Flags.ManageChannels,
+    PermissionsBitField.Flags.SendMessages,
+    PermissionsBitField.Flags.SendMessagesInThreads,
+    PermissionsBitField.Flags.CreatePublicThreads,
+    PermissionsBitField.Flags.ManageThreads,
+    PermissionsBitField.Flags.ReadMessageHistory,
+    PermissionsBitField.Flags.AddReactions,
+    PermissionsBitField.Flags.ManageMessages,
+    PermissionsBitField.Flags.UseExternalEmojis,
+    PermissionsBitField.Flags.AttachFiles,
+    PermissionsBitField.Flags.Connect,
+    PermissionsBitField.Flags.Speak,
+  ],
+  scopes = ['bot'],
+  guildId,
+  disableGuildSelect = false,
+}: GenerateInstallUrlOptions): string {
+  const permissionsBitField = new PermissionsBitField(permissions)
+  const permissionsValue = permissionsBitField.bitfield.toString()
+
+  const url = new URL('https://discord.com/api/oauth2/authorize')
+  url.searchParams.set('client_id', clientId)
+  url.searchParams.set('permissions', permissionsValue)
+  url.searchParams.set('scope', scopes.join(' '))
+
+  if (guildId) {
+    url.searchParams.set('guild_id', guildId)
+  }
+
+  if (disableGuildSelect) {
+    url.searchParams.set('disable_guild_select', 'true')
+  }
+
+  return url.toString()
+}
+
+export function deduplicateByKey<T, K>(arr: T[], keyFn: (item: T) => K): T[] {
+  const seen = new Set<K>()
+  return arr.filter((item) => {
+    const key = keyFn(item)
+    if (seen.has(key)) {
+      return false
+    }
+    seen.add(key)
+    return true
+  })
+}
+
+export function isAbortError(
+  error: unknown,
+  signal?: AbortSignal,
+): error is Error {
+  return (
+    (error instanceof Error &&
+      (error.name === 'AbortError' ||
+        error.name === 'Aborterror' ||
+        error.name === 'aborterror' ||
+        error.name.toLowerCase() === 'aborterror' ||
+        error.message?.includes('aborted') ||
+        (signal?.aborted ?? false))) ||
+    (error instanceof DOMException && error.name === 'AbortError')
+  )
+}
+
+const rtf = new Intl.RelativeTimeFormat('en', { numeric: 'auto' })
+
+const TIME_DIVISIONS: Array<{ amount: number; name: Intl.RelativeTimeFormatUnit }> = [
+  { amount: 60, name: 'seconds' },
+  { amount: 60, name: 'minutes' },
+  { amount: 24, name: 'hours' },
+  { amount: 7, name: 'days' },
+  { amount: 4.34524, name: 'weeks' },
+  { amount: 12, name: 'months' },
+  { amount: Number.POSITIVE_INFINITY, name: 'years' },
+]
+
+export function formatDistanceToNow(date: Date): string {
+  let duration = (date.getTime() - Date.now()) / 1000
+
+  for (const division of TIME_DIVISIONS) {
+    if (Math.abs(duration) < division.amount) {
+      return rtf.format(Math.round(duration), division.name)
+    }
+    duration /= division.amount
+  }
+  return rtf.format(Math.round(duration), 'years')
+}
+
+const dtf = new Intl.DateTimeFormat('en-US', {
+  month: 'short',
+  day: 'numeric',
+  year: 'numeric',
+  hour: 'numeric',
+  minute: '2-digit',
+  hour12: true,
+})
+
+export function formatDateTime(date: Date): string {
+  return dtf.format(date)
+}