kimaki 0.4.38 → 0.4.40

package/src/markdown.ts

@@ -1,12 +1,22 @@
 // Session-to-markdown renderer for sharing.
 // Generates shareable markdown from OpenCode sessions, formatting
 // user messages, assistant responses, tool calls, and reasoning blocks.
+// Uses errore for type-safe error handling.
 
 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'
 import { createLogger } from './logger.js'
+import { SessionNotFoundError, MessagesNotFoundError } from './errors.js'
+
+// Generic error for unexpected exceptions in async operations
+class UnexpectedError extends createTaggedError({
+  name: 'UnexpectedError',
+  message: '$message',
+}) {}
 
 const markdownLogger = createLogger('MARKDOWN')
 
@@ -16,13 +26,13 @@ export class ShareMarkdown {
   /**
    * Generate a markdown representation of a session
    * @param options Configuration options
-   * @returns Markdown string representation of the session
+   * @returns Error or markdown string
    */
   async generate(options: {
     sessionID: string
     includeSystemInfo?: boolean
     lastAssistantOnly?: boolean
-  }): Promise<string> {
+  }): Promise<SessionNotFoundError | MessagesNotFoundError | string> {
     const { sessionID, includeSystemInfo, lastAssistantOnly } = options
 
     // Get session info
@@ -30,7 +40,7 @@ export class ShareMarkdown {
       path: { id: sessionID },
     })
     if (!sessionResponse.data) {
-      throw new Error(`Session ${sessionID} not found`)
+      return new SessionNotFoundError({ sessionId: sessionID })
     }
     const session = sessionResponse.data
 
@@ -39,7 +49,7 @@ export class ShareMarkdown {
       path: { id: sessionID },
     })
     if (!messagesResponse.data) {
-      throw new Error(`No messages found for session ${sessionID}`)
+      return new MessagesNotFoundError({ sessionId: sessionID })
     }
     const messages = messagesResponse.data
 
@@ -234,7 +244,7 @@ export class ShareMarkdown {
  * Includes system prompt (optional), user messages, assistant text,
  * and tool calls in compact form (name + params only, no output).
  */
-export async function getCompactSessionContext({
+export function getCompactSessionContext({
   client,
   sessionId,
   includeSystemPrompt = false,
@@ -244,114 +254,121 @@ export async function getCompactSessionContext({
   sessionId: string
   includeSystemPrompt?: boolean
   maxMessages?: number
-}): Promise<string> {
-  try {
-    const messagesResponse = await client.session.messages({
-      path: { id: sessionId },
-    })
-    const messages = messagesResponse.data || []
-
-    const lines: string[] = []
-
-    // Get system prompt if requested
-    // Note: OpenCode SDK doesn't expose system prompt directly. We try multiple approaches:
-    // 1. session.system field (if available in future SDK versions)
-    // 2. synthetic text part in first assistant message (current approach)
-    if (includeSystemPrompt && messages.length > 0) {
-      const firstAssistant = messages.find((m) => m.info.role === 'assistant')
-      if (firstAssistant) {
-        // look for text part marked as synthetic (system prompt)
-        const systemPart = (firstAssistant.parts || []).find(
-          (p) => p.type === 'text' && (p as any).synthetic === true,
-        )
-        if (systemPart && 'text' in systemPart && systemPart.text) {
-          lines.push('[System Prompt]')
-          const truncated = systemPart.text.slice(0, 3000)
-          lines.push(truncated)
-          if (systemPart.text.length > 3000) {
-            lines.push('...(truncated)')
+}): Promise<UnexpectedError | string> {
+  return errore.tryAsync({
+    try: async () => {
+      const messagesResponse = await client.session.messages({
+        path: { id: sessionId },
+      })
+      const messages = messagesResponse.data || []
+
+      const lines: string[] = []
+
+      // Get system prompt if requested
+      // Note: OpenCode SDK doesn't expose system prompt directly. We try multiple approaches:
+      // 1. session.system field (if available in future SDK versions)
+      // 2. synthetic text part in first assistant message (current approach)
+      if (includeSystemPrompt && messages.length > 0) {
+        const firstAssistant = messages.find((m) => m.info.role === 'assistant')
+        if (firstAssistant) {
+          // look for text part marked as synthetic (system prompt)
+          const systemPart = (firstAssistant.parts || []).find(
+            (p) => p.type === 'text' && (p as any).synthetic === true,
+          )
+          if (systemPart && 'text' in systemPart && systemPart.text) {
+            lines.push('[System Prompt]')
+            const truncated = systemPart.text.slice(0, 3000)
+            lines.push(truncated)
+            if (systemPart.text.length > 3000) {
+              lines.push('...(truncated)')
+            }
+            lines.push('')
           }
-          lines.push('')
         }
       }
-    }
 
-    // Process recent messages
-    const recentMessages = messages.slice(-maxMessages)
-
-    for (const msg of recentMessages) {
-      if (msg.info.role === 'user') {
-        const textParts = (msg.parts || [])
-          .filter((p) => p.type === 'text' && 'text' in p)
-          .map((p) => ('text' in p ? extractNonXmlContent(p.text || '') : ''))
-          .filter(Boolean)
-        if (textParts.length > 0) {
-          lines.push(`[User]: ${textParts.join(' ').slice(0, 1000)}`)
-          lines.push('')
-        }
-      } else if (msg.info.role === 'assistant') {
-        // Get assistant text parts (non-synthetic, non-empty)
-        const textParts = (msg.parts || [])
-          .filter((p) => p.type === 'text' && 'text' in p && !p.synthetic && p.text)
-          .map((p) => ('text' in p ? p.text : ''))
-          .filter(Boolean)
-        if (textParts.length > 0) {
-          lines.push(`[Assistant]: ${textParts.join(' ').slice(0, 1000)}`)
-          lines.push('')
-        }
+      // Process recent messages
+      const recentMessages = messages.slice(-maxMessages)
+
+      for (const msg of recentMessages) {
+        if (msg.info.role === 'user') {
+          const textParts = (msg.parts || [])
+            .filter((p) => p.type === 'text' && 'text' in p)
+            .map((p) => ('text' in p ? extractNonXmlContent(p.text || '') : ''))
+            .filter(Boolean)
+          if (textParts.length > 0) {
+            lines.push(`[User]: ${textParts.join(' ').slice(0, 1000)}`)
+            lines.push('')
+          }
+        } else if (msg.info.role === 'assistant') {
+          // Get assistant text parts (non-synthetic, non-empty)
+          const textParts = (msg.parts || [])
+            .filter((p) => p.type === 'text' && 'text' in p && !p.synthetic && p.text)
+            .map((p) => ('text' in p ? p.text : ''))
+            .filter(Boolean)
+          if (textParts.length > 0) {
+            lines.push(`[Assistant]: ${textParts.join(' ').slice(0, 1000)}`)
+            lines.push('')
+          }
 
-        // Get tool calls in compact form (name + params only)
-        const toolParts = (msg.parts || []).filter(
-          (p) => p.type === 'tool' && 'state' in p && p.state?.status === 'completed',
-        )
-        for (const part of toolParts) {
-          if (part.type === 'tool' && 'tool' in part && 'state' in part) {
-            const toolName = part.tool
-            // skip noisy tools
-            if (toolName === 'todoread' || toolName === 'todowrite') {
-              continue
+          // Get tool calls in compact form (name + params only)
+          const toolParts = (msg.parts || []).filter(
+            (p) => p.type === 'tool' && 'state' in p && p.state?.status === 'completed',
+          )
+          for (const part of toolParts) {
+            if (part.type === 'tool' && 'tool' in part && 'state' in part) {
+              const toolName = part.tool
+              // skip noisy tools
+              if (toolName === 'todoread' || toolName === 'todowrite') {
+                continue
+              }
+              const input = part.state?.input || {}
+              const normalize = (value: string) => value.replace(/\s+/g, ' ').trim()
+              // compact params: just key=value on one line
+              const params = Object.entries(input)
+                .map(([k, v]) => {
+                  const val =
+                    typeof v === 'string' ? v.slice(0, 100) : JSON.stringify(v).slice(0, 100)
+                  return `${k}=${normalize(val)}`
+                })
+                .join(', ')
+              lines.push(`[Tool ${toolName}]: ${params}`)
             }
-            const input = part.state?.input || {}
-            // compact params: just key=value on one line
-            const params = Object.entries(input)
-              .map(([k, v]) => {
-                const val =
-                  typeof v === 'string' ? v.slice(0, 100) : JSON.stringify(v).slice(0, 100)
-                return `${k}=${val}`
-              })
-              .join(', ')
-            lines.push(`[Tool ${toolName}]: ${params}`)
           }
         }
       }
-    }
 
-    return lines.join('\n').slice(0, 8000)
-  } catch (e) {
-    markdownLogger.error('Failed to get compact session context:', e)
-    return ''
-  }
+      return lines.join('\n').slice(0, 8000)
+    },
+    catch: (e) => {
+      markdownLogger.error('Failed to get compact session context:', e)
+      return new UnexpectedError({ message: 'Failed to get compact session context', cause: e })
+    },
+  })
 }
 
 /**
  * Get the last session for a directory (excluding the current one).
  */
-export async function getLastSessionId({
+export function getLastSessionId({
   client,
   excludeSessionId,
 }: {
   client: OpencodeClient
   excludeSessionId?: string
-}): Promise<string | null> {
-  try {
-    const sessionsResponse = await client.session.list()
-    const sessions = sessionsResponse.data || []
-
-    // Sessions are sorted by time, get the most recent one that isn't the current
-    const lastSession = sessions.find((s) => s.id !== excludeSessionId)
-    return lastSession?.id || null
-  } catch (e) {
-    markdownLogger.error('Failed to get last session:', e)
-    return null
-  }
+}): Promise<UnexpectedError | (string | null)> {
+  return errore.tryAsync({
+    try: async () => {
+      const sessionsResponse = await client.session.list()
+      const sessions = sessionsResponse.data || []
+
+      // Sessions are sorted by time, get the most recent one that isn't the current
+      const lastSession = sessions.find((s) => s.id !== excludeSessionId)
+      return lastSession?.id || null
+    },
+    catch: (e) => {
+      markdownLogger.error('Failed to get last session:', e)
+      return new UnexpectedError({ message: 'Failed to get last session', cause: e })
+    },
+  })
 }

package/src/message-formatting.ts

@@ -7,7 +7,9 @@ import type { FilePartInput } from '@opencode-ai/sdk'
 import type { Message } from 'discord.js'
 import fs from 'node:fs'
 import path from 'node:path'
+import * as errore from 'errore'
 import { createLogger } from './logger.js'
+import { FetchError } from './errors.js'
 
 // Generic message type compatible with both v1 and v2 SDK
 type GenericSessionMessage = {
@@ -87,17 +89,18 @@ export async function getTextAttachments(message: Message): Promise<string> {
 
   const textContents = await Promise.all(
     textAttachments.map(async (attachment) => {
-      try {
-        const response = await fetch(attachment.url)
-        if (!response.ok) {
-          return `<attachment filename="${attachment.name}" error="Failed to fetch: ${response.status}" />`
-        }
-        const text = await response.text()
-        return `<attachment filename="${attachment.name}" mime="${attachment.contentType}">\n${text}\n</attachment>`
-      } catch (error) {
-        const errMsg = error instanceof Error ? error.message : String(error)
-        return `<attachment filename="${attachment.name}" error="${errMsg}" />`
+      const response = await errore.tryAsync({
+        try: () => fetch(attachment.url),
+        catch: (e) => new FetchError({ url: attachment.url, cause: e }),
+      })
+      if (response instanceof Error) {
+        return `<attachment filename="${attachment.name}" error="${response.message}" />`
+      }
+      if (!response.ok) {
+        return `<attachment filename="${attachment.name}" error="Failed to fetch: ${response.status}" />`
       }
+      const text = await response.text()
+      return `<attachment filename="${attachment.name}" mime="${attachment.contentType}">\n${text}\n</attachment>`
     }),
   )
 
@@ -121,28 +124,30 @@ export async function getFileAttachments(message: Message): Promise<FilePartInpu
 
   const results = await Promise.all(
     fileAttachments.map(async (attachment) => {
-      try {
-        const response = await fetch(attachment.url)
-        if (!response.ok) {
-          logger.error(`Failed to fetch attachment ${attachment.name}: ${response.status}`)
-          return null
-        }
+      const response = await errore.tryAsync({
+        try: () => fetch(attachment.url),
+        catch: (e) => new FetchError({ url: attachment.url, cause: e }),
+      })
+      if (response instanceof Error) {
+        logger.error(`Error downloading attachment ${attachment.name}:`, response.message)
+        return null
+      }
+      if (!response.ok) {
+        logger.error(`Failed to fetch attachment ${attachment.name}: ${response.status}`)
+        return null
+      }
 
-        const buffer = Buffer.from(await response.arrayBuffer())
-        const localPath = path.join(ATTACHMENTS_DIR, `${message.id}-${attachment.name}`)
-        fs.writeFileSync(localPath, buffer)
+      const buffer = Buffer.from(await response.arrayBuffer())
+      const localPath = path.join(ATTACHMENTS_DIR, `${message.id}-${attachment.name}`)
+      fs.writeFileSync(localPath, buffer)
 
-        logger.log(`Downloaded attachment to ${localPath}`)
+      logger.log(`Downloaded attachment to ${localPath}`)
 
-        return {
-          type: 'file' as const,
-          mime: attachment.contentType || 'application/octet-stream',
-          filename: attachment.name,
-          url: localPath,
-        }
-      } catch (error) {
-        logger.error(`Error downloading attachment ${attachment.name}:`, error)
-        return null
+      return {
+        type: 'file' as const,
+        mime: attachment.contentType || 'application/octet-stream',
+        filename: attachment.name,
+        url: localPath,
       }
     }),
   )
@@ -207,9 +212,9 @@ export function getToolSummaryText(part: Part): string {
     return ''
   }
 
+  // Task tool display is handled via subtask part in session-handler (shows label like explore-1)
   if (part.tool === 'task') {
-    const description = (part.state.input?.description as string) || ''
-    return description ? `_${escapeInlineMarkdown(description)}_` : ''
+    return ''
   }
 
   if (part.tool === 'skill') {
@@ -253,9 +258,15 @@ export function formatTodoList(part: Part): string {
   return `${num} **${escapeInlineMarkdown(content)}**`
 }
 
-export function formatPart(part: Part): string {
+export function formatPart(part: Part, prefix?: string): string {
+  const pfx = prefix ? `${prefix}: ` : ''
+
   if (part.type === 'text') {
     if (!part.text?.trim()) return ''
+    // For subtask text, always use bullet with prefix
+    if (prefix) {
+      return `⬥ ${pfx}${part.text.trim()}`
+    }
     const trimmed = part.text.trimStart()
     const firstChar = trimmed[0] || ''
     const markdownStarters = ['#', '*', '_', '-', '>', '`', '[', '|']
@@ -268,11 +279,11 @@ export function formatPart(part: Part): string {
 
   if (part.type === 'reasoning') {
     if (!part.text?.trim()) return ''
-    return `┣ thinking`
+    return `┣ ${pfx}thinking`
   }
 
   if (part.type === 'file') {
-    return `📄 ${part.filename || 'File'}`
+    return prefix ? `📄 ${pfx}${part.filename || 'File'}` : `📄 ${part.filename || 'File'}`
   }
 
   if (part.type === 'step-start' || part.type === 'step-finish' || part.type === 'patch') {
@@ -280,16 +291,17 @@ export function formatPart(part: Part): string {
   }
 
   if (part.type === 'agent') {
-    return `┣ agent ${part.id}`
+    return `┣ ${pfx}agent ${part.id}`
   }
 
   if (part.type === 'snapshot') {
-    return `┣ snapshot ${part.snapshot}`
+    return `┣ ${pfx}snapshot ${part.snapshot}`
   }
 
   if (part.type === 'tool') {
     if (part.tool === 'todowrite') {
-      return formatTodoList(part)
+      const formatted = formatTodoList(part)
+      return prefix && formatted ? `┣ ${pfx}${formatted}` : formatted
     }
 
     // Question tool is handled via Discord dropdowns, not text
@@ -297,6 +309,11 @@ export function formatPart(part: Part): string {
       return ''
     }
 
+    // Task tool display is handled in session-handler with proper label
+    if (part.tool === 'task') {
+      return ''
+    }
+
     if (part.state.status === 'pending') {
       return ''
     }
@@ -331,7 +348,7 @@ export function formatPart(part: Part): string {
       }
       return '┣'
     })()
-    return `${icon} ${part.tool} ${toolTitle} ${summaryText}`
+    return `${icon} ${pfx}${part.tool} ${toolTitle} ${summaryText}`.trim()
   }
 
   logger.warn('Unknown part type:', part)

package/src/opencode.ts

@@ -1,6 +1,7 @@
 // OpenCode server process manager.
 // Spawns and maintains OpenCode API servers per project directory,
 // handles automatic restarts on failure, and provides typed SDK clients.
+// Uses errore for type-safe error handling.
 
 import { spawn, type ChildProcess } from 'node:child_process'
 import fs from 'node:fs'
@@ -10,7 +11,15 @@ import {
   createOpencodeClient as createOpencodeClientV2,
   type OpencodeClient as OpencodeClientV2,
 } from '@opencode-ai/sdk/v2'
+import * as errore from 'errore'
 import { createLogger } from './logger.js'
+import {
+  DirectoryNotAccessibleError,
+  ServerStartError,
+  ServerNotReadyError,
+  FetchError,
+  type OpenCodeErrors,
+} from './errors.js'
 
 const opencodeLogger = createLogger('OPENCODE')
 
@@ -44,46 +53,39 @@ async function getOpenPort(): Promise<number> {
   })
 }
 
-async function waitForServer(port: number, maxAttempts = 30): Promise<boolean> {
+async function waitForServer(port: number, maxAttempts = 30): Promise<ServerStartError | true> {
   for (let i = 0; i < maxAttempts; i++) {
-    try {
-      const endpoints = [
-        `http://127.0.0.1:${port}/api/health`,
-        `http://127.0.0.1:${port}/`,
-        `http://127.0.0.1:${port}/api`,
-      ]
-
-      for (const endpoint of endpoints) {
-        try {
-          const response = await fetch(endpoint)
-          if (response.status < 500) {
-            return true
-          }
-          const body = await response.text()
-          // Fatal errors that won't resolve with retrying
-          if (body.includes('BunInstallFailedError')) {
-            throw new Error(`Server failed to start: ${body.slice(0, 200)}`)
-          }
-        } catch (e) {
-          // Re-throw fatal errors
-          if ((e as Error).message?.includes('Server failed to start')) {
-            throw e
-          }
-        }
+    const endpoints = [
+      `http://127.0.0.1:${port}/api/health`,
+      `http://127.0.0.1:${port}/`,
+      `http://127.0.0.1:${port}/api`,
+    ]
+
+    for (const endpoint of endpoints) {
+      const response = await errore.tryAsync({
+        try: () => fetch(endpoint),
+        catch: (e) => new FetchError({ url: endpoint, cause: e }),
+      })
+      if (response instanceof Error) {
+        // Connection refused or other transient errors - continue polling
+        opencodeLogger.debug(`Server polling attempt failed: ${response.message}`)
+        continue
+      }
+      if (response.status < 500) {
+        return true
       }
-    } catch (e) {
-      // Re-throw fatal errors that won't resolve with retrying
-      if ((e as Error).message?.includes('Server failed to start')) {
-        throw e
+      const body = await response.text()
+      // Fatal errors that won't resolve with retrying
+      if (body.includes('BunInstallFailedError')) {
+        return new ServerStartError({ port, reason: body.slice(0, 200) })
       }
-      opencodeLogger.debug(`Server polling attempt failed: ${(e as Error).message}`)
     }
     await new Promise((resolve) => setTimeout(resolve, 1000))
   }
-  throw new Error(`Server did not start on port ${port} after ${maxAttempts} seconds`)
+  return new ServerStartError({ port, reason: `Server did not start after ${maxAttempts} seconds` })
 }
 
-export async function initializeOpencodeForDirectory(directory: string) {
+export async function initializeOpencodeForDirectory(directory: string): Promise<OpenCodeErrors | (() => OpencodeClient)> {
   const existing = opencodeServers.get(directory)
   if (existing && !existing.process.killed) {
     opencodeLogger.log(
@@ -92,19 +94,21 @@ export async function initializeOpencodeForDirectory(directory: string) {
     return () => {
       const entry = opencodeServers.get(directory)
       if (!entry?.client) {
-        throw new Error(
-          `OpenCode server for directory "${directory}" is in an error state (no client available)`,
-        )
+        throw new ServerNotReadyError({ directory })
       }
       return entry.client
     }
   }
 
   // Verify directory exists and is accessible before spawning
-  try {
-    fs.accessSync(directory, fs.constants.R_OK | fs.constants.X_OK)
-  } catch {
-    throw new Error(`Directory does not exist or is not accessible: ${directory}`)
+  const accessCheck = errore.tryFn({
+    try: () => {
+      fs.accessSync(directory, fs.constants.R_OK | fs.constants.X_OK)
+    },
+    catch: () => new DirectoryNotAccessibleError({ directory }),
+  })
+  if (accessCheck instanceof Error) {
+    return accessCheck
   }
 
   const port = await getOpenPort()
@@ -159,8 +163,10 @@ export async function initializeOpencodeForDirectory(directory: string) {
         opencodeLogger.log(
           `Restarting server for directory: ${directory} (attempt ${retryCount + 1}/5)`,
         )
-        initializeOpencodeForDirectory(directory).catch((e) => {
-          opencodeLogger.error(`Failed to restart opencode server:`, e)
+        initializeOpencodeForDirectory(directory).then((result) => {
+          if (result instanceof Error) {
+            opencodeLogger.error(`Failed to restart opencode server:`, result)
+          }
         })
       } else {
         opencodeLogger.error(`Server for ${directory} crashed too many times (5), not restarting`)
@@ -170,17 +176,16 @@ export async function initializeOpencodeForDirectory(directory: string) {
     }
   })
 
-  try {
-    await waitForServer(port)
-    opencodeLogger.log(`Server ready on port ${port}`)
-  } catch (e) {
+  const waitResult = await waitForServer(port)
+  if (waitResult instanceof Error) {
     // Dump buffered logs on failure
     opencodeLogger.error(`Server failed to start for ${directory}:`)
     for (const line of logBuffer) {
       opencodeLogger.error(`  ${line}`)
     }
-    throw e
+    return waitResult
   }
+  opencodeLogger.log(`Server ready on port ${port}`)
 
   const baseUrl = `http://127.0.0.1:${port}`
   const fetchWithTimeout = (request: Request) =>
@@ -209,9 +214,7 @@ export async function initializeOpencodeForDirectory(directory: string) {
   return () => {
     const entry = opencodeServers.get(directory)
     if (!entry?.client) {
-      throw new Error(
-        `OpenCode server for directory "${directory}" is in an error state (no client available)`,
-      )
+      throw new ServerNotReadyError({ directory })
     }
     return entry.client
   }