thincoder 0.12.2 → 0.12.4

package/src/tui/index.mjs

@@ -18,7 +18,7 @@
 
 import { emitKeypressEvents } from "node:readline"
 import { PassThrough } from "node:stream"
-import { saveSession, archiveCurrent, listSlots } from "../session.mjs"
+import { saveSession } from "../session.mjs"
 import { closeAllMcp } from "../mcp.mjs"
 import { ansi, C } from "./ansi.mjs"
 import { createRenderLoop } from "./render-loop.mjs"
@@ -27,7 +27,7 @@ import { createWizard } from "./wizard.mjs"
 import { createPickers } from "./pickers.mjs"
 import { runDistill as runDistillImpl } from "./distill-cmd.mjs"
 import { createInteraction } from "./interaction.mjs"
-import { pasteClipboardImage as pasteClipboardImageImpl, insertPastedText } from "./clipboard.mjs"
+import { pasteClipboardImage as pasteClipboardImageImpl, insertPastedText, translateShiftEnter } from "./clipboard.mjs"
 import { runAgentTurn } from "./agent-turn.mjs"
 import { createKeyHandler } from "./key-handler.mjs"
 import { showStartup, backgroundIndex } from "./startup.mjs"
@@ -59,10 +59,12 @@ export async function startTUI(agent, opts = {}) {
   const state = {
     lines: [], // conversation lines: { text, color }
     streaming: "", // current streaming buffer
+    advisorStreaming: "", // advisor streaming buffer (formatted like main response)
     input: [], // input buffer (codepoint array)
     cursor: 0,
     history: [],
     historyIndex: -1,
+    _draft: null, // stashed unsent input while navigating history (restored on down past newest)
     scroll: 0, // scroll lines from bottom upward
     processing: false,
     controller: null, // AbortController for current agent run
@@ -78,16 +80,16 @@ export async function startTUI(agent, opts = {}) {
     ctxCache: { len: -1, tokens: 0 }, // context utilization estimate cache (estimateTokens is O(n), only recompute when history grows)
     reasoning: "", // thinking stream buffer (dimmed display)
     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: {}, // 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",
     queue: [], // queued messages while processing: [{ text }], auto-dequeued when current turn finishes
     interruptPrompt: null, // Ctrl+I interrupt message input: { text: "" } or null
+    search: null, // Ctrl+F search mode: { query: "", matches: [{lineIndex, charIndex}], index: 0 } or null
     expandedBlocks: new Set(), // block hashes that are expanded (Enter toggles)
     foldEnabled: true, // global fold toggle — /fold on|off
+    exitArmed: false, // Ctrl+C double-confirm: first press arms, second (within window) exits
   }
 
   // On session restore, if all tasks are completed, auto-collapse the todo panel (match runtime behavior)
@@ -108,7 +110,11 @@ export async function startTUI(agent, opts = {}) {
   const startupRows = process.stdout.rows || 24
   emitKeypressEvents(keyStream)
   process.stdin.setRawMode(true)
-  process.stdout.write(ansi.altBuffer + ansi.hideCursor + ansi.mouseOn + ansi.bracketedPasteOn)
+  // Keyboard enhancement — enable BOTH protocols (unsupported terminals ignore them):
+  // kitty push (\x1b[>1u): Shift+Enter → \x1b[13;2u (Windows Terminal 1.19+, VS Code, kitty, iTerm2)
+  // modifyOtherKeys lvl 2 (\x1b[>4;2m): Shift+Enter → \x1b[27;2;13~ (mintty / Git Bash)
+  // translateShiftEnter (stdin layer) maps both to \x1b\r → meta+return → multiline branch.
+  process.stdout.write(ansi.altBuffer + ansi.hideCursor + ansi.mouseOn + ansi.bracketedPasteOn + ansi.keyboardPush + ansi.modifyOtherKeysOn)
 
   const utf8Decoder = new TextDecoder("utf-8", { fatal: false })
 
@@ -181,6 +187,9 @@ export async function startTUI(agent, opts = {}) {
       text = text.slice(0, -tail[0].length)
     }
 
+    // Shift+Enter (keyboard-enhanced terminals) → Alt+Enter path (\x1b\r = meta+return)
+    text = translateShiftEnter(text)
+
     if (state.scroll !== lastRenderedScroll) {
       lastRenderedScroll = state.scroll
       render()
@@ -195,9 +204,10 @@ export async function startTUI(agent, opts = {}) {
   const cleanup = () => {
     if (cleanedUp) return
     cleanedUp = true
-    // Save session before exit (synchronous write); archive current to a slot first, then save new — never lose data
+    // Save session before exit (synchronous write).
+    // Archiving to a slot is handled by /new and /session switch — not on every exit,
+    // otherwise simply opening and closing the TUI repeatedly would fill all slots with duplicates.
     try {
-      archiveCurrent(agent.cwd)
       saveSession(agent, state.lines)
     } catch {
       // Save failure shouldn't block exit
@@ -209,7 +219,7 @@ export async function startTUI(agent, opts = {}) {
       // Can't close? fine, process is exiting anyway
     }
     process.stdin.setRawMode(false)
-    process.stdout.write(ansi.clearScreen + ansi.mouseOff + ansi.bracketedPasteOff + ansi.mainBuffer + ansi.showCursor + ansi.reset)
+    process.stdout.write(ansi.clearScreen + ansi.mouseOff + ansi.bracketedPasteOff + ansi.keyboardPop + ansi.modifyOtherKeysOff + ansi.mainBuffer + ansi.showCursor + ansi.reset)
   }
   process.on("exit", cleanup)
 
@@ -259,6 +269,7 @@ export async function startTUI(agent, opts = {}) {
     state.cursor = 0
     state.history.push(text)
     state.historyIndex = -1
+    state._draft = null // submitted — the draft is now history
     state.scroll = 0
 
     // Slash commands: handled locally, don't enter agent loop
@@ -353,7 +364,7 @@ export async function startTUI(agent, opts = {}) {
     agent, state, render, popPicker, renderPickerLines,
     handleSlash, handleTab, submit, pasteClipboardImage,
     wizardChooseProvider, wizardSubmitText, cancelWizard, wizardProviderItems,
-    renderWizard, pushLine, cleanup,
+    renderWizard, pushLine, cleanup, showPicker,
   })
   keyStream.on("keypress", (str, key) => {
     try {

package/src/tui/key-handler.mjs

@@ -2,14 +2,59 @@ import { ansi, C } from "./ansi.mjs"
 import { readClipboardText, insertPastedText } from "./clipboard.mjs"
 import { computeLayout } from "./layout.mjs"
 
+/** Perform search on state.lines, update state.search.matches and clamp index */
+function performSearch(state) {
+  if (!state.search) return
+  const query = state.search.query.toLowerCase()
+  state.search.matches = []
+  // Clear old highlights
+  state.lines.forEach(l => delete l._searchMatches)
+
+  if (!query) { state.search.index = 0; return }
+
+  state.lines.forEach((line, lineIndex) => {
+    const text = (line.text || "").toLowerCase()
+    let charIndex = text.indexOf(query)
+    if (charIndex !== -1) {
+      line._searchMatches = []
+    }
+    while (charIndex !== -1) {
+      state.search.matches.push({ lineIndex, charIndex })
+      line._searchMatches.push(charIndex)
+      charIndex = text.indexOf(query, charIndex + 1)
+    }
+  })
+
+  if (state.search.matches.length === 0) {
+    state.search.index = 0
+  } else {
+    state.search.index = Math.min(state.search.index, state.search.matches.length - 1)
+  }
+}
+
+/** Estimate scroll position to make a line visible (simplified) */
+function scrollToMatch(state, lineIndex) {
+  if (lineIndex == null) return
+  // Rough estimate: each state.line takes 1-2 rendered lines
+  let estimatedLine = 0
+  for (let i = 0; i < lineIndex && i < state.lines.length; i++) {
+    estimatedLine += Math.max(1, Math.ceil((state.lines[i].text?.length || 0) / 80))
+  }
+  const rows = process.stdout.rows || 24
+  const visibleH = Math.max(5, rows - 10) // reserve space for header, input, status, etc.
+  // scroll is number of lines hidden above viewport
+  // We want estimatedLine to be near the bottom of the viewport
+  state.scroll = Math.max(0, state.lines.length - estimatedLine - visibleH + 3)
+}
+
 /** Keyboard event dispatch: permission confirm / question / picker / wizard / edit / scroll / history / paste.
  *  Extracted from index.mjs.
  *  ctx: { agent, state, render, renderPickerLines, popPicker,
  *         handleSlash, handleTab, submit, pasteClipboardImage,
  *         wizardChooseProvider, wizardSubmitText, cancelWizard, wizardProviderItems,
- *         renderWizard, pushLine, cleanup } */
+ *         renderWizard, pushLine, cleanup, showPicker } */
 export function createKeyHandler(ctx) {
-  const { agent, state, render, popPicker, renderPickerLines, handleSlash, handleTab, submit, pasteClipboardImage, wizardChooseProvider, wizardSubmitText, cancelWizard, wizardProviderItems, renderWizard, pushLine, cleanup } = ctx
+  const { agent, state, render, popPicker, renderPickerLines, handleSlash, handleTab, submit, pasteClipboardImage, wizardChooseProvider, wizardSubmitText, cancelWizard, wizardProviderItems, renderWizard, pushLine, cleanup, showPicker } = ctx
 
   return function onKeypress(str, key = {}) {
     // permission confirm state: y approve / n deny / a approve + turn ON AUTO (no further prompts)
@@ -24,6 +69,8 @@ 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)
@@ -102,7 +149,71 @@ export function createKeyHandler(ctx) {
       return
     }
 
-    if (key.ctrl && key.name === "c") {
+    // Search mode: Ctrl+F to enter, Ctrl+N/Ctrl+P (or Ctrl+G/Ctrl+R) navigate, Esc exit
+  if (key.ctrl && key.name === "f" && !state.permission && !state.question) {
+    if (!state.search) {
+      state.search = { query: "", matches: [], index: 0 }
+    }
+    render()
+    return
+  }
+
+  if (state.search) {
+    if (key.name === "escape" || (key.ctrl && key.name === "c")) {
+      state.search = null
+      render()
+      return
+    }
+    // Navigation requires Ctrl — bare n/p are query characters (regression fix: bare n/p
+    // used to hijack typing, making it impossible to type those letters into the query)
+    if ((key.ctrl && key.name === "n") || (key.ctrl && key.name === "g")) {
+      // Next match
+      if (state.search.matches.length > 0) {
+        state.search.index = (state.search.index + 1) % state.search.matches.length
+        scrollToMatch(state, state.search.matches[state.search.index].lineIndex)
+      }
+      render()
+      return
+    }
+    if ((key.ctrl && key.name === "p") || (key.ctrl && key.name === "r")) {
+      // Previous match
+      if (state.search.matches.length > 0) {
+        state.search.index = (state.search.index - 1 + state.search.matches.length) % state.search.matches.length
+        scrollToMatch(state, state.search.matches[state.search.index].lineIndex)
+      }
+      render()
+      return
+    }
+    if (key.name === "return") {
+      // Exit search mode but keep highlighting until next Ctrl+F
+      state.search = null
+      render()
+      return
+    }
+    if (key.name === "backspace") {
+      if (state.search.query.length > 0) {
+        state.search.query = state.search.query.slice(0, -1)
+        performSearch(state)
+        render()
+      }
+      return
+    }
+    // Regular character input
+    if (str && str.length === 1 && !key.ctrl && !key.alt && !key.meta) {
+      state.search.query += str
+      performSearch(state)
+      if (state.search.matches.length > 0) {
+        scrollToMatch(state, state.search.matches[state.search.index].lineIndex)
+      }
+      render()
+      return
+    }
+    // Swallow every other key (arrows/Tab/Delete/…) — without this they fall through
+    // to normal input handling and edit the HIDDEN state.input instead of the search box
+    return
+  }
+
+  if (key.ctrl && key.name === "c") {
       // picker 打开时 Ctrl+C = 取消当前 picker（等同 Esc），不杀进程
       if (state.picker) {
         popPicker(null)
@@ -114,12 +225,41 @@ export function createKeyHandler(ctx) {
         render()
         return
       }
+      // 防误触：空闲态第一次 Ctrl+C 仅提示并武装，窗口内再按才真正退出
+      if (!state.exitArmed) {
+        state.exitArmed = true
+        if (ctx.exitArmTimer) clearTimeout(ctx.exitArmTimer)
+        ctx.exitArmTimer = setTimeout(() => { state.exitArmed = false }, ctx.exitArmDelay ?? 3000)
+        ctx.exitArmTimer.unref?.()
+        pushLine("[exit] Press Ctrl+C again within 3s to exit", C.warn)
+        render()
+        return
+      }
+      if (ctx.exitArmTimer) clearTimeout(ctx.exitArmTimer)
       cleanup()
       // 延迟退出可注入（测试传大值并清理定时器，避免定时器在 mock 恢复后调到真 process.exit）
       ctx.exitTimer = setTimeout(() => process.exit(0), ctx.exitDelay ?? 100)
       ctx.exitTimer.unref?.()
     }
 
+    // F1: 显示快捷键帮助
+    if (key.name === "f1" && !state.picker && !state.permission && !state.question) {
+      showPicker("Keyboard Shortcuts", [
+        { type: "item", text: "Ctrl+C — Cancel/Abort; idle: press twice to exit" },
+        { type: "item", text: "Ctrl+I — Interrupt and inject message" },
+        { type: "item", text: "Ctrl+F — Search conversation history" },
+        { type: "item", text: "Shift+Enter / Ctrl+J — Insert newline (multiline input)" },
+        { type: "item", text: "Alt+V — Paste clipboard image" },
+        { type: "item", text: "Ctrl+U — Clear input line" },
+        { type: "item", text: "Esc — Cancel current input/picker" },
+        { type: "item", text: "↑/↓ — Navigate input history" },
+        { type: "item", text: "PgUp/PgDn — Scroll conversation" },
+        { type: "item", text: "Enter — Send message or confirm selection" },
+        { type: "item", text: "F1 — Show this help" },
+      ])
+      return
+    }
+
     // Ctrl+I (or Tab during processing): interrupt and inject a message
     if ((key.ctrl && !key.alt && key.name === "i") || (key.name === "tab" && state.processing && !state.interruptPrompt)) {
       if (state.processing && state.controller && !state.interruptPrompt) {
@@ -274,6 +414,11 @@ export function createKeyHandler(ctx) {
     // input history
     if (key.name === "up") {
       if (state.history.length) {
+        // Draft protection: entering history navigation with unsent input stashes it,
+        // so navigating back down past the newest entry restores what was being typed.
+        if (state.historyIndex === -1 && state.input.length > 0) {
+          state._draft = [...state.input]
+        }
         state.historyIndex = state.historyIndex === -1 ? state.history.length - 1 : Math.max(0, state.historyIndex - 1)
         state.input = [...state.history[state.historyIndex]]
         state.cursor = state.input.length
@@ -286,7 +431,9 @@ export function createKeyHandler(ctx) {
         state.historyIndex++
         if (state.historyIndex >= state.history.length) {
           state.historyIndex = -1
-          state.input = []
+          // Restore the stashed draft instead of wiping back to blank
+          state.input = state._draft ? [...state._draft] : []
+          state._draft = null
         } else {
           state.input = [...state.history[state.historyIndex]]
         }
@@ -335,12 +482,28 @@ export function createKeyHandler(ctx) {
       return
     }
     if (key.name === "return" || key.name === "enter" || str === "\r") {
-      submit().catch((e) => pushLine(`[error] ${e.message}`, C.error))
+      // Multiline newline — three entry points (docs/design/TUI-INPUT-BOX.md §1.5):
+      //  1. Alt+Enter: readline parses \x1b\r as meta+return (all terminals)
+      //  2. Shift+Enter: keyboard-enhanced terminals send \x1b[13;2u / \x1b[27;2;13~,
+      //     translateShiftEnter maps them to \x1b\r → also meta+return
+      //  3. Ctrl+J: sends \n (0x0A), readline parses as name:"enter" — the universal
+      //     fallback: \n and \r are distinct bytes in EVERY terminal, no protocol needed
+      //     (legacy conhost users: Shift+Enter is a bare \r there, physically
+      //     indistinguishable from Enter — Ctrl+J is their newline key)
+      if ((key.name === "return" && key.meta) || key.name === "enter") {
+        state.input.splice(state.cursor, 0, "\n")
+        state.cursor++
+        render()
+      } else {
+        submit().catch((e) => pushLine(`[error] ${e.message}`, C.error))
+      }
       return
     }
 
-    // Ctrl+V: paste clipboard text into the active text target
-    if (key.ctrl && !key.alt && key.name === "v") {
+    // Ctrl+V: paste clipboard text into the active text target.
+    // Exclude meta (ESC-prefix) so Ctrl+Alt+V — which readline reports as ctrl+meta —
+    // falls through to the image-paste branch below instead of being eaten here.
+    if (key.ctrl && !key.alt && !key.meta && key.name === "v") {
       ;(async () => {
         const text = await readClipboardText()
         if (text) {
@@ -351,8 +514,13 @@ export function createKeyHandler(ctx) {
       return
     }
 
-    // Ctrl+Alt+V (Windows) / Alt+V: paste clipboard image
-    const isPasteImage = key.name === "v" && key.alt
+    // Alt+V / Ctrl+Alt+V: paste clipboard image.
+    // NOTE: readline reports ESC-prefixed combos as key.meta, NOT key.alt (probe-verified:
+    // \x1b + char → { meta: true, alt: false }). Checking key.alt alone is a dead branch —
+    // the key fell through to the printable handler which ignores meta keys, so image paste
+    // silently did nothing. Accept meta (and alt, for terminals that set it); the text-paste
+    // branch above excludes meta so Ctrl+Alt+V reaches here.
+    const isPasteImage = key.name === "v" && (key.alt || key.meta)
     if (isPasteImage) {
       pasteClipboardImage(agent).catch((e) => pushLine(`[error] ${e.message}`, C.error))
       return

package/src/tui/layout.mjs

@@ -22,8 +22,8 @@ export function computeLayout(state, { cols, rows }) {
   const W = Math.max(20, cols - 1)
 
   // --- input box ---
-  const inputBuf = state.interruptPrompt ? [...state.interruptPrompt.text] : state.input
-  const inputCursor = state.interruptPrompt ? inputBuf.length : state.cursor
+  const inputBuf = state.search ? [...state.search.query] : (state.interruptPrompt ? [...state.interruptPrompt.text] : state.input)
+  const inputCursor = state.search ? inputBuf.length : (state.interruptPrompt ? inputBuf.length : state.cursor)
   const inputLayout = layoutInput(inputBuf, inputCursor, W - 4)
   let inputOffset = 0
   if (inputLayout.lines.length > MAX_INPUT_LINES) {
@@ -69,10 +69,10 @@ 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.
+  // Tool output panels: max 9 lines per panel (1 title + 8 content), 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
+  const panels = Object.values(state.outputPanels ?? {}).filter((p) => !p.done || (p.closeAt ?? 0) > Date.now())
+  const outputPanelsH = panels.length > 0 ? Math.min(panels.length * 9, rows - 10) : 0
 
   // Permission preview (height depends on wrapped content)
   let permPreviewLines = []

package/src/tui/markdown.mjs

@@ -0,0 +1,52 @@
+/**
+ * markdown.mjs — lightweight inline markdown rendering for the TUI display layer.
+ *
+ * Zero dependencies, display-only: turns raw markdown markers into ANSI styling so
+ * model replies stop showing literal `**`, `##`, backtick markers (IK5VW3).
+ *
+ * Design constraints:
+ * - Operates on ALREADY-WRAPPED single lines (call after wrapText): inserting ANSI
+ *   here cannot break width math, because wrapping already happened.
+ * - Uses narrow-scope SGR resets (22 = bold off, 27 = reverse off, 29 = strikethrough off)
+ *   instead of reset(0), so the line's base color (C.text etc.) survives.
+ * - Code spans are extracted FIRST: anything inside backticks is styled as code and
+ *   its `**`/`__` markers are NOT interpreted (markdown semantics).
+ * - Unclosed markers are left as-is (streaming safety: mid-token `**bo` renders literally).
+ */
+
+const BOLD = "\x1b[1m"
+const BOLD_OFF = "\x1b[22m"
+const REVERSE = "\x1b[7m"
+const REVERSE_OFF = "\x1b[27m"
+const STRIKE = "\x1b[9m"
+const STRIKE_OFF = "\x1b[29m"
+
+/** Render inline markers on a single text line: `code` spans, **bold**, __bold__, ~~strike~~. */
+export function renderMarkdownInline(line) {
+  if (!line || line.indexOf("*") === -1 && line.indexOf("`") === -1 && line.indexOf("_") === -1 && line.indexOf("~") === -1) {
+    return line
+  }
+
+  // Split on backticks: even indexes are plain text (bold/strike processed),
+  // odd indexes are code spans (styled as-is, markers inside untouched).
+  const parts = line.split("`")
+  let out = ""
+  for (let i = 0; i < parts.length; i++) {
+    if (i % 2 === 1) {
+      out += REVERSE + parts[i] + REVERSE_OFF
+    } else {
+      out += parts[i]
+        .replace(/\*\*([^*\n]+)\*\*/g, `${BOLD}$1${BOLD_OFF}`)
+        .replace(/__([^_\n]+)__/g, `${BOLD}$1${BOLD_OFF}`)
+        .replace(/~~([^~\n]+)~~/g, `${STRIKE}$1${STRIKE_OFF}`)
+    }
+  }
+  return out
+}
+
+/** Render a heading line: strip leading `#` markers and bold the whole line. Returns original when not a heading. */
+export function renderMarkdownHeading(line) {
+  const m = /^\s{0,3}(#{1,6})\s+(.*)$/.exec(line)
+  if (!m || !m[2]) return line
+  return `${BOLD}${m[2]}${BOLD_OFF}`
+}