kimaki 0.4.37 → 0.4.39

package/src/discord-bot.ts

@@ -53,6 +53,7 @@ import {
   type ThreadChannel,
 } from 'discord.js'
 import fs from 'node:fs'
+import * as errore from 'errore'
 import { extractTagsArrays } from './xml.js'
 import { createLogger } from './logger.js'
 import { setGlobalDispatcher, Agent } from 'undici'
@@ -149,10 +150,12 @@ export async function startDiscordBot({
       }
       if (message.partial) {
         discordLogger.log(`Fetching partial message ${message.id}`)
-        try {
-          await message.fetch()
-        } catch (error) {
-          discordLogger.log(`Failed to fetch partial message ${message.id}:`, error)
+        const fetched = await errore.tryAsync({
+          try: () => message.fetch(),
+          catch: (e) => e as Error,
+        })
+        if (errore.isError(fetched)) {
+          discordLogger.log(`Failed to fetch partial message ${message.id}:`, fetched.message)
           return
         }
       }
@@ -230,17 +233,11 @@ export async function startDiscordBot({
             return
           }
 
-          // Include starter message (notification) as context for the session
+          // Include starter message as context for the session
           let prompt = message.content
           const starterMessage = await thread.fetchStarterMessage().catch(() => null)
-          if (starterMessage?.content) {
-            // Strip notification prefix if present
-            const notificationContent = starterMessage.content
-              .replace(/^📢 \*\*Notification\*\*\n?/, '')
-              .trim()
-            if (notificationContent) {
-              prompt = `Context from notification:\n${notificationContent}\n\nUser request:\n${message.content}`
-            }
+          if (starterMessage?.content && starterMessage.content !== message.content) {
+            prompt = `Context from thread:\n${starterMessage.content}\n\nUser request:\n${message.content}`
           }
 
           await handleOpencodeSession({
@@ -262,30 +259,41 @@ export async function startDiscordBot({
         if (projectDirectory) {
           try {
             const getClient = await initializeOpencodeForDirectory(projectDirectory)
+            if (errore.isError(getClient)) {
+              voiceLogger.error(`[SESSION] Failed to initialize OpenCode client:`, getClient.message)
+              throw new Error(getClient.message)
+            }
             const client = getClient()
 
             // get current session context (without system prompt, it would be duplicated)
             if (row.session_id) {
-              currentSessionContext = await getCompactSessionContext({
+              const result = await getCompactSessionContext({
                 client,
                 sessionId: row.session_id,
                 includeSystemPrompt: false,
                 maxMessages: 15,
               })
+              if (errore.isOk(result)) {
+                currentSessionContext = result
+              }
             }
 
             // get last session context (with system prompt for project context)
-            const lastSessionId = await getLastSessionId({
+            const lastSessionResult = await getLastSessionId({
               client,
               excludeSessionId: row.session_id,
             })
+            const lastSessionId = errore.unwrapOr(lastSessionResult, null)
             if (lastSessionId) {
-              lastSessionContext = await getCompactSessionContext({
+              const result = await getCompactSessionContext({
                 client,
                 sessionId: lastSessionId,
                 includeSystemPrompt: true,
                 maxMessages: 10,
               })
+              if (errore.isOk(result)) {
+                lastSessionContext = result
+              }
             }
           } catch (e) {
             voiceLogger.error(`Could not get session context:`, e)
@@ -419,42 +427,42 @@ export async function startDiscordBot({
     }
   })
 
-  // Magic prefix used by `kimaki send` CLI command to initiate sessions
-  const BOT_SESSION_PREFIX = '🤖 **Bot-initiated session**'
-
-  // Handle bot-initiated threads created by `kimaki send`
+  // Handle bot-initiated threads created by `kimaki send` (without --notify-only)
   discordClient.on(Events.ThreadCreate, async (thread, newlyCreated) => {
     try {
       if (!newlyCreated) {
         return
       }
 
+      // Check if this thread is marked for auto-start in the database
+      const db = getDatabase()
+      const pendingRow = db
+        .prepare('SELECT thread_id FROM pending_auto_start WHERE thread_id = ?')
+        .get(thread.id) as { thread_id: string } | undefined
+
+      if (!pendingRow) {
+        return // Not a CLI-initiated auto-start thread
+      }
+
+      // Remove from pending table
+      db.prepare('DELETE FROM pending_auto_start WHERE thread_id = ?').run(thread.id)
+
+      discordLogger.log(`[BOT_SESSION] Detected bot-initiated thread: ${thread.name}`)
+
       // Only handle threads in text channels
       const parent = thread.parent as TextChannel | null
       if (!parent || parent.type !== ChannelType.GuildText) {
         return
       }
 
-      // Get the starter message to check for magic prefix
+      // Get the starter message for the prompt
       const starterMessage = await thread.fetchStarterMessage().catch(() => null)
       if (!starterMessage) {
         discordLogger.log(`[THREAD_CREATE] Could not fetch starter message for thread ${thread.id}`)
         return
       }
 
-      // Only handle messages from this bot with the magic prefix
-      if (starterMessage.author.id !== discordClient.user?.id) {
-        return
-      }
-
-      if (!starterMessage.content.startsWith(BOT_SESSION_PREFIX)) {
-        return
-      }
-
-      discordLogger.log(`[BOT_SESSION] Detected bot-initiated thread: ${thread.name}`)
-
-      // Extract the prompt (everything after the prefix)
-      const prompt = starterMessage.content.slice(BOT_SESSION_PREFIX.length).trim()
+      const prompt = starterMessage.content.trim()
       if (!prompt) {
         discordLogger.log(`[BOT_SESSION] No prompt found in starter message`)
         return

package/src/errors.ts

@@ -0,0 +1,208 @@
+// TaggedError definitions for type-safe error handling with errore.
+// Errors are grouped by category: infrastructure, domain, and validation.
+// Use errore.matchError() for exhaustive error handling in command handlers.
+
+import * as errore from 'errore'
+
+// ═══════════════════════════════════════════════════════════════════════════
+// INFRASTRUCTURE ERRORS - Server, filesystem, external services
+// ═══════════════════════════════════════════════════════════════════════════
+
+export class DirectoryNotAccessibleError extends errore.TaggedError('DirectoryNotAccessibleError')<{
+  directory: string
+  message: string
+}>() {
+  constructor(args: { directory: string }) {
+    super({ ...args, message: `Directory does not exist or is not accessible: ${args.directory}` })
+  }
+}
+
+export class ServerStartError extends errore.TaggedError('ServerStartError')<{
+  port: number
+  reason: string
+  message: string
+}>() {
+  constructor(args: { port: number; reason: string }) {
+    super({ ...args, message: `Server failed to start on port ${args.port}: ${args.reason}` })
+  }
+}
+
+export class ServerNotFoundError extends errore.TaggedError('ServerNotFoundError')<{
+  directory: string
+  message: string
+}>() {
+  constructor(args: { directory: string }) {
+    super({ ...args, message: `OpenCode server not found for directory: ${args.directory}` })
+  }
+}
+
+export class ServerNotReadyError extends errore.TaggedError('ServerNotReadyError')<{
+  directory: string
+  message: string
+}>() {
+  constructor(args: { directory: string }) {
+    super({
+      ...args,
+      message: `OpenCode server for directory "${args.directory}" is in an error state (no client available)`,
+    })
+  }
+}
+
+export class ApiKeyMissingError extends errore.TaggedError('ApiKeyMissingError')<{
+  service: string
+  message: string
+}>() {
+  constructor(args: { service: string }) {
+    super({ ...args, message: `${args.service} API key is required` })
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// DOMAIN ERRORS - Sessions, messages, transcription
+// ═══════════════════════════════════════════════════════════════════════════
+
+export class SessionNotFoundError extends errore.TaggedError('SessionNotFoundError')<{
+  sessionId: string
+  message: string
+}>() {
+  constructor(args: { sessionId: string }) {
+    super({ ...args, message: `Session ${args.sessionId} not found` })
+  }
+}
+
+export class SessionCreateError extends errore.TaggedError('SessionCreateError')<{
+  message: string
+  cause?: unknown
+}>() {}
+
+export class MessagesNotFoundError extends errore.TaggedError('MessagesNotFoundError')<{
+  sessionId: string
+  message: string
+}>() {
+  constructor(args: { sessionId: string }) {
+    super({ ...args, message: `No messages found for session ${args.sessionId}` })
+  }
+}
+
+export class TranscriptionError extends errore.TaggedError('TranscriptionError')<{
+  reason: string
+  message: string
+  cause?: unknown
+}>() {
+  constructor(args: { reason: string; cause?: unknown }) {
+    super({ ...args, message: `Transcription failed: ${args.reason}` })
+  }
+}
+
+export class GrepSearchError extends errore.TaggedError('GrepSearchError')<{
+  pattern: string
+  message: string
+  cause?: unknown
+}>() {
+  constructor(args: { pattern: string; cause?: unknown }) {
+    super({ ...args, message: `Grep search failed for pattern: ${args.pattern}` })
+  }
+}
+
+export class GlobSearchError extends errore.TaggedError('GlobSearchError')<{
+  pattern: string
+  message: string
+  cause?: unknown
+}>() {
+  constructor(args: { pattern: string; cause?: unknown }) {
+    super({ ...args, message: `Glob search failed for pattern: ${args.pattern}` })
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// VALIDATION ERRORS - Input validation, format checks
+// ═══════════════════════════════════════════════════════════════════════════
+
+export class InvalidAudioFormatError extends errore.TaggedError('InvalidAudioFormatError')<{
+  message: string
+}>() {
+  constructor() {
+    super({ message: 'Invalid audio format' })
+  }
+}
+
+export class EmptyTranscriptionError extends errore.TaggedError('EmptyTranscriptionError')<{
+  message: string
+}>() {
+  constructor() {
+    super({ message: 'Model returned empty transcription' })
+  }
+}
+
+export class NoResponseContentError extends errore.TaggedError('NoResponseContentError')<{
+  message: string
+}>() {
+  constructor() {
+    super({ message: 'No response content from model' })
+  }
+}
+
+export class NoToolResponseError extends errore.TaggedError('NoToolResponseError')<{
+  message: string
+}>() {
+  constructor() {
+    super({ message: 'No valid tool responses' })
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// NETWORK ERRORS - Fetch and HTTP
+// ═══════════════════════════════════════════════════════════════════════════
+
+export class FetchError extends errore.TaggedError('FetchError')<{
+  url: string
+  message: string
+  cause?: unknown
+}>() {
+  constructor(args: { url: string; cause?: unknown }) {
+    const causeMsg = args.cause instanceof Error ? args.cause.message : String(args.cause)
+    super({ ...args, message: `Fetch failed for ${args.url}: ${causeMsg}` })
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// API ERRORS - External service responses
+// ═══════════════════════════════════════════════════════════════════════════
+
+export class DiscordApiError extends errore.TaggedError('DiscordApiError')<{
+  status: number
+  message: string
+}>() {
+  constructor(args: { status: number; body?: string }) {
+    super({ ...args, message: `Discord API error: ${args.status}${args.body ? ` - ${args.body}` : ''}` })
+  }
+}
+
+export class OpenCodeApiError extends errore.TaggedError('OpenCodeApiError')<{
+  status: number
+  message: string
+}>() {
+  constructor(args: { status: number; body?: string }) {
+    super({ ...args, message: `OpenCode API error (${args.status})${args.body ? `: ${args.body}` : ''}` })
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// UNION TYPES - For function signatures
+// ═══════════════════════════════════════════════════════════════════════════
+
+export type TranscriptionErrors =
+  | ApiKeyMissingError
+  | InvalidAudioFormatError
+  | TranscriptionError
+  | EmptyTranscriptionError
+  | NoResponseContentError
+  | NoToolResponseError
+
+export type OpenCodeErrors =
+  | DirectoryNotAccessibleError
+  | ServerStartError
+  | ServerNotFoundError
+  | ServerNotReadyError
+
+export type SessionErrors = SessionNotFoundError | MessagesNotFoundError | OpenCodeApiError

package/src/genai-worker.ts

@@ -4,13 +4,14 @@
 
 import { parentPort, threadId } from 'node:worker_threads'
 import { createWriteStream, type WriteStream } from 'node:fs'
-import { mkdir } from 'node:fs/promises'
 import path from 'node:path'
+import * as errore from 'errore'
 import { Resampler } from '@purinton/resampler'
 import * as prism from 'prism-media'
 import { startGenAiSession } from './genai.js'
 import type { Session } from '@google/genai'
 import { getTools } from './tools.js'
+import { mkdir } from 'node:fs/promises'
 import type { WorkerInMessage, WorkerOutMessage } from './worker-types.js'
 import { createLogger } from './logger.js'
 
@@ -127,26 +128,28 @@ async function createAssistantAudioLogStream(
   const timestamp = new Date().toISOString().replace(/[:.]/g, '-')
   const audioDir = path.join(process.cwd(), 'discord-audio-logs', guildId, channelId)
 
-  try {
-    await mkdir(audioDir, { recursive: true })
+  const mkdirError = await errore.tryAsync({
+    try: () => mkdir(audioDir, { recursive: true }),
+    catch: (e) => e as Error,
+  })
+  if (errore.isError(mkdirError)) {
+    workerLogger.error(`Failed to create audio log directory:`, mkdirError.message)
+    return null
+  }
 
-    // Create stream for assistant audio (24kHz mono s16le PCM)
-    const outputFileName = `assistant_${timestamp}.24.pcm`
-    const outputFilePath = path.join(audioDir, outputFileName)
-    const outputAudioStream = createWriteStream(outputFilePath)
+  // Create stream for assistant audio (24kHz mono s16le PCM)
+  const outputFileName = `assistant_${timestamp}.24.pcm`
+  const outputFilePath = path.join(audioDir, outputFileName)
+  const outputAudioStream = createWriteStream(outputFilePath)
 
-    // Add error handler to prevent crashes
-    outputAudioStream.on('error', (error) => {
-      workerLogger.error(`Assistant audio log stream error:`, error)
-    })
+  // Add error handler to prevent crashes
+  outputAudioStream.on('error', (error) => {
+    workerLogger.error(`Assistant audio log stream error:`, error)
+  })
 
-    workerLogger.log(`Created assistant audio log: ${outputFilePath}`)
+  workerLogger.log(`Created assistant audio log: ${outputFilePath}`)
 
-    return outputAudioStream
-  } catch (error) {
-    workerLogger.error(`Failed to create audio log directory:`, error)
-    return null
-  }
+  return outputAudioStream
 }
 
 // Handle encoded Opus packets

package/src/interaction-handler.ts

@@ -20,7 +20,7 @@ import {
   handleProviderSelectMenu,
   handleModelSelectMenu,
 } from './commands/model.js'
-import { handleAgentCommand, handleAgentSelectMenu } from './commands/agent.js'
+import { handleAgentCommand, handleAgentSelectMenu, handleQuickAgentCommand } from './commands/agent.js'
 import { handleAskQuestionSelectMenu } from './commands/ask-question.js'
 import { handleQueueCommand, handleClearQueueCommand } from './commands/queue.js'
 import { handleUndoCommand, handleRedoCommand } from './commands/undo-redo.js'
@@ -136,6 +136,12 @@ export function registerInteractionHandler({
             return
         }
 
+        // Handle quick agent commands (ending with -agent suffix, but not the base /agent command)
+        if (interaction.commandName.endsWith('-agent') && interaction.commandName !== 'agent') {
+          await handleQuickAgentCommand({ command: interaction, appId })
+          return
+        }
+
         // Handle user-defined commands (ending with -cmd suffix)
         if (interaction.commandName.endsWith('-cmd')) {
           await handleUserCommand({ command: interaction, appId })

package/src/markdown.test.ts

@@ -1,6 +1,7 @@
 import { test, expect, beforeAll, afterAll } from 'vitest'
 import { spawn, type ChildProcess } from 'child_process'
 import { OpencodeClient } from '@opencode-ai/sdk'
+import * as errore from 'errore'
 import { ShareMarkdown, getCompactSessionContext } from './markdown.js'
 
 let serverProcess: ChildProcess
@@ -121,11 +122,14 @@ test('generate markdown from first available session', async () => {
   const exporter = new ShareMarkdown(client)
 
   // Generate markdown with system info
-  const markdown = await exporter.generate({
+  const markdownResult = await exporter.generate({
     sessionID,
     includeSystemInfo: true,
   })
 
+  expect(errore.isOk(markdownResult)).toBe(true)
+  const markdown = errore.unwrap(markdownResult)
+
   console.log(`Generated markdown length: ${markdown.length} characters`)
 
   // Basic assertions
@@ -299,13 +303,16 @@ test('generate markdown from multiple sessions', async () => {
 test.skipIf(process.env.CI)('getCompactSessionContext generates compact format', async () => {
   const sessionId = 'ses_46c2205e8ffeOll1JUSuYChSAM'
 
-  const context = await getCompactSessionContext({
+  const contextResult = await getCompactSessionContext({
     client,
     sessionId,
     includeSystemPrompt: true,
     maxMessages: 15,
   })
 
+  expect(errore.isOk(contextResult)).toBe(true)
+  const context = errore.unwrap(contextResult)
+
   console.log(`Generated compact context length: ${context.length} characters`)
 
   expect(context).toBeTruthy()
@@ -319,13 +326,16 @@ test.skipIf(process.env.CI)('getCompactSessionContext generates compact format',
 test.skipIf(process.env.CI)('getCompactSessionContext without system prompt', async () => {
   const sessionId = 'ses_46c2205e8ffeOll1JUSuYChSAM'
 
-  const context = await getCompactSessionContext({
+  const contextResult = await getCompactSessionContext({
     client,
     sessionId,
     includeSystemPrompt: false,
     maxMessages: 10,
   })
 
+  expect(errore.isOk(contextResult)).toBe(true)
+  const context = errore.unwrap(contextResult)
+
   console.log(`Generated compact context (no system) length: ${context.length} characters`)
 
   expect(context).toBeTruthy()