kimaki 0.4.24 → 0.4.26

package/src/logger.ts

@@ -1,16 +1,57 @@
+// Prefixed logging utility using @clack/prompts.
+// Creates loggers with consistent prefixes for different subsystems
+// (DISCORD, VOICE, SESSION, etc.) for easier debugging.
+
 import { log } from '@clack/prompts'
+import fs from 'node:fs'
+import path, { dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+const isDev = !__dirname.includes('node_modules')
+
+const logFilePath = path.join(__dirname, '..', 'tmp', 'kimaki.log')
+
+// reset log file on startup in dev mode
+if (isDev) {
+  const logDir = path.dirname(logFilePath)
+  if (!fs.existsSync(logDir)) {
+    fs.mkdirSync(logDir, { recursive: true })
+  }
+  fs.writeFileSync(logFilePath, `--- kimaki log started at ${new Date().toISOString()} ---\n`)
+}
+
+function writeToFile(level: string, prefix: string, args: any[]) {
+  if (!isDev) {
+    return
+  }
+  const timestamp = new Date().toISOString()
+  const message = `[${timestamp}] [${level}] [${prefix}] ${args.map((arg) => String(arg)).join(' ')}\n`
+  fs.appendFileSync(logFilePath, message)
+}
 
 export function createLogger(prefix: string) {
   return {
-    log: (...args: any[]) =>
-      log.info([`[${prefix}]`, ...args.map((arg) => String(arg))].join(' ')),
-    error: (...args: any[]) =>
-      log.error([`[${prefix}]`, ...args.map((arg) => String(arg))].join(' ')),
-    warn: (...args: any[]) =>
-      log.warn([`[${prefix}]`, ...args.map((arg) => String(arg))].join(' ')),
-    info: (...args: any[]) =>
-      log.info([`[${prefix}]`, ...args.map((arg) => String(arg))].join(' ')),
-    debug: (...args: any[]) =>
-      log.info([`[${prefix}]`, ...args.map((arg) => String(arg))].join(' ')),
+    log: (...args: any[]) => {
+      writeToFile('INFO', prefix, args)
+      log.info([`[${prefix}]`, ...args.map((arg) => String(arg))].join(' '))
+    },
+    error: (...args: any[]) => {
+      writeToFile('ERROR', prefix, args)
+      log.error([`[${prefix}]`, ...args.map((arg) => String(arg))].join(' '))
+    },
+    warn: (...args: any[]) => {
+      writeToFile('WARN', prefix, args)
+      log.warn([`[${prefix}]`, ...args.map((arg) => String(arg))].join(' '))
+    },
+    info: (...args: any[]) => {
+      writeToFile('INFO', prefix, args)
+      log.info([`[${prefix}]`, ...args.map((arg) => String(arg))].join(' '))
+    },
+    debug: (...args: any[]) => {
+      writeToFile('DEBUG', prefix, args)
+      log.info([`[${prefix}]`, ...args.map((arg) => String(arg))].join(' '))
+    },
   }
 }

package/src/markdown.test.ts

@@ -1,7 +1,7 @@
 import { test, expect, beforeAll, afterAll } from 'vitest'
 import { spawn, type ChildProcess } from 'child_process'
 import { OpencodeClient } from '@opencode-ai/sdk'
-import { ShareMarkdown } from './markdown.js'
+import { ShareMarkdown, getCompactSessionContext } from './markdown.js'
 
 let serverProcess: ChildProcess
 let client: OpencodeClient
@@ -312,3 +312,47 @@ test('generate markdown from multiple sessions', async () => {
     }
   }
 })
+
+// test for getCompactSessionContext - disabled in CI since it requires a specific session
+test.skipIf(process.env.CI)('getCompactSessionContext generates compact format', async () => {
+  const sessionId = 'ses_46c2205e8ffeOll1JUSuYChSAM'
+
+  const context = await getCompactSessionContext({
+    client,
+    sessionId,
+    includeSystemPrompt: true,
+    maxMessages: 15,
+  })
+
+  console.log(`Generated compact context length: ${context.length} characters`)
+
+  expect(context).toBeTruthy()
+  expect(context.length).toBeGreaterThan(0)
+  // should have tool calls or messages
+  expect(context).toMatch(/\[Tool \w+\]:|\[User\]:|\[Assistant\]:/)
+
+  await expect(context).toMatchFileSnapshot(
+    './__snapshots__/compact-session-context.md',
+  )
+})
+
+test.skipIf(process.env.CI)('getCompactSessionContext without system prompt', async () => {
+  const sessionId = 'ses_46c2205e8ffeOll1JUSuYChSAM'
+
+  const context = await getCompactSessionContext({
+    client,
+    sessionId,
+    includeSystemPrompt: false,
+    maxMessages: 10,
+  })
+
+  console.log(`Generated compact context (no system) length: ${context.length} characters`)
+
+  expect(context).toBeTruthy()
+  // should NOT have system prompt
+  expect(context).not.toContain('[System Prompt]')
+
+  await expect(context).toMatchFileSnapshot(
+    './__snapshots__/compact-session-context-no-system.md',
+  )
+})

package/src/markdown.ts

@@ -1,7 +1,14 @@
+// Session-to-markdown renderer for sharing.
+// Generates shareable markdown from OpenCode sessions, formatting
+// user messages, assistant responses, tool calls, and reasoning blocks.
+
 import type { OpencodeClient } from '@opencode-ai/sdk'
 import * as yaml from 'js-yaml'
 import { formatDateTime } from './utils.js'
 import { extractNonXmlContent } from './xml.js'
+import { createLogger } from './logger.js'
+
+const markdownLogger = createLogger('MARKDOWN')
 
 export class ShareMarkdown {
   constructor(private client: OpencodeClient) {}
@@ -227,3 +234,132 @@ export class ShareMarkdown {
     return `${minutes}m ${seconds}s`
   }
 }
+
+/**
+ * Generate compact session context for voice transcription.
+ * Includes system prompt (optional), user messages, assistant text,
+ * and tool calls in compact form (name + params only, no output).
+ */
+export async function getCompactSessionContext({
+  client,
+  sessionId,
+  includeSystemPrompt = false,
+  maxMessages = 20,
+}: {
+  client: OpencodeClient
+  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)')
+          }
+          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
+            }
+            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 ''
+  }
+}
+
+/**
+ * Get the last session for a directory (excluding the current one).
+ */
+export async 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
+  }
+}

package/src/message-formatting.test.ts

@@ -0,0 +1,81 @@
+import { describe, test, expect } from 'vitest'
+import { formatTodoList } from './message-formatting.js'
+import type { Part } from '@opencode-ai/sdk'
+
+describe('formatTodoList', () => {
+  test('formats active todo with monospace numbers', () => {
+    const part: Part = {
+      id: 'test',
+      type: 'tool',
+      tool: 'todowrite',
+      sessionID: 'ses_test',
+      messageID: 'msg_test',
+      callID: 'call_test',
+      state: {
+        status: 'completed',
+        input: {
+          todos: [
+            { content: 'First task', status: 'completed' },
+            { content: 'Second task', status: 'in_progress' },
+            { content: 'Third task', status: 'pending' },
+          ],
+        },
+        output: '',
+        title: 'todowrite',
+        metadata: {},
+        time: { start: 0, end: 0 },
+      },
+    }
+
+    expect(formatTodoList(part)).toMatchInlineSnapshot(`"⑵ **second task**"`)
+  })
+
+  test('formats double digit todo numbers', () => {
+    const todos = Array.from({ length: 12 }, (_, i) => ({
+      content: `Task ${i + 1}`,
+      status: i === 11 ? 'in_progress' : 'completed',
+    }))
+
+    const part: Part = {
+      id: 'test',
+      type: 'tool',
+      tool: 'todowrite',
+      sessionID: 'ses_test',
+      messageID: 'msg_test',
+      callID: 'call_test',
+      state: {
+        status: 'completed',
+        input: { todos },
+        output: '',
+        title: 'todowrite',
+        metadata: {},
+        time: { start: 0, end: 0 },
+      },
+    }
+
+    expect(formatTodoList(part)).toMatchInlineSnapshot(`"⑿ **task 12**"`)
+  })
+
+  test('lowercases first letter of content', () => {
+    const part: Part = {
+      id: 'test',
+      type: 'tool',
+      tool: 'todowrite',
+      sessionID: 'ses_test',
+      messageID: 'msg_test',
+      callID: 'call_test',
+      state: {
+        status: 'completed',
+        input: {
+          todos: [{ content: 'Fix the bug', status: 'in_progress' }],
+        },
+        output: '',
+        title: 'todowrite',
+        metadata: {},
+        time: { start: 0, end: 0 },
+      },
+    }
+
+    expect(formatTodoList(part)).toMatchInlineSnapshot(`"⑴ **fix the bug**"`)
+  })
+})

package/src/message-formatting.ts

@@ -1,9 +1,64 @@
-import type { Part, FilePartInput } from '@opencode-ai/sdk'
+// OpenCode message part formatting for Discord.
+// Converts SDK message parts (text, tools, reasoning) to Discord-friendly format,
+// handles file attachments, and provides tool summary generation.
+
+import type { Part } from '@opencode-ai/sdk/v2'
+import type { FilePartInput } from '@opencode-ai/sdk'
 import type { Message } from 'discord.js'
+import fs from 'node:fs'
+import path from 'node:path'
 import { createLogger } from './logger.js'
 
+// Generic message type compatible with both v1 and v2 SDK
+type GenericSessionMessage = {
+  info: { role: string; id?: string }
+  parts: Part[]
+}
+
+const ATTACHMENTS_DIR = path.join(process.cwd(), 'tmp', 'discord-attachments')
+
 const logger = createLogger('FORMATTING')
 
+/**
+ * Escapes Discord inline markdown characters so dynamic content
+ * doesn't break formatting when wrapped in *, _, **, etc.
+ */
+function escapeInlineMarkdown(text: string): string {
+  return text.replace(/([*_~|`\\])/g, '\\$1')
+}
+
+/**
+ * Collects and formats the last N assistant parts from session messages.
+ * Used by both /resume and /fork to show recent assistant context.
+ */
+export function collectLastAssistantParts({
+  messages,
+  limit = 30,
+}: {
+  messages: GenericSessionMessage[]
+  limit?: number
+}): { partIds: string[]; content: string; skippedCount: number } {
+  const allAssistantParts: { id: string; content: string }[] = []
+
+  for (const message of messages) {
+    if (message.info.role === 'assistant') {
+      for (const part of message.parts) {
+        const content = formatPart(part)
+        if (content.trim()) {
+          allAssistantParts.push({ id: part.id, content: content.trimEnd() })
+        }
+      }
+    }
+  }
+
+  const partsToRender = allAssistantParts.slice(-limit)
+  const partIds = partsToRender.map((p) => p.id)
+  const content = partsToRender.map((p) => p.content).join('\n')
+  const skippedCount = allAssistantParts.length - partsToRender.length
+
+  return { partIds, content, skippedCount }
+}
+
 export const TEXT_MIME_TYPES = [
   'text/',
   'application/json',
@@ -49,7 +104,7 @@ export async function getTextAttachments(message: Message): Promise<string> {
   return textContents.join('\n\n')
 }
 
-export function getFileAttachments(message: Message): FilePartInput[] {
+export async function getFileAttachments(message: Message): Promise<FilePartInput[]> {
   const fileAttachments = Array.from(message.attachments.values()).filter(
     (attachment) => {
       const contentType = attachment.contentType || ''
@@ -59,12 +114,44 @@ export function getFileAttachments(message: Message): FilePartInput[] {
     },
   )
 
-  return fileAttachments.map((attachment) => ({
-    type: 'file' as const,
-    mime: attachment.contentType || 'application/octet-stream',
-    filename: attachment.name,
-    url: attachment.url,
-  }))
+  if (fileAttachments.length === 0) {
+    return []
+  }
+
+  // ensure tmp directory exists
+  if (!fs.existsSync(ATTACHMENTS_DIR)) {
+    fs.mkdirSync(ATTACHMENTS_DIR, { recursive: true })
+  }
+
+  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 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}`)
+
+        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 results.filter((r) => r !== null) as FilePartInput[]
 }
 
 export function getToolSummaryText(part: Part): string {
@@ -77,7 +164,7 @@ export function getToolSummaryText(part: Part): string {
     const added = newString.split('\n').length
     const removed = oldString.split('\n').length
     const fileName = filePath.split('/').pop() || ''
-    return fileName ? `*${fileName}* (+${added}-${removed})` : `(+${added}-${removed})`
+    return fileName ? `*${escapeInlineMarkdown(fileName)}* (+${added}-${removed})` : `(+${added}-${removed})`
   }
 
   if (part.tool === 'write') {
@@ -85,35 +172,35 @@ export function getToolSummaryText(part: Part): string {
     const content = (part.state.input?.content as string) || ''
     const lines = content.split('\n').length
     const fileName = filePath.split('/').pop() || ''
-    return fileName ? `*${fileName}* (${lines} line${lines === 1 ? '' : 's'})` : `(${lines} line${lines === 1 ? '' : 's'})`
+    return fileName ? `*${escapeInlineMarkdown(fileName)}* (${lines} line${lines === 1 ? '' : 's'})` : `(${lines} line${lines === 1 ? '' : 's'})`
   }
 
   if (part.tool === 'webfetch') {
     const url = (part.state.input?.url as string) || ''
     const urlWithoutProtocol = url.replace(/^https?:\/\//, '')
-    return urlWithoutProtocol ? `*${urlWithoutProtocol}*` : ''
+    return urlWithoutProtocol ? `*${escapeInlineMarkdown(urlWithoutProtocol)}*` : ''
   }
 
   if (part.tool === 'read') {
     const filePath = (part.state.input?.filePath as string) || ''
     const fileName = filePath.split('/').pop() || ''
-    return fileName ? `*${fileName}*` : ''
+    return fileName ? `*${escapeInlineMarkdown(fileName)}*` : ''
   }
 
   if (part.tool === 'list') {
     const path = (part.state.input?.path as string) || ''
     const dirName = path.split('/').pop() || path
-    return dirName ? `*${dirName}*` : ''
+    return dirName ? `*${escapeInlineMarkdown(dirName)}*` : ''
   }
 
   if (part.tool === 'glob') {
     const pattern = (part.state.input?.pattern as string) || ''
-    return pattern ? `*${pattern}*` : ''
+    return pattern ? `*${escapeInlineMarkdown(pattern)}*` : ''
   }
 
   if (part.tool === 'grep') {
     const pattern = (part.state.input?.pattern as string) || ''
-    return pattern ? `*${pattern}*` : ''
+    return pattern ? `*${escapeInlineMarkdown(pattern)}*` : ''
   }
 
   if (part.tool === 'bash' || part.tool === 'todoread' || part.tool === 'todowrite') {
@@ -122,12 +209,12 @@ export function getToolSummaryText(part: Part): string {
 
   if (part.tool === 'task') {
     const description = (part.state.input?.description as string) || ''
-    return description ? `_${description}_` : ''
+    return description ? `_${escapeInlineMarkdown(description)}_` : ''
   }
 
   if (part.tool === 'skill') {
     const name = (part.state.input?.name as string) || ''
-    return name ? `_${name}_` : ''
+    return name ? `_${escapeInlineMarkdown(name)}_` : ''
   }
 
   if (!part.state.input) return ''
@@ -136,7 +223,7 @@ export function getToolSummaryText(part: Part): string {
     .map(([key, value]) => {
       if (value === null || value === undefined) return null
       const stringValue = typeof value === 'string' ? value : JSON.stringify(value)
-      const truncatedValue = stringValue.length > 300 ? stringValue.slice(0, 300) + '…' : stringValue
+      const truncatedValue = stringValue.length > 50 ? stringValue.slice(0, 50) + '…' : stringValue
       return `${key}: ${truncatedValue}`
     })
     .filter(Boolean)
@@ -158,17 +245,31 @@ export function formatTodoList(part: Part): string {
   })
   const activeTodo = todos[activeIndex]
   if (activeIndex === -1 || !activeTodo) return ''
-  return `${activeIndex + 1}. **${activeTodo.content}**`
+  // parenthesized digits ⑴-⒇ for 1-20, fallback to regular number for 21+
+  const parenthesizedDigits = '⑴⑵⑶⑷⑸⑹⑺⑻⑼⑽⑾⑿⒀⒁⒂⒃⒄⒅⒆⒇'
+  const todoNumber = activeIndex + 1
+  const num = todoNumber <= 20 ? parenthesizedDigits[todoNumber - 1] : `(${todoNumber})`
+  const content = activeTodo.content.charAt(0).toLowerCase() + activeTodo.content.slice(1)
+  return `${num} **${escapeInlineMarkdown(content)}**`
 }
 
 export function formatPart(part: Part): string {
   if (part.type === 'text') {
-    return part.text || ''
+    if (!part.text?.trim()) return ''
+    const trimmed = part.text.trimStart()
+    const firstChar = trimmed[0] || ''
+    const markdownStarters = ['#', '*', '_', '-', '>', '`', '[', '|']
+    const startsWithMarkdown =
+      markdownStarters.includes(firstChar) || /^\d+\./.test(trimmed)
+    if (startsWithMarkdown) {
+      return `\n${part.text}`
+    }
+    return `⬥ ${part.text}`
   }
 
   if (part.type === 'reasoning') {
     if (!part.text?.trim()) return ''
-    return `◼︎ thinking`
+    return `┣ thinking`
   }
 
   if (part.type === 'file') {
@@ -180,11 +281,11 @@ export function formatPart(part: Part): string {
   }
 
   if (part.type === 'agent') {
-    return `◼︎ agent ${part.id}`
+    return `┣ agent ${part.id}`
   }
 
   if (part.type === 'snapshot') {
-    return `◼︎ snapshot ${part.snapshot}`
+    return `┣ snapshot ${part.snapshot}`
   }
 
   if (part.type === 'tool') {
@@ -192,6 +293,11 @@ export function formatPart(part: Part): string {
       return formatTodoList(part)
     }
 
+    // Question tool is handled via Discord dropdowns, not text
+    if (part.tool === 'question') {
+      return ''
+    }
+
     if (part.state.status === 'pending') {
       return ''
     }
@@ -206,19 +312,26 @@ export function formatPart(part: Part): string {
       const command = (part.state.input?.command as string) || ''
       const description = (part.state.input?.description as string) || ''
       const isSingleLine = !command.includes('\n')
-      const hasUnderscores = command.includes('_')
-      if (isSingleLine && !hasUnderscores && command.length <= 50) {
-        toolTitle = `_${command}_`
+      if (isSingleLine && command.length <= 50) {
+        toolTitle = `_${escapeInlineMarkdown(command)}_`
       } else if (description) {
-        toolTitle = `_${description}_`
+        toolTitle = `_${escapeInlineMarkdown(description)}_`
       } else if (stateTitle) {
-        toolTitle = `_${stateTitle}_`
+        toolTitle = `_${escapeInlineMarkdown(stateTitle)}_`
       }
     } else if (stateTitle) {
-      toolTitle = `_${stateTitle}_`
+      toolTitle = `_${escapeInlineMarkdown(stateTitle)}_`
     }
 
-    const icon = part.state.status === 'error' ? '⨯' : '◼︎'
+    const icon = (() => {
+      if (part.state.status === 'error') {
+        return '⨯'
+      }
+      if (part.tool === 'edit' || part.tool === 'write') {
+        return '◼︎'
+      }
+      return '┣'
+    })()
     return `${icon} ${part.tool} ${toolTitle} ${summaryText}`
   }