kimaki 0.4.38 → 0.4.39

package/src/commands/remove-project.ts

@@ -1,6 +1,7 @@
 // /remove-project command - Remove Discord channels for a project.
 
 import path from 'node:path'
+import * as errore from 'errore'
 import type { CommandContext, AutocompleteContext } from './types.js'
 import { getDatabase } from '../database.js'
 import { createLogger } from '../logger.js'
@@ -36,19 +37,27 @@ export async function handleRemoveProjectCommand({ command, appId }: CommandCont
     const failedChannels: string[] = []
 
     for (const { channel_id, channel_type } of channels) {
-      try {
-        const channel = await guild.channels.fetch(channel_id).catch(() => null)
-
-        if (channel) {
+      const channel = await errore.tryAsync({
+        try: () => guild.channels.fetch(channel_id),
+        catch: (e) => e as Error,
+      })
+      
+      if (errore.isError(channel)) {
+        logger.error(`Failed to fetch channel ${channel_id}:`, channel)
+        failedChannels.push(`${channel_type}: ${channel_id}`)
+        continue
+      }
+      
+      if (channel) {
+        try {
           await channel.delete(`Removed by /remove-project command`)
           deletedChannels.push(`${channel_type}: ${channel_id}`)
-        } else {
-          // Channel doesn't exist in this guild or was already deleted
-          deletedChannels.push(`${channel_type}: ${channel_id} (already deleted)`)
+        } catch (error) {
+          logger.error(`Failed to delete channel ${channel_id}:`, error)
+          failedChannels.push(`${channel_type}: ${channel_id}`)
         }
-      } catch (error) {
-        logger.error(`Failed to delete channel ${channel_id}:`, error)
-        failedChannels.push(`${channel_type}: ${channel_id}`)
+      } else {
+        deletedChannels.push(`${channel_type}: ${channel_id} (already deleted)`)
       }
     }
 
@@ -103,13 +112,16 @@ export async function handleRemoveProjectAutocomplete({
     const projectsInGuild: { directory: string; channelId: string }[] = []
 
     for (const { directory, channel_id } of allChannels) {
-      try {
-        const channel = await guild.channels.fetch(channel_id).catch(() => null)
-        if (channel) {
-          projectsInGuild.push({ directory, channelId: channel_id })
-        }
-      } catch {
+      const channel = await errore.tryAsync({
+        try: () => guild.channels.fetch(channel_id),
+        catch: (e) => e as Error,
+      })
+      if (errore.isError(channel)) {
         // Channel not in this guild, skip
+        continue
+      }
+      if (channel) {
+        projectsInGuild.push({ directory, channelId: channel_id })
       }
     }
 

package/src/commands/resume.ts

@@ -14,6 +14,7 @@ import { sendThreadMessage, resolveTextChannel, getKimakiMetadata } from '../dis
 import { extractTagsArrays } from '../xml.js'
 import { collectLastAssistantParts } from '../message-formatting.js'
 import { createLogger } from '../logger.js'
+import * as errore from 'errore'
 
 const logger = createLogger('RESUME')
 
@@ -60,6 +61,10 @@ export async function handleResumeCommand({ command, appId }: CommandContext): P
 
   try {
     const getClient = await initializeOpencodeForDirectory(projectDirectory)
+    if (errore.isError(getClient)) {
+      await command.editReply(getClient.message)
+      return
+    }
 
     const sessionResponse = await getClient().session.get({
       path: { id: sessionId },
@@ -168,6 +173,10 @@ export async function handleResumeAutocomplete({
 
   try {
     const getClient = await initializeOpencodeForDirectory(projectDirectory)
+    if (errore.isError(getClient)) {
+      await interaction.respond([])
+      return
+    }
 
     const sessionsResponse = await getClient().session.list()
     if (!sessionsResponse.data) {

package/src/commands/session.ts

@@ -10,6 +10,7 @@ import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js'
 import { extractTagsArrays } from '../xml.js'
 import { handleOpencodeSession } from '../session-handler.js'
 import { createLogger } from '../logger.js'
+import * as errore from 'errore'
 
 const logger = createLogger('SESSION')
 
@@ -58,6 +59,10 @@ export async function handleSessionCommand({ command, appId }: CommandContext):
 
   try {
     const getClient = await initializeOpencodeForDirectory(projectDirectory)
+    if (errore.isError(getClient)) {
+      await command.editReply(getClient.message)
+      return
+    }
 
     const files = filesString
       .split(',')
@@ -128,6 +133,10 @@ async function handleAgentAutocomplete({ interaction, appId }: AutocompleteConte
 
   try {
     const getClient = await initializeOpencodeForDirectory(projectDirectory)
+    if (errore.isError(getClient)) {
+      await interaction.respond([])
+      return
+    }
 
     const agentsResponse = await getClient().app.agents({
       query: { directory: projectDirectory },
@@ -207,6 +216,10 @@ export async function handleSessionAutocomplete({
 
   try {
     const getClient = await initializeOpencodeForDirectory(projectDirectory)
+    if (errore.isError(getClient)) {
+      await interaction.respond([])
+      return
+    }
 
     const response = await getClient().find.files({
       query: {

package/src/commands/share.ts

@@ -6,6 +6,7 @@ import { getDatabase } from '../database.js'
 import { initializeOpencodeForDirectory } from '../opencode.js'
 import { resolveTextChannel, getKimakiMetadata, SILENT_MESSAGE_FLAGS } from '../discord-utils.js'
 import { createLogger } from '../logger.js'
+import * as errore from 'errore'
 
 const logger = createLogger('SHARE')
 
@@ -63,8 +64,17 @@ export async function handleShareCommand({ command }: CommandContext): Promise<v
 
   const sessionId = row.session_id
 
+  const getClient = await initializeOpencodeForDirectory(directory)
+  if (errore.isError(getClient)) {
+    await command.reply({
+      content: `Failed to share session: ${getClient.message}`,
+      ephemeral: true,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+    return
+  }
+
   try {
-    const getClient = await initializeOpencodeForDirectory(directory)
     const response = await getClient().session.share({
       path: { id: sessionId },
     })

package/src/commands/undo-redo.ts

@@ -6,6 +6,7 @@ import { getDatabase } from '../database.js'
 import { initializeOpencodeForDirectory } from '../opencode.js'
 import { resolveTextChannel, getKimakiMetadata, SILENT_MESSAGE_FLAGS } from '../discord-utils.js'
 import { createLogger } from '../logger.js'
+import * as errore from 'errore'
 
 const logger = createLogger('UNDO-REDO')
 
@@ -63,11 +64,15 @@ export async function handleUndoCommand({ command }: CommandContext): Promise<vo
 
   const sessionId = row.session_id
 
-  try {
-    await command.deferReply({ flags: SILENT_MESSAGE_FLAGS })
+  await command.deferReply({ flags: SILENT_MESSAGE_FLAGS })
 
-    const getClient = await initializeOpencodeForDirectory(directory)
+  const getClient = await initializeOpencodeForDirectory(directory)
+  if (errore.isError(getClient)) {
+    await command.editReply(`Failed to undo: ${getClient.message}`)
+    return
+  }
 
+  try {
     // Fetch messages to find the last assistant message
     const messagesResponse = await getClient().session.messages({
       path: { id: sessionId },
@@ -166,11 +171,15 @@ export async function handleRedoCommand({ command }: CommandContext): Promise<vo
 
   const sessionId = row.session_id
 
-  try {
-    await command.deferReply({ flags: SILENT_MESSAGE_FLAGS })
+  await command.deferReply({ flags: SILENT_MESSAGE_FLAGS })
 
-    const getClient = await initializeOpencodeForDirectory(directory)
+  const getClient = await initializeOpencodeForDirectory(directory)
+  if (errore.isError(getClient)) {
+    await command.editReply(`Failed to redo: ${getClient.message}`)
+    return
+  }
 
+  try {
     // Check if session has reverted state
     const sessionResponse = await getClient().session.get({
       path: { id: sessionId },

package/src/database.ts

@@ -5,6 +5,7 @@
 import Database from 'better-sqlite3'
 import fs from 'node:fs'
 import path from 'node:path'
+import * as errore from 'errore'
 import { createLogger } from './logger.js'
 import { getDataDir } from './config.js'
 
@@ -16,10 +17,14 @@ export function getDatabase(): Database.Database {
   if (!db) {
     const dataDir = getDataDir()
 
-    try {
-      fs.mkdirSync(dataDir, { recursive: true })
-    } catch (error) {
-      dbLogger.error(`Failed to create data directory ${dataDir}:`, error)
+    const mkdirError = errore.tryFn({
+      try: () => {
+        fs.mkdirSync(dataDir, { recursive: true })
+      },
+      catch: (e) => e as Error,
+    })
+    if (errore.isError(mkdirError)) {
+      dbLogger.error(`Failed to create data directory ${dataDir}:`, mkdirError.message)
     }
 
     const dbPath = path.join(dataDir, 'discord-sessions.db')

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
         }
       }
@@ -256,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)

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/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()