kimaki 0.4.45 → 0.4.47

package/src/session-handler.ts

@@ -24,7 +24,7 @@ import {
 import { sendThreadMessage, NOTIFY_MESSAGE_FLAGS, SILENT_MESSAGE_FLAGS } from './discord-utils.js'
 import { formatPart } from './message-formatting.js'
 import { getOpencodeSystemMessage, type WorktreeInfo } from './system-message.js'
-import { createLogger } from './logger.js'
+import { createLogger, LogPrefix } from './logger.js'
 import { isAbortError } from './utils.js'
 import {
   showAskUserQuestionDropdowns,
@@ -38,9 +38,9 @@ import {
 } from './commands/permissions.js'
 import * as errore from 'errore'
 
-const sessionLogger = createLogger('SESSION')
-const voiceLogger = createLogger('VOICE')
-const discordLogger = createLogger('DISCORD')
+const sessionLogger = createLogger(LogPrefix.SESSION)
+const voiceLogger = createLogger(LogPrefix.VOICE)
+const discordLogger = createLogger(LogPrefix.DISCORD)
 
 export const abortControllers = new Map<string, AbortController>()
 
@@ -86,6 +86,8 @@ export type QueuedMessage = {
 // Key is threadId, value is array of queued messages
 export const messageQueue = new Map<string, QueuedMessage[]>()
 
+const activeEventHandlers = new Map<string, Promise<void>>()
+
 export function addToQueue({
   threadId,
   message,
@@ -132,7 +134,7 @@ export async function abortAndRetrySession({
   sessionLogger.log(`[ABORT+RETRY] Aborting session ${sessionId} for model change`)
 
   // Abort with special reason so we don't show "completed" message
-  controller.abort('model-change')
+  controller.abort(new Error('model-change'))
 
   // Also call the API abort endpoint
   const getClient = await initializeOpencodeForDirectory(projectDirectory)
@@ -301,6 +303,15 @@ export async function handleOpencodeSession({
   if (existingController) {
     voiceLogger.log(`[ABORT] Cancelling existing request for session: ${session.id}`)
     existingController.abort(new Error('New request started'))
+    const abortResult = await errore.tryAsync(() => {
+      return getClient().session.abort({
+        path: { id: session.id },
+        query: { directory: sdkDirectory },
+      })
+    })
+    if (abortResult instanceof Error) {
+      sessionLogger.log(`[ABORT] Server abort failed (may be already done):`, abortResult)
+    }
   }
 
   // Auto-reject ALL pending permissions for this thread
@@ -339,10 +350,10 @@ export async function handleOpencodeSession({
     }
   }
 
-  // Cancel any pending question tool if user sends a new message (silently, no thread message)
-  const questionCancelled = await cancelPendingQuestion(thread.id)
-  if (questionCancelled) {
-    sessionLogger.log(`[QUESTION] Cancelled pending question due to new message`)
+  // Answer any pending question tool with the user's message (silently, no thread message)
+  const questionAnswered = await cancelPendingQuestion(thread.id, prompt)
+  if (questionAnswered) {
+    sessionLogger.log(`[QUESTION] Answered pending question with user message`)
   }
 
   const abortController = new AbortController()
@@ -363,6 +374,17 @@ export async function handleOpencodeSession({
     return
   }
 
+  const previousHandler = activeEventHandlers.get(thread.id)
+  if (previousHandler) {
+    sessionLogger.log(`[EVENT] Waiting for previous handler to finish`)
+    await Promise.race([
+      previousHandler,
+      new Promise((resolve) => {
+        setTimeout(resolve, 1000)
+      }),
+    ])
+  }
+
   // Use v2 client for event subscription (has proper types for question.asked events)
   const clientV2 = getOpencodeClientV2(directory)
   if (!clientV2) {
@@ -396,8 +418,10 @@ export async function handleOpencodeSession({
   let usedAgent: string | undefined
   let tokensUsedInSession = 0
   let lastDisplayedContextPercentage = 0
+  let lastRateLimitDisplayTime = 0
   let modelContextLimit: number | undefined
   let assistantMessageId: string | undefined
+  let handlerPromise: Promise<void> | null = null
 
   let typingInterval: NodeJS.Timeout | null = null
 
@@ -726,6 +750,10 @@ export async function handleOpencodeSession({
       part: Part,
       subtaskInfo: { label: string; assistantMessageId?: string },
     ) => {
+      // In text-only mode, skip all subtask output (they're tool-related)
+      if (verbosity === 'text-only') {
+        return
+      }
       if (part.type === 'step-start' || part.type === 'step-finish') {
         return
       }
@@ -984,10 +1012,53 @@ export async function handleOpencodeSession({
       })
     }
 
+    const handleSessionStatus = async (properties: {
+      sessionID: string
+      status: { type: 'idle' } | { type: 'retry'; attempt: number; message: string; next: number } | { type: 'busy' }
+    }) => {
+      if (properties.sessionID !== session.id) {
+        return
+      }
+      if (properties.status.type !== 'retry') {
+        return
+      }
+      // Throttle to once per 10 seconds
+      const now = Date.now()
+      if (now - lastRateLimitDisplayTime < 10_000) {
+        return
+      }
+      lastRateLimitDisplayTime = now
+
+      const { attempt, message, next } = properties.status
+      const remainingMs = Math.max(0, next - now)
+      const remainingSec = Math.ceil(remainingMs / 1000)
+
+      const duration = (() => {
+        if (remainingSec < 60) {
+          return `${remainingSec}s`
+        }
+        const mins = Math.floor(remainingSec / 60)
+        const secs = remainingSec % 60
+        return secs > 0 ? `${mins}m ${secs}s` : `${mins}m`
+      })()
+
+      const chunk = `⬦ ${message} - retrying in ${duration} (attempt #${attempt})`
+      await thread.send({ content: chunk, flags: SILENT_MESSAGE_FLAGS })
+    }
+
     const handleSessionIdle = (idleSessionId: string) => {
       if (idleSessionId === session.id) {
+        // Ignore stale session.idle events - if we haven't received any content yet
+        // (no assistantMessageId set), this is likely a stale event from before
+        // the prompt was sent or from a previous request's subscription state.
+        if (!assistantMessageId) {
+          sessionLogger.log(
+            `[SESSION IDLE] Ignoring stale idle event for ${session.id} (no content received yet)`,
+          )
+          return
+        }
         sessionLogger.log(`[SESSION IDLE] Session ${session.id} is idle, aborting`)
-        abortController.abort('finished')
+        abortController.abort(new Error('finished'))
         return
       }
 
@@ -1024,6 +1095,9 @@ export async function handleOpencodeSession({
           case 'session.idle':
             handleSessionIdle(event.properties.sessionID)
             break
+          case 'session.status':
+            await handleSessionStatus(event.properties)
+            break
           default:
             break
         }
@@ -1052,7 +1126,8 @@ export async function handleOpencodeSession({
         stopTyping = null
       }
 
-      if (!abortController.signal.aborted || abortController.signal.reason === 'finished') {
+      const abortReason = (abortController.signal.reason as Error)?.message
+      if (!abortController.signal.aborted || abortReason === 'finished') {
         const sessionDuration = prettyMilliseconds(Date.now() - sessionStartTime)
         const attachCommand = port ? ` ⋅ ${session.id}` : ''
         const modelInfo = usedModel ? ` ⋅ ${usedModel}` : ''
@@ -1143,7 +1218,7 @@ export async function handleOpencodeSession({
         }
       } else {
         sessionLogger.log(
-          `Session was aborted (reason: ${abortController.signal.reason}), skipping duration message`,
+          `Session was aborted (reason: ${abortReason}), skipping duration message`,
         )
       }
     }
@@ -1151,7 +1226,13 @@ export async function handleOpencodeSession({
 
   const promptResult: Error | { sessionID: string; result: any; port?: number } | undefined =
     await errore.tryAsync(async () => {
-      const eventHandlerPromise = eventHandler()
+      const newHandlerPromise = eventHandler().finally(() => {
+        if (activeEventHandlers.get(thread.id) === newHandlerPromise) {
+          activeEventHandlers.delete(thread.id)
+        }
+      })
+      activeEventHandlers.set(thread.id, newHandlerPromise)
+      handlerPromise = newHandlerPromise
 
     if (abortController.signal.aborted) {
       sessionLogger.log(`[DEBOUNCE] Aborted before prompt, exiting`)
@@ -1256,7 +1337,7 @@ export async function handleOpencodeSession({
       throw new Error(`OpenCode API error (${response.response.status}): ${errorMessage}`)
     }
 
-    abortController.abort('finished')
+    abortController.abort(new Error('finished'))
 
     sessionLogger.log(`Successfully sent prompt, got response`)
 
@@ -1273,6 +1354,15 @@ export async function handleOpencodeSession({
     return { sessionID: session.id, result: response.data, port }
   })
 
+  if (handlerPromise) {
+    await Promise.race([
+      handlerPromise,
+      new Promise((resolve) => {
+        setTimeout(resolve, 1000)
+      }),
+    ])
+  }
+
   if (!errore.isError(promptResult)) {
     return promptResult
   }
@@ -1283,7 +1373,7 @@ export async function handleOpencodeSession({
   }
 
   sessionLogger.error(`ERROR: Failed to send prompt:`, promptError)
-  abortController.abort('error')
+  abortController.abort(new Error('error'))
 
   if (originalMessage) {
     const reactionResult = await errore.tryAsync(async () => {

package/src/tools.ts

@@ -12,10 +12,10 @@ import {
   type AssistantMessage,
   type Provider,
 } from '@opencode-ai/sdk'
-import { createLogger } from './logger.js'
+import { createLogger, LogPrefix } from './logger.js'
 import * as errore from 'errore'
 
-const toolsLogger = createLogger('TOOLS')
+const toolsLogger = createLogger(LogPrefix.TOOLS)
 
 import { ShareMarkdown } from './markdown.js'
 import { formatDistanceToNow } from './utils.js'

package/src/voice-handler.ts

@@ -37,9 +37,9 @@ import {
 import { transcribeAudio } from './voice.js'
 import { FetchError } from './errors.js'
 
-import { createLogger } from './logger.js'
+import { createLogger, LogPrefix } from './logger.js'
 
-const voiceLogger = createLogger('VOICE')
+const voiceLogger = createLogger(LogPrefix.VOICE)
 
 export type VoiceConnectionData = {
   connection: VoiceConnection

package/src/voice.ts

@@ -5,7 +5,7 @@
 
 import { GoogleGenAI, Type, type Content, type Part, type Tool } from '@google/genai'
 import * as errore from 'errore'
-import { createLogger } from './logger.js'
+import { createLogger, LogPrefix } from './logger.js'
 import { glob } from 'glob'
 import { ripGrep } from 'ripgrep-js'
 import {
@@ -19,7 +19,7 @@ import {
   GlobSearchError,
 } from './errors.js'
 
-const voiceLogger = createLogger('VOICE')
+const voiceLogger = createLogger(LogPrefix.VOICE)
 
 export type TranscriptionToolRunner = ({
   name,

package/src/worktree-utils.ts

@@ -1,14 +1,15 @@
 // Worktree utility functions.
 // Wrapper for OpenCode worktree creation that also initializes git submodules.
+// Also handles capturing and applying git diffs when creating worktrees from threads.
 
-import { exec } from 'node:child_process'
+import { exec, spawn } from 'node:child_process'
 import { promisify } from 'node:util'
-import { createLogger } from './logger.js'
+import { createLogger, LogPrefix } from './logger.js'
 import type { getOpencodeClientV2 } from './opencode.js'
 
 export const execAsync = promisify(exec)
 
-const logger = createLogger('WORKTREE-UTILS')
+const logger = createLogger(LogPrefix.WORKTREE)
 
 type OpencodeClientV2 = NonNullable<ReturnType<typeof getOpencodeClientV2>>
 
@@ -20,16 +21,21 @@ type WorktreeResult = {
 /**
  * Create a worktree using OpenCode SDK and initialize git submodules.
  * This wrapper ensures submodules are properly set up in new worktrees.
+ *
+ * If diff is provided, it's applied BEFORE submodule update to ensure
+ * any submodule pointer changes in the diff are respected.
  */
 export async function createWorktreeWithSubmodules({
   clientV2,
   directory,
   name,
+  diff,
 }: {
   clientV2: OpencodeClientV2
   directory: string
   name: string
-}): Promise<WorktreeResult | Error> {
+  diff?: CapturedDiff | null
+}): Promise<WorktreeResult & { diffApplied: boolean } | Error> {
   // 1. Create worktree via OpenCode SDK
   const response = await clientV2.worktree.create({
     directory,
@@ -45,8 +51,19 @@ export async function createWorktreeWithSubmodules({
   }
 
   const worktreeDir = response.data.directory
+  let diffApplied = false
 
-  // 2. Init submodules in new worktree (don't block on failure)
+  // 2. Apply diff BEFORE submodule update (if provided)
+  // This ensures any submodule pointer changes in the diff are applied first,
+  // so submodule update checks out the correct commits.
+  if (diff) {
+    logger.log(`Applying diff to ${worktreeDir} before submodule init`)
+    diffApplied = await applyGitDiff(worktreeDir, diff)
+  }
+
+  // 3. Init submodules in new worktree (don't block on failure)
+  // Uses --init to initialize, --recursive for nested submodules.
+  // Submodules will be checked out at the commit specified by the (possibly updated) index.
   try {
     logger.log(`Initializing submodules in ${worktreeDir}`)
     await execAsync('git submodule update --init --recursive', {
@@ -60,7 +77,7 @@ export async function createWorktreeWithSubmodules({
     )
   }
 
-  // 3. Install dependencies using ni (detects package manager from lockfile)
+  // 4. Install dependencies using ni (detects package manager from lockfile)
   try {
     logger.log(`Installing dependencies in ${worktreeDir}`)
     await execAsync('npx -y ni', {
@@ -74,5 +91,92 @@ export async function createWorktreeWithSubmodules({
     )
   }
 
-  return response.data
+  return { ...response.data, diffApplied }
+}
+
+/**
+ * Captured git diff (both staged and unstaged changes).
+ */
+export type CapturedDiff = {
+  unstaged: string
+  staged: string
+}
+
+/**
+ * Capture git diff from a directory (both staged and unstaged changes).
+ * Returns null if no changes or on error.
+ */
+export async function captureGitDiff(directory: string): Promise<CapturedDiff | null> {
+  try {
+    // Capture unstaged changes
+    const unstagedResult = await execAsync('git diff', { cwd: directory })
+    const unstaged = unstagedResult.stdout.trim()
+
+    // Capture staged changes
+    const stagedResult = await execAsync('git diff --staged', { cwd: directory })
+    const staged = stagedResult.stdout.trim()
+
+    if (!unstaged && !staged) {
+      return null
+    }
+
+    return { unstaged, staged }
+  } catch (e) {
+    logger.warn(`Failed to capture git diff from ${directory}: ${e instanceof Error ? e.message : String(e)}`)
+    return null
+  }
+}
+
+/**
+ * Run a git command with stdin input.
+ * Uses spawn to pipe the diff content to git apply.
+ */
+function runGitWithStdin(args: string[], cwd: string, input: string): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const child = spawn('git', args, { cwd, stdio: ['pipe', 'pipe', 'pipe'] })
+
+    let stderr = ''
+    child.stderr?.on('data', (data) => {
+      stderr += data.toString()
+    })
+
+    child.on('close', (code) => {
+      if (code === 0) {
+        resolve()
+      } else {
+        reject(new Error(stderr || `git ${args.join(' ')} failed with code ${code}`))
+      }
+    })
+
+    child.on('error', reject)
+
+    child.stdin?.write(input)
+    child.stdin?.end()
+  })
+}
+
+/**
+ * Apply a captured git diff to a directory.
+ * Applies staged changes first, then unstaged.
+ */
+export async function applyGitDiff(directory: string, diff: CapturedDiff): Promise<boolean> {
+  try {
+    // Apply staged changes first (and stage them)
+    if (diff.staged) {
+      logger.log(`Applying staged diff to ${directory}`)
+      await runGitWithStdin(['apply', '--index'], directory, diff.staged)
+    }
+
+    // Apply unstaged changes (don't stage them)
+    if (diff.unstaged) {
+      logger.log(`Applying unstaged diff to ${directory}`)
+      await runGitWithStdin(['apply'], directory, diff.unstaged)
+    }
+
+    logger.log(`Successfully applied diff to ${directory}`)
+    return true
+  } catch (e) {
+    logger.warn(`Failed to apply git diff to ${directory}: ${e instanceof Error ? e.message : String(e)}`)
+    return false
+  }
 }

package/src/xml.ts

@@ -4,9 +4,9 @@
 
 import { DomHandler, Parser, ElementType } from 'htmlparser2'
 import type { ChildNode, Element, Text } from 'domhandler'
-import { createLogger } from './logger.js'
+import { createLogger, LogPrefix } from './logger.js'
 
-const xmlLogger = createLogger('XML')
+const xmlLogger = createLogger(LogPrefix.XML)
 
 export function extractTagsArrays<T extends string>({
   xml,