kimaki 0.4.39 → 0.4.41

package/src/errors.ts

@@ -2,190 +2,117 @@
 // Errors are grouped by category: infrastructure, domain, and validation.
 // Use errore.matchError() for exhaustive error handling in command handlers.
 
-import * as errore from 'errore'
+import { createTaggedError } 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` })
-  }
-}
+export class DirectoryNotAccessibleError extends createTaggedError({
+  name: 'DirectoryNotAccessibleError',
+  message: 'Directory does not exist or is not accessible: $directory',
+}) {}
+
+export class ServerStartError extends createTaggedError({
+  name: 'ServerStartError',
+  message: 'Server failed to start on port $port: $reason',
+}) {}
+
+export class ServerNotFoundError extends createTaggedError({
+  name: 'ServerNotFoundError',
+  message: 'OpenCode server not found for directory: $directory',
+}) {}
+
+export class ServerNotReadyError extends createTaggedError({
+  name: 'ServerNotReadyError',
+  message: 'OpenCode server for directory "$directory" is in an error state (no client available)',
+}) {}
+
+export class ApiKeyMissingError extends createTaggedError({
+  name: 'ApiKeyMissingError',
+  message: '$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}` })
-  }
-}
+export class SessionNotFoundError extends createTaggedError({
+  name: 'SessionNotFoundError',
+  message: 'Session $sessionId not found',
+}) {}
+
+export class SessionCreateError extends createTaggedError({
+  name: 'SessionCreateError',
+  message: '$message',
+}) {}
+
+export class MessagesNotFoundError extends createTaggedError({
+  name: 'MessagesNotFoundError',
+  message: 'No messages found for session $sessionId',
+}) {}
+
+export class TranscriptionError extends createTaggedError({
+  name: 'TranscriptionError',
+  message: 'Transcription failed: $reason',
+}) {}
+
+export class GrepSearchError extends createTaggedError({
+  name: 'GrepSearchError',
+  message: 'Grep search failed for pattern: $pattern',
+}) {}
+
+export class GlobSearchError extends createTaggedError({
+  name: 'GlobSearchError',
+  message: 'Glob search failed for pattern: $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' })
-  }
-}
+export class InvalidAudioFormatError extends createTaggedError({
+  name: 'InvalidAudioFormatError',
+  message: 'Invalid audio format',
+}) {}
+
+export class EmptyTranscriptionError extends createTaggedError({
+  name: 'EmptyTranscriptionError',
+  message: 'Model returned empty transcription',
+}) {}
+
+export class NoResponseContentError extends createTaggedError({
+  name: 'NoResponseContentError',
+  message: 'No response content from model',
+}) {}
+
+export class NoToolResponseError extends createTaggedError({
+  name: 'NoToolResponseError',
+  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}` })
-  }
-}
+export class FetchError extends createTaggedError({
+  name: 'FetchError',
+  message: 'Fetch failed for $url',
+}) {}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // 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}` : ''}` })
-  }
-}
+export class DiscordApiError extends createTaggedError({
+  name: 'DiscordApiError',
+  message: 'Discord API error: $status $body',
+}) {}
+
+export class OpenCodeApiError extends createTaggedError({
+  name: 'OpenCodeApiError',
+  message: 'OpenCode API error ($status): $body',
+}) {}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // UNION TYPES - For function signatures
@@ -205,4 +132,7 @@ export type OpenCodeErrors =
   | ServerNotFoundError
   | ServerNotReadyError
 
-export type SessionErrors = SessionNotFoundError | MessagesNotFoundError | OpenCodeApiError
+export type SessionErrors =
+  | SessionNotFoundError
+  | MessagesNotFoundError
+  | OpenCodeApiError

package/src/genai-worker.ts

@@ -132,7 +132,7 @@ async function createAssistantAudioLogStream(
     try: () => mkdir(audioDir, { recursive: true }),
     catch: (e) => e as Error,
   })
-  if (errore.isError(mkdirError)) {
+  if (mkdirError instanceof Error) {
     workerLogger.error(`Failed to create audio log directory:`, mkdirError.message)
     return null
   }

package/src/interaction-handler.ts

@@ -4,6 +4,7 @@
 
 import { Events, type Client, type Interaction } from 'discord.js'
 import { handleSessionCommand, handleSessionAutocomplete } from './commands/session.js'
+import { handleNewWorktreeCommand } from './commands/worktree.js'
 import { handleResumeCommand, handleResumeAutocomplete } from './commands/resume.js'
 import { handleAddProjectCommand, handleAddProjectAutocomplete } from './commands/add-project.js'
 import {
@@ -52,7 +53,7 @@ export function registerInteractionHandler({
 
       if (interaction.isAutocomplete()) {
         switch (interaction.commandName) {
-          case 'session':
+          case 'new-session':
             await handleSessionAutocomplete({ interaction, appId })
             return
 
@@ -78,10 +79,14 @@ export function registerInteractionHandler({
         interactionLogger.log(`[COMMAND] Processing: ${interaction.commandName}`)
 
         switch (interaction.commandName) {
-          case 'session':
+          case 'new-session':
             await handleSessionCommand({ command: interaction, appId })
             return
 
+          case 'new-worktree':
+            await handleNewWorktreeCommand({ command: interaction, appId })
+            return
+
           case 'resume':
             await handleResumeCommand({ command: interaction, appId })
             return

package/src/markdown.ts

@@ -5,6 +5,7 @@
 
 import type { OpencodeClient } from '@opencode-ai/sdk'
 import * as errore from 'errore'
+import { createTaggedError } from 'errore'
 import * as yaml from 'js-yaml'
 import { formatDateTime } from './utils.js'
 import { extractNonXmlContent } from './xml.js'
@@ -12,10 +13,10 @@ import { createLogger } from './logger.js'
 import { SessionNotFoundError, MessagesNotFoundError } from './errors.js'
 
 // Generic error for unexpected exceptions in async operations
-class UnexpectedError extends errore.TaggedError('UnexpectedError')<{
-  message: string
-  cause?: unknown
-}>() {}
+class UnexpectedError extends createTaggedError({
+  name: 'UnexpectedError',
+  message: '$message',
+}) {}
 
 const markdownLogger = createLogger('MARKDOWN')
 

package/src/message-formatting.ts

@@ -93,7 +93,7 @@ export async function getTextAttachments(message: Message): Promise<string> {
         try: () => fetch(attachment.url),
         catch: (e) => new FetchError({ url: attachment.url, cause: e }),
       })
-      if (errore.isError(response)) {
+      if (response instanceof Error) {
         return `<attachment filename="${attachment.name}" error="${response.message}" />`
       }
       if (!response.ok) {
@@ -128,7 +128,7 @@ export async function getFileAttachments(message: Message): Promise<FilePartInpu
         try: () => fetch(attachment.url),
         catch: (e) => new FetchError({ url: attachment.url, cause: e }),
       })
-      if (errore.isError(response)) {
+      if (response instanceof Error) {
         logger.error(`Error downloading attachment ${attachment.name}:`, response.message)
         return null
       }

package/src/opencode.ts

@@ -66,7 +66,7 @@ async function waitForServer(port: number, maxAttempts = 30): Promise<ServerStar
         try: () => fetch(endpoint),
         catch: (e) => new FetchError({ url: endpoint, cause: e }),
       })
-      if (errore.isError(response)) {
+      if (response instanceof Error) {
         // Connection refused or other transient errors - continue polling
         opencodeLogger.debug(`Server polling attempt failed: ${response.message}`)
         continue
@@ -107,7 +107,7 @@ export async function initializeOpencodeForDirectory(directory: string): Promise
     },
     catch: () => new DirectoryNotAccessibleError({ directory }),
   })
-  if (errore.isError(accessCheck)) {
+  if (accessCheck instanceof Error) {
     return accessCheck
   }
 
@@ -164,7 +164,7 @@ export async function initializeOpencodeForDirectory(directory: string): Promise
           `Restarting server for directory: ${directory} (attempt ${retryCount + 1}/5)`,
         )
         initializeOpencodeForDirectory(directory).then((result) => {
-          if (errore.isError(result)) {
+          if (result instanceof Error) {
             opencodeLogger.error(`Failed to restart opencode server:`, result)
           }
         })
@@ -177,7 +177,7 @@ export async function initializeOpencodeForDirectory(directory: string): Promise
   })
 
   const waitResult = await waitForServer(port)
-  if (errore.isError(waitResult)) {
+  if (waitResult instanceof Error) {
     // Dump buffered logs on failure
     opencodeLogger.error(`Server failed to start for ${directory}:`)
     for (const line of logBuffer) {

package/src/session-handler.ts

@@ -105,7 +105,7 @@ export async function abortAndRetrySession({
 
   // Also call the API abort endpoint
   const getClient = await initializeOpencodeForDirectory(projectDirectory)
-  if (errore.isError(getClient)) {
+  if (getClient instanceof Error) {
     sessionLogger.error(`[ABORT+RETRY] Failed to initialize OpenCode client:`, getClient.message)
     return false
   }
@@ -188,7 +188,7 @@ export async function handleOpencodeSession({
   sessionLogger.log(`Using directory: ${directory}`)
 
   const getClient = await initializeOpencodeForDirectory(directory)
-  if (errore.isError(getClient)) {
+  if (getClient instanceof Error) {
     await sendThreadMessage(thread, `✗ ${getClient.message}`)
     return
   }

package/src/tools.ts

@@ -36,7 +36,7 @@ export async function getTools({
   }) => void
 }) {
   const getClient = await initializeOpencodeForDirectory(directory)
-  if (errore.isError(getClient)) {
+  if (getClient instanceof Error) {
     throw new Error(getClient.message)
   }
   const client = getClient()
@@ -298,7 +298,7 @@ export async function getTools({
             sessionID: sessionId,
             lastAssistantOnly: true,
           })
-          if (errore.isError(markdownResult)) {
+          if (markdownResult instanceof Error) {
             throw new Error(markdownResult.message)
           }
 
@@ -311,7 +311,7 @@ export async function getTools({
           const markdownResult = await markdownRenderer.generate({
             sessionID: sessionId,
           })
-          if (errore.isError(markdownResult)) {
+          if (markdownResult instanceof Error) {
             throw new Error(markdownResult.message)
           }
 

package/src/voice-handler.ts

@@ -450,7 +450,7 @@ export async function processVoiceAttachment({
     try: () => fetch(audioAttachment.url),
     catch: (e) => new FetchError({ url: audioAttachment.url, cause: e }),
   })
-  if (errore.isError(audioResponse)) {
+  if (audioResponse instanceof Error) {
     voiceLogger.error(`Failed to download audio attachment:`, audioResponse.message)
     await sendThreadMessage(thread, `⚠️ Failed to download audio: ${audioResponse.message}`)
     return null
@@ -498,7 +498,7 @@ export async function processVoiceAttachment({
     lastSessionContext,
   })
 
-  if (errore.isError(transcription)) {
+  if (transcription instanceof Error) {
     const errMsg = errore.matchError(transcription, {
       ApiKeyMissingError: (e) => e.message,
       InvalidAudioFormatError: (e) => e.message,
@@ -532,7 +532,7 @@ export async function processVoiceAttachment({
       ])
       if (renamed === null) {
         voiceLogger.log(`Thread name update timed out`)
-      } else if (errore.isError(renamed)) {
+      } else if (renamed instanceof Error) {
         voiceLogger.log(`Could not update thread name:`, renamed.message)
       } else {
         voiceLogger.log(`Updated thread name to: "${threadName}"`)

package/src/voice.ts

@@ -145,7 +145,7 @@ function createToolRunner({ directory }: { directory?: string }): TranscriptionT
       voiceLogger.log(`Grep search: "${pattern}"`)
       const result = await runGrep({ pattern, directory })
       const output = (() => {
-        if (errore.isError(result)) {
+        if (result instanceof Error) {
           voiceLogger.error('grep search failed:', result)
           return 'grep search failed'
         }
@@ -160,7 +160,7 @@ function createToolRunner({ directory }: { directory?: string }): TranscriptionT
       voiceLogger.log(`Glob search: "${pattern}"`)
       const result = await runGlob({ pattern, directory })
       const output = (() => {
-        if (errore.isError(result)) {
+        if (result instanceof Error) {
           voiceLogger.error('glob search failed:', result)
           return 'glob search failed'
         }
@@ -214,7 +214,7 @@ export async function runTranscriptionLoop({
     catch: (e) => new TranscriptionError({ reason: `API call failed: ${String(e)}`, cause: e }),
   })
 
-  if (errore.isError(initialResponse)) {
+  if (initialResponse instanceof Error) {
     return initialResponse
   }
 
@@ -323,7 +323,7 @@ export async function runTranscriptionLoop({
       catch: (e) => new TranscriptionError({ reason: `API call failed: ${String(e)}`, cause: e }),
     })
 
-    if (errore.isError(nextResponse)) {
+    if (nextResponse instanceof Error) {
       return nextResponse
     }