thincoder 0.11.0 → 0.12.0

package/src/tui/index.mjs

@@ -5,7 +5,7 @@
  *
  * Large logic blocks extracted to independent modules:
  *   agent-turn.mjs    — agent loop + callback construction
- *   key-handler.mjs   — keyboard event dispatch
+ *   render-loop.mjs  — frame scheduler + incremental panel rendering
  *   startup.mjs       — startup screen + session restore + background indexing
  *   interaction.mjs   — permission approval + Q&A
  *   pickers.mjs       — generic list picker + model picker
@@ -20,15 +20,8 @@ import { emitKeypressEvents } from "node:readline"
 import { PassThrough } from "node:stream"
 import { saveSession, archiveCurrent, listSlots } from "../session.mjs"
 import { closeAllMcp } from "../mcp.mjs"
-import { estimateTokens } from "../context.mjs"
 import { ansi, C } from "./ansi.mjs"
-import {
-  renderFrame, countConvLines, convCacheKey,
-  renderHeader, renderConversation, renderTodo, renderSubagent,
-  renderOutput, renderPermission, renderQueue, renderPicker,
-  renderInputBox, renderStatus,
-} from "./render-frame.mjs"
-import { computeLayout } from "./layout.mjs"
+import { createRenderLoop } from "./render-loop.mjs"
 import { SLASH_COMMANDS, SLASH_ALIASES, createSlashCommands } from "./slash-commands.mjs"
 import { createWizard } from "./wizard.mjs"
 import { createPickers } from "./pickers.mjs"
@@ -87,7 +80,7 @@ export async function startTUI(agent, opts = {}) {
     completion: null, // Tab completion state { candidates, index }
     toolStreams: {}, // per-tool live output (isolated by tool name, parallel tools don't interleave)
     subTasks: {}, // sub-agent panel: { roleName: { role, text, done } }, one line per role, marked done briefly after completion
-    outputPanels: {}, // generic tool output panel: { toolName: { text, done } } — streamed live during execution, collapsed to summary on completion
+    outputPanels: {}, // tool output panels: { toolName: { parts: [{kind, text}], len, done, closeAt } } — streamed live during execution, kept visible for a grace period after completion
     currentTool: null, // currently executing tool name (shown in status bar)
     processingStarted: 0, // current turn start time (status bar timer)
     status: "Ready",
@@ -247,184 +240,11 @@ export async function startTUI(agent, opts = {}) {
 
   // ---------------------------------------------------------- Render
 
-  // Panel cache for incremental rendering: panelName → { y, h, content }
-  const panelCache = new Map()
-  let lastCols = 0, lastRows = 0
-  let lastConvKey = "", lastConvCols = 0, lastConvScroll = -1
-  const convLineCache = []  // line-level cache for conversation panel (per-line diff)
-  let renderRequested = false, renderTimer = null, lastRenderAt = 0
-  const MIN_RENDER_INTERVAL_MS = 16  // ~60fps cap, matching pi-tui
-
-  function scheduleRender() {
-    if (renderTimer) return
-    const elapsed = performance.now() - lastRenderAt
-    const delay = Math.max(0, MIN_RENDER_INTERVAL_MS - elapsed)
-    renderTimer = setTimeout(() => {
-      renderTimer = null
-      if (!renderRequested) return
-      renderRequested = false
-      lastRenderAt = performance.now()
-      doRender()
-      if (renderRequested) scheduleRender()  // more requests arrived during render
-    }, delay)
-  }
-
-  /** Rate-limited render entry point. All call sites use this. */
-  function render() {
-    if (renderRequested) return
-    renderRequested = true
-    // process.nextTick merges multiple synchronous render() calls
-    // within the same tick into a single scheduleRender call.
-    process.nextTick(() => scheduleRender())
-  }
-
-  /** Build ANSI content for a panel at its layout position. Returns null if unchanged. */
-  function buildPanel(name, panelLayout, lines, cacheKey) {
-    if (!panelLayout) {
-      if (panelCache.has(name)) panelCache.delete(name)
-      return null
-    }
-    const content = lines.join("\r\n")
-    const cached = panelCache.get(name)
-    const effectiveKey = cacheKey ?? content
-    if (cached && cached.y === panelLayout.y && cached.h === panelLayout.h && cached.key === effectiveKey) return null
-    const rows = []
-    for (let i = 0; i < panelLayout.h; i++) {
-      rows.push(`\x1b[${panelLayout.y + 1 + i};1H${lines[i] ?? ""}\x1b[K`)
-    }
-    panelCache.set(name, { y: panelLayout.y, h: panelLayout.h, key: effectiveKey })
-    return rows.join("")
-  }
-
-  /** Detect if panel layout structure changed (appeared/disappeared/shifted).
-   *  Only checks panels that are ALREADY cached — new panels (not yet written)
-   *  are not a structural change; the incremental path will write them naturally. */
-  function layoutStructureChanged(layout) {
-    for (const [name, cached] of panelCache) {
-      const p = layout.panels[name] ?? null
-      if (p == null) return true  // cached panel disappeared → layout changed
-      if (p.y !== cached.y || p.h !== cached.h) return true  // shifted/resized
-    }
-    return false
-  }
-
-  function doRender() {
-    try {
-      const dims = { cols: process.stdout.columns || startupCols, rows: process.stdout.rows || startupRows }
-      const layout = computeLayout(state, dims)
-      const { W, panels, inputLayout, inputOffset, boxLines, visibleTasks, allSubs, permPreviewLines, overlay } = layout
-
-      // Side effects: clamp scroll + overlay + update ctxCache
-      const convLines = countConvLines(state, dims.cols)
-      state.scroll = Math.min(state.scroll, Math.max(0, convLines - panels.conversation.h))
-      if (overlay && panels.picker) {
-        const winH = panels.picker.h - 1
-        if (overlay.selectedLine < overlay.scroll) overlay.scroll = overlay.selectedLine
-        if (overlay.selectedLine >= overlay.scroll + winH) overlay.scroll = overlay.selectedLine - winH + 1
-      }
-      if (state.ctxCache.len !== agent.history.length) {
-        state.ctxCache = { len: agent.history.length, tokens: estimateTokens(agent.history) }
-      }
-
-      // 后台更新提示：等 picker/权限确认/提问弹层全部关闭后再弹，不硬抢
-      // （key-handler 分支顺序 permission → question → picker，任一激活时弹了也摸不到）
-      if (pendingNoticeReady(state)) {
-        const notice = state.pendingNotice
-        state.pendingNotice = null
-        showUpdateNotice(notice).catch((e) => pushLine(`[error] ${e.message}`, C.error))
-      }
-
-      // Terminal resize or panel layout shift → full redraw (using legacy renderFrame).
-      // Don't clear panelCache — update positions so the next incremental check
-      // sees correct Y/h. Content keys will be stale, forcing a one-time rewrite
-      // per panel on the next frame (much cheaper than another full redraw).
-      if (dims.cols !== lastCols || dims.rows !== lastRows || layoutStructureChanged(layout)) {
-        lastCols = dims.cols; lastRows = dims.rows
-        // Update cached panel positions (content stays stale → next frame rewrites)
-        for (const [name, panelLayout] of Object.entries(panels)) {
-          if (!panelLayout) { panelCache.delete(name); continue }
-          const cached = panelCache.get(name)
-          if (cached) { cached.y = panelLayout.y; cached.h = panelLayout.h }
-        }
-        const isStreaming = state.processing && !state.permission && !state.question && !state.picker
-        const isWizard = state.wizard?.step === "provider"
-        // Content + cursor in a single write. Hardware cursor stays hidden —
-        // the visual cursor is drawn in the input box as SGR reverse video.
-        // Position for IME, hide for visual (matching pi-tui).
-        const { frame, cursorRow, cursorCol } = renderFrame(state, agent, { cols: dims.cols, rows: dims.rows, slashCommands: SLASH_COMMANDS })
-        if (isStreaming) {
-          process.stdout.write(ansi.syncUpdateStart + ansi.home + frame + ansi.clearToEnd + ansi.syncUpdateEnd + `\x1b[${cursorRow};${cursorCol}H${ansi.hideCursor}`)
-        } else if (isWizard) {
-          process.stdout.write(ansi.syncUpdateStart + ansi.home + frame + ansi.clearToEnd + ansi.syncUpdateEnd + ansi.hideCursor)
-        } else {
-          process.stdout.write(ansi.syncUpdateStart + ansi.home + frame + ansi.clearToEnd + ansi.syncUpdateEnd + `\x1b[${cursorRow};${cursorCol}H${ansi.hideCursor}`)
-        }
-        return
-      }
-
-      // ---- Incremental rendering (layout stable) ----
-      // pi-tui pattern: content inside sync-update block; cursor outside.
-      // DECSET 2026 buffers all panel writes and renders them atomically.
-      // Cursor hide/show/position MUST be outside — otherwise the terminal's
-      // internal cursor state machine and the sync render buffer can disagree.
-      const out = []
-      const push = (s) => { if (s != null) out.push(s) }
-
-      // Always-visible panels
-      push(buildPanel("header", panels.header, [renderHeader(agent, dims.cols)]))
-      push(buildPanel("status", panels.status, [renderStatus(state, agent, dims.cols, SLASH_COMMANDS)]))
-      push(buildPanel("inputBox", panels.inputBox, renderInputBox(state, W, boxLines, dims.cols, inputLayout, inputOffset)))
-
-      // Conversation: line-level cache — only push changed lines
-      const convKey = convCacheKey(state)
-      const convChanged = convKey !== lastConvKey || dims.cols !== lastConvCols || state.scroll !== lastConvScroll
-      if (convChanged) {
-        lastConvKey = convKey; lastConvCols = dims.cols; lastConvScroll = state.scroll
-        const lines = renderConversation(state, dims.cols, panels.conversation.h, state.scroll)
-        const y = panels.conversation.y + 1
-        for (let i = 0; i < lines.length; i++) {
-          if (lines[i] !== convLineCache[i]) {
-            out.push(`\x1b[${y + i};1H${lines[i]}\x1b[K`)
-            convLineCache[i] = lines[i]
-          }
-        }
-        if (convLineCache.length > lines.length) {
-          for (let i = lines.length; i < convLineCache.length; i++) {
-            out.push(`\x1b[${y + i};1H\x1b[K`)
-          }
-        }
-        convLineCache.length = lines.length
-      }
-
-      // Conditional panels
-      push(buildPanel("todo", panels.todo, renderTodo(visibleTasks, dims.cols)))
-      push(buildPanel("subagent", panels.subagent, renderSubagent(allSubs, W)))
-      push(buildPanel("output", panels.output, renderOutput(state, W, panels.output?.h ?? 0)))
-      push(buildPanel("permission", panels.permission, renderPermission(permPreviewLines)))
-      if (panels.queue) push(buildPanel("queue", panels.queue, [renderQueue(state, W)]))
-      else panelCache.delete("queue")
-      if (panels.picker) push(buildPanel("picker", panels.picker, renderPicker(state, dims.cols, panels.picker, overlay)))
-      else panelCache.delete("picker")
-
-      // Determine cursor suffix — appended to the same write() as the sync block.
-      // MUST position the cursor at the input box even when hidden: the terminal's
-      // cursor position determines where the IME candidate window appears.
-      // pi-tui's positionHardwareCursor does the same — positions first, then
-      // decides show/hide based on showHardwareCursor.
-      // Hardware cursor stays hidden — the visual cursor is drawn in the input
-      // box text as SGR reverse video (matching pi-tui's approach).
-      // We still position the hardware cursor for IME candidate window placement.
-      const cr = panels.inputBox.y + 1 + (inputLayout.cursorLine - inputOffset) + 1
-      const cc = 3 + inputLayout.cursorCol
-      const hasOverlay = state.permission || state.question || state.picker || state.wizard?.step === "provider"
-      const cursorSuffix = hasOverlay ? "" : `\x1b[${cr};${cc}H${ansi.hideCursor}`
-
-      // Single write: sync markers + content + cursor — atomic as far as the terminal is concerned
-      if (out.length || cursorSuffix) process.stdout.write(ansi.syncUpdateStart + out.join("") + ansi.syncUpdateEnd + cursorSuffix)
-    } catch (e) {
-      // Don't let a render error crash the TUI
-    }
-  }
+  const renderLoop = createRenderLoop(state, agent,
+    { startupDims: { cols: startupCols, rows: startupRows }, SLASH_COMMANDS,
+      pendingNoticeReady, get showUpdateNotice() { return showUpdateNotice } },
+    pushLine)
+  const { render, scheduleRender } = renderLoop
 
   process.stdout.on("resize", () => {
     try { render() } catch { /* resize error — ignore */ }
@@ -596,5 +416,6 @@ export async function startTUI(agent, opts = {}) {
 
 function summarize(obj) {
   const s = JSON.stringify(obj)
+  if (s === "{}") return "" // no-arg tools (advisor/verify/…) — don't render empty braces
   return s.length > 80 ? s.slice(0, 80) + "…" : s
 }

package/src/tui/interaction.mjs

@@ -37,7 +37,8 @@ export function createInteraction(ctx) {
   function askPermission(name, args) {
     // auto mode: fully authorized, no more prompts
     if (agent.autoApprove) {
-      pushLine(`  [auto] ${name} ${summarize(args)}`, C.warn)
+      const argSummary = summarize(args)
+      pushLine(`  [auto] ${name}${argSummary ? ` ${argSummary}` : ""}`, C.warn)
       return Promise.resolve(true)
     }
     // store preview content in permissionPreview, rendered above input box next to "Allow?" prompt

package/src/tui/key-handler.mjs

@@ -24,8 +24,6 @@ export function createKeyHandler(ctx) {
         state.status = "Processing..."
         if (answer === "a" && !isContinue) {
           agent.autoApprove = true
-          agent._pendingReminders = agent._pendingReminders ?? []
-          agent._pendingReminders.push("[System reminder: AUTO mode is now ON. All tool calls are automatically approved. Use /auto to disable.]")
           pushLine(`  [auto] AUTO ON: tool calls no longer prompt for approval (/auto to disable)`, C.warn)
         }
         const approved = answer === "y" || (answer === "a" && !isContinue)
@@ -140,8 +138,14 @@ export function createKeyHandler(ctx) {
         const msg = (state.interruptPrompt.text ?? "").trim()
         state.interruptPrompt = null
         if (msg) {
-          pushLine(`  [inject] ${msg}`, C.warn)
-          state.controller.abort({ interrupt: true, message: msg })
+          // Guard: if the turn already finished while the user was typing, the controller
+          // may have been replaced or already aborted — don't abort a live turn by mistake.
+          if (state.processing && state.controller && !state.controller.signal.aborted) {
+            pushLine(`  [inject] ${msg}`, C.warn)
+            state.controller.abort({ interrupt: true, message: msg })
+          } else {
+            pushLine(`  [inject — turn ended, message queued] ${msg}`, C.dim)
+          }
           render()
         }
       } else if (key.name === "backspace") {

package/src/tui/layout.mjs

@@ -69,8 +69,9 @@ export function computeLayout(state, { cols, rows }) {
     ? Math.min(allSubs.length, MAX_SUB_LINES) + (allSubs.length > MAX_SUB_LINES ? 1 : 0)
     : 0
 
-  // Tool output panels: max 8 lines per panel, capped at reasonable total
-  const panels = Object.values(state.outputPanels).filter((p) => !p.done)
+  // Tool output panels: max 8 lines per panel, capped at reasonable total.
+  // Done panels stay visible until their closeAt grace elapses (render loop prunes them).
+  const panels = Object.values(state.outputPanels).filter((p) => !p.done || (p.closeAt ?? 0) > Date.now())
   const outputPanelsH = panels.length > 0 ? Math.min(panels.length * 8, rows - 10) : 0
 
   // Permission preview (height depends on wrapped content)

package/src/tui/render-conversation.mjs

@@ -0,0 +1,92 @@
+/**
+ * render-conversation.mjs — conversation panel line builder
+ * Extracted from render-frame.mjs.
+ */
+import { ansi, C } from "./ansi.mjs"
+import { formatTables, sanitizeDisplay, wrapText } from "./render.mjs"
+
+let _convCache = { key: "", cols: 0, lines: [] }
+
+export function convCacheKey(state) {
+  const lastLine = state.lines.length > 0 ? state.lines[state.lines.length - 1] : null
+  return `${state.lines.length}|${lastLine?.text.length ?? 0}|${state.streaming.length}|${state.reasoning.length}|${Object.keys(state.toolStreams).length}|${state.foldEnabled !== false ? "f" : "u"}`
+}
+
+function buildConvLines(state, cols) {
+  const key = convCacheKey(state)
+  if (_convCache.key === key && _convCache.cols === cols) return _convCache.lines
+
+  const convLines = []
+  for (const l of state.lines) {
+    for (const line of formatTables(sanitizeDisplay(l.text), cols - 1)) {
+      for (const wrapped of wrapText(line, cols - 1)) {
+        convLines.push({ text: wrapped, color: l.color, _foldId: l._foldId })
+      }
+    }
+  }
+  if (state.reasoning) {
+    for (const wrapped of wrapText(sanitizeDisplay(state.reasoning), cols - 1)) {
+      convLines.push({ text: wrapped, color: C.reason })
+    }
+  }
+  if (state.streaming) {
+    for (const line of formatTables(sanitizeDisplay(state.streaming), cols - 1)) {
+      for (const wrapped of wrapText(line, cols - 1)) {
+        convLines.push({ text: wrapped, color: C.text })
+      }
+    }
+  }
+  const allStreams = Object.values(state.toolStreams).join("")
+  if (allStreams) {
+    const tail = sanitizeDisplay(allStreams.slice(-4000))
+    for (const wrapped of wrapText(tail, cols - 1)) {
+      convLines.push({ text: wrapped, color: C.dim })
+    }
+  }
+
+  // Fold long blocks (> 8 consecutive dim lines)
+  const FOLD_LINES = 8
+  let foldCounter = 0
+  const folded = []
+  let i = 0
+  while (i < convLines.length) {
+    const line = convLines[i]
+    if (line.color === C.dim) {
+      let j = i
+      while (j < convLines.length && convLines[j].color === C.dim) j++
+      const blockLen = j - i
+      if (blockLen > FOLD_LINES) {
+        const foldKey = `fold-${foldCounter++}`
+        if (state.foldEnabled !== false && !state.expandedBlocks?.has(foldKey)) {
+          folded.push(convLines[i])
+          if (blockLen > 2) folded.push(convLines[i + 1])
+          folded.push({ text: `  … ${blockLen - 2} more lines — Enter to expand`, color: C.fold, _foldToggle: foldKey })
+          i = j
+          continue
+        }
+      }
+    }
+    folded.push(line)
+    i++
+  }
+
+  _convCache = { key, cols, lines: folded }
+  return folded
+}
+
+export function countConvLines(state, cols) {
+  return buildConvLines(state, cols).length
+}
+
+export function renderConversation(state, cols, visibleH, scroll) {
+  const convLines = buildConvLines(state, cols)
+  const maxScroll = Math.max(0, convLines.length - visibleH)
+  const clamped = Math.min(scroll, maxScroll)
+  const end = convLines.length - clamped
+  const visible = convLines.slice(Math.max(0, end - visibleH), end)
+  const pad = visibleH - visible.length
+  const out = []
+  for (let p = 0; p < pad; p++) out.push("")
+  for (const l of visible) out.push(`${l.color ?? ""}${l.text}${ansi.reset}`)
+  return out
+}