iCode-TUI 0.29.1__py3-none-any.whl

chrys/app/tui/widgets/chat/renderers/hosted_search.py

@@ -0,0 +1,167 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Rich renderer for provider-hosted search and fetch calls."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any
+
+from chrys.app.tui.widgets.chat.renderers.hosted_generic import (
+    HOSTED_RESULT,
+    HostedToolCall,
+    _bounded_json,
+    _bounded_text,
+    _display_text,
+    _first_value,
+    _hosted_card_css,
+    _parsed_mapping,
+    _sequence,
+)
+from chrys.foundation.i18n import msg
+from chrys.foundation.i18n.formatting import sanitize_legacy_block, sanitize_legacy_scalar
+
+_HOSTED_SEARCH_RESULT_COUNT = msg(
+    "tui.hosted.search.result_count",
+    fallback="{count} result",
+    plural_fallback="{count} results",
+)
+_HOSTED_SEARCH_QUERIES = msg("tui.hosted.search.queries", fallback="Queries:")
+_HOSTED_SEARCH_QUERY_ACTION = msg("tui.hosted.search.query_action", fallback="Query/action:")
+_HOSTED_SEARCH_RESULTS = msg("tui.hosted.search.results", fallback="Results: {n}")
+_HOSTED_SEARCH_CITATIONS = msg(
+    "tui.hosted.search.citations",
+    fallback="Citations and URLs:",
+)
+_HOSTED_SEARCH_EMPTY = msg(
+    "tui.hosted.search.empty",
+    fallback="No search details returned",
+)
+
+
+def _search_subject(args: Mapping[str, Any]) -> str:
+    queries = _sequence(args.get("queries"))
+    if queries:
+        subject = _display_text(queries[0])
+        return f"{subject} +{len(queries) - 1}" if len(queries) > 1 else subject
+    action = args.get("action")
+    if isinstance(action, Mapping):
+        value = _first_value(action, "query", "url", "type")
+        if value is not None:
+            return _display_text(value)
+    value = _first_value(args, "query", "url", "input")
+    return _display_text(value)
+
+
+def _search_action_type(args: Mapping[str, Any]) -> str:
+    action_type = args.get("type")
+    if isinstance(action_type, str) and action_type.strip():
+        return action_type.strip()
+    action = args.get("action")
+    if isinstance(action, Mapping):
+        action_type = action.get("type")
+        if isinstance(action_type, str) and action_type.strip():
+            return action_type.strip()
+    return ""
+
+
+def _result_items(parsed: Mapping[str, Any]) -> list[Any]:
+    for key in ("results", "citations", "items"):
+        items = _sequence(parsed.get(key))
+        if items:
+            return items
+    return []
+
+
+def _result_count(result: str, metadata: Mapping[str, Any]) -> int | None:
+    for key in ("result_count", "results_count", "count"):
+        value = metadata.get(key)
+        if isinstance(value, int) and not isinstance(value, bool):
+            return value
+    parsed = _parsed_mapping(result)
+    for key in ("results", "citations", "items"):
+        if key in parsed:
+            return len(_sequence(parsed[key]))
+    return None
+
+
+def _is_action_echo(result: str) -> bool:
+    candidate = result.removeprefix("Error: ").strip()
+    return set(_parsed_mapping(candidate)) == {"action"}
+
+
+def _citation_lines(parsed: Mapping[str, Any]) -> list[str]:
+    lines: list[str] = []
+    for item in _result_items(parsed)[:5]:
+        if isinstance(item, Mapping):
+            title = _first_value(item, "title", "filename", "name", "text")
+            url = _first_value(item, "url", "uri")
+            if title is not None and url is not None:
+                lines.append(f"- {_display_text(title)} — {_display_text(url)}")
+            elif url is not None:
+                lines.append(f"- {_display_text(url)}")
+            else:
+                lines.append(f"- {_bounded_json(item)}")
+        else:
+            lines.append(f"- {_display_text(item)}")
+    return lines
+
+
+class HostedSearchToolCall(HostedToolCall):
+    """Search/fetch card with query, result-count, and citation summaries."""
+
+    DEFAULT_CSS = _hosted_card_css("HostedSearchToolCall")
+
+    def __init__(
+        self,
+        call_id: str,
+        tool_name: str,
+        args_summary: str = "",
+        args: dict[str, Any] | None = None,
+    ) -> None:
+        super().__init__(call_id, tool_name, args_summary, args=args)
+        self._result_count: int | None = None
+
+    def _label_details(self) -> list[str]:
+        details: list[str] = []
+        subject = _search_subject(self.args)
+        if subject:
+            details.append(sanitize_legacy_scalar(_bounded_text(subject)))
+        if self._result_count is not None:
+            details.append(self._render_message(_HOSTED_SEARCH_RESULT_COUNT.bind(count=self._result_count)))
+        return details
+
+    def _border_title_text(self) -> str:
+        return sanitize_legacy_scalar(_search_action_type(self.args) or self.tool_name)
+
+    def _format_complete_details(self, result: str) -> str:
+        parsed = _parsed_mapping(result)
+        sections: list[str] = []
+        queries = _sequence(self.args.get("queries"))
+        if queries:
+            sections.append(
+                f"{self._render_message(_HOSTED_SEARCH_QUERIES.bind())} {sanitize_legacy_block(_bounded_json(queries))}"
+            )
+        elif subject := _search_subject(self.args):
+            sections.append(
+                f"{self._render_message(_HOSTED_SEARCH_QUERY_ACTION.bind())} "
+                f"{sanitize_legacy_block(_bounded_text(subject))}"
+            )
+        if self._result_count is not None:
+            sections.append(self._render_message(_HOSTED_SEARCH_RESULTS.bind(n=self._result_count)))
+        citations = _citation_lines(parsed)
+        if citations:
+            sections.append(
+                f"{self._render_message(_HOSTED_SEARCH_CITATIONS.bind())}\n"
+                f"{sanitize_legacy_block(_bounded_text(chr(10).join(citations)))}"
+            )
+        elif result and not _is_action_echo(result):
+            sections.append(
+                f"{self._render_message(HOSTED_RESULT.bind())}\n{sanitize_legacy_block(_bounded_text(result))}"
+            )
+        return "\n\n".join(sections) or self._render_message(_HOSTED_SEARCH_EMPTY.bind())
+
+    def set_complete(self, result: str, duration_ms: int = 0, **kwargs: Any) -> None:
+        metadata = kwargs.get("metadata")
+        self._result_count = _result_count(result, metadata if isinstance(metadata, Mapping) else {})
+        super().set_complete(result, duration_ms, **kwargs)

chrys/app/tui/widgets/chat/renderers/hosted_shell.py

@@ -0,0 +1,132 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Rich renderer for provider-hosted shell execution."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any
+
+from chrys.app.tui.widgets.chat.renderers.hosted_generic import (
+    HOSTED_FILES,
+    HOSTED_OUTPUT,
+    HostedToolCall,
+    _artifact_summary,
+    _bounded_text,
+    _display_text,
+    _first_value,
+    _hosted_card_css,
+    _parsed_mapping,
+    _sequence,
+)
+from chrys.app.tui.widgets.chat.renderers.skill import SKILL_EXIT
+from chrys.foundation.i18n import msg
+from chrys.foundation.i18n.formatting import sanitize_legacy_block, sanitize_legacy_scalar
+
+_HOSTED_SHELL_TIMED_OUT_STATUS = msg("tui.hosted.shell.status.timed_out", fallback="timed out")
+_HOSTED_SHELL_COMMANDS = msg("tui.hosted.shell.commands", fallback="Commands:")
+_HOSTED_SHELL_STDOUT = msg("tui.hosted.shell.stdout", fallback="stdout:")
+_HOSTED_SHELL_STDERR = msg("tui.hosted.shell.stderr", fallback="stderr:")
+_HOSTED_SHELL_EXIT = msg("tui.hosted.shell.exit", fallback="Exit: {exit_code}")
+_HOSTED_SHELL_TIMED_OUT = msg("tui.hosted.shell.timed_out", fallback="Timed out: {answer}")
+_HOSTED_SHELL_YES = msg("tui.hosted.shell.yes", fallback="yes")
+_HOSTED_SHELL_NO = msg("tui.hosted.shell.no", fallback="no")
+_HOSTED_SHELL_EMPTY = msg("tui.hosted.shell.empty", fallback="No shell output")
+
+
+def _commands(args: Mapping[str, Any]) -> list[str]:
+    values = _sequence(args.get("commands"))
+    if values:
+        return [_display_text(value) for value in values]
+    command = _first_value(args, "command", "input")
+    return [_display_text(command)] if command is not None else []
+
+
+def _shell_details(result: str, metadata: Mapping[str, Any]) -> dict[str, Any]:
+    details = dict(metadata)
+    parsed = _parsed_mapping(result)
+    for key in ("stdout", "stderr", "exit_code", "timed_out"):
+        if key not in details and key in parsed:
+            details[key] = parsed[key]
+    outputs = _sequence(parsed.get("outputs")) or _sequence(metadata.get("outputs"))
+    if outputs:
+        first = outputs[0]
+        if isinstance(first, Mapping):
+            for key in ("stdout", "stderr", "exit_code", "timed_out"):
+                if key not in details and key in first:
+                    details[key] = first[key]
+    return details
+
+
+class HostedShellToolCall(HostedToolCall):
+    """Provider-hosted shell card without local approval or path chrome."""
+
+    DEFAULT_CSS = _hosted_card_css("HostedShellToolCall")
+
+    def __init__(
+        self,
+        call_id: str,
+        tool_name: str,
+        args_summary: str = "",
+        args: dict[str, Any] | None = None,
+    ) -> None:
+        super().__init__(call_id, tool_name, args_summary, args=args)
+        self._details: dict[str, Any] = {}
+
+    def _label_details(self) -> list[str]:
+        details: list[str] = []
+        commands = _commands(self.args)
+        if commands:
+            first = sanitize_legacy_scalar(_bounded_text(commands[0]))
+            details.append(f"{first} +{len(commands) - 1}" if len(commands) > 1 else first)
+        exit_code = self._details.get("exit_code")
+        if isinstance(exit_code, int) and not isinstance(exit_code, bool):
+            details.append(self._render_message(SKILL_EXIT.bind(code=exit_code)))
+        elif self._details.get("timed_out") is True:
+            details.append(self._render_message(_HOSTED_SHELL_TIMED_OUT_STATUS.bind()))
+        return details
+
+    def _format_complete_details(self, result: str) -> str:
+        sections: list[str] = []
+        commands = _commands(self.args)
+        if commands:
+            sections.append(
+                f"{self._render_message(_HOSTED_SHELL_COMMANDS.bind())}\n"
+                f"{sanitize_legacy_block(_bounded_text(chr(10).join(commands)))}"
+            )
+        stdout = _first_value(self._details, "stdout")
+        stderr = _first_value(self._details, "stderr")
+        if stdout is not None:
+            sections.append(
+                f"{self._render_message(_HOSTED_SHELL_STDOUT.bind())}\n"
+                f"{sanitize_legacy_block(_bounded_text(_display_text(stdout)))}"
+            )
+        if stderr is not None:
+            sections.append(
+                f"{self._render_message(_HOSTED_SHELL_STDERR.bind())}\n"
+                f"{sanitize_legacy_block(_bounded_text(_display_text(stderr)))}"
+            )
+        exit_code = self._details.get("exit_code")
+        timed_out = self._details.get("timed_out")
+        if exit_code is not None:
+            sections.append(
+                self._render_message(
+                    _HOSTED_SHELL_EXIT.bind(exit_code=sanitize_legacy_scalar(_display_text(exit_code)))
+                )
+            )
+        if timed_out is not None:
+            answer = self._render_message((_HOSTED_SHELL_YES if timed_out is True else _HOSTED_SHELL_NO).bind())
+            sections.append(self._render_message(_HOSTED_SHELL_TIMED_OUT.bind(answer=answer)))
+        if stdout is None and stderr is None and result:
+            sections.append(
+                f"{self._render_message(HOSTED_OUTPUT.bind())}\n{sanitize_legacy_block(_bounded_text(result))}"
+            )
+        artifact_text = _artifact_summary(self.artifacts, self._render_message)
+        if artifact_text:
+            sections.append(f"{self._render_message(HOSTED_FILES.bind())}\n{artifact_text}")
+        return "\n\n".join(sections) or self._render_message(_HOSTED_SHELL_EMPTY.bind())
+
+    def set_complete(self, result: str, duration_ms: int = 0, **kwargs: Any) -> None:
+        metadata = kwargs.get("metadata")
+        self._details = _shell_details(result, metadata if isinstance(metadata, Mapping) else {})
+        super().set_complete(result, duration_ms, **kwargs)

chrys/app/tui/widgets/chat/renderers/read_file.py

@@ -0,0 +1,399 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Renderer for the ``read_file`` tool.
+
+Shows a ``- read_file (Nms)`` label followed by a bordered panel with
+the file path as border title and syntax-highlighted content inside.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+from contextlib import suppress
+from typing import TYPE_CHECKING, Any, ClassVar
+
+from rich.console import Group
+from rich.syntax import Syntax
+from rich.text import Text
+from textual.timer import Timer
+from textual.widget import Widget
+from textual.widgets import Static
+
+from chrys.app.tui.i18n import render_str, render_text, widget_localizer
+from chrys.app.tui.util.source_text import sanitize_source_text
+from chrys.app.tui.util.static_update import update_static_in_place
+from chrys.app.tui.util.visibility import is_widget_shown_on_active_screen
+from chrys.app.tui.widgets.chat.tool_call import (
+    TOOL_CARD_REJECTED,
+    BaseToolCard,
+    ToolCardHeader,
+    fmt_duration,
+    tool_result_render_status,
+)
+from chrys.foundation.i18n import msg
+from chrys.foundation.tool_kinds import KIND_FILESYSTEM_READ
+
+if TYPE_CHECKING:
+    from textual.app import ComposeResult
+
+_READ_FILE_READING = msg("tui.tool_card.read_file.reading", fallback="reading")
+_READ_FILE_LINE_COUNT = msg(
+    "tui.tool_card.read_file.line_count",
+    fallback="{count} line",
+    plural_fallback="{count} lines",
+)
+_READ_FILE_LINE_RANGE = msg(
+    "tui.tool_card.read_file.line_range",
+    fallback=" ({first}-{last})",
+)
+_READ_FILE_ERROR_SUFFIX = msg("tui.tool_card.read_file.error_suffix", fallback="error")
+
+_MAX_LINES = 5
+"""Max lines of file content to show before truncating."""
+
+_HEADER_RE = re.compile(r"^File:\s+(.+?)\s+\((\d+)\s+lines?,\s+(\d+)\s+chars?\)")
+"""Matches the 'File: /path (N lines, M chars)' header."""
+
+_LINE_RE = re.compile(r"^(\d+)\|(.*)$")
+"""Matches numbered content lines like '13|def foo():'."""
+
+_TRUNCATION_NOTICE_PREFIXES = ("[Truncated", "[Long lines truncated")
+"""Footer notices emitted by the read_file tool when it caps output."""
+
+
+_LEXER_BY_EXTENSION: dict[str, str] = {
+    ".py": "python",
+    ".js": "javascript",
+    ".ts": "typescript",
+    ".tsx": "tsx",
+    ".jsx": "jsx",
+    ".rs": "rust",
+    ".go": "go",
+    ".java": "java",
+    ".c": "c",
+    ".cpp": "cpp",
+    ".h": "c",
+    ".hpp": "cpp",
+    ".cs": "csharp",
+    ".rb": "ruby",
+    ".php": "php",
+    ".swift": "swift",
+    ".kt": "kotlin",
+    ".scala": "scala",
+    ".sh": "bash",
+    ".bash": "bash",
+    ".zsh": "zsh",
+    ".fish": "fish",
+    ".ps1": "powershell",
+    ".sql": "sql",
+    ".html": "html",
+    ".htm": "html",
+    ".css": "css",
+    ".scss": "scss",
+    ".less": "less",
+    ".xml": "xml",
+    ".json": "json",
+    ".yaml": "yaml",
+    ".yml": "yaml",
+    ".toml": "toml",
+    ".ini": "ini",
+    ".cfg": "ini",
+    ".md": "markdown",
+    ".rst": "rst",
+    ".tex": "latex",
+    ".r": "r",
+    ".lua": "lua",
+    ".pl": "perl",
+    ".ex": "elixir",
+    ".exs": "elixir",
+    ".erl": "erlang",
+    ".hs": "haskell",
+    ".ml": "ocaml",
+    ".dart": "dart",
+    ".vim": "vim",
+    ".dockerfile": "dockerfile",
+    ".tf": "terraform",
+    ".proto": "protobuf",
+    ".graphql": "graphql",
+    ".gql": "graphql",
+}
+"""Pygments lexer names by lowercased file extension."""
+
+
+def _guess_lexer(path: str) -> str:
+    """Guess Pygments lexer name from file extension."""
+    return _LEXER_BY_EXTENSION.get(os.path.splitext(path)[1].lower(), "text")
+
+
+def _parse_read_result(result: str) -> tuple[str, list[tuple[int, str]], bool, bool]:
+    """Parse read_file result.
+
+    Returns: (file_path, [(line_num, text)], truncated, is_error)
+    """
+    if result.startswith("Error:"):
+        return "", [], False, True
+
+    lines = result.split("\n")
+    if not lines:
+        return "", [], False, True
+
+    # Parse header
+    file_path = ""
+    m = _HEADER_RE.match(lines[0])
+    if m:
+        file_path = m.group(1)
+        lines = lines[1:]
+
+    # Parse numbered content lines
+    content_lines: list[tuple[int, str]] = []
+    truncated = False
+    for line in lines:
+        lm = _LINE_RE.match(line)
+        if lm:
+            content_lines.append((int(lm.group(1)), lm.group(2)))
+        elif line.startswith("[Truncated"):
+            truncated = True
+
+    return file_path, content_lines, truncated, False
+
+
+class ReadFileToolCall(BaseToolCard):
+    """Rich renderer for ``read_file`` tool calls.
+
+    Layout:
+    - ``- read_file (Nms)`` label (bold)
+    - Indented bordered panel with file path as title
+    - Syntax-highlighted content inside
+    """
+
+    DEFAULT_CSS = """
+    ReadFileToolCall {
+        height: auto;
+        padding: 0 0 0 2;
+        margin: 0 0 1 0;
+    }
+    ReadFileToolCall #rf-label {
+        height: auto;
+    }
+    ReadFileToolCall > #rf-panel {
+        height: auto;
+        margin: 0 0 0 2;
+        border: round $tui-border-primary 50%;
+        border-title-color: $text-error;
+        border-title-style: bold;
+        border-subtitle-align: right;
+        border-subtitle-color: $text-muted;
+        padding: 0 1;
+    }
+    ReadFileToolCall.-success > #rf-panel {
+        border: round $tui-border-success 30%;
+        border-title-color: $success;
+        border-subtitle-color: $success;
+
+        border-title-style: not bold;
+    }
+    ReadFileToolCall.-error > #rf-panel {
+        border: round $tui-border-error 50%;
+        border-title-color: $text-error;
+        border-subtitle-color: $text-error;
+
+        border-title-style: not bold;
+    }
+    ReadFileToolCall.-rejected > #rf-panel {
+        border: round $tui-border-warning 50%;
+        border-title-color: $warning;
+        border-subtitle-color: $warning;
+
+        border-title-style: not bold;
+    }
+    """
+
+    _SPINNERS: ClassVar[str] = "◐◓◑◒"
+
+    def __init__(
+        self,
+        call_id: str,
+        tool_name: str,
+        args_summary: str = "",
+        args: dict[str, Any] | None = None,
+    ) -> None:
+        super().__init__(call_id, tool_name, args_summary, args=args)
+        self._spin_idx = 0
+        self._timer: Timer | None = None
+        self._file_path = self.args.get("path", "")
+
+    def _label_text(self, duration_ms: int = 0) -> Text:
+        t = Text()
+        t.append("• ", style="bold")
+        t.append(self.tool_name, style="bold")
+        if duration_ms:
+            t.append(f" ({fmt_duration(duration_ms)})", style="dim")
+        if self._file_path:
+            t.append(f" {self._file_path}", style="dim")
+        return t
+
+    def compose(self) -> ComposeResult:
+        yield ToolCardHeader(self._label_text(), id="rf-label")
+        # A single bordered Static is the whole result panel: spinner while
+        # running, syntax-highlighted preview (or error text) once done.
+        panel = Static(self._render_spinner(), id="rf-panel")
+        panel.border_title = Text(os.path.basename(self._file_path)) if self._file_path else Text(self.tool_name)
+        yield panel
+
+    def on_mount(self) -> None:
+        self._timer = self.set_interval(0.12, self._spin)
+
+    def on_unmount(self) -> None:
+        if self._timer is not None:
+            self._timer.stop()
+
+    def _spin(self) -> None:
+        if self.status == "running":
+            self._spin_idx = (self._spin_idx + 1) % len(self._SPINNERS)
+            # Only a shown card repaints (see ``ToolCall._spin``); the first tick after it shows paints it.
+            if not is_widget_shown_on_active_screen(self):
+                return
+            with suppress(Exception):
+                update_static_in_place(self.query_one("#rf-panel", Static), self._render_spinner())
+
+    def _render_spinner(self) -> Text:
+        t = Text()
+        t.append(f"{self._SPINNERS[self._spin_idx]} ", style="yellow")
+        t.append(render_str(widget_localizer(self), _READ_FILE_READING.bind()), style="yellow")
+        return t
+
+    def _tool_view_output_widgets(self) -> list[Widget]:
+        """Show the full file content, syntax-highlighted, with no line cap."""
+        file_path, content_lines, _truncated, is_error = _parse_read_result(self.result_text)
+        if is_error or not content_lines:
+            return super()._tool_view_output_widgets()
+        from chrys.app.tui.widgets.syntax_theme import transparent_syntax
+
+        code = sanitize_source_text("\n".join(text for _, text in content_lines))
+        syntax = transparent_syntax(
+            code,
+            _guess_lexer(file_path or self._file_path),
+            dark=self._view_dark(),
+            line_numbers=True,
+            start_line=content_lines[0][0],
+        )
+        widgets: list[Widget] = [Static(syntax, classes="tool-view-code")]
+        # The read tool truncates at source (line-count and long-line caps);
+        # surface every notice so the modal never presents partial content as
+        # complete.
+        widgets.extend(
+            Static(Text(line, style="dim"), classes="tool-view-text")
+            for line in self.result_text.split("\n")
+            if line.startswith(_TRUNCATION_NOTICE_PREFIXES)
+        )
+        return widgets
+
+    def set_complete(self, result: str, duration_ms: int = 0, **kwargs: Any) -> None:
+        """Mark as complete with syntax-highlighted output."""
+        self.result_text = result
+        self.duration_ms = duration_ms
+        self.approval = kwargs.get("approval")
+        metadata = kwargs.get("metadata")
+        self.metadata = metadata if isinstance(metadata, dict) else {}
+        self.status = "complete"
+        if self._timer is not None:
+            self._timer.stop()
+
+        file_path, content_lines, file_truncated, parsed_error = _parse_read_result(result)
+        render_status = tool_result_render_status(
+            result,
+            self.approval,
+            self.tool_kind or KIND_FILESYSTEM_READ,
+            self.metadata,
+            parsed_error=parsed_error,
+            parsed_error_overrides_structured_success=True,
+        )
+
+        # Update label with duration
+        with suppress(Exception):
+            self.query_one("#rf-label", Static).update(self._label_text(duration_ms))
+
+        # Update panel title and subtitle
+        panel = self.query_one("#rf-panel", Static)
+        if file_path:
+            self._file_path = file_path
+        panel.border_title = Text(os.path.basename(self._file_path))
+        if content_lines:
+            n = len(content_lines)
+            first, last = content_lines[0][0], content_lines[-1][0]
+            subtitle = render_str(widget_localizer(self), _READ_FILE_LINE_COUNT.bind(count=n))
+            if first != 1 or last != n:
+                subtitle += render_str(
+                    widget_localizer(self),
+                    _READ_FILE_LINE_RANGE.bind(first=first, last=last),
+                )
+            panel.border_subtitle = Text(subtitle)
+
+        if render_status == "rejected":
+            self.status = "rejected"
+            panel.border_subtitle = render_text(widget_localizer(self), TOOL_CARD_REJECTED.bind())
+            self.add_class("-rejected")
+            with suppress(Exception):
+                panel.update(Text(result))
+            self.add_class("-done")
+            self._show_tool_copy_button()
+            return
+
+        if render_status == "error":
+            self.status = "error"
+            self.add_class("-error")
+            with suppress(Exception):
+                panel.update(Text(result))
+            self.add_class("-done")
+            self._show_tool_copy_button()
+            return
+
+        self.add_class("-success")
+
+        # Truncate to max lines
+        display_truncated = file_truncated
+        display_lines = content_lines
+        if len(display_lines) > _MAX_LINES:
+            display_lines = display_lines[:_MAX_LINES]
+            display_truncated = True
+
+        # Build syntax-highlighted output
+        if display_lines:
+            code = sanitize_source_text("\n".join(text for _, text in display_lines))
+            lexer = _guess_lexer(self._file_path)
+            start_line = display_lines[0][0]
+            syntax = Syntax(
+                code,
+                lexer,
+                line_numbers=True,
+                start_line=start_line,
+                theme="ansi_dark",
+            )
+            with suppress(Exception):
+                if display_truncated:
+                    panel.update(Group(syntax, Text("...", style="dim")))
+                else:
+                    panel.update(syntax)
+        else:
+            with suppress(Exception):
+                panel.update("")
+
+        self.add_class("-done")
+        self._show_tool_copy_button()
+
+    def set_error(self, error: str) -> None:
+        """Mark as failed."""
+        self.result_text = error
+        self.status = "error"
+        if self._timer is not None:
+            self._timer.stop()
+
+        panel = self.query_one("#rf-panel", Static)
+        error_label = render_str(widget_localizer(self), _READ_FILE_ERROR_SUFFIX.bind())
+        panel.border_title = Text(f"{self._file_path} [{error_label}]")
+        self.add_class("-error")
+        with suppress(Exception):
+            panel.update(Text(error))
+        self.add_class("-done")
+        self._show_tool_copy_button()