thincoder 0.12.11 → 0.12.13

package/src/tui/render-conversation.mjs

@@ -17,17 +17,29 @@ let _convCache = { key: "", cols: 0, lines: [] }
  * @returns {string} ANSI-rendered line whose display width equals stringWidth(text)
  */
 function renderMarkdownPreservingWidth(text) {
-  const rendered = renderMarkdownInline(renderMarkdownHeading(text))
-  const diff = stringWidth(text) - stringWidth(rendered)
-  return diff > 0 ? rendered + " ".repeat(diff) : rendered
+  // Line-by-line: render + compensate per line. The per-line padding serves
+  // NON-table text (so `**bold** text` next to plain text keeps its width).
+  // Table alignment is NOT provided by the padding — formatTables strips cell
+  // padding during trim and recomputes widths from the RENDERED text (that is
+  // the render-before-measure contract).
+  return text.split("\n").map((line) => {
+    const rendered = renderMarkdownInline(renderMarkdownHeading(line))
+    const diff = stringWidth(line) - stringWidth(rendered)
+    return diff > 0 ? rendered + " ".repeat(diff) : rendered
+  }).join("\n")
 }
+// Test seam (mirrors the _-prefixed seams in run.mjs).
+export { renderMarkdownPreservingWidth as _renderMarkdownPreservingWidth }
 
 
 export function convCacheKey(state) {
   const lastLine = state.lines.length > 0 ? state.lines[state.lines.length - 1] : null
   // expandedBlocks participates: expanding/folding a block must invalidate the cache
   const exp = state.expandedBlocks ? [...state.expandedBlocks].sort().join(",") : ""
-  return `${state.lines.length}|${lastLine?.text.length ?? 0}|${state.streaming.length}|${state.reasoning.length}|${state.advisorStreaming?.length ?? 0}|${state._advisorThink?.length ?? 0}|${state.foldEnabled !== false ? "f" : "u"}|${exp}`
+  // Content prefix in the signature: same kind+length with different content
+  // would otherwise collide (stale render); 8 chars disambiguate in practice.
+  const blocksSig = (state._advisorBlocks ?? []).map((b) => `${b.kind}:${b.text?.length ?? 0}:${String(b.text ?? "").slice(0, 8)}`).join(",")
+  return `${state.lines.length}|${lastLine?.text.length ?? 0}|${state.streaming.length}|${state.reasoning.length}|${blocksSig}|${state.foldEnabled !== false ? "f" : "u"}|${exp}`
 }
 
 /** Fold marker line: bold-cyan icon + "click to …" phrase underlined (clickable affordance).
@@ -70,6 +82,13 @@ function highlightSearchMatches(text, query, matchesInLine, globalCurrentIndex,
   return result
 }
 
+/**
+ * Build the conversation lines for the given state.
+ * NOTE: module-level _convCache is read/written as a side effect (keyed by
+ * convCacheKey + cols) — the function is pure w.r.t. its input except for
+ * that cache; direct callers outside renderConversation/countConvLines
+ * should be aware the cache persists across calls.
+ */
 function buildConvLines(state, cols) {
   const key = convCacheKey(state)
   if (_convCache.key === key && _convCache.cols === cols) return _convCache.lines
@@ -90,19 +109,25 @@ function buildConvLines(state, cols) {
 
     // Long-message folding: ANY single line (main output C.text, thinking C.reason,
     // tool summaries C.dim — whatever wraps beyond LONG_FOLD_LINES display rows)
-    // collapses to [blank, ▶, first 4, last] — 5 content lines. Main output and
-    // thinking are the REAL long content; bidirectional folding (collapse markers
-    // + click toggle) keeps them readable — the 0.12.7 dim-only restriction was a
-    // temporary fix for the single-direction era and is now reverted. Keyed by the
-    // source-line index (`long-${i}`) so the toggle survives re-renders.
+    // collapses to [first 4, ▶, last]; expanded long blocks render as
+    // [blank, ▼, every line]. Main output and thinking are the REAL long
+    // content; bidirectional folding (collapse markers + click toggle) keeps
+    // them readable — the 0.12.7 dim-only restriction was a temporary fix for
+    // the single-direction era and is now reverted. Keyed by the source-line
+    // index (`long-${i}`) so the toggle survives re-renders.
     const longKey = `long-${i}`
     const folded = state.foldEnabled !== false && !state.expandedBlocks?.has(longKey)
     const block = []
-    for (const line of formatTables(sanitizeDisplay(text), cols - 1)) {
+    // Lightweight markdown display (IK5VW3): render BEFORE measuring — the
+    // table column math (formatTables) and wrapping must see the RENDERED
+    // text (ANSI consumes zero display width; the width functions are
+    // ANSI-aware). Rendering after wrapping measured raw markdown
+    // (`**bold**` = 8) against displayed text (4) and sliced markers
+    // mid-sequence — the table misalignment the user kept reporting.
+    const renderedText = renderMarkdownPreservingWidth(sanitizeDisplay(text))
+    for (const line of formatTables(renderedText, cols - 1)) {
       for (const wrapped of wrapText(line, cols - 1)) {
-        // Lightweight markdown display (IK5VW3): headings bold + inline markers styled.
-        // Runs AFTER wrapping so the ANSI it inserts never skews width math.
-        block.push({ text: renderMarkdownPreservingWidth(wrapped), color: l.color, _foldId: l._foldId, _src: i })
+        block.push({ text: wrapped, color: l.color, _foldId: l._foldId, _src: i })
       }
     }
     if (folded && block.length > LONG_FOLD_LINES) {
@@ -114,15 +139,21 @@ function buildConvLines(state, cols) {
       convLines.push(foldHintLine(`▶ … ${block.length - FOLD_KEEP} more lines — click to expand`, longKey, i))
       convLines.push(block[block.length - 1])
     } else if (block.length > LONG_FOLD_LINES) {
-      // EXPANDED long block: blank line + ▼ control line at the HEAD, directly
-      // before the content. DIM blocks must not re-trigger the consecutive-dim
-      // folding below (folding stacked on folding — reported regression).
-      if (l.color === C.dim) {
-        for (const line of block) line._skipDimFold = true
+      if (state.foldEnabled === false) {
+        // Folding fully off — content already fully visible; a "click to
+        // collapse" hint would be misleading (toggling has no effect).
+        convLines.push(...block)
+      } else {
+        // EXPANDED long block: blank line + ▼ control line at the HEAD, directly
+        // before the content. DIM blocks must not re-trigger the consecutive-dim
+        // folding below (folding stacked on folding — reported regression).
+        if (l.color === C.dim) {
+          for (const line of block) line._skipDimFold = true
+        }
+        convLines.push(blankLine())
+        convLines.push(foldHintLine(`▼ … ${block.length} lines — click to collapse`, longKey, i))
+        convLines.push(...block)
       }
-      convLines.push(blankLine())
-      convLines.push(foldHintLine(`▼ … ${block.length} lines — click to collapse`, longKey, i))
-      convLines.push(...block)
     } else {
       convLines.push(...block)
     }
@@ -132,25 +163,40 @@ function buildConvLines(state, cols) {
       convLines.push({ text: wrapped, color: C.reason })
     }
   }
-  if (state._advisorThink || state.advisorStreaming) {
-    const thinkLines = state._advisorThink ? sanitizeDisplay(state._advisorThink).split("\n") : []
-    const mainLines = state.advisorStreaming
-      ? formatTables(sanitizeDisplay(state.advisorStreaming), cols - 3)
-      : []
-    const allLines = [...thinkLines.map(l => ({ text: l, color: C.reason })), ...mainLines.map(l => ({ text: l, color: C.text }))]
-    const truncated = allLines.length > 5
-    if (truncated) convLines.push({ text: "│ …", color: C.dim })
-    const shown = truncated ? allLines.slice(-5) : allLines
-    for (const { text, color } of shown) {
-      for (const wrapped of wrapText(text, cols - 3)) {
-        convLines.push({ text: `│ ${wrapped}`, color })
+  const advisorBlocks = state._advisorBlocks ?? []
+  if (advisorBlocks.length > 0) {
+    // ORDERED block display — the blocks preserve the emission order
+    // (think → tool → think → … → final) and render as one interleaved
+    // stream: thinking in reasoning color, tool progress/final in text color.
+    // Full-length, no preview truncation; long content scrolls via the
+    // conversation window like everything else.
+    // NOTE: formatTables returns an ARRAY of lines (not a string) — calling
+    // .split on it crashed the whole render (tools/final never displayed).
+    for (const block of advisorBlocks) {
+      const color = { think: C.reason, tool: C.tool, text: C.text }[block.kind] ?? C.text
+      const source = sanitizeDisplay(block.text)
+      // kind:"text" (the final review prose) gets the same lightweight markdown
+      // styling as the main agent response. Rendered BEFORE measuring: the
+      // width math (formatTables / wrapText) must see the RENDERED text —
+      // measuring raw markdown (`**bold**` = 8) against displayed text (4)
+      // misaligned table columns; wrapping raw markdown sliced markers
+      // mid-sequence (`**bo` + `ld**`) so the renderer never saw complete ones.
+      const rows = block.kind === "think"
+        ? source.split("\n")
+        : formatTables(block.kind === "text" ? renderMarkdownPreservingWidth(source) : source, cols - 3)
+      for (const line of rows) {
+        for (const wrapped of wrapText(line, cols - 3)) {
+          convLines.push({ text: `│ ${wrapped}`, color })
+        }
       }
     }
   }
   if (state.streaming) {
-    for (const line of formatTables(sanitizeDisplay(state.streaming), cols - 1)) {
+    // Rendered BEFORE formatTables — see the advisor-block comment above.
+    const rendered = renderMarkdownPreservingWidth(sanitizeDisplay(state.streaming))
+    for (const line of formatTables(rendered, cols - 1)) {
       for (const wrapped of wrapText(line, cols - 1)) {
-        convLines.push({ text: renderMarkdownPreservingWidth(wrapped), color: C.text })
+        convLines.push({ text: wrapped, color: C.text })
       }
     }
   }
@@ -177,10 +223,15 @@ function buildConvLines(state, cols) {
           i = j
           continue
         }
-        // EXPANDED consecutive-dim block: blank + ▼ at the HEAD, then every line
-        folded.push(blankLine())
-        folded.push(foldHintLine(`▼ … ${blockLen} lines — click to collapse`, foldKey))
-        for (let k = i; k < j; k++) folded.push(convLines[k])
+        // EXPANDED consecutive-dim block: blank + ▼ at the HEAD, then every line.
+        // foldEnabled=false → raw block, no hint (toggling would be a no-op).
+        if (state.foldEnabled === false) {
+          for (let k = i; k < j; k++) folded.push(convLines[k])
+        } else {
+          folded.push(blankLine())
+          folded.push(foldHintLine(`▼ … ${blockLen} lines — click to collapse`, foldKey))
+          for (let k = i; k < j; k++) folded.push(convLines[k])
+        }
         i = j
         continue
       }

package/src/tui/tool-summaries.mjs

@@ -0,0 +1,113 @@
+/**
+ * tool-summaries.mjs — one-line tool-result summaries for the TUI "done" lines.
+ * Extracted from agent-turn.mjs (file-size split): pure functions, no state.
+ */
+
+/** Extract a one-line summary from tool output for the done line */
+export function formatToolSummary(name, result) {
+  if (name === "verify") return _verifySummary(result)
+  if (name === "bash") return _bashSummary(result)
+  if (name === "advisor") return _advisorSummary(result)
+  if (name === "read" || name === "read_file") return _readSummary(result)
+  if (name === "write" || name === "write_file") return _writeSummary(result)
+  if (name === "grep" || name === "search") return _grepSummary(result)
+  if (name === "glob") return _globSummary(result)
+  // Default: first non-empty line
+  const first = result.split("\n").find((l) => l.trim())
+  return first ? `${name}: ${first.slice(0, 100)}` : null
+}
+
+function _readSummary(result) {
+  const lines = result.split("\n")
+  // Look for line count in result
+  const countMatch = result.match(/(\d+) lines?/)
+  if (countMatch) return `${countMatch[1]} lines`
+  // Fallback: count actual lines
+  return `${lines.length} lines`
+}
+
+function _writeSummary(result) {
+  // Extract file size or confirmation
+  if (result.includes("wrote") || result.includes("created")) {
+    const sizeMatch = result.match(/(\d+)(?:\s*(?:bytes?|chars?))/i)
+    return sizeMatch ? `wrote ${sizeMatch[1]} bytes` : "wrote file"
+  }
+  const first = result.split("\n").find((l) => l.trim())
+  return first ? first.slice(0, 80) : "wrote"
+}
+
+function _grepSummary(result) {
+  const lines = result.split("\n").filter((l) => l.trim())
+  const count = lines.length
+  if (count === 0) return "no matches"
+  if (count === 1) return "1 match"
+  return `${count} matches`
+}
+
+function _globSummary(result) {
+  const lines = result.split("\n").filter((l) => l.trim())
+  const count = lines.length
+  if (count === 0) return "no files"
+  if (count === 1) return "1 file"
+  return `${count} files`
+}
+
+/**
+ * bash result format: "[stdout]:\n<out>\n\n[stderr]:\n<err>\n\n(exit code 0)".
+ * The first non-empty line is always the "[stdout]:" marker — useless as a summary.
+ * Show the LAST output line (usually the meaningful tail) plus the exit status.
+ */
+function _bashSummary(result) {
+  const isMarker = (l) => /^\[(stdout|stderr)\]:$/.test(l) || /^\((exit code|killed)/.test(l)
+  const lines = result.split("\n").map((l) => l.trim()).filter((l) => l && !isMarker(l))
+  const status = result.match(/\((?:exit code|killed)[^)]*\)/)?.[0]
+  const parts = []
+  if (lines.length > 0) parts.push(lines[lines.length - 1].slice(0, 100))
+  if (status) parts.push(status)
+  return parts.length > 0 ? `bash: ${parts.join(" ")}` : null
+}
+
+function _advisorSummary(result) {
+  const text = String(result ?? "")
+  // Error / skip messages — extract the reason after "Advisor:"
+  const errMatch = text.trimStart().match(/^Advisor:\s*(.+)/)
+  if (errMatch) return `advisor: ${errMatch[1].split(".")[0]}`
+  const critical = (text.match(/\| \d+ \|.*\| 🔴/g) || []).length
+  const advisory = (text.match(/\| \d+ \|.*\| 🟡/g) || []).length
+  const style = (text.match(/\| \d+ \|.*\| 🔵/g) || []).length
+  // Protocol: zero 🔴 rows in the review table = pass (phrase fallback for
+  // table-free summaries like "No issues found").
+  if (critical === 0 && (/\| \d+ \|/.test(text)
+    || /no\s+🔴|all.*(?:resolved|fixed|pass)|pass(?:es|ed)?\b|no\s+(?:critical\s+)?issues?/i.test(text))) {
+    return "advisor: passed"
+  }
+  const parts = []
+  if (critical) parts.push(`${critical} critical`)
+  if (advisory) parts.push(`${advisory} advisory`)
+  if (style) parts.push(`${style} style`)
+  if (parts.length === 0) return null
+  return `advisor: ${parts.join(", ")}`
+}
+
+function _verifySummary(result) {
+  const lines = result.split("\n")
+  const summary = []
+  // Changed files count
+  const changed = lines.find((l) => l.startsWith("Changed files:"))
+  if (changed) {
+    const m = changed.match(/files changed/) ? changed.replace(/^Changed files \(.*?\)/, "Changed files") : changed
+    summary.push(m)
+  }
+  // Syntax check results
+  const syntax = lines.filter((l) => l.startsWith("  ✗"))
+  if (syntax.length > 0) {
+    summary.push(`${syntax.length} syntax error(s)`)
+  }
+  // Test results
+  const testLine = lines.find((l) => l.startsWith("✓ Tests passed.") || l.startsWith("✗ Tests FAILED"))
+  if (testLine) summary.push(testLine.trim())
+  // Task list
+  const taskLine = lines.find((l) => l.startsWith("Task list:"))
+  if (taskLine) summary.push(taskLine)
+  return summary.length > 0 ? `verify: ${summary.join(" — ")}` : ""
+}