klaude-code 1.2.6__py3-none-any.whl → 1.8.0__py3-none-any.whl

klaude_code/ui/renderers/assistant.py

@@ -1,7 +1,14 @@
 from rich.console import RenderableType
+from rich.padding import Padding
+from rich.text import Text
 
+from klaude_code import const
 from klaude_code.ui.renderers.common import create_grid
 from klaude_code.ui.rich.markdown import NoInsetMarkdown
+from klaude_code.ui.rich.theme import ThemeKey
+
+# UI markers
+ASSISTANT_MESSAGE_MARK = "•"
 
 
 def render_assistant_message(content: str, *, code_theme: str) -> RenderableType | None:
@@ -15,7 +22,7 @@ def render_assistant_message(content: str, *, code_theme: str) -> RenderableType
 
     grid = create_grid()
     grid.add_row(
-        "•",
-        NoInsetMarkdown(stripped, code_theme=code_theme),
+        Text(ASSISTANT_MESSAGE_MARK, style=ThemeKey.ASSISTANT_MESSAGE_MARK),
+        Padding(NoInsetMarkdown(stripped, code_theme=code_theme), (0, const.MARKDOWN_RIGHT_MARGIN, 0, 0)),
     )
     return grid

klaude_code/ui/renderers/bash_syntax.py

@@ -0,0 +1,178 @@
+"""Bash command syntax highlighting for terminal display."""
+
+import re
+from typing import Any
+
+from pygments.lexers import BashLexer  # pyright: ignore[reportUnknownVariableType]
+from pygments.token import Token
+from rich.text import Text
+
+from klaude_code.ui.rich.theme import ThemeKey
+
+# Token types for bash syntax highlighting
+_STRING_TOKENS = frozenset(
+    {
+        Token.Literal.String,
+        Token.Literal.String.Double,
+        Token.Literal.String.Single,
+        Token.Literal.String.Backtick,
+        Token.Literal.String.Escape,
+        Token.Literal.String.Heredoc,
+        Token.Comment,
+        Token.Comment.Single,
+        Token.Comment.Hashbang,
+    }
+)
+
+_OPERATOR_TOKENS = frozenset(
+    {
+        Token.Operator,
+        Token.Punctuation,
+    }
+)
+
+# Operators that start a new command context (next non-whitespace token is a command)
+_COMMAND_STARTERS = frozenset({"&&", "||", "|", ";", "&"})
+
+# Commands that have subcommands (e.g., git commit, docker run)
+_SUBCOMMAND_COMMANDS = frozenset(
+    {
+        # Version control
+        "git",
+        "jj",
+        "hg",
+        "svn",
+        # Container & orchestration
+        "docker",
+        "docker-compose",
+        "podman",
+        "kubectl",
+        "helm",
+        # Package managers
+        "npm",
+        "yarn",
+        "pnpm",
+        "cargo",
+        "uv",
+        "pip",
+        "poetry",
+        "brew",
+        "apt",
+        "apt-get",
+        "dnf",
+        "yum",
+        "pacman",
+        # Cloud CLIs
+        "aws",
+        "gcloud",
+        "az",
+        # Language tools
+        "go",
+        "rustup",
+        "python",
+        "ruby",
+        # Other common tools
+        "gh",
+        "systemctl",
+        "launchctl",
+        "supervisorctl",
+    }
+)
+
+_LEXER: Any = BashLexer(ensurenl=False)  # pyright: ignore[reportUnknownVariableType]
+
+# Regex to match heredoc: << [-]? [space]? ['"]? DELIMITER ['"]? [extra] \n body \n DELIMITER
+# Groups: (<<-?) (space) (quote) (delimiter) (quote) (extra on first line) (body) (end delimiter)
+_HEREDOC_PATTERN = re.compile(
+    r"^(<<-?)(\s*)(['\"]?)(\w+)\3([^\n]*)(\n.*\n)(\4)$",
+    re.DOTALL,
+)
+
+
+def _append_heredoc(result: Text, token_value: str) -> None:
+    """Append heredoc token with delimiter highlighting."""
+    match = _HEREDOC_PATTERN.match(token_value)
+    if match:
+        operator, space, quote, delimiter, extra, body, end_delimiter = match.groups()
+        # << or <<-
+        result.append(operator, style=ThemeKey.BASH_OPERATOR)
+        # Optional space
+        if space:
+            result.append(space)
+        # Opening quote
+        if quote:
+            result.append(quote, style=ThemeKey.BASH_HEREDOC_DELIMITER)
+        # Delimiter name (e.g., EOF)
+        result.append(delimiter, style=ThemeKey.BASH_HEREDOC_DELIMITER)
+        # Closing quote
+        if quote:
+            result.append(quote, style=ThemeKey.BASH_HEREDOC_DELIMITER)
+        # Extra content on first line (e.g., "> file.py")
+        if extra:
+            result.append(extra, style=ThemeKey.BASH_ARGUMENT)
+        # Body content
+        result.append(body, style=ThemeKey.BASH_STRING)
+        # End delimiter
+        result.append(end_delimiter, style=ThemeKey.BASH_HEREDOC_DELIMITER)
+    else:
+        # Fallback: couldn't parse heredoc structure
+        result.append(token_value, style=ThemeKey.BASH_STRING)
+
+
+def highlight_bash_command(command: str) -> Text:
+    """Apply bash syntax highlighting to a command string, returning Rich Text.
+
+    Styling:
+    - Command names (first token after line start or operators): bold green
+    - Subcommands (for commands like git, docker): bold green
+    - Arguments: green
+    - Operators (&&, ||, |, ;): dim green
+    - Strings and comments: green
+    """
+    result = Text()
+    token_type: Any
+    token_value: str
+
+    # Track whether next non-whitespace token is a command
+    expect_command = True
+    # Track whether next non-flag token is a subcommand
+    expect_subcommand = False
+
+    for token_type, token_value in _LEXER.get_tokens(command):
+        # Determine style based on token type and context
+        if token_type in _STRING_TOKENS:
+            # Check if this is a heredoc (starts with <<)
+            if token_value.startswith("<<"):
+                _append_heredoc(result, token_value)
+            else:
+                result.append(token_value, style=ThemeKey.BASH_STRING)
+            expect_subcommand = False
+        elif token_type in _OPERATOR_TOKENS:
+            result.append(token_value, style=ThemeKey.BASH_OPERATOR)
+            # After command-starting operators, next token is a command
+            if token_value in _COMMAND_STARTERS:
+                expect_command = True
+                expect_subcommand = False
+        elif token_type in (Token.Text.Whitespace,):
+            result.append(token_value)
+        elif token_type == Token.Name.Builtin:
+            # Built-in commands are always commands
+            result.append(token_value, style=ThemeKey.BASH_COMMAND)
+            expect_command = False
+            expect_subcommand = token_value in _SUBCOMMAND_COMMANDS
+        elif expect_command and token_value.strip():
+            # First non-whitespace token in command context
+            result.append(token_value, style=ThemeKey.BASH_COMMAND)
+            expect_command = False
+            expect_subcommand = token_value in _SUBCOMMAND_COMMANDS
+        elif expect_subcommand and token_value.strip() and not token_value.startswith("-"):
+            # Subcommand: non-flag token after a command that has subcommands
+            result.append(token_value, style=ThemeKey.BASH_COMMAND)
+            expect_subcommand = False
+        else:
+            # Regular arguments (including flags, which reset subcommand expectation)
+            result.append(token_value, style=ThemeKey.BASH_ARGUMENT)
+            if token_value.strip():
+                expect_subcommand = False
+
+    return result

klaude_code/ui/renderers/common.py

@@ -1,4 +1,9 @@
+from rich.style import Style
 from rich.table import Table
+from rich.text import Text
+
+from klaude_code import const
+from klaude_code.ui.rich.theme import ThemeKey
 
 
 def create_grid() -> Table:
@@ -6,3 +11,76 @@ def create_grid() -> Table:
     grid.add_column(no_wrap=True)
     grid.add_column(overflow="fold")
     return grid
+
+
+def truncate_display(
+    text: str,
+    max_lines: int = const.TRUNCATE_DISPLAY_MAX_LINES,
+    max_line_length: int = const.TRUNCATE_DISPLAY_MAX_LINE_LENGTH,
+    *,
+    base_style: str | Style | None = None,
+) -> Text:
+    """Truncate long text for terminal display.
+
+    Applies `ThemeKey.TOOL_RESULT_TRUNCATED` style to truncation indicators.
+    """
+    # Expand tabs to spaces to ensure correct alignment when Rich applies padding.
+    text = text.expandtabs(8)
+
+    if max_lines <= 0:
+        truncated_lines = text.split("\n")
+        remaining = max(0, len(truncated_lines))
+        return Text(f"… (more {remaining} lines)", style=ThemeKey.TOOL_RESULT_TRUNCATED)
+
+    lines = text.split("\n")
+    truncated_lines = 0
+    head_lines: list[str] = []
+    tail_lines: list[str] = []
+
+    if len(lines) > max_lines:
+        truncated_lines = len(lines) - max_lines
+
+        # If the hidden section is too small, show everything instead of inserting
+        # the "(more N lines)" indicator.
+        if truncated_lines < 5:
+            truncated_lines = 0
+            head_lines = lines
+        else:
+            head_count = max_lines // 2
+            tail_count = max_lines - head_count
+            head_lines = lines[:head_count]
+            tail_lines = lines[-tail_count:]
+    else:
+        head_lines = lines
+
+    def append_line(out: Text, line: str) -> None:
+        if len(line) > max_line_length:
+            extra_chars = len(line) - max_line_length
+            out.append(line[:max_line_length])
+            out.append_text(
+                Text(
+                    f" … (more {extra_chars} characters in this line)",
+                    style=ThemeKey.TOOL_RESULT_TRUNCATED,
+                )
+            )
+        else:
+            out.append(line)
+
+    out = Text()
+    if base_style is not None:
+        out.style = base_style
+
+    for idx, line in enumerate(head_lines):
+        append_line(out, line)
+        if idx < len(head_lines) - 1 or truncated_lines > 0 or tail_lines:
+            out.append("\n")
+
+    if truncated_lines > 0:
+        out.append_text(Text(f"⋮ (more {truncated_lines} lines)\n", style=ThemeKey.TOOL_RESULT_TRUNCATED))
+
+    for idx, line in enumerate(tail_lines):
+        append_line(out, line)
+        if idx < len(tail_lines) - 1:
+            out.append("\n")
+
+    return out

klaude_code/ui/renderers/developer.py

@@ -4,11 +4,12 @@ from rich.table import Table
 from rich.text import Text
 
 from klaude_code.protocol import commands, events, model
-from klaude_code.ui.renderers import diffs as r_diffs
-from klaude_code.ui.renderers.common import create_grid
+from klaude_code.ui.renderers.common import create_grid, truncate_display
 from klaude_code.ui.renderers.tools import render_path
+from klaude_code.ui.rich.markdown import NoInsetMarkdown
 from klaude_code.ui.rich.theme import ThemeKey
-from klaude_code.ui.utils.common import truncate_display
+
+REMINDER_BULLET = "  ⧉"
 
 
 def need_render_developer_message(e: events.DeveloperMessageEvent) -> bool:
@@ -18,6 +19,7 @@ def need_render_developer_message(e: events.DeveloperMessageEvent) -> bool:
         or e.item.todo_use
         or e.item.at_files
         or e.item.user_image_count
+        or e.item.skill_name
     )
 
 
@@ -32,7 +34,7 @@ def render_developer_message(e: events.DeveloperMessageEvent) -> RenderableType:
     if mp := e.item.memory_paths:
         grid = create_grid()
         grid.add_row(
-            Text("  +", style=ThemeKey.REMINDER),
+            Text(REMINDER_BULLET, style=ThemeKey.REMINDER),
             Text.assemble(
                 ("Load memory ", ThemeKey.REMINDER),
                 Text(", ", ThemeKey.REMINDER).join(
@@ -46,7 +48,7 @@ def render_developer_message(e: events.DeveloperMessageEvent) -> RenderableType:
         grid = create_grid()
         for file_path in fc:
             grid.add_row(
-                Text("  +", style=ThemeKey.REMINDER),
+                Text(REMINDER_BULLET, style=ThemeKey.REMINDER),
                 Text.assemble(
                     ("Read ", ThemeKey.REMINDER),
                     render_path(file_path, ThemeKey.REMINDER_BOLD),
@@ -58,31 +60,62 @@ def render_developer_message(e: events.DeveloperMessageEvent) -> RenderableType:
     if e.item.todo_use:
         grid = create_grid()
         grid.add_row(
-            Text("  +", style=ThemeKey.REMINDER),
+            Text(REMINDER_BULLET, style=ThemeKey.REMINDER),
             Text("Todo hasn't been updated recently", ThemeKey.REMINDER),
         )
         parts.append(grid)
 
     if e.item.at_files:
         grid = create_grid()
+        # Group at_files by (operation, mentioned_in)
+        grouped: dict[tuple[str, str | None], list[str]] = {}
         for at_file in e.item.at_files:
-            grid.add_row(
-                Text("  +", style=ThemeKey.REMINDER),
-                Text.assemble(
-                    (f"{at_file.operation} ", ThemeKey.REMINDER),
-                    render_path(at_file.path, ThemeKey.REMINDER_BOLD),
-                ),
-            )
+            key = (at_file.operation, at_file.mentioned_in)
+            if key not in grouped:
+                grouped[key] = []
+            grouped[key].append(at_file.path)
+
+        for (operation, mentioned_in), paths in grouped.items():
+            path_texts = Text(", ", ThemeKey.REMINDER).join(render_path(p, ThemeKey.REMINDER_BOLD) for p in paths)
+            if mentioned_in:
+                grid.add_row(
+                    Text(REMINDER_BULLET, style=ThemeKey.REMINDER),
+                    Text.assemble(
+                        (f"{operation} ", ThemeKey.REMINDER),
+                        path_texts,
+                        (" mentioned in ", ThemeKey.REMINDER),
+                        render_path(mentioned_in, ThemeKey.REMINDER_BOLD),
+                    ),
+                )
+            else:
+                grid.add_row(
+                    Text(REMINDER_BULLET, style=ThemeKey.REMINDER),
+                    Text.assemble(
+                        (f"{operation} ", ThemeKey.REMINDER),
+                        path_texts,
+                    ),
+                )
         parts.append(grid)
 
     if uic := e.item.user_image_count:
         grid = create_grid()
         grid.add_row(
-            Text("  +", style=ThemeKey.REMINDER),
+            Text(REMINDER_BULLET, style=ThemeKey.REMINDER),
             Text(f"Attached {uic} image{'s' if uic > 1 else ''}", style=ThemeKey.REMINDER),
         )
         parts.append(grid)
 
+    if sn := e.item.skill_name:
+        grid = create_grid()
+        grid.add_row(
+            Text(REMINDER_BULLET, style=ThemeKey.REMINDER),
+            Text.assemble(
+                ("Activated skill ", ThemeKey.REMINDER),
+                (sn, ThemeKey.REMINDER_BOLD),
+            ),
+        )
+        parts.append(grid)
+
     return Group(*parts) if parts else Text("")
 
 
@@ -92,18 +125,18 @@ def render_command_output(e: events.DeveloperMessageEvent) -> RenderableType:
         return Text("")
 
     match e.item.command_output.command_name:
-        case commands.CommandName.DIFF:
-            if e.item.content is None or len(e.item.content) == 0:
-                return Padding.indent(Text("(no changes)", style=ThemeKey.TOOL_RESULT), level=2)
-            return r_diffs.render_diff_panel(e.item.content, show_file_name=True)
         case commands.CommandName.HELP:
             return Padding.indent(Text.from_markup(e.item.content or ""), level=2)
         case commands.CommandName.STATUS:
             return _render_status_output(e.item.command_output)
+        case commands.CommandName.RELEASE_NOTES:
+            return Padding.indent(NoInsetMarkdown(e.item.content or ""), level=2)
+        case commands.CommandName.FORK_SESSION:
+            return _render_fork_session_output(e.item.command_output)
         case _:
             content = e.item.content or "(no content)"
             style = ThemeKey.TOOL_RESULT if not e.item.command_output.is_error else ThemeKey.ERROR
-            return Padding.indent(Text(truncate_display(content), style=style), level=2)
+            return Padding.indent(truncate_display(content, base_style=style), level=2)
 
 
 def _format_tokens(tokens: int) -> str:
@@ -115,44 +148,67 @@ def _format_tokens(tokens: int) -> str:
     return str(tokens)
 
 
-def _format_cost(cost: float | None) -> str:
-    """Format cost in USD."""
+def _format_cost(cost: float | None, currency: str = "USD") -> str:
+    """Format cost with currency symbol."""
     if cost is None:
         return "-"
+    symbol = "¥" if currency == "CNY" else "$"
     if cost < 0.01:
-        return f"${cost:.4f}"
-    return f"${cost:.2f}"
+        return f"{symbol}{cost:.4f}"
+    return f"{symbol}{cost:.2f}"
+
+
+def _render_fork_session_output(command_output: model.CommandOutput) -> RenderableType:
+    """Render fork session output with usage instructions."""
+    if not isinstance(command_output.ui_extra, model.SessionIdUIExtra):
+        return Padding.indent(Text("(no session id)", style=ThemeKey.METADATA), level=2)
+
+    grid = Table.grid(padding=(0, 1))
+    session_id = command_output.ui_extra.session_id
+    grid.add_column(style=ThemeKey.METADATA, overflow="fold")
+
+    grid.add_row(Text("Session forked. Resume command copied to clipboard:", style=ThemeKey.METADATA))
+    grid.add_row(Text(f"  klaude --resume-by-id {session_id}", style=ThemeKey.METADATA_BOLD))
+
+    return Padding.indent(grid, level=2)
 
 
 def _render_status_output(command_output: model.CommandOutput) -> RenderableType:
-    """Render session status as a two-column table with sections."""
-    if not command_output.ui_extra or not command_output.ui_extra.session_status:
-        return Text("(no status data)", style=ThemeKey.TOOL_RESULT)
+    """Render session status with total cost and per-model breakdown."""
+    if not isinstance(command_output.ui_extra, model.SessionStatusUIExtra):
+        return Text("(no status data)", style=ThemeKey.METADATA)
 
-    status = command_output.ui_extra.session_status
+    status = command_output.ui_extra
     usage = status.usage
 
     table = Table.grid(padding=(0, 2))
-    table.add_column(style=ThemeKey.TOOL_RESULT, no_wrap=True)
-    table.add_column(style=ThemeKey.TOOL_RESULT, no_wrap=True)
-    # Token Usage section
-    table.add_row(Text("Token Usage", style="bold"), "")
-    table.add_row("Input Tokens", _format_tokens(usage.input_tokens))
-    if usage.cached_tokens > 0:
-        table.add_row("Cached Tokens", _format_tokens(usage.cached_tokens))
-    if usage.reasoning_tokens > 0:
-        table.add_row("Reasoning Tokens", _format_tokens(usage.reasoning_tokens))
-    table.add_row("Output Tokens", _format_tokens(usage.output_tokens))
-    table.add_row("Total Tokens", _format_tokens(usage.total_tokens))
-
-    # Cost section
-    if usage.total_cost is not None:
-        table.add_row("", "")  # Empty line
-        table.add_row(Text("Cost", style="bold"), "")
-        table.add_row("Input Cost", _format_cost(usage.input_cost))
-        if usage.cache_read_cost is not None and usage.cache_read_cost > 0:
-            table.add_row("Cache Read Cost", _format_cost(usage.cache_read_cost))
-        table.add_row("Output Cost", _format_cost(usage.output_cost))
-        table.add_row("Total Cost", _format_cost(usage.total_cost))
+    table.add_column(style=ThemeKey.METADATA, overflow="fold")
+    table.add_column(style=ThemeKey.METADATA, overflow="fold")
+
+    # Total cost line
+    table.add_row(
+        Text("Total cost:", style=ThemeKey.METADATA_BOLD),
+        Text(_format_cost(usage.total_cost, usage.currency), style=ThemeKey.METADATA_BOLD),
+    )
+
+    # Per-model breakdown
+    if status.by_model:
+        table.add_row(Text("Usage by model:", style=ThemeKey.METADATA_BOLD), "")
+        for meta in status.by_model:
+            model_label = meta.model_name
+            if meta.provider:
+                model_label = f"{meta.model_name} ({meta.provider.lower().replace(' ', '-')})"
+
+            if meta.usage:
+                usage_detail = (
+                    f"{_format_tokens(meta.usage.input_tokens)} input, "
+                    f"{_format_tokens(meta.usage.output_tokens)} output, "
+                    f"{_format_tokens(meta.usage.cached_tokens)} cache read, "
+                    f"{_format_tokens(meta.usage.reasoning_tokens)} thinking, "
+                    f"({_format_cost(meta.usage.total_cost, meta.usage.currency)})"
+                )
+            else:
+                usage_detail = "(no usage data)"
+            table.add_row(f"{model_label}:", usage_detail)
 
     return Padding.indent(table, level=2)

klaude_code/ui/renderers/diffs.py

@@ -5,6 +5,7 @@ from rich.panel import Panel
 from rich.text import Text
 
 from klaude_code import const
+from klaude_code.protocol import model
 from klaude_code.ui.renderers.common import create_grid
 from klaude_code.ui.rich.theme import ThemeKey
 
@@ -73,10 +74,7 @@ def render_diff(diff_text: str, show_file_name: bool = False) -> RenderableType:
         if line.startswith("--- "):
             raw = line[4:].strip()
             if raw != "/dev/null":
-                if raw.startswith(("a/", "b/")):
-                    from_file_name = raw[2:]
-                else:
-                    from_file_name = raw
+                from_file_name = raw[2:] if raw.startswith(("a/", "b/")) else raw
             continue
 
         # Parse file name from diff headers
@@ -150,7 +148,7 @@ def render_diff(diff_text: str, show_file_name: bool = False) -> RenderableType:
                 plus = parts[2]  # like '+12,4'
                 new_start = int(plus[1:].split(",")[0])
                 new_ln = new_start
-            except Exception:
+            except (IndexError, ValueError):
                 new_ln = None
             if has_rendered_diff_content:
                 grid.add_row(Text(f"{'⋮':>{const.DIFF_PREFIX_WIDTH}}", style=ThemeKey.TOOL_RESULT), "")
@@ -182,11 +180,35 @@ def render_diff(diff_text: str, show_file_name: bool = False) -> RenderableType:
     return grid
 
 
+def render_structured_diff(ui_extra: model.DiffUIExtra, show_file_name: bool = False) -> RenderableType:
+    files = ui_extra.files
+    if not files:
+        return Text("")
+
+    grid = create_grid()
+    grid.padding = (0, 0)
+    show_headers = show_file_name or len(files) > 1
+
+    for idx, file_diff in enumerate(files):
+        if idx > 0:
+            grid.add_row("", "")
+
+        if show_headers:
+            grid.add_row(*_render_file_header(file_diff))
+
+        for line in file_diff.lines:
+            prefix = _make_structured_prefix(line, const.DIFF_PREFIX_WIDTH)
+            text = _render_structured_line(line)
+            grid.add_row(Text(prefix, ThemeKey.TOOL_RESULT), text)
+
+    return grid
+
+
 def render_diff_panel(
     diff_text: str,
     *,
     show_file_name: bool = True,
-    heading: str = "Git Diff",
+    heading: str = "DIFF",
     indent: int = 2,
 ) -> RenderableType:
     lines = diff_text.splitlines()
@@ -213,3 +235,62 @@ def render_diff_panel(
     if indent <= 0:
         return panel
     return Padding.indent(panel, level=indent)
+
+
+def _render_file_header(file_diff: model.DiffFileDiff) -> tuple[Text, Text]:
+    file_text = Text(file_diff.file_path, style=ThemeKey.DIFF_FILE_NAME)
+    stats_text = Text()
+    if file_diff.stats_add > 0:
+        stats_text.append(f"+{file_diff.stats_add}", style=ThemeKey.DIFF_STATS_ADD)
+    if file_diff.stats_remove > 0:
+        if stats_text.plain:
+            stats_text.append(" ")
+        stats_text.append(f"-{file_diff.stats_remove}", style=ThemeKey.DIFF_STATS_REMOVE)
+
+    file_line = Text(style=ThemeKey.DIFF_FILE_NAME)
+    file_line.append_text(file_text)
+    if stats_text.plain:
+        file_line.append(" (")
+        file_line.append_text(stats_text)
+        file_line.append(")")
+
+    if file_diff.stats_add > 0 and file_diff.stats_remove == 0:
+        file_mark = "+"
+    elif file_diff.stats_remove > 0 and file_diff.stats_add == 0:
+        file_mark = "-"
+    else:
+        file_mark = "±"
+
+    prefix = Text(f"{file_mark:>{const.DIFF_PREFIX_WIDTH}}  ", style=ThemeKey.DIFF_FILE_NAME)
+    return prefix, file_line
+
+
+def _make_structured_prefix(line: model.DiffLine, width: int) -> str:
+    if line.kind == "gap":
+        return f"{'⋮':>{width}}  "
+    number = " " * width
+    if line.kind in {"add", "ctx"} and line.new_line_no is not None:
+        number = f"{line.new_line_no:>{width}}"
+    marker = "+" if line.kind == "add" else "-" if line.kind == "remove" else " "
+    return f"{number} {marker}"
+
+
+def _render_structured_line(line: model.DiffLine) -> Text:
+    if line.kind == "gap":
+        return Text("")
+    text = Text()
+    for span in line.spans:
+        text.append(span.text, style=_span_style(line.kind, span.op))
+    return text
+
+
+def _span_style(line_kind: str, span_op: str) -> ThemeKey:
+    if line_kind == "add":
+        if span_op == "insert":
+            return ThemeKey.DIFF_ADD_CHAR
+        return ThemeKey.DIFF_ADD
+    if line_kind == "remove":
+        if span_op == "delete":
+            return ThemeKey.DIFF_REMOVE_CHAR
+        return ThemeKey.DIFF_REMOVE
+    return ThemeKey.TOOL_RESULT

klaude_code/ui/renderers/errors.py

@@ -5,12 +5,17 @@ from klaude_code.ui.renderers.common import create_grid
 from klaude_code.ui.rich.theme import ThemeKey
 
 
-def render_error(error_msg: Text, indent: int = 2) -> RenderableType:
-    """Stateless error renderer.
+def render_error(error_msg: Text) -> RenderableType:
+    """Render error with X mark for error events."""
+    grid = create_grid()
+    error_msg.style = ThemeKey.ERROR
+    grid.add_row(Text("✘", style=ThemeKey.ERROR_BOLD), error_msg)
+    return grid
+
 
-    Shows a two-column grid with an error mark and truncated message.
-    """
+def render_tool_error(error_msg: Text) -> RenderableType:
+    """Render error with indent for tool results."""
     grid = create_grid()
-    error_msg.stylize(ThemeKey.ERROR)
-    grid.add_row(Text(" " * indent + "✘", style=ThemeKey.ERROR_BOLD), error_msg)
+    error_msg.style = ThemeKey.ERROR
+    grid.add_row(Text(" "), error_msg)
     return grid