klaude-code 1.2.1__py3-none-any.whl → 1.2.3__py3-none-any.whl

klaude_code/ui/renderers/tools.py

@@ -5,11 +5,13 @@ from rich.console import RenderableType
 from rich.padding import Padding
 from rich.text import Text
 
-from klaude_code.const import INVALID_TOOL_CALL_MAX_LENGTH
-from klaude_code.core.sub_agent import is_sub_agent_tool as _is_sub_agent_tool
+from klaude_code import const
 from klaude_code.protocol import events, model
-from klaude_code.ui.base.theme import ThemeKey
-from klaude_code.ui.renderers.common import create_grid, truncate_display
+from klaude_code.protocol.sub_agent import is_sub_agent_tool as _is_sub_agent_tool
+from klaude_code.ui.renderers import diffs as r_diffs
+from klaude_code.ui.renderers.common import create_grid
+from klaude_code.ui.rich.theme import ThemeKey
+from klaude_code.ui.utils.common import truncate_display
 
 
 def is_sub_agent_tool(tool_name: str) -> bool:
@@ -43,9 +45,15 @@ def render_generic_tool_call(tool_name: str, arguments: str, markup: str = "•"
         elif len(json_dict) == 1:
             arguments_column = Text(str(next(iter(json_dict.values()))), ThemeKey.TOOL_PARAM)
         else:
-            arguments_column = Text(", ".join([f"{k}: {v}" for k, v in json_dict.items()]), ThemeKey.TOOL_PARAM)
+            arguments_column = Text(
+                ", ".join([f"{k}: {v}" for k, v in json_dict.items()]),
+                ThemeKey.TOOL_PARAM,
+            )
     except json.JSONDecodeError:
-        arguments_column = Text(arguments.strip()[:INVALID_TOOL_CALL_MAX_LENGTH], style=ThemeKey.INVALID_TOOL_CALL_ARGS)
+        arguments_column = Text(
+            arguments.strip()[: const.INVALID_TOOL_CALL_MAX_LENGTH],
+            style=ThemeKey.INVALID_TOOL_CALL_ARGS,
+        )
     grid.add_row(tool_name_column, arguments_column)
     return grid
 
@@ -60,7 +68,8 @@ def render_update_plan_tool_call(arguments: str) -> RenderableType:
             payload = json.loads(arguments)
         except json.JSONDecodeError:
             explanation_column = Text(
-                arguments.strip()[:INVALID_TOOL_CALL_MAX_LENGTH], style=ThemeKey.INVALID_TOOL_CALL_ARGS
+                arguments.strip()[: const.INVALID_TOOL_CALL_MAX_LENGTH],
+                style=ThemeKey.INVALID_TOOL_CALL_ARGS,
             )
         else:
             explanation = payload.get("explanation")
@@ -103,7 +112,10 @@ def render_read_tool_call(arguments: str) -> RenderableType:
             )
     except json.JSONDecodeError:
         render_result = render_result.append_text(
-            Text(arguments.strip()[:INVALID_TOOL_CALL_MAX_LENGTH], style=ThemeKey.INVALID_TOOL_CALL_ARGS)
+            Text(
+                arguments.strip()[: const.INVALID_TOOL_CALL_MAX_LENGTH],
+                style=ThemeKey.INVALID_TOOL_CALL_ARGS,
+            )
         )
     grid.add_row(Text("←", ThemeKey.TOOL_MARK), render_result)
     return grid
@@ -123,7 +135,12 @@ def render_edit_tool_call(arguments: str) -> Text:
         render_result = (
             render_result.append_text(Text("Edit", ThemeKey.TOOL_NAME))
             .append_text(Text(" "))
-            .append_text(Text(arguments.strip()[:INVALID_TOOL_CALL_MAX_LENGTH], style=ThemeKey.INVALID_TOOL_CALL_ARGS))
+            .append_text(
+                Text(
+                    arguments.strip()[: const.INVALID_TOOL_CALL_MAX_LENGTH],
+                    style=ThemeKey.INVALID_TOOL_CALL_ARGS,
+                )
+            )
         )
     return render_result
 
@@ -149,7 +166,12 @@ def render_write_tool_call(arguments: str) -> Text:
         render_result = (
             render_result.append_text(Text("Write", ThemeKey.TOOL_NAME))
             .append_text(Text(" "))
-            .append_text(Text(arguments.strip()[:INVALID_TOOL_CALL_MAX_LENGTH], style=ThemeKey.INVALID_TOOL_CALL_ARGS))
+            .append_text(
+                Text(
+                    arguments.strip()[: const.INVALID_TOOL_CALL_MAX_LENGTH],
+                    style=ThemeKey.INVALID_TOOL_CALL_ARGS,
+                )
+            )
         )
     return render_result
 
@@ -168,7 +190,10 @@ def render_multi_edit_tool_call(arguments: str) -> Text:
         )
     except json.JSONDecodeError:
         render_result = render_result.append_text(
-            Text(arguments.strip()[:INVALID_TOOL_CALL_MAX_LENGTH], style=ThemeKey.INVALID_TOOL_CALL_ARGS)
+            Text(
+                arguments.strip()[: const.INVALID_TOOL_CALL_MAX_LENGTH],
+                style=ThemeKey.INVALID_TOOL_CALL_ARGS,
+            )
         )
     return render_result
 
@@ -181,7 +206,10 @@ def render_apply_patch_tool_call(arguments: str) -> RenderableType:
             ("→ ", ThemeKey.TOOL_MARK),
             ("Apply Patch", ThemeKey.TOOL_NAME),
             " ",
-            Text(arguments.strip()[:INVALID_TOOL_CALL_MAX_LENGTH], style=ThemeKey.INVALID_TOOL_CALL_ARGS),
+            Text(
+                arguments.strip()[: const.INVALID_TOOL_CALL_MAX_LENGTH],
+                style=ThemeKey.INVALID_TOOL_CALL_ARGS,
+            ),
         )
 
     patch_content = payload.get("patch", "")
@@ -193,9 +221,12 @@ def render_apply_patch_tool_call(arguments: str) -> RenderableType:
     if isinstance(patch_content, str):
         lines = [line for line in patch_content.splitlines() if line and not line.startswith("*** Begin Patch")]
         if lines:
-            summary = Text(lines[0][:INVALID_TOOL_CALL_MAX_LENGTH], ThemeKey.TOOL_PARAM)
+            summary = Text(lines[0][: const.INVALID_TOOL_CALL_MAX_LENGTH], ThemeKey.TOOL_PARAM)
     else:
-        summary = Text(str(patch_content)[:INVALID_TOOL_CALL_MAX_LENGTH], ThemeKey.INVALID_TOOL_CALL_ARGS)
+        summary = Text(
+            str(patch_content)[: const.INVALID_TOOL_CALL_MAX_LENGTH],
+            ThemeKey.INVALID_TOOL_CALL_ARGS,
+        )
 
     if summary.plain:
         grid.add_row(header, summary)
@@ -207,9 +238,17 @@ def render_apply_patch_tool_call(arguments: str) -> RenderableType:
 
 def render_todo(tr: events.ToolResultEvent) -> RenderableType:
     if tr.ui_extra is None:
-        return Text.assemble(("  ✘", ThemeKey.ERROR_BOLD), " ", Text("(no content)", style=ThemeKey.ERROR))
+        return Text.assemble(
+            ("  ✘", ThemeKey.ERROR_BOLD),
+            " ",
+            Text("(no content)", style=ThemeKey.ERROR),
+        )
     if tr.ui_extra.type != model.ToolResultUIExtraType.TODO_LIST or tr.ui_extra.todo_list is None:
-        return Text.assemble(("  ✘", ThemeKey.ERROR_BOLD), " ", Text("(invalid ui_extra)", style=ThemeKey.ERROR))
+        return Text.assemble(
+            ("  ✘", ThemeKey.ERROR_BOLD),
+            " ",
+            Text("(invalid ui_extra)", style=ThemeKey.ERROR),
+        )
 
     ui_extra = tr.ui_extra.todo_list
     todo_grid = create_grid()
@@ -241,7 +280,9 @@ def render_generic_tool_result(result: str, *, is_error: bool = False) -> Render
     return Padding.indent(Text(truncate_display(result), style=style), level=2)
 
 
-def _extract_mermaid_link(ui_extra: model.ToolResultUIExtra | None) -> model.MermaidLinkUIExtra | None:
+def _extract_mermaid_link(
+    ui_extra: model.ToolResultUIExtra | None,
+) -> model.MermaidLinkUIExtra | None:
     if ui_extra is None:
         return None
     if ui_extra.type != model.ToolResultUIExtraType.MERMAID_LINK:
@@ -264,7 +305,10 @@ def render_memory_tool_call(arguments: str) -> RenderableType:
         payload: dict[str, str] = json.loads(arguments)
     except json.JSONDecodeError:
         tool_name_column = Text.assemble(("★", ThemeKey.TOOL_MARK), " ", ("Memory", ThemeKey.TOOL_NAME))
-        summary = Text(arguments.strip()[:INVALID_TOOL_CALL_MAX_LENGTH], style=ThemeKey.INVALID_TOOL_CALL_ARGS)
+        summary = Text(
+            arguments.strip()[: const.INVALID_TOOL_CALL_MAX_LENGTH],
+            style=ThemeKey.INVALID_TOOL_CALL_ARGS,
+        )
         grid.add_row(tool_name_column, summary)
         return grid
 
@@ -308,7 +352,10 @@ def render_mermaid_tool_call(arguments: str) -> RenderableType:
     try:
         payload: dict[str, str] = json.loads(arguments)
     except json.JSONDecodeError:
-        summary = Text(arguments.strip()[:INVALID_TOOL_CALL_MAX_LENGTH], style=ThemeKey.INVALID_TOOL_CALL_ARGS)
+        summary = Text(
+            arguments.strip()[: const.INVALID_TOOL_CALL_MAX_LENGTH],
+            style=ThemeKey.INVALID_TOOL_CALL_ARGS,
+        )
     else:
         code = payload.get("code", "")
         if code:
@@ -330,7 +377,9 @@ def render_mermaid_tool_result(tr: events.ToolResultEvent) -> RenderableType:
     return Padding.indent(link_text, level=2)
 
 
-def _extract_truncation(ui_extra: model.ToolResultUIExtra | None) -> model.TruncationUIExtra | None:
+def _extract_truncation(
+    ui_extra: model.ToolResultUIExtra | None,
+) -> model.TruncationUIExtra | None:
     if ui_extra is None:
         return None
     if ui_extra.type != model.ToolResultUIExtraType.TRUNCATION:
@@ -357,3 +406,146 @@ def render_truncation_info(ui_extra: model.TruncationUIExtra) -> RenderableType:
 def get_truncation_info(tr: events.ToolResultEvent) -> model.TruncationUIExtra | None:
     """Extract truncation info from a tool result event."""
     return _extract_truncation(tr.ui_extra)
+
+
+# Tool name to mark mapping
+_TOOL_MARKS: dict[str, str] = {
+    "Read": "←",
+    "Edit": "→",
+    "Write": "→",
+    "MultiEdit": "→",
+    "Bash": ">",
+    "apply_patch": "→",
+    "TodoWrite": "◎",
+    "update_plan": "◎",
+    "Mermaid": "⧉",
+    "Memory": "★",
+    "Skill": "◈",
+}
+
+# Tool name to active form mapping (for spinner status)
+_TOOL_ACTIVE_FORM: dict[str, str] = {
+    "Bash": "Bashing",
+    "apply_patch": "Patching",
+    "Edit": "Editing",
+    "MultiEdit": "Editing",
+    "Read": "Reading",
+    "Write": "Writing",
+    "TodoWrite": "Planning",
+    "update_plan": "Planning",
+    "Skill": "Skilling",
+    "Mermaid": "Diagramming",
+    "Memory": "Memorizing",
+    "WebFetch": "Fetching",
+}
+
+
+def get_tool_active_form(tool_name: str) -> str:
+    """Get the active form of a tool name for spinner status.
+
+    Checks both the static mapping and sub agent profiles.
+    """
+    if tool_name in _TOOL_ACTIVE_FORM:
+        return _TOOL_ACTIVE_FORM[tool_name]
+
+    # Check sub agent profiles
+    from klaude_code.protocol.sub_agent import get_sub_agent_profile_by_tool
+
+    profile = get_sub_agent_profile_by_tool(tool_name)
+    if profile and profile.active_form:
+        return profile.active_form
+
+    return f"Calling {tool_name}"
+
+
+def render_tool_call(e: events.ToolCallEvent) -> RenderableType | None:
+    """Unified entry point for rendering tool calls.
+
+    Returns a Rich Renderable or None if the tool call should not be rendered.
+    """
+    from klaude_code.protocol import tools
+
+    if is_sub_agent_tool(e.tool_name):
+        return None
+
+    match e.tool_name:
+        case tools.READ:
+            return render_read_tool_call(e.arguments)
+        case tools.EDIT:
+            return render_edit_tool_call(e.arguments)
+        case tools.WRITE:
+            return render_write_tool_call(e.arguments)
+        case tools.MULTI_EDIT:
+            return render_multi_edit_tool_call(e.arguments)
+        case tools.BASH:
+            return render_generic_tool_call(e.tool_name, e.arguments, ">")
+        case tools.APPLY_PATCH:
+            return render_apply_patch_tool_call(e.arguments)
+        case tools.TODO_WRITE:
+            return render_generic_tool_call("Update Todos", "", "◎")
+        case tools.UPDATE_PLAN:
+            return render_update_plan_tool_call(e.arguments)
+        case tools.MERMAID:
+            return render_mermaid_tool_call(e.arguments)
+        case tools.MEMORY:
+            return render_memory_tool_call(e.arguments)
+        case tools.SKILL:
+            return render_generic_tool_call(e.tool_name, e.arguments, "◈")
+        case _:
+            return render_generic_tool_call(e.tool_name, e.arguments)
+
+
+def _extract_diff_text(ui_extra: model.ToolResultUIExtra | None) -> str | None:
+    if ui_extra is None:
+        return None
+    if ui_extra.type == model.ToolResultUIExtraType.DIFF_TEXT:
+        return ui_extra.diff_text
+    return None
+
+
+def render_tool_result(e: events.ToolResultEvent) -> RenderableType | None:
+    """Unified entry point for rendering tool results.
+
+    Returns a Rich Renderable or None if the tool result should not be rendered.
+    """
+    from klaude_code.protocol import tools
+    from klaude_code.ui.renderers import errors as r_errors
+
+    if is_sub_agent_tool(e.tool_name):
+        return None
+
+    # Handle error case
+    if e.status == "error" and e.ui_extra is None:
+        error_msg = Text(truncate_display(e.result))
+        return r_errors.render_error(error_msg)
+
+    # Show truncation info if output was truncated and saved to file
+    truncation_info = get_truncation_info(e)
+    if truncation_info:
+        return render_truncation_info(truncation_info)
+
+    diff_text = _extract_diff_text(e.ui_extra)
+
+    match e.tool_name:
+        case tools.READ:
+            return None
+        case tools.EDIT | tools.MULTI_EDIT | tools.WRITE:
+            return Padding.indent(r_diffs.render_diff(diff_text or ""), level=2)
+        case tools.MEMORY:
+            if diff_text:
+                return Padding.indent(r_diffs.render_diff(diff_text), level=2)
+            elif len(e.result.strip()) > 0:
+                return render_generic_tool_result(e.result)
+            return None
+        case tools.TODO_WRITE | tools.UPDATE_PLAN:
+            return render_todo(e)
+        case tools.MERMAID:
+            return render_mermaid_tool_result(e)
+        case _:
+            if e.tool_name in (tools.BASH, tools.APPLY_PATCH) and e.result.startswith("diff --git"):
+                return r_diffs.render_diff_panel(e.result, show_file_name=True)
+            if e.tool_name == tools.APPLY_PATCH and diff_text:
+                return Padding.indent(r_diffs.render_diff(diff_text, show_file_name=True), level=2)
+            if len(e.result.strip()) == 0:
+                return render_generic_tool_result("(no content)")
+            return render_generic_tool_result(e.result)

klaude_code/ui/renderers/user_input.py

@@ -3,9 +3,9 @@ import re
 from rich.console import Group, RenderableType
 from rich.text import Text
 
-from klaude_code.protocol.commands import CommandName
-from klaude_code.ui.base.theme import ThemeKey
+from klaude_code.command import is_slash_command_name
 from klaude_code.ui.renderers.common import create_grid
+from klaude_code.ui.rich.theme import ThemeKey
 
 
 def render_at_pattern(
@@ -25,14 +25,6 @@ def render_at_pattern(
     return Text(text, style=other_style)
 
 
-def _is_valid_slash_command(command: str) -> bool:
-    try:
-        CommandName(command)
-        return True
-    except ValueError:
-        return False
-
-
 def render_user_input(content: str) -> RenderableType:
     """Render a user message as a group of quoted lines with styles.
 
@@ -41,27 +33,31 @@ def render_user_input(content: str) -> RenderableType:
     """
     lines = content.strip().split("\n")
     renderables: list[RenderableType] = []
+    has_command = False
     for i, line in enumerate(lines):
         line_text = render_at_pattern(line)
 
         if i == 0 and line.startswith("/"):
             splits = line.split(" ", maxsplit=1)
-            if _is_valid_slash_command(splits[0][1:]):
-                if len(splits) <= 1:
-                    renderables.append(Text(f" {line} ", style=ThemeKey.USER_INPUT_SLASH_COMMAND))
-                    continue
-                else:
-                    line_text = Text.assemble(
-                        (f" {splits[0]} ", ThemeKey.USER_INPUT_SLASH_COMMAND),
-                        " ",
-                        render_at_pattern(splits[1]),
-                    )
-                    renderables.append(line_text)
-                    continue
+            if is_slash_command_name(splits[0][1:]):
+                has_command = True
+                line_text = Text.assemble(
+                    (f"{splits[0]}", ThemeKey.USER_INPUT_SLASH_COMMAND),
+                    " ",
+                    render_at_pattern(splits[1]) if len(splits) > 1 else Text(""),
+                )
+                renderables.append(line_text)
+                continue
 
         renderables.append(line_text)
     grid = create_grid()
-    grid.add_row(Text("❯", style=ThemeKey.USER_INPUT_PROMPT), Group(*renderables))
+    grid.padding = (0, 0)
+    mark = (
+        Text("❯ ", style=ThemeKey.USER_INPUT_PROMPT)
+        if not has_command
+        else Text("  ", style=ThemeKey.USER_INPUT_SLASH_COMMAND)
+    )
+    grid.add_row(mark, Group(*renderables))
     return grid
 
 

klaude_code/ui/rich/__init__.py

@@ -0,0 +1 @@
+# Rich rendering utilities

klaude_code/ui/{rich_ext → rich}/searchable_text.py

@@ -23,7 +23,9 @@ class SearchableFormattedText:
         self._plain = plain
 
     # Recognized by prompt_toolkit's to_formatted_text(value)
-    def __pt_formatted_text__(self) -> Iterable[Tuple[str, str]]:  # pragma: no cover - passthrough
+    def __pt_formatted_text__(
+        self,
+    ) -> Iterable[Tuple[str, str]]:  # pragma: no cover - passthrough
         return self._fragments
 
     # Provide a human-readable representation.

klaude_code/ui/{renderers → rich}/status.py

@@ -13,8 +13,8 @@ from rich.table import Table
 from rich.text import Text
 
 from klaude_code import const
-from klaude_code.ui.base.terminal_color import get_last_terminal_background_rgb
-from klaude_code.ui.base.theme import ThemeKey
+from klaude_code.ui.rich.theme import ThemeKey
+from klaude_code.ui.terminal.color import get_last_terminal_background_rgb
 
 BREATHING_SPINNER_NAME = "dot"
 
@@ -52,10 +52,21 @@ def _shimmer_profile(main_text: str) -> list[tuple[str, float]]:
         return []
 
     padding = const.STATUS_SHIMMER_PADDING
-    period = len(chars) + padding * 2
+    char_count = len(chars)
+    period = char_count + padding * 2
+
+    # Keep a roughly constant shimmer speed (characters per second)
+    # regardless of text length by deriving a character velocity from a
+    # baseline text length and the configured sweep duration.
+    # The baseline is chosen to be close to the default
+    # "Thinking … (esc to interrupt)" status line.
+    baseline_chars = 30
+    base_period = baseline_chars + padding * 2
     sweep_seconds = const.STATUS_SHIMMER_SWEEP_SECONDS
+    char_speed = base_period / sweep_seconds if sweep_seconds > 0 else base_period
+
     elapsed = _elapsed_since_start()
-    pos_f = (elapsed % sweep_seconds) / sweep_seconds * float(period)
+    pos_f = (elapsed * char_speed) % float(period)
     pos = int(pos_f)
     band_half_width = const.STATUS_SHIMMER_BAND_HALF_WIDTH
 
@@ -144,37 +155,37 @@ def _breathing_style(console: Console, base_style: Style, intensity: float) -> S
 class ShimmerStatusText:
     """Renderable status line with shimmer effect on the main text and hint."""
 
-    def __init__(self, main_text: str, main_style: ThemeKey) -> None:
-        self._main_text = main_text
+    def __init__(self, main_text: str | Text, main_style: ThemeKey) -> None:
+        self._main_text = main_text if isinstance(main_text, Text) else Text(main_text)
         self._main_style = main_style
-        self._hint_text = " (esc to interrupt)"
+        self._hint_text = Text(" (esc to interrupt)")
         self._hint_style = ThemeKey.STATUS_HINT
 
     def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
-        text = Text()
+        result = Text()
         main_style = console.get_style(str(self._main_style))
         hint_style = console.get_style(str(self._hint_style))
 
-        combined_text = f"{self._main_text}{self._hint_text}"
-        split_index = len(self._main_text)
+        combined_text = self._main_text.plain + self._hint_text.plain
+        split_index = len(self._main_text.plain)
 
         for index, (ch, intensity) in enumerate(_shimmer_profile(combined_text)):
-            base_style = main_style if index < split_index else hint_style
+            if index < split_index:
+                # Get style from main_text, merge with main_style
+                char_style = self._main_text.get_style_at_offset(console, index)
+                base_style = main_style + char_style
+            else:
+                base_style = hint_style
             style = _shimmer_style(console, base_style, intensity)
-            text.append(ch, style=style)
+            result.append(ch, style=style)
 
-        yield text
+        yield result
 
 
 def spinner_name() -> str:
     return BREATHING_SPINNER_NAME
 
 
-def render_status_text(main_text: str, main_style: ThemeKey) -> RenderableType:
-    """Create animated status text with shimmer main text and hint suffix."""
-    return ShimmerStatusText(main_text, main_style)
-
-
 class BreathingSpinner(RichSpinner):
     """Custom spinner that animates color instead of glyphs.
 

klaude_code/ui/{base → rich}/theme.py

@@ -124,6 +124,9 @@ class ThemeKey(str, Enum):
     WELCOME_HIGHLIGHT_BOLD = "welcome.highlight.bold"
     WELCOME_HIGHLIGHT = "welcome.highlight"
     WELCOME_INFO = "welcome.info"
+    # WELCOME DEBUG
+    WELCOME_DEBUG_TITLE = "welcome.debug.title"
+    WELCOME_DEBUG_BORDER = "welcome.debug.border"
     # RESUME
     RESUME_FLAG = "resume.flag"
     RESUME_INFO = "resume.info"
@@ -177,8 +180,8 @@ def get_theme(theme: str | None = None) -> Themes:
                 ThemeKey.METADATA_DIM.value: "dim " + palette.grey_blue,
                 ThemeKey.METADATA_BOLD.value: "bold " + palette.grey_blue,
                 # SPINNER_STATUS
-                ThemeKey.SPINNER_STATUS.value: palette.green,
-                ThemeKey.SPINNER_STATUS_TEXT.value: palette.green,
+                ThemeKey.SPINNER_STATUS.value: palette.blue,
+                ThemeKey.SPINNER_STATUS_TEXT.value: palette.blue,
                 # STATUS
                 ThemeKey.STATUS_HINT.value: palette.grey2,
                 # REMINDER
@@ -212,6 +215,9 @@ def get_theme(theme: str | None = None) -> Themes:
                 ThemeKey.WELCOME_HIGHLIGHT_BOLD.value: "bold",
                 ThemeKey.WELCOME_HIGHLIGHT.value: palette.blue,
                 ThemeKey.WELCOME_INFO.value: palette.grey1,
+                # WELCOME DEBUG
+                ThemeKey.WELCOME_DEBUG_TITLE.value: "bold " + palette.red,
+                ThemeKey.WELCOME_DEBUG_BORDER.value: palette.red,
                 # RESUME
                 ThemeKey.RESUME_FLAG.value: "bold reverse " + palette.green,
                 ThemeKey.RESUME_INFO.value: palette.green,

klaude_code/ui/terminal/__init__.py

@@ -0,0 +1 @@
+# Terminal utilities

klaude_code/ui/{base/terminal_color.py → terminal/color.py}

@@ -99,7 +99,10 @@ def _query_color_slot(slot: int, timeout: float) -> tuple[int, int, int] | None:
                         )
 
     except OSError as exc:
-        log_debug(f"Failed to open /dev/tty for OSC color query: {exc}", debug_type=DebugType.TERMINAL)
+        log_debug(
+            f"Failed to open /dev/tty for OSC color query: {exc}",
+            debug_type=DebugType.TERMINAL,
+        )
         return None
 
     if raw is None or not raw:

klaude_code/ui/{base/terminal_control.py → terminal/control.py}

@@ -37,6 +37,7 @@ def start_esc_interrupt_monitor(
 
     # Fallback for non-interactive or non-POSIX environments.
     if not sys.stdin.isatty() or os.name != "posix":
+
         async def _noop() -> None:  # type: ignore[return-type]
             return None
 

klaude_code/ui/{base/terminal_notifier.py → terminal/notifier.py}

@@ -52,7 +52,10 @@ class TerminalNotifier:
 
     def notify(self, notification: Notification) -> bool:
         if not self.config.enabled:
-            log_debug("Terminal notifier skipped: disabled via config", debug_type=DebugType.TERMINAL)
+            log_debug(
+                "Terminal notifier skipped: disabled via config",
+                debug_type=DebugType.TERMINAL,
+            )
             return False
 
         output = resolve_stream(self.config.stream)
@@ -100,5 +103,5 @@ class TerminalNotifier:
 def _compact(text: str, limit: int = 160) -> str:
     squashed = " ".join(text.split())
     if len(squashed) > limit:
-        return squashed[: limit - 3] + "..."
+        return squashed[: limit - 3] + "…"
     return squashed

klaude_code/ui/utils/__init__.py

@@ -0,0 +1 @@
+# UI utilities

klaude_code/ui/{base/utils.py → utils/common.py}

@@ -2,6 +2,8 @@ import re
 import subprocess
 from pathlib import Path
 
+from klaude_code import const
+
 LEADING_NEWLINES_REGEX = re.compile(r"^\n{2,}")
 
 
@@ -36,14 +38,24 @@ def get_current_git_branch(path: Path | None = None) -> str | None:
 
     try:
         # Check if in git repository
-        git_dir = subprocess.run(["git", "rev-parse", "--git-dir"], cwd=path, capture_output=True, text=True, timeout=2)
+        git_dir = subprocess.run(
+            ["git", "rev-parse", "--git-dir"],
+            cwd=path,
+            capture_output=True,
+            text=True,
+            timeout=2,
+        )
 
         if git_dir.returncode != 0:
             return None
 
         # Get current branch name
         result = subprocess.run(
-            ["git", "branch", "--show-current"], cwd=path, capture_output=True, text=True, timeout=2
+            ["git", "branch", "--show-current"],
+            cwd=path,
+            capture_output=True,
+            text=True,
+            timeout=2,
         )
 
         if result.returncode == 0:
@@ -52,7 +64,11 @@ def get_current_git_branch(path: Path | None = None) -> str | None:
 
         # Fallback: get HEAD reference
         head_file = subprocess.run(
-            ["git", "rev-parse", "--abbrev-ref", "HEAD"], cwd=path, capture_output=True, text=True, timeout=2
+            ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+            cwd=path,
+            capture_output=True,
+            text=True,
+            timeout=2,
         )
 
         if head_file.returncode == 0:
@@ -74,3 +90,19 @@ def show_path_with_tilde(path: Path | None = None):
         return f"~/{relative_path}"
     except ValueError:
         return str(path)
+
+
+def truncate_display(
+    text: str,
+    max_lines: int = const.TRUNCATE_DISPLAY_MAX_LINES,
+    max_line_length: int = const.TRUNCATE_DISPLAY_MAX_LINE_LENGTH,
+) -> str:
+    lines = text.split("\n")
+    if len(lines) > max_lines:
+        lines = lines[:max_lines] + ["… (more " + str(len(lines) - max_lines) + " lines)"]
+    for i, line in enumerate(lines):
+        if len(line) > max_line_length:
+            lines[i] = (
+                line[:max_line_length] + "… (more " + str(len(line) - max_line_length) + " characters in this line)"
+            )
+    return "\n".join(lines)

{klaude_code-1.2.1.dist-info → klaude_code-1.2.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: klaude-code
-Version: 1.2.1
+Version: 1.2.3
 Summary: Add your description here
 Requires-Dist: anthropic>=0.66.0
 Requires-Dist: openai>=1.102.0