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

klaude_code/ui/renderers/user_input.py

@@ -1,39 +1,84 @@
 import re
+from collections.abc import Callable
 
 from rich.console import Group, RenderableType
 from rich.text import Text
 
-from klaude_code.command import is_slash_command_name
+from klaude_code.skill import get_available_skills
 from klaude_code.ui.renderers.common import create_grid
 from klaude_code.ui.rich.theme import ThemeKey
 
+# Module-level command name checker. Set by cli/runtime.py on startup.
+_command_name_checker: Callable[[str], bool] | None = None
+
+
+def set_command_name_checker(checker: Callable[[str], bool]) -> None:
+    """Set the command name validation function (called from runtime layer)."""
+    global _command_name_checker
+    _command_name_checker = checker
+
+
+def is_slash_command_name(name: str) -> bool:
+    """Check if name is a valid slash command using the injected checker."""
+    if _command_name_checker is None:
+        return False
+    return _command_name_checker(name)
+
+
+# Match @-file patterns only when they appear at the beginning of the line
+# or immediately after whitespace, to avoid treating mid-word email-like
+# patterns such as foo@bar.com as file references.
+AT_FILE_RENDER_PATTERN = re.compile(r'(?<!\S)@("([^"]+)"|\S+)')
+
+# Match $skill or ¥skill pattern at the beginning of the first line
+SKILL_RENDER_PATTERN = re.compile(r"^[$¥](\S+)")
+
+USER_MESSAGE_MARK = "❯ "
+
 
 def render_at_pattern(
     text: str,
     at_style: str = ThemeKey.USER_INPUT_AT_PATTERN,
     other_style: str = ThemeKey.USER_INPUT,
 ) -> Text:
-    if "@" in text:
-        parts = re.split(r"(\s+)", text)
-        result = Text("")
-        for s in parts:
-            if s.startswith("@"):
-                result.append_text(Text(s, at_style))
-            else:
-                result.append_text(Text(s, other_style))
-        return result
-    return Text(text, style=other_style)
+    if "@" not in text:
+        return Text(text, style=other_style)
+
+    result = Text("")
+    last_end = 0
+    for match in AT_FILE_RENDER_PATTERN.finditer(text):
+        start, end = match.span()
+        if start > last_end:
+            # Text before the @-pattern
+            result.append_text(Text(text[last_end:start], other_style))
+        # The @-pattern itself (e.g. @path or @"path with spaces")
+        result.append_text(Text(text[start:end], at_style))
+        last_end = end
+
+    if last_end < len(text):
+        result.append_text(Text(text[last_end:], other_style))
+
+    return result
+
+
+def _is_valid_skill_name(name: str) -> bool:
+    """Check if a skill name is valid (exists in loaded skills)."""
+    short = name.split(":")[-1] if ":" in name else name
+    available_skills = get_available_skills()
+    return any(skill_name in (name, short) for skill_name, _, _ in available_skills)
 
 
 def render_user_input(content: str) -> RenderableType:
     """Render a user message as a group of quoted lines with styles.
 
     - Highlights slash command on the first line if recognized
+    - Highlights $skill pattern on the first line if recognized
     - Highlights @file patterns in all lines
     """
     lines = content.strip().split("\n")
     renderables: list[RenderableType] = []
     has_command = False
+    command_style: str | None = None
     for i, line in enumerate(lines):
         line_text = render_at_pattern(line)
 
@@ -41,6 +86,7 @@ def render_user_input(content: str) -> RenderableType:
             splits = line.split(" ", maxsplit=1)
             if is_slash_command_name(splits[0][1:]):
                 has_command = True
+                command_style = ThemeKey.USER_INPUT_SLASH_COMMAND
                 line_text = Text.assemble(
                     (f"{splits[0]}", ThemeKey.USER_INPUT_SLASH_COMMAND),
                     " ",
@@ -49,13 +95,27 @@ def render_user_input(content: str) -> RenderableType:
                 renderables.append(line_text)
                 continue
 
+        if i == 0 and (line.startswith("$") or line.startswith("¥")):
+            m = SKILL_RENDER_PATTERN.match(line)
+            if m and _is_valid_skill_name(m.group(1)):
+                has_command = True
+                command_style = ThemeKey.USER_INPUT_SKILL
+                skill_token = m.group(0)  # e.g. "$skill-name"
+                rest = line[len(skill_token) :]
+                line_text = Text.assemble(
+                    (skill_token, ThemeKey.USER_INPUT_SKILL),
+                    render_at_pattern(rest) if rest else Text(""),
+                )
+                renderables.append(line_text)
+                continue
+
         renderables.append(line_text)
     grid = create_grid()
     grid.padding = (0, 0)
     mark = (
-        Text("❯ ", style=ThemeKey.USER_INPUT_PROMPT)
+        Text(USER_MESSAGE_MARK, style=ThemeKey.USER_INPUT_PROMPT)
         if not has_command
-        else Text("  ", style=ThemeKey.USER_INPUT_SLASH_COMMAND)
+        else Text("  ", style=command_style or ThemeKey.USER_INPUT_SLASH_COMMAND)
     )
     grid.add_row(mark, Group(*renderables))
     return grid

klaude_code/ui/rich/__init__.py

@@ -1 +1,10 @@
-# Rich rendering utilities
+"""Rich rendering utilities.
+
+This package installs a small monkey-patch that improves CJK line breaking in Rich.
+"""
+
+from __future__ import annotations
+
+from .cjk_wrap import install_rich_cjk_wrap_patch
+
+install_rich_cjk_wrap_patch()

klaude_code/ui/rich/cjk_wrap.py

@@ -0,0 +1,228 @@
+"""Monkey-patch Rich wrapping for better CJK line breaks."""
+
+from __future__ import annotations
+
+import unicodedata
+from collections.abc import Callable
+
+
+def _is_cjk_char(ch: str) -> bool:
+    return unicodedata.east_asian_width(ch) in ("W", "F")
+
+
+def _contains_cjk(text: str) -> bool:
+    return any(_is_cjk_char(ch) for ch in text)
+
+
+def _is_ascii_word_char(ch: str) -> bool:
+    o = ord(ch)
+    return (48 <= o <= 57) or (65 <= o <= 90) or (97 <= o <= 122) or ch in "_."
+
+
+def _find_prefix_len_for_remaining(word: str, remaining_space: int) -> int:
+    """Find a prefix length (in chars) that fits remaining_space.
+
+    This prefers breakpoints that don't split ASCII word-like runs.
+    """
+
+    if remaining_space <= 0:
+        return 0
+
+    # Local import keeps import-time overhead low.
+    from rich.cells import get_character_cell_size
+
+    total = 0
+    best = 0
+    n = len(word)
+
+    for i, ch in enumerate(word):
+        total += get_character_cell_size(ch)
+        if total > remaining_space:
+            break
+
+        boundary = i + 1
+        if boundary >= n:
+            best = boundary
+            break
+
+        # Avoid leaving a path separator at the start of the next line.
+        if word[boundary] in "/":
+            continue
+
+        # Disallow breaks inside ASCII word runs: ...a|b...
+        if _is_ascii_word_char(word[boundary - 1]) and _is_ascii_word_char(word[boundary]):
+            continue
+
+        best = boundary
+
+    return best
+
+
+_rich_cjk_wrap_patch_installed = False
+
+
+def install_rich_cjk_wrap_patch() -> bool:
+    """Install a monkey-patch that improves CJK line wrapping in Rich.
+
+    Rich wraps text by tokenizing on whitespace, which causes long CJK runs to be
+    treated as a single "word" and moved to the next line wholesale.
+
+    This patch keeps ASCII word wrapping behaviour intact, but allows breaking
+    CJK-containing tokens at the end of a line to fill remaining space.
+
+    Returns:
+        True if the patch was installed in this process.
+    """
+
+    global _rich_cjk_wrap_patch_installed
+    if _rich_cjk_wrap_patch_installed:
+        return False
+
+    import rich._wrap as _wrap
+    import rich.text as _text
+    from rich._loop import loop_last
+    from rich.cells import cell_len, chop_cells
+
+    _OPEN_TO_CLOSE = {
+        "(": ")",
+        "（": "）",
+        "[": "]",
+        "{": "}",
+        "“": "”",
+        "‘": "’",
+        "《": "》",
+        "〈": "〉",
+        "「": "」",
+        "『": "』",
+        "【": "】",
+    }
+
+    def _leading_unclosed_delim(word: str) -> str | None:
+        stripped = word.lstrip()
+        if not stripped:
+            return None
+
+        close_delim = _OPEN_TO_CLOSE.get(stripped[0])
+        if close_delim is None:
+            return None
+
+        if close_delim in stripped:
+            return None
+
+        return close_delim
+
+    def _close_delim_appears_soon(
+        word_tokens: list[str],
+        *,
+        start_index: int,
+        close_delim: str,
+        max_chars: int = 32,
+        max_tokens: int = 4,
+    ) -> bool:
+        consumed = 0
+        for token in word_tokens[start_index + 1 : start_index + 1 + max_tokens]:
+            if not token:
+                continue
+
+            close_pos = token.find(close_delim)
+            if close_pos != -1 and (consumed + close_pos) < max_chars:
+                return True
+
+            consumed += len(token)
+            if consumed >= max_chars:
+                return False
+
+        return False
+
+    def divide_line_patched(text: str, width: int, fold: bool = True) -> list[int]:
+        break_positions: list[int] = []
+
+        def append(pos: int) -> None:
+            if pos and (not break_positions or break_positions[-1] != pos):
+                break_positions.append(pos)
+
+        cell_offset = 0
+        _cell_len: Callable[[str], int] = cell_len
+
+        words = list(_wrap.words(text))
+        word_tokens = [w for _s, _e, w in words]
+
+        for index, (start, _end, word) in enumerate(words):
+            next_word: str | None = None
+            if index + 1 < len(words):
+                next_word = words[index + 1][2]
+
+            # Heuristic: avoid leaving an unclosed opening delimiter fragment (e.g. "(Deep ")
+            # at the end of a line when the next token will wrap.
+            word_length = _cell_len(word.rstrip())
+            remaining_space = width - cell_offset
+            if remaining_space >= word_length and cell_offset and start and next_word is not None:
+                cell_offset_with_trailing = cell_offset + _cell_len(word)
+                next_length = _cell_len(next_word.rstrip())
+                next_will_wrap = next_length > width or (width - cell_offset_with_trailing) < next_length
+
+                close_delim = _leading_unclosed_delim(word)
+                if close_delim is not None and next_will_wrap:
+                    stripped = word.strip()
+                    if _cell_len(stripped) <= 16 and _close_delim_appears_soon(
+                        word_tokens, start_index=index, close_delim=close_delim
+                    ):
+                        append(start)
+                        cell_offset = _cell_len(word)
+                        continue
+
+            while True:
+                word_length = _cell_len(word.rstrip())
+                remaining_space = width - cell_offset
+
+                if remaining_space >= word_length:
+                    cell_offset += _cell_len(word)
+                    break
+
+                # Prefer splitting CJK-containing tokens to fill remaining space.
+                if fold and cell_offset and start and remaining_space > 0 and _contains_cjk(word):
+                    prefix_len = _find_prefix_len_for_remaining(word, remaining_space)
+                    if prefix_len:
+                        break_at = start + prefix_len
+                        append(break_at)
+                        word = word[prefix_len:]
+                        start = break_at
+
+                        # If the remainder fits on the next (empty) line, keep Rich's
+                        # existing behaviour and move on.
+                        if _cell_len(word.rstrip()) <= width:
+                            cell_offset = _cell_len(word)
+                            break
+
+                        # Otherwise, continue folding the remainder starting on a new line.
+                        cell_offset = 0
+                        continue
+
+                # Fall back to Rich's original logic.
+                if word_length > width:
+                    if fold:
+                        folded_word = chop_cells(word, width=width)
+                        for last, line in loop_last(folded_word):
+                            if start:
+                                append(start)
+                            if last:
+                                cell_offset = _cell_len(line)
+                            else:
+                                start += len(line)
+                    else:
+                        if start:
+                            append(start)
+                        cell_offset = _cell_len(word)
+                    break
+
+                if cell_offset and start:
+                    append(start)
+                    cell_offset = _cell_len(word)
+                break
+
+        return break_positions
+
+    _wrap.divide_line = divide_line_patched  # pyright: ignore[reportPrivateImportUsage]
+    _text.divide_line = divide_line_patched  # pyright: ignore[reportPrivateImportUsage]
+    _rich_cjk_wrap_patch_installed = True
+    return True

klaude_code/ui/rich/code_panel.py

@@ -0,0 +1,131 @@
+"""A panel that only has top and bottom borders, no left/right borders or padding."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from rich.cells import cell_len
+from rich.console import ConsoleRenderable, RichCast
+from rich.jupyter import JupyterMixin
+from rich.measure import Measurement
+from rich.segment import Segment
+from rich.style import StyleType
+
+if TYPE_CHECKING:
+    from rich.console import Console, ConsoleOptions, RenderResult
+
+# Box drawing characters
+TOP_LEFT = "┌"  # ┌
+TOP_RIGHT = "┐"  # ┐
+BOTTOM_LEFT = "└"  # └
+BOTTOM_RIGHT = "┘"  # ┘
+HORIZONTAL = "─"  # ─
+
+
+class CodePanel(JupyterMixin):
+    """A panel with only top and bottom borders, no left/right borders.
+
+    This is designed for code blocks where you want easy copy-paste without
+    picking up border characters on the sides.
+
+    Example:
+        >>> console.print(CodePanel(Syntax(code, "python")))
+
+    Renders as:
+        ┌──────────────────────────┐
+        code line 1
+        code line 2
+        └──────────────────────────┘
+    """
+
+    def __init__(
+        self,
+        renderable: ConsoleRenderable | RichCast | str,
+        *,
+        border_style: StyleType = "none",
+        expand: bool = False,
+        padding: int = 1,
+    ) -> None:
+        """Initialize the CodePanel.
+
+        Args:
+            renderable: A console renderable object.
+            border_style: The style of the border. Defaults to "none".
+            expand: If True, expand to fill available width. Defaults to False.
+            padding: Left/right padding for content. Defaults to 1.
+        """
+        self.renderable = renderable
+        self.border_style = border_style
+        self.expand = expand
+        self.padding = padding
+
+    @staticmethod
+    def _measure_max_line_cells(lines: list[list[Segment]]) -> int:
+        max_cells = 0
+        for line in lines:
+            plain = "".join(segment.text for segment in line).rstrip()
+            max_cells = max(max_cells, cell_len(plain))
+        return max_cells
+
+    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
+        border_style = console.get_style(self.border_style)
+        max_width = options.max_width
+        pad = self.padding
+
+        max_content_width = max(max_width - pad * 2, 1)
+
+        # Measure the content width (account for padding)
+        if self.expand:
+            content_width = max_content_width
+        else:
+            probe_options = options.update(width=max_content_width)
+            probe_lines = console.render_lines(self.renderable, probe_options, pad=False)
+            content_width = self._measure_max_line_cells(probe_lines)
+            content_width = max(1, min(content_width, max_content_width))
+
+        # Render content lines
+        child_options = options.update(width=content_width)
+        lines = console.render_lines(self.renderable, child_options)
+
+        # Calculate border width based on content width + padding
+        border_width = content_width + pad * 2
+
+        new_line = Segment.line()
+        pad_segment = Segment(" " * pad) if pad > 0 else None
+
+        # Top border: ┌───...───┐
+        top_border = (
+            TOP_LEFT + (HORIZONTAL * (border_width - 2)) + TOP_RIGHT if border_width >= 2 else HORIZONTAL * border_width
+        )
+        yield Segment(top_border, border_style)
+        yield new_line
+
+        # Content lines with padding
+        for line in lines:
+            if pad_segment:
+                yield pad_segment
+            yield from line
+            if pad_segment:
+                yield pad_segment
+            yield new_line
+
+        # Bottom border: └───...───┘
+        bottom_border = (
+            BOTTOM_LEFT + (HORIZONTAL * (border_width - 2)) + BOTTOM_RIGHT
+            if border_width >= 2
+            else HORIZONTAL * border_width
+        )
+        yield Segment(bottom_border, border_style)
+        yield new_line
+
+    def __rich_measure__(self, console: Console, options: ConsoleOptions) -> Measurement:
+        if self.expand:
+            return Measurement(options.max_width, options.max_width)
+        max_width = options.max_width
+        max_content_width = max(max_width - self.padding * 2, 1)
+        probe_options = options.update(width=max_content_width)
+        probe_lines = console.render_lines(self.renderable, probe_options, pad=False)
+        content_width = self._measure_max_line_cells(probe_lines)
+        content_width = max(1, min(content_width, max_content_width))
+        width = content_width + self.padding * 2
+        return Measurement(width, width)

klaude_code/ui/rich/live.py

@@ -63,3 +63,20 @@ class CropAboveLive(Live):
 
     def update(self, renderable: RenderableType, refresh: bool = True) -> None:  # type: ignore[override]
         super().update(CropAbove(renderable, style=self._crop_style), refresh=refresh)
+
+
+class SingleLine:
+    """Render only the first line of a renderable.
+
+    This is used to ensure dynamic UI elements (spinners / status) never wrap
+    to multiple lines, which would appear as a vertical "jump".
+    """
+
+    def __init__(self, renderable: RenderableType) -> None:
+        self.renderable = renderable
+
+    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
+        line_options = options.update(no_wrap=True, overflow="ellipsis", height=1)
+        lines = console.render_lines(self.renderable, line_options, pad=False)
+        if lines:
+            yield from lines[0]