thincoder 0.11.1 → 0.12.0

package/src/tui/cmd-mcp.mjs

@@ -21,7 +21,7 @@ async function addAndConnect(ctx, srv) {
     const entry = { name: srv.name }
     if (srv.url) { entry.url = srv.url; if (srv.headers) entry.headers = srv.headers }
     else if (srv.wsUrl) { entry.wsUrl = srv.wsUrl; if (srv.headers) entry.headers = srv.headers }
-    else { entry.command = srv.command; if (srv.args) entry.args = srv.args }
+    else { entry.command = srv.command; if (srv.args) entry.args = srv.args; if (srv.env) entry.env = srv.env }
     raw.mcp.servers.push(entry)
   })
   agent.config ??= {}
@@ -136,7 +136,9 @@ Return ONLY the JSON object:`,
       if (!cmd) return
       const argsInput = await askQuestion("Arguments (space-separated, or leave empty):")
       const cmdArgs = argsInput ? argsInput.split(/\s+/) : undefined
-      await addAndConnect(ctx, { name, command: cmd, args: cmdArgs })
+      const envInput = await askQuestion("Environment variables (KEY=value, space-separated, or leave empty):")
+      const env = envInput ? parseHeaders(envInput.split(/\s+/)) : undefined
+      await addAndConnect(ctx, { name, command: cmd, args: cmdArgs, env })
     } else {
       const urlPrompt = transport === "ws" ? "WebSocket URL (ws://…):" : "HTTP URL (https://…):"
       const url = await askQuestion(urlPrompt)

package/src/tui/cmd-plan.mjs

@@ -1,12 +1,10 @@
 /** /plan command: toggle plan mode (read-only explore → design → implement).
- *  ctx: { agent } */
+ *  ctx: { agent, pushLine, pushLabel } */
+import { ansi, C } from "./ansi.mjs"
+
 export async function handlePlanCommand(ctx) {
-  const { agent } = ctx
+  const { agent, pushLine, pushLabel } = ctx
   agent.planMode = !agent.planMode
-  agent._pendingReminders = agent._pendingReminders ?? []
-  if (agent.planMode) {
-    agent._pendingReminders.push("[System reminder: plan mode is now ON. You are restricted to READ-ONLY tools — explore, search, read, analyze. DO NOT write, edit, or run mutation commands. Present your design to the user first.]")
-  } else {
-    agent._pendingReminders.push("[System reminder: plan mode is now OFF. You may edit files, run commands, and implement changes.]")
-  }
+  pushLabel("❯ Plan", ansi.bold + C.tool)
+  pushLine(`Plan mode: ${agent.planMode ? "ON" : "OFF"}`, C.tool)
 }

package/src/tui/cmd-think.mjs

@@ -1,68 +1,27 @@
-import { C } from "./ansi.mjs"
-
 /** /think command: toggle thinking mode, set reasoning effort.
- *  Extracted from slash-commands.mjs.
- *  ctx: { agent, showPicker, syncProviderField, pushLine } */
+ *  Interactive loop UX — stays in menu after each action, Esc to exit.
+ *  ctx: { agent, showPicker, syncProviderField, pushLine, pushLabel } */
+import { ansi, C } from "./ansi.mjs"
+
 export async function handleThinkCommand(ctx, args = []) {
-  const { agent, showPicker, syncProviderField, pushLine } = ctx
-  const cur = agent.provider
+  const { agent, showPicker, syncProviderField, pushLine, pushLabel } = ctx
   const { specForModel } = await import("../config.mjs")
+
+  // Fast path: direct args — exit immediately
+  const cur = agent.provider
   const spec = specForModel(cur.model)
   const isEffortOnly = spec.thinkApi === "effort"
   const thinkOnValue = spec.thinkEnabledValue ?? "enabled"
   const isCustomThink = thinkOnValue !== "enabled"
   const effortLevels = spec.reasoningEffortEnum ?? ["high", "max"]
 
-  async function apply(e) {
-    if (e.action === "auto") {
-      const cfg = agent.config.agent ??= {}
-      cfg.autoThink = !cfg.autoThink
-      agent._pendingReminders = agent._pendingReminders ?? []
-      if (cfg.autoThink) {
-        // Turn off manual effort — auto will set it per-turn
-        delete cur.reasoningEffort
-        await syncProviderField("reasoningEffort", undefined)
-        agent._pendingReminders.push("[System reminder: Auto-think is now ON. Reasoning effort will be automatically set per-task based on difficulty classification.]")
-      } else {
-        agent._pendingReminders.push("[System reminder: Auto-think is now OFF. Reasoning effort will remain at its current manual setting.]")
-      }
-    } else if (e.action === "effort") {
-      cur.reasoningEffort = e.level
-      await syncProviderField("reasoningEffort", e.level)
-    } else {
-      const enable = e.action === "on"
-      if (isEffortOnly) {
-        if (!enable) delete cur.reasoningEffort
-        else if (!cur.reasoningEffort) cur.reasoningEffort = "high"
-        if (!enable) await syncProviderField("reasoningEffort", undefined)
-        else await syncProviderField("reasoningEffort", cur.reasoningEffort)
-      } else {
-        if (enable) {
-          cur.thinking = { type: thinkOnValue }
-          if (!cur.reasoningEffort) cur.reasoningEffort = "high"
-        } else {
-          // Custom-think models (MiniMax "adaptive") don't support "disabled" — remove the field instead
-          cur.thinking = isCustomThink ? undefined : { type: "disabled" }
-          delete cur.reasoningEffort
-        }
-        await syncProviderField("thinking", cur.thinking)
-        if (enable) {
-          await syncProviderField("reasoningEffort", cur.reasoningEffort)
-        } else {
-          await syncProviderField("reasoningEffort", undefined)
-        }
-      }
-    }
-  }
-
-  // Direct args: /think on|off │ /think effort <level>
-  // autoThink 开启时手动值每轮被覆盖（picker 里也隐藏了开关/effort 项），直参同样拒绝
   const autoThinkEnabled = agent.config?.agent?.autoThink === true
   const sub = args[0]?.toLowerCase()
   if (sub === "on" || sub === "off") {
     if (autoThinkEnabled) { pushLine("Auto-think is ON — manual settings are overridden each turn; turn Auto off first via /think", C.error); return }
-    await apply({ action: sub })
-    pushLine(`Thinking: ${sub}`, C.dim)
+    await applyThink({ action: sub }, agent, syncProviderField, spec, isEffortOnly, isCustomThink, thinkOnValue)
+    pushLabel("❯ Think", ansi.bold + C.tool)
+    pushLine(`Thinking: ${sub}`, C.tool)
     return
   }
   if (sub === "effort") {
@@ -72,29 +31,93 @@ export async function handleThinkCommand(ctx, args = []) {
       return
     }
     if (autoThinkEnabled) { pushLine("Auto-think is ON — manual settings are overridden each turn; turn Auto off first via /think", C.error); return }
-    await apply({ action: "effort", level })
-    pushLine(`Thinking effort: ${level}`, C.dim)
+    await applyThink({ action: "effort", level }, agent, syncProviderField, spec, isEffortOnly, isCustomThink, thinkOnValue)
+    pushLabel("❯ Think", ansi.bold + C.tool)
+    pushLine(`Thinking effort: ${level}`, C.tool)
     return
   }
   if (sub) { pushLine("Usage: /think [on|off|effort <level>]", C.error); return }
 
-  // "enabled" when thinking.type matches the model's enabled value, or when thinking is absent and the model is NOT a custom-think model (defaults to on for standard models)
-  const thinkingEnabled = cur.thinking?.type === thinkOnValue || (cur.thinking?.type === undefined && !isCustomThink)
-  const entries = []
-  // Auto-think: classify difficulty per-prompt and auto-set reasoning effort
-  entries.push({ type: "item", text: `Auto: ${autoThinkEnabled ? "ON" : "OFF"}`, action: "auto" })
-  if (!isEffortOnly) {
-    if (!autoThinkEnabled) entries.push({ type: "item", text: `Thinking: ${thinkingEnabled ? "ON" : "OFF"}`, action: thinkingEnabled ? "off" : "on" })
+  // ── Interactive loop ──
+  let mainIdx = 0
+  for (;;) {
+    const autoOn = agent.config?.agent?.autoThink === true
+    const thinkingEnabled = cur.thinking?.type === thinkOnValue
+      || (cur.thinking?.type === undefined && !isCustomThink)
+
+    const entries = [
+      { type: "header", text: `Auto: ${autoOn ? "ON" : "OFF"} | Thinking: ${thinkingEnabled ? "ON" : "OFF"} | Effort: ${cur.reasoningEffort || "—"}` },
+      { type: "item", text: `Auto: ${autoOn ? "ON" : "OFF"}`, action: "auto" },
+    ]
+    if (!isEffortOnly && !autoOn) {
+      entries.push({ type: "item", text: `Thinking: ${thinkingEnabled ? "ON" : "OFF"}`, action: thinkingEnabled ? "off" : "on" })
+    }
+    if (!autoOn) {
+      for (const level of effortLevels) {
+        const mark = cur.reasoningEffort === level ? "▸ " : "  "
+        entries.push({ type: "item", text: `${mark}effort: ${level}`, action: "effort", level })
+      }
+    }
+
+    const e = await showPicker("Think", entries, { defaultIndex: mainIdx })
+    if (!e) return // Esc
+    mainIdx = Math.max(0, entries.filter((en) => en.type === "item").indexOf(e))
+
+    const prevAuto = autoOn
+    const prevThinking = thinkingEnabled
+    const prevEffort = cur.reasoningEffort
+
+    await applyThink(e, agent, syncProviderField, spec, isEffortOnly, isCustomThink, thinkOnValue)
+
+    // Feedback
+    pushLabel("❯ Think", ansi.bold + C.tool)
+    if (e.action === "auto") {
+      const newAuto = agent.config?.agent?.autoThink === true
+      pushLine(`Auto-think: ${newAuto ? "ON" : "OFF"}`, C.tool)
+    } else if (e.action === "effort") {
+      pushLine(`Reasoning effort: ${e.level}`, C.tool)
+    } else {
+      const nowEnabled = cur.thinking?.type === thinkOnValue
+        || (cur.thinking?.type === undefined && !isCustomThink)
+      pushLine(`Thinking: ${nowEnabled ? "ON" : "OFF"}`, C.tool)
+    }
   }
-  if (spec.reasoningEffortEnum && !autoThinkEnabled) {
-    for (const level of spec.reasoningEffortEnum) {
-      const mark = cur.reasoningEffort === level ? "▸ " : "  "
-      entries.push({ type: "item", text: `${mark}effort: ${level}`, action: "effort", level })
+}
+
+/** Shared apply logic — extracted from handleThinkCommand for reuse in both fast path and loop */
+async function applyThink(e, agent, syncProviderField, spec, isEffortOnly, isCustomThink, thinkOnValue) {
+  const cur = agent.provider
+  if (e.action === "auto") {
+    const cfg = agent.config.agent ??= {}
+    cfg.autoThink = !cfg.autoThink
+    if (cfg.autoThink) {
+      delete cur.reasoningEffort
+      await syncProviderField("reasoningEffort", undefined)
+    }
+  } else if (e.action === "effort") {
+    cur.reasoningEffort = e.level
+    await syncProviderField("reasoningEffort", e.level)
+  } else {
+    const enable = e.action === "on"
+    if (isEffortOnly) {
+      if (!enable) delete cur.reasoningEffort
+      else if (!cur.reasoningEffort) cur.reasoningEffort = "high"
+      if (!enable) await syncProviderField("reasoningEffort", undefined)
+      else await syncProviderField("reasoningEffort", cur.reasoningEffort)
+    } else {
+      if (enable) {
+        cur.thinking = { type: thinkOnValue }
+        if (!cur.reasoningEffort) cur.reasoningEffort = "high"
+      } else {
+        cur.thinking = isCustomThink ? undefined : { type: "disabled" }
+        delete cur.reasoningEffort
+      }
+      await syncProviderField("thinking", cur.thinking)
+      if (enable) {
+        await syncProviderField("reasoningEffort", cur.reasoningEffort)
+      } else {
+        await syncProviderField("reasoningEffort", undefined)
+      }
     }
-  } else if (!autoThinkEnabled) {
-    entries.push({ type: "item", text: "effort: high", action: "effort", level: "high" })
-    entries.push({ type: "item", text: "effort: max", action: "effort", level: "max" })
   }
-  const e = await showPicker("Think", entries)
-  if (e) await apply(e)
 }

package/src/tui/index.mjs

@@ -80,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",
@@ -416,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)

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 || p._pendingDone)
+  // 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-frame.mjs

@@ -83,24 +83,47 @@ export function renderSubagent(allSubs, W) {
   return out
 }
 
-/** Tool output panels (streaming output like tail -f). Returns empty when no active output. */
+/** Per-kind panel colors: reasoning faint, tool progress cyan, main output gray. */
+const PANEL_KIND_COLORS = { think: C.reason, tool: C.tool, text: C.dim }
+
+/**
+ * Flatten panel parts into display lines, tracking each line's kind.
+ * A part not starting mid-line continues the previous line (kind of the line's first fragment wins).
+ */
+function panelLines(p) {
+  const lines = []
+  for (const part of p.parts ?? []) {
+    part.text.split("\n").forEach((seg, j) => {
+      if (j === 0 && lines.length > 0) {
+        const last = lines[lines.length - 1]
+        // Empty trailing line = previous part ended exactly at a line break — the new
+        // part owns this line's kind. Otherwise it's a genuine mid-line continuation.
+        if (last.text === "") last.kind = part.kind
+        last.text += seg
+      } else {
+        lines.push({ kind: part.kind, text: seg })
+      }
+    })
+  }
+  return lines.filter((l) => l.text.trim())
+}
+
+/** Tool output panels (streaming output like tail -f). Returns empty when no visible output. */
 export function renderOutput(state, W, panelH) {
-  const active = Object.values(state.outputPanels).filter((p) => !p.done)
+  // Same visibility predicate as computeLayout: done panels linger until closeAt
+  const active = Object.values(state.outputPanels).filter((p) => !p.done || (p.closeAt ?? 0) > Date.now())
   if (active.length === 0) return []
   const out = []
   const linesPerPanel = Math.max(1, Math.floor(panelH / active.length))
-  for (const p of active) {
-    const textLines = (p.text ?? "").split("\n").filter((l) => l.trim())
-    const tail = textLines.slice(-linesPerPanel)
-    for (const line of tail) {
-      out.push(`${C.dim}  │ ${sliceByWidth(sanitizeDisplay(line), W - 5)}${ansi.reset}`)
+  const perPanel = active.map((p) => panelLines(p).slice(-linesPerPanel))
+  for (const lines of perPanel) {
+    for (const l of lines) {
+      const color = PANEL_KIND_COLORS[l.kind] ?? C.dim
+      out.push(`${color}  │ ${sliceByWidth(sanitizeDisplay(l.text), W - 5)}${ansi.reset}`)
     }
   }
   // Fill remaining rows to match panelH exactly
-  const used = active.reduce((s, p) => {
-    const tl = (p.text ?? "").split("\n").filter((l) => l.trim()).slice(-linesPerPanel)
-    return s + tl.length
-  }, 0)
+  const used = perPanel.reduce((s, lines) => s + lines.length, 0)
   for (let i = used; i < panelH; i++) out.push("")
   return out
 }
@@ -230,80 +253,59 @@ export function renderStatus(state, agent, cols, slashCommands) {
 }
 
 // ====================================================================
-// Legacy: full-frame renderer (wraps individual panel functions)
+// Frame composition
 // ====================================================================
 
 /**
- * Render one frame, returns { frame, cursorRow, cursorCol }.
- * Pure function: does not modify state/agent.
- * @deprecated Prefer individual panel functions for incremental rendering.
+ * Compose the whole screen as a rows array, placing each panel at its
+ * layout-computed y coordinate. Single source of truth for what the screen
+ * should look like — the render loop diffs these rows against what it last
+ * wrote and repaints only changed rows (absolute positioning).
+ *
+ * @returns {{ rows: string[], cursorRow: number, cursorCol: number, layout: object }}
  */
-export function renderFrame(state, agent, opts) {
+export function renderRows(state, agent, opts) {
   const cols = opts.cols || 80
   const rows = opts.rows || 24
   const slashCommands = opts.slashCommands ?? []
-  const platform = opts.platform ?? process.platform
 
   const layout = computeLayout(state, { cols, rows })
   const { W, panels, inputLayout, inputOffset, boxLines, visibleTasks, allSubs, permPreviewLines, overlay } = layout
 
-  const out = [ansi.home]
-  let cursorRow = 0, cursorCol = 0
-
-  // header
-  out.push(`${renderHeader(agent, cols)}\x1b[K`)
-
-  // conversation
-  for (const l of renderConversation(state, cols, panels.conversation.h, state.scroll)) {
-    out.push(`${l}\x1b[K`)
-  }
-
-  // picker
-  if (panels.picker) {
-    for (const l of renderPicker(state, cols, panels.picker, overlay)) {
-      out.push(`${l}\x1b[K`)
+  const screen = new Array(rows).fill("")
+  const put = (y, lines) => {
+    for (let i = 0; i < lines.length && y + i < rows; i++) {
+      if (y + i >= 0) screen[y + i] = `${lines[i]}\x1b[K`
     }
   }
 
-  // todo
-  for (const l of renderTodo(visibleTasks, cols)) out.push(`${l}\x1b[K`)
-
-  // subagent
-  if (panels.subagent) {
-    for (const l of renderSubagent(allSubs, W)) out.push(`${l}\x1b[K`)
-  }
+  put(panels.header.y, [renderHeader(agent, cols)])
+  put(panels.conversation.y, renderConversation(state, cols, panels.conversation.h, state.scroll))
+  if (panels.subagent) put(panels.subagent.y, renderSubagent(allSubs, W))
+  if (panels.output) put(panels.output.y, renderOutput(state, W, panels.output.h))
+  if (panels.todo) put(panels.todo.y, renderTodo(visibleTasks, cols))
+  if (panels.picker) put(panels.picker.y, renderPicker(state, cols, panels.picker, overlay))
+  if (panels.permission) put(panels.permission.y, renderPermission(permPreviewLines))
+  if (panels.queue) put(panels.queue.y, [renderQueue(state, W)])
+  put(panels.inputBox.y, renderInputBox(state, W, boxLines, cols, inputLayout, inputOffset))
+  put(panels.status.y, [renderStatus(state, agent, cols, slashCommands)])
 
-  // output panels
-  if (panels.output) {
-    for (const l of renderOutput(state, W, panels.output.h)) out.push(`${l}\x1b[K`)
-  }
-
-  // permission preview
-  if (panels.permission) {
-    for (const l of renderPermission(permPreviewLines)) out.push(`${l}\x1b[K`)
-  }
-
-  // queue preview
-  if (panels.queue) {
-    const qLine = renderQueue(state, W)
-    if (qLine) out.push(`${qLine}\x1b[K`)
-  }
-
-  // input box
-  for (const l of renderInputBox(state, W, boxLines, cols, inputLayout, inputOffset)) out.push(`${l}\x1b[K`)
-
-  // status bar
-  out.push(`${renderStatus(state, agent, cols, slashCommands)}\x1b[K`)
-
-  const frame = out.join("\r\n")
-
-  // cursor position
+  let cursorRow = 0, cursorCol = 0
   if (!state.permission && !state.question && !state.picker && state.wizard?.step !== "provider") {
     cursorRow = panels.inputBox.y + 1 + (inputLayout.cursorLine - inputOffset) + 1
     cursorCol = 3 + inputLayout.cursorCol
   }
 
-  return { frame, cursorRow, cursorCol }
+  return { rows: screen, cursorRow, cursorCol, layout }
+}
+
+/**
+ * Render one frame, returns { frame, cursorRow, cursorCol }.
+ * @deprecated Use renderRows + row-diff (render-loop). Kept for tests/legacy callers.
+ */
+export function renderFrame(state, agent, opts) {
+  const { rows, cursorRow, cursorCol } = renderRows(state, agent, opts)
+  return { frame: rows.join("\r\n"), cursorRow, cursorCol }
 }
 
 // ====================================================================