fix(tui): show line count and preview in collapsed ReadFile cards

Collapsed reads said "Read 1 file (ctrl+o to expand)", hiding the line count
and content so a successful read looked like it returned nothing. Render a
line-count-aware summary with the file basename (e.g. "Read 140 lines from
console.py") plus a short, cell-width-capped preview of the leading lines.

Line count prefers the tool message, falls back to counting the body, and
stays truthful when unknowable ("Read file content") or empty ("Read 0
lines"). Preview is ANSI-sanitized, capped to a few visual lines, width-capped
per line, and skipped on narrow terminals. Expanded mode and the LLM-facing
tool result are unchanged.

Author: elkaix

src/pythinker_code/ui/shell/tool_renderers/read.py

@@ -7,11 +7,15 @@
 
 from __future__ import annotations
 
+import re
+from pathlib import PurePosixPath, PureWindowsPath
 from typing import Any
 
 from rich.console import Group, RenderableType
 from rich.text import Text
 
+from pythinker_code.ui.shell.components import sanitize_ansi
+from pythinker_code.ui.shell.components.render_utils import truncate_to_width
 from pythinker_code.ui.shell.tool_renderers import (
     ToolRenderContext,
     ToolRenderDefinition,
@@ -27,10 +31,16 @@
     pending_tool_call_header,
     running_spinner,
     shorten_path,
+    tab_to_spaces,
     tool_call_header,
 )
+from pythinker_code.ui.theme import tui_rich_style
 
 _TOOL_NAME = "ReadFile"
+# Compact collapsed preview: a few leading lines so humans/models can confirm
+# content was returned without dumping the file. Expanded mode shows it all.
+_PREVIEW_MAX_LINES = 4
+_LINES_READ_RE = re.compile(r"(\d+)\s+lines?\s+read")
 
 
 def _format_line_range(args: dict[str, Any]) -> Text | None:
@@ -98,6 +108,77 @@ def _friendly_error(text: str) -> str:
     return "Error reading file"
 
 
+def _basename(path: Any) -> str | None:
+    """Display basename for a read path, or ``None`` when unavailable.
+
+    The call row already shows the (shortened) path, so the result summary only
+    needs the leaf name — and never a fuller path that would leak more than the
+    call row already does. Handle both POSIX and Windows separators since the
+    path is model-supplied text, not a resolved local path.
+    """
+    raw = as_str(path)
+    if raw is None or not raw.strip():
+        return None
+    name = PureWindowsPath(PurePosixPath(raw).name).name
+    return name or None
+
+
+def _line_count(message: str | None, output_text: str) -> int | None:
+    """Lines read in this call: prefer the tool message, else count the body.
+
+    Returns ``None`` only when the count is genuinely unknowable (no message and
+    no body) — callers must then avoid asserting a count rather than lie with 0.
+    """
+    if message:
+        match = _LINES_READ_RE.search(message)
+        if match:
+            return int(match.group(1))
+        if "no lines read" in message.lower():
+            return 0
+    if output_text:
+        cleaned = output_text.rstrip("\n")
+        return cleaned.count("\n") + 1 if cleaned else 0
+    return None
+
+
+def _summary_text(count: int | None, basename: str | None) -> str:
+    if count is None:
+        head = "Read file content"
+    else:
+        head = f"Read {count} {'line' if count == 1 else 'lines'}"
+    if basename:
+        head += f" from {basename}"
+    return head
+
+
+def _preview(output_text: str, width: int) -> Text | None:
+    """A few leading body lines, ANSI-stripped and width-capped per line.
+
+    Caps both the number of visual lines (``_PREVIEW_MAX_LINES``) and each
+    line's width so a file with very long lines can never produce giant
+    collapsed output. Returns ``None`` when there is nothing friendly to show.
+    """
+    cleaned = sanitize_ansi(output_text or "").rstrip("\n")
+    if not cleaned:
+        return None
+    # Width ceiling keyed off terminal cell width, leaving room for the card
+    # gutter so each preview line stays on a single visual row. On a terminal
+    # too narrow to show anything useful, skip the preview entirely.
+    limit = min(max(width - 6, 0), 200)
+    if limit < 12:
+        return None
+    out = Text(style=tui_rich_style("tool_output"))
+    for index, line in enumerate(cleaned.split("\n")[:_PREVIEW_MAX_LINES]):
+        if index:
+            out.append("\n")
+        # Cell-width aware: a wide-glyph / CJK / emoji line is truncated by the
+        # space it actually occupies, not its character count.
+        out.append(truncate_to_width(tab_to_spaces(line), limit))
+    out.no_wrap = True
+    out.overflow = "ellipsis"
+    return out if out.plain else None
+
+
 def _render_result(ctx: ToolRenderContext, result: ToolResultPayload) -> RenderableType | None:
     ctx.state["__suppress_generic_expand_hint__"] = True
     if result.is_error:
@@ -109,13 +190,24 @@ def _render_result(ctx: ToolRenderContext, result: ToolResultPayload) -> Rendera
     if isinstance(message, str) and message.startswith("Directory listing for `"):
         return fg("tool_output", "Listed 1 directory")
 
+    # An empty string is a valid (empty-file) body — only fall back to the
+    # flattened text when ``output`` is absent/non-string, so an empty read
+    # never inherits unrelated metadata from ``result.text``.
     output = result.details.get("output")
-    output_text = output if isinstance(output, str) and output else result.text
+    output_text = output if isinstance(output, str) else result.text
+
+    count = _line_count(message if isinstance(message, str) else None, output_text)
+    basename = _basename(ctx.args.get("path"))
+    summary = _summary_text(count, basename)
+
     if not output_text:
-        return fg("tool_output", "Read 1 file")
+        # Nothing to preview or expand (empty file / no body): truthful summary only.
+        return fg("tool_output", summary)
 
     if not ctx.expanded:
-        return fg("tool_output", "Read 1 file (ctrl+o to expand)")
+        collapsed = fg("tool_output", f"{summary} (ctrl+o to expand)")
+        preview = _preview(output_text, ctx.width)
+        return Group(collapsed, preview) if preview is not None else collapsed
 
     start_line = 1
     offset = ctx.args.get("line_offset")
@@ -128,11 +220,7 @@ def _render_result(ctx: ToolRenderContext, result: ToolResultPayload) -> Rendera
         start_line=start_line,
         style_token="tool_output",
     )
-    return (
-        Group(fg("tool_output", "Read 1 file"), body)
-        if body.plain
-        else fg("tool_output", "Read 1 file")
-    )
+    return Group(fg("tool_output", summary), body) if body.plain else fg("tool_output", summary)
 
 
 READ_RENDERER = ToolRenderDefinition(

tests/ui_and_conv/test_tui_card_tool_renderers.py

@@ -134,7 +134,9 @@ def test_read_renders_path_and_range():
     assert "⏺ Read(" in rendered
     assert "src/foo.py" in rendered
     assert ":10-39" in rendered
-    assert "Read 1 file (ctrl+o to expand)" in rendered
+    # Line-count-aware summary with basename, not the generic "Read 1 file".
+    assert "Read 2 lines from foo.py (ctrl+o to expand)" in rendered
+    assert "Read 1 file" not in rendered
 
 
 def test_read_renders_negative_offset_as_tail():
@@ -158,12 +160,93 @@ def test_read_renders_negative_offset_with_limit():
     assert ":tail 100 · limit 20" in rendered
 
 
-def test_read_result_matches_reference_summary_only():
+def test_read_collapsed_shows_count_and_capped_preview():
     body = "\n".join(f"line {i}" for i in range(20))
     rendered = _render("ReadFile", {"path": "/repo/x.py"}, output=body)
-    assert "Read 1 file (ctrl+o to expand)" in rendered
-    assert "line 0" not in rendered
-    assert "more lines" not in rendered
+    # Line-count-aware summary replaces the generic "Read 1 file".
+    assert "Read 20 lines from x.py (ctrl+o to expand)" in rendered
+    assert "Read 1 file" not in rendered
+    # A short preview of leading lines is shown, but the preview is capped:
+    # the first line appears, a line past the cap does not.
+    assert "line 0" in rendered
+    assert "line 19" not in rendered
+
+
+def test_read_collapsed_caps_preview_line_width_no_giant_output():
+    # A single very long line must not blow up the collapsed card height.
+    long_line = "x" * 500
+    rendered = _render("ReadFile", {"path": "/repo/big.py"}, output=long_line, width=80)
+    assert "Read 1 line from big.py (ctrl+o to expand)" in rendered
+    # Width-capped: the full 500-char line is truncated, so total output stays small.
+    assert "x" * 500 not in rendered
+    assert rendered.count("\n") < 6
+
+
+def test_read_preview_skips_on_narrow_terminal():
+    from pythinker_code.ui.shell.tool_renderers.read import _preview
+
+    # Too narrow to show anything useful → no preview at all.
+    assert _preview("some content here", width=10) is None
+    # Roomy terminal → preview present.
+    assert _preview("some content here", width=100) is not None
+
+
+def test_read_preview_truncates_by_cell_width_not_char_count():
+    # Wide (2-cell) glyphs must be measured by display width, so the preview
+    # line fits the column budget instead of overflowing on char count alone.
+    from pythinker_code.ui.shell.components.render_utils import cell_len
+    from pythinker_code.ui.shell.tool_renderers.read import _preview
+
+    preview = _preview("世" * 200, width=60)
+    assert preview is not None
+    assert cell_len(preview.plain) <= 60
+
+
+def test_read_collapsed_uses_message_line_count():
+    rendered = _render(
+        "ReadFile",
+        {"path": "/repo/src/_live_view.py", "line_offset": 1, "n_lines": 1000},
+        details={
+            "message": "140 lines read from file starting from line 1. Total lines in file: 320.",
+            "output": "     1\tdef view():\n     2\t    return 1",
+        },
+    )
+    assert "Read 140 lines from _live_view.py (ctrl+o to expand)" in rendered
+
+
+def test_read_collapsed_falls_back_when_count_unknown():
+    # No message and no body text → count is unknowable; never assert a fake 0.
+    rendered = _render("ReadFile", {"path": "/repo/x.py"}, details={"message": ""})
+    assert "Read file content" in rendered
+    assert "Read 0 lines" not in rendered
+
+
+def test_read_collapsed_empty_file_is_truthful():
+    rendered = _render(
+        "ReadFile",
+        {"path": "/repo/empty.py"},
+        details={"message": "No lines read from file. Total lines in file: 0."},
+    )
+    assert "Read 0 lines from empty.py" in rendered
+    # Nothing to expand for an empty file.
+    assert "ctrl+o to expand" not in rendered
+
+
+def test_read_collapsed_preview_sanitizes_control_sequences():
+    body = "\x1b[31mred\x1b[0m\x07\nsecond"
+    rendered = _render("ReadFile", {"path": "/repo/x.py"}, output=body)
+    assert "red" in rendered
+    assert "\x1b" not in rendered
+    assert "\x07" not in rendered
+
+
+def test_read_expanded_shows_full_content():
+    body = "\n".join(f"line {i}" for i in range(20))
+    rendered = _render("ReadFile", {"path": "/repo/x.py"}, output=body, expanded=True)
+    assert "Read 20 lines from x.py" in rendered
+    # Every line is present when expanded, including past the collapsed cap.
+    assert "line 0" in rendered
+    assert "line 19" in rendered
 
 
 def test_read_error_prefers_structured_message():

tests/ui_and_conv/test_tui_transcript_enhancements.py

@@ -71,7 +71,7 @@ def test_finished_expandable_tool_card_remains_available_after_flush(monkeypatch
     block = view._completed_expandable_tool_card()
     assert block is not None
     expanded = render_plain(block.render_expanded(), width=100)
-    assert "Read 1 file" in expanded
+    assert "Read 20 lines from big.py" in expanded
     assert "line 0" in expanded
     assert "line 19" in expanded