klaude-code 1.2.6__py3-none-any.whl

klaude_code/ui/renderers/diffs.py

@@ -0,0 +1,215 @@
+from rich import box
+from rich.console import Group, RenderableType
+from rich.padding import Padding
+from rich.panel import Panel
+from rich.text import Text
+
+from klaude_code import const
+from klaude_code.ui.renderers.common import create_grid
+from klaude_code.ui.rich.theme import ThemeKey
+
+
+def _make_diff_prefix(line: str, new_ln: int | None, width: int) -> tuple[str, int | None]:
+    kind = line[0]
+
+    number = " " * width
+    if kind in {"+", " "} and new_ln is not None:
+        number = f"{new_ln:>{width}}"
+        new_ln += 1
+
+    if kind == "-":
+        marker = "-"
+    elif kind == "+":
+        marker = "+"
+    else:
+        marker = " "
+
+    prefix = f"{number} {marker}"
+    return prefix, new_ln
+
+
+def render_diff(diff_text: str, show_file_name: bool = False) -> RenderableType:
+    if diff_text == "":
+        return Text("")
+
+    lines = diff_text.split("\n")
+    grid = create_grid()
+    grid.padding = (0, 0)
+
+    # Track line numbers based on hunk headers
+    new_ln: int | None = None
+    # Track if we're in untracked files section
+    in_untracked_section = False
+    # Track whether we've already rendered a file header
+    has_rendered_file_header = False
+    # Track whether we have rendered actual diff content for the current file
+    has_rendered_diff_content = False
+    # Track the "from" file name from --- line (used for deleted files)
+    from_file_name: str | None = None
+
+    for i, line in enumerate(lines):
+        # Check for untracked files section header
+        if line == "git ls-files --others --exclude-standard":
+            in_untracked_section = True
+            grid.add_row("", "")
+            grid.add_row("", Text("Untracked files:", style=ThemeKey.TOOL_MARK))
+            grid.add_row("", "")
+            continue
+
+        # Handle untracked files
+        if in_untracked_section:
+            # If we hit a new section or empty line, we're done with untracked files
+            if line.startswith("diff --git") or line.strip() == "":
+                in_untracked_section = False
+            elif line.strip():  # Non-empty line in untracked section
+                file_text = Text(line.strip(), style=ThemeKey.TOOL_PARAM_BOLD)
+                grid.add_row(
+                    Text(f"{'+':>{const.DIFF_PREFIX_WIDTH}}", style=ThemeKey.TOOL_PARAM_BOLD),
+                    file_text,
+                )
+                continue
+
+        # Capture "from" file name from --- line (needed for deleted files)
+        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
+            continue
+
+        # Parse file name from diff headers
+        if show_file_name and line.startswith("+++ "):
+            # Extract file name from +++ header with proper handling of /dev/null
+            raw = line[4:].strip()
+            if raw == "/dev/null":
+                # File was deleted, use the "from" file name
+                file_name = from_file_name or raw
+            elif raw.startswith(("a/", "b/")):
+                file_name = raw[2:]
+            else:
+                file_name = raw
+
+            file_text = Text(file_name, style=ThemeKey.DIFF_FILE_NAME)
+
+            # Count actual +/- lines for this file from i+1 onwards
+            file_additions = 0
+            file_deletions = 0
+            for remaining_line in lines[i + 1 :]:
+                if remaining_line.startswith("diff --git"):
+                    break
+                elif remaining_line.startswith("+") and not remaining_line.startswith("+++"):
+                    file_additions += 1
+                elif remaining_line.startswith("-") and not remaining_line.startswith("---"):
+                    file_deletions += 1
+
+            # Create stats text
+            stats_text = Text()
+            if file_additions > 0:
+                stats_text.append(f"+{file_additions}", style=ThemeKey.DIFF_STATS_ADD)
+            if file_deletions > 0:
+                if file_additions > 0:
+                    stats_text.append(" ")
+                stats_text.append(f"-{file_deletions}", style=ThemeKey.DIFF_STATS_REMOVE)
+
+            # Combine file name and stats
+            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 has_rendered_file_header:
+                grid.add_row("", "")
+
+            if file_additions > 0 and file_deletions == 0:
+                file_mark = "+"
+            elif file_deletions > 0 and file_additions == 0:
+                file_mark = "-"
+            else:
+                file_mark = "±"
+
+            grid.add_row(
+                Text(f"{file_mark:>{const.DIFF_PREFIX_WIDTH}}  ", style=ThemeKey.DIFF_FILE_NAME),
+                file_line,
+            )
+            has_rendered_file_header = True
+            has_rendered_diff_content = False
+            continue
+
+        if line.startswith("diff --git"):
+            has_rendered_diff_content = False
+            continue
+
+        # Parse hunk headers to reset counters: @@ -l,s +l,s @@
+        if line.startswith("@@"):
+            try:
+                parts = line.split()
+                plus = parts[2]  # like '+12,4'
+                new_start = int(plus[1:].split(",")[0])
+                new_ln = new_start
+            except Exception:
+                new_ln = None
+            if has_rendered_diff_content:
+                grid.add_row(Text(f"{'⋮':>{const.DIFF_PREFIX_WIDTH}}", style=ThemeKey.TOOL_RESULT), "")
+            continue
+
+        # Skip +++ lines (already handled above)
+        if line.startswith("+++ "):
+            continue
+
+        # Only handle unified diff hunk lines; ignore other metadata like
+        # "diff --git" or "index ..." which would otherwise skew counters.
+        if not line or line[:1] not in {" ", "+", "-"}:
+            continue
+
+        # Compute line number prefix and style diff content
+        prefix, new_ln = _make_diff_prefix(line, new_ln, const.DIFF_PREFIX_WIDTH)
+
+        if line.startswith("-"):
+            text = Text(line[1:])
+            text.stylize(ThemeKey.DIFF_REMOVE)
+        elif line.startswith("+"):
+            text = Text(line[1:])
+            text.stylize(ThemeKey.DIFF_ADD)
+        else:
+            text = Text(line, style=ThemeKey.TOOL_RESULT)
+        grid.add_row(Text(prefix, ThemeKey.TOOL_RESULT), text)
+        has_rendered_diff_content = True
+
+    return grid
+
+
+def render_diff_panel(
+    diff_text: str,
+    *,
+    show_file_name: bool = True,
+    heading: str = "Git Diff",
+    indent: int = 2,
+) -> RenderableType:
+    lines = diff_text.splitlines()
+    truncated_notice: Text | None = None
+    if len(lines) > const.MAX_DIFF_LINES:
+        truncated_lines = len(lines) - const.MAX_DIFF_LINES
+        diff_text = "\n".join(lines[: const.MAX_DIFF_LINES])
+        truncated_notice = Text(f"… truncated {truncated_lines} lines", style=ThemeKey.TOOL_MARK)
+
+    diff_body = render_diff(diff_text, show_file_name=show_file_name)
+    renderables: list[RenderableType] = [
+        Text(f" {heading} ", style="bold reverse"),
+        diff_body,
+    ]
+    if truncated_notice is not None:
+        renderables.extend([Text(""), truncated_notice])
+
+    panel = Panel.fit(
+        Group(*renderables),
+        border_style=ThemeKey.LINES,
+        title_align="center",
+        box=box.ROUNDED,
+    )
+    if indent <= 0:
+        return panel
+    return Padding.indent(panel, level=indent)

klaude_code/ui/renderers/errors.py

@@ -0,0 +1,16 @@
+from rich.console import RenderableType
+from rich.text import Text
+
+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.
+
+    Shows a two-column grid with an error mark and truncated message.
+    """
+    grid = create_grid()
+    error_msg.stylize(ThemeKey.ERROR)
+    grid.add_row(Text(" " * indent + "✘", style=ThemeKey.ERROR_BOLD), error_msg)
+    return grid

klaude_code/ui/renderers/metadata.py

@@ -0,0 +1,190 @@
+from importlib.metadata import version
+
+from rich import box
+from rich.box import Box
+from rich.console import Group, RenderableType
+from rich.padding import Padding
+from rich.panel import Panel
+from rich.text import Text
+
+from klaude_code.protocol import events
+from klaude_code.trace import is_debug_enabled
+from klaude_code.ui.rich.theme import ThemeKey
+from klaude_code.ui.utils.common import format_number
+
+
+def _get_version() -> str:
+    """Get the current version of klaude-code."""
+    try:
+        return version("klaude-code")
+    except Exception:
+        return "unknown"
+
+
+def render_response_metadata(e: events.ResponseMetadataEvent) -> RenderableType:
+    metadata = e.metadata
+
+    # Line 1: Model and Provider
+    model_text = Text()
+    model_text.append_text(Text("- ", style=ThemeKey.METADATA_BOLD)).append_text(
+        Text(metadata.model_name, style=ThemeKey.METADATA_BOLD)
+    )
+    if metadata.provider is not None:
+        model_text.append_text(Text("@", style=ThemeKey.METADATA)).append_text(
+            Text(metadata.provider.lower().replace(" ", "-"), style=ThemeKey.METADATA)
+        )
+
+    renderables: list[RenderableType] = [model_text]
+
+    # Line 2: Token consumption, Context, TPS, Cost
+    parts: list[Text] = []
+
+    if metadata.usage is not None:
+        # Input
+        input_parts: list[tuple[str, str]] = [
+            ("input:", ThemeKey.METADATA_DIM),
+            (format_number(metadata.usage.input_tokens), ThemeKey.METADATA_DIM),
+        ]
+        if metadata.usage.input_cost is not None:
+            input_parts.append((f"(${metadata.usage.input_cost:.4f})", ThemeKey.METADATA_DIM))
+        parts.append(Text.assemble(*input_parts))
+
+        # Cached
+        if metadata.usage.cached_tokens > 0:
+            cached_parts: list[tuple[str, str]] = [
+                ("cached:", ThemeKey.METADATA_DIM),
+                (format_number(metadata.usage.cached_tokens), ThemeKey.METADATA_DIM),
+            ]
+            if metadata.usage.cache_read_cost is not None:
+                cached_parts.append((f"(${metadata.usage.cache_read_cost:.4f})", ThemeKey.METADATA_DIM))
+            parts.append(Text.assemble(*cached_parts))
+
+        # Output
+        output_parts: list[tuple[str, str]] = [
+            ("output:", ThemeKey.METADATA_DIM),
+            (format_number(metadata.usage.output_tokens), ThemeKey.METADATA_DIM),
+        ]
+        if metadata.usage.output_cost is not None:
+            output_parts.append((f"(${metadata.usage.output_cost:.4f})", ThemeKey.METADATA_DIM))
+        parts.append(Text.assemble(*output_parts))
+
+        # Reasoning
+        if metadata.usage.reasoning_tokens > 0:
+            parts.append(
+                Text.assemble(
+                    ("thinking", ThemeKey.METADATA_DIM),
+                    (":", ThemeKey.METADATA_DIM),
+                    (
+                        format_number(metadata.usage.reasoning_tokens),
+                        ThemeKey.METADATA_DIM,
+                    ),
+                )
+            )
+
+        # Context
+        if metadata.usage.context_usage_percent is not None:
+            parts.append(
+                Text.assemble(
+                    ("context", ThemeKey.METADATA_DIM),
+                    (":", ThemeKey.METADATA_DIM),
+                    (
+                        f"{metadata.usage.context_usage_percent:.1f}%",
+                        ThemeKey.METADATA_DIM,
+                    ),
+                )
+            )
+
+        # TPS
+        if metadata.usage.throughput_tps is not None:
+            parts.append(
+                Text.assemble(
+                    ("tps", ThemeKey.METADATA_DIM),
+                    (":", ThemeKey.METADATA_DIM),
+                    (f"{metadata.usage.throughput_tps:.1f}", ThemeKey.METADATA_DIM),
+                )
+            )
+
+    # Duration
+    if metadata.task_duration_s is not None:
+        parts.append(
+            Text.assemble(
+                ("time", ThemeKey.METADATA_DIM),
+                (":", ThemeKey.METADATA_DIM),
+                (f"{metadata.task_duration_s:.1f}s", ThemeKey.METADATA_DIM),
+            )
+        )
+
+    # Cost (USD)
+    if metadata.usage is not None and metadata.usage.total_cost is not None:
+        parts.append(
+            Text.assemble(
+                ("cost", ThemeKey.METADATA_DIM),
+                (":", ThemeKey.METADATA_DIM),
+                (f"${metadata.usage.total_cost:.4f}", ThemeKey.METADATA_DIM),
+            )
+        )
+
+    if parts:
+        line2 = Text("/", style=ThemeKey.METADATA_DIM).join(parts)
+        renderables.append(Padding(line2, (0, 0, 0, 2)))
+
+    return Group(*renderables)
+
+
+def render_welcome(e: events.WelcomeEvent, *, box_style: Box | None = None) -> RenderableType:
+    """Render the welcome panel with model info and settings."""
+    if box_style is None:
+        box_style = box.ROUNDED
+
+    debug_mode = is_debug_enabled()
+
+    # First line: Klaude Code version
+    klaude_code_style = ThemeKey.WELCOME_DEBUG_TITLE if debug_mode else ThemeKey.WELCOME_HIGHLIGHT_BOLD
+    panel_content = Text.assemble(
+        ("Klaude Code", klaude_code_style),
+        (f" v{_get_version()}\n", ThemeKey.WELCOME_INFO),
+        (str(e.llm_config.model), ThemeKey.WELCOME_HIGHLIGHT),
+        (" @ ", ThemeKey.WELCOME_INFO),
+        (e.llm_config.provider_name, ThemeKey.WELCOME_INFO),
+    )
+
+    # Collect all config items to display
+    config_items: list[tuple[str, str]] = []
+
+    if e.llm_config.thinking is not None:
+        if e.llm_config.thinking.reasoning_effort:
+            config_items.append(("reasoning-effort", e.llm_config.thinking.reasoning_effort))
+        if e.llm_config.thinking.reasoning_summary:
+            config_items.append(("reasoning-summary", e.llm_config.thinking.reasoning_summary))
+        if e.llm_config.thinking.budget_tokens:
+            config_items.append(("thinking-budget", str(e.llm_config.thinking.budget_tokens)))
+
+    if e.llm_config.verbosity:
+        config_items.append(("verbosity", str(e.llm_config.verbosity)))
+
+    if pr := e.llm_config.provider_routing:
+        if pr.sort:
+            config_items.append(("provider-sort", str(pr.sort)))
+        if pr.only:
+            config_items.append(("provider-only", ">".join(pr.only)))
+        if pr.order:
+            config_items.append(("provider-order", ">".join(pr.order)))
+
+    # Render config items with tree-style prefixes
+    for i, (key, value) in enumerate(config_items):
+        is_last = i == len(config_items) - 1
+        prefix = "└─ " if is_last else "├─ "
+        panel_content.append_text(
+            Text.assemble(
+                ("\n", ThemeKey.WELCOME_INFO),
+                (prefix, ThemeKey.LINES),
+                (f"{key}: ", ThemeKey.WELCOME_INFO),
+                (value, ThemeKey.WELCOME_INFO),
+            )
+        )
+
+    border_style = ThemeKey.WELCOME_DEBUG_BORDER if debug_mode else ThemeKey.LINES
+    return Group(
+        Panel.fit(panel_content, border_style=border_style, box=box_style),
+        "",  # empty line
+    )

klaude_code/ui/renderers/sub_agent.py

@@ -0,0 +1,71 @@
+import json
+
+from rich.console import Group, RenderableType
+from rich.panel import Panel
+from rich.style import Style
+from rich.text import Text
+
+from klaude_code import const
+from klaude_code.protocol import events, model
+from klaude_code.protocol.sub_agent import get_sub_agent_profile_by_tool
+from klaude_code.ui.rich.markdown import NoInsetMarkdown
+from klaude_code.ui.rich.theme import ThemeKey
+
+
+def render_sub_agent_call(e: model.SubAgentState, style: Style | None = None) -> RenderableType:
+    """Render sub-agent tool call header and prompt body."""
+    desc = Text(
+        f" {e.sub_agent_desc} ",
+        style=Style(color=style.color if style else None, bold=True, reverse=True),
+    )
+    return Group(
+        Text.assemble((e.sub_agent_type, ThemeKey.TOOL_NAME), " ", desc),
+        Text(e.sub_agent_prompt, style=style or ""),
+    )
+
+
+def render_sub_agent_result(result: str, *, code_theme: str, style: Style | None = None) -> RenderableType:
+    stripped_result = result.strip()
+    lines = stripped_result.splitlines()
+    if len(lines) > const.SUB_AGENT_RESULT_MAX_LINES:
+        hidden_count = len(lines) - const.SUB_AGENT_RESULT_MAX_LINES
+        truncated_text = "\n".join(lines[-const.SUB_AGENT_RESULT_MAX_LINES :])
+        return Panel.fit(
+            Group(
+                Text(
+                    f"… more {hidden_count} lines — use /export to view full output",
+                    style=ThemeKey.TOOL_RESULT,
+                ),
+                NoInsetMarkdown(truncated_text, code_theme=code_theme, style=style or ""),
+            ),
+            border_style=ThemeKey.LINES,
+        )
+    return Panel.fit(
+        NoInsetMarkdown(stripped_result, code_theme=code_theme),
+        border_style=ThemeKey.LINES,
+    )
+
+
+def build_sub_agent_state_from_tool_call(e: events.ToolCallEvent) -> model.SubAgentState | None:
+    """Build SubAgentState from a tool call event for replay rendering."""
+    profile = get_sub_agent_profile_by_tool(e.tool_name)
+    if profile is None:
+        return None
+    description = profile.name
+    prompt = ""
+    if e.arguments:
+        try:
+            payload: dict[str, object] = json.loads(e.arguments)
+        except json.JSONDecodeError:
+            payload = {}
+        desc_value = payload.get("description")
+        if isinstance(desc_value, str) and desc_value.strip():
+            description = desc_value.strip()
+        prompt_value = payload.get("prompt") or payload.get("task")
+        if isinstance(prompt_value, str):
+            prompt = prompt_value.strip()
+    return model.SubAgentState(
+        sub_agent_type=profile.name,
+        sub_agent_desc=description,
+        sub_agent_prompt=prompt,
+    )

klaude_code/ui/renderers/thinking.py

@@ -0,0 +1,39 @@
+from rich.console import RenderableType
+from rich.padding import Padding
+from rich.text import Text
+
+from klaude_code.ui.rich.markdown import NoInsetMarkdown
+from klaude_code.ui.rich.theme import ThemeKey
+
+
+def thinking_prefix() -> Text:
+    return Text.from_markup("[not italic]⸫[/not italic] Thinking …", style=ThemeKey.THINKING)
+
+
+def _normalize_thinking_content(content: str) -> str:
+    """Normalize thinking content for display."""
+    return (
+        content.rstrip()
+        .replace("**\n\n", "**  \n")
+        .replace("\\n\\n\n\n", "")  # Weird case of Gemini 3
+        .replace("****", "**\n\n**")  # remove extra newlines after bold titles
+    )
+
+
+def render_thinking(content: str, *, code_theme: str, style: str) -> RenderableType | None:
+    """Render thinking content as indented markdown.
+
+    Returns None if content is empty.
+    Note: Caller should push thinking_markdown_theme before printing.
+    """
+    if len(content.strip()) == 0:
+        return None
+
+    return Padding.indent(
+        NoInsetMarkdown(
+            _normalize_thinking_content(content),
+            code_theme=code_theme,
+            style=style,
+        ),
+        level=2,
+    )