klaude-code 2.9.1__py3-none-any.whl → 2.10.1__py3-none-any.whl

klaude_code/tui/components/tools.py

@@ -4,6 +4,7 @@ from typing import Any, cast
 
 from rich import box
 from rich.console import Group, RenderableType
+from rich.padding import Padding
 from rich.panel import Panel
 from rich.style import Style
 from rich.text import Text
@@ -166,7 +167,6 @@ def render_bash_tool_call(arguments: str) -> RenderableType:
     if isinstance(command, str) and command.strip():
         cmd_str = command.strip()
         highlighted = highlight_bash_command(cmd_str)
-        highlighted.stylize(ThemeKey.CODE_BACKGROUND)
 
         display_line_count = len(highlighted.plain.splitlines())
 
@@ -189,7 +189,8 @@ def render_bash_tool_call(arguments: str) -> RenderableType:
                 highlighted.append(f" {timeout_ms // 1000}s", style=ThemeKey.TOOL_TIMEOUT)
             else:
                 highlighted.append(f" {timeout_ms}ms", style=ThemeKey.TOOL_TIMEOUT)
-        return _render_tool_call_tree(mark=MARK_BASH, tool_name=tool_name, details=highlighted)
+        padded = Padding(highlighted, pad=0, style=ThemeKey.CODE_BACKGROUND, expand=False)
+        return _render_tool_call_tree(mark=MARK_BASH, tool_name=tool_name, details=padded)
     else:
         summary = Text("", ThemeKey.TOOL_PARAM)
         if isinstance(timeout_ms, int):
@@ -565,6 +566,7 @@ _TOOL_ACTIVE_FORM: dict[str, str] = {
     tools.WEB_SEARCH: "Searching Web",
     tools.REPORT_BACK: "Reporting",
     tools.IMAGE_GEN: "Generating Image",
+    tools.TASK: "Spawning Task",
 }
 
 

klaude_code/tui/components/user_input.py

@@ -1,21 +1,19 @@
 import re
 
 from rich.console import Group, RenderableType
+from rich.padding import Padding
 from rich.text import Text
 
 from klaude_code.const import TAB_EXPAND_WIDTH
-from klaude_code.skill import get_available_skills
-from klaude_code.tui.components.common import create_grid
+from klaude_code.skill import list_skill_names
+from klaude_code.tui.components.bash_syntax import highlight_bash_command
 from klaude_code.tui.components.rich.theme import ThemeKey
 
-# Match @-file patterns only when they appear at the beginning of the line
+# Match inline 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 inline (at start of line or after whitespace)
-SKILL_RENDER_PATTERN = re.compile(r"(?<!\S)[$¥](\S+)")
-
+# Group 1 is present only for $/¥ skills and captures the skill token (without the $/¥).
+INLINE_RENDER_PATTERN = re.compile(r'(?<!\S)(?:@(?:"[^"]+"|\S+)|[$¥](\S+))')
 USER_MESSAGE_MARK = "❯ "
 
 
@@ -24,86 +22,78 @@ def render_at_and_skill_patterns(
     at_style: str = ThemeKey.USER_INPUT_AT_PATTERN,
     skill_style: str = ThemeKey.USER_INPUT_SKILL,
     other_style: str = ThemeKey.USER_INPUT,
+    available_skill_names: set[str] | None = None,
 ) -> Text:
     """Render text with highlighted @file and $skill patterns."""
-    has_at = "@" in text
-    has_skill = "$" in text or "\u00a5" in text  # $ or ¥
-
-    if not has_at and not has_skill:
-        return Text(text, style=other_style)
-
-    # Collect all matches with their styles
-    matches: list[tuple[int, int, str]] = []  # (start, end, style)
-
-    if has_at:
-        for match in AT_FILE_RENDER_PATTERN.finditer(text):
-            matches.append((match.start(), match.end(), at_style))
-
-    if has_skill:
-        for match in SKILL_RENDER_PATTERN.finditer(text):
-            skill_name = match.group(1)
-            if _is_valid_skill_name(skill_name):
-                matches.append((match.start(), match.end(), skill_style))
-
-    if not matches:
-        return Text(text, style=other_style)
-
-    # Sort by start position
-    matches.sort(key=lambda x: x[0])
+    result = Text(text, style=other_style, overflow="fold")
+    for match in INLINE_RENDER_PATTERN.finditer(text):
+        skill_name = match.group(1)
+        if skill_name is None:
+            result.stylize(at_style, match.start(), match.end())
+            continue
 
-    result = Text("")
-    last_end = 0
-    for start, end, style in matches:
-        if start < last_end:
-            continue  # Skip overlapping matches
-        if start > last_end:
-            result.append_text(Text(text[last_end:start], other_style))
-        result.append_text(Text(text[start:end], style))
-        last_end = end
+        if available_skill_names is None:
+            available_skill_names = set(list_skill_names())
 
-    if last_end < len(text):
-        result.append_text(Text(text[last_end:], other_style))
+        short = skill_name.split(":")[-1] if ":" in skill_name else skill_name
+        if skill_name in available_skill_names or short in available_skill_names:
+            result.stylize(skill_style, match.start(), match.end())
 
     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 token on the first line
     - Highlights @file and $skill patterns in all lines
+    - Wrapped in a Panel for block-style background
     """
     lines = content.strip().split("\n")
+    is_bash_mode = bool(lines) and lines[0].startswith("!")
+
+    available_skill_names: set[str] | None = None
+
     renderables: list[RenderableType] = []
     for i, line in enumerate(lines):
-        line = line.expandtabs(TAB_EXPAND_WIDTH)
+        if not line.strip():
+            continue
+        if "\t" in line:
+            line = line.expandtabs(TAB_EXPAND_WIDTH)
+
+        if is_bash_mode and i == 0:
+            renderables.append(highlight_bash_command(line[1:]))
+            continue
+        if is_bash_mode and i > 0:
+            renderables.append(highlight_bash_command(line))
+            continue
+
+        if available_skill_names is None and ("$" in line or "\u00a5" in line):
+            available_skill_names = set(list_skill_names())
         # Handle slash command on first line
         if i == 0 and line.startswith("/"):
             splits = line.split(" ", maxsplit=1)
             line_text = Text.assemble(
                 (splits[0], ThemeKey.USER_INPUT_SLASH_COMMAND),
                 " ",
-                render_at_and_skill_patterns(splits[1]) if len(splits) > 1 else Text(""),
+                render_at_and_skill_patterns(splits[1], available_skill_names=available_skill_names)
+                if len(splits) > 1
+                else Text(""),
+                overflow="fold",
             )
             renderables.append(line_text)
             continue
 
         # Render @file and $skill patterns
-        renderables.append(render_at_and_skill_patterns(line))
+        renderables.append(render_at_and_skill_patterns(line, available_skill_names=available_skill_names))
 
-    grid = create_grid()
-    grid.padding = (0, 0)
-    mark = Text(USER_MESSAGE_MARK, style=ThemeKey.USER_INPUT_PROMPT)
-    grid.add_row(mark, Group(*renderables))
-    return grid
+    return Padding(
+        Group(*renderables),
+        pad=(0, 1),
+        style=ThemeKey.USER_INPUT,
+        expand=False,
+    )
 
 
 def render_interrupt() -> RenderableType:
-    return Text("  Interrupted by user\n", style=ThemeKey.INTERRUPT)
+    return Text("Interrupted by user", style=ThemeKey.INTERRUPT)

klaude_code/tui/components/welcome.py

@@ -1,4 +1,5 @@
 from importlib.metadata import PackageNotFoundError, version
+from pathlib import Path
 
 from rich.console import Group, RenderableType
 from rich.text import Text
@@ -10,6 +11,19 @@ from klaude_code.tui.components.rich.theme import ThemeKey
 from klaude_code.ui.common import format_model_params
 
 
+def _format_memory_path(path: str, *, work_dir: Path) -> str:
+    """Format memory path for display - show relative path or ~ for home."""
+    p = Path(path)
+    try:
+        return str(p.relative_to(work_dir))
+    except ValueError:
+        pass
+    try:
+        return f"~/{p.relative_to(Path.home())}"
+    except ValueError:
+        return path
+
+
 def _get_version() -> str:
     """Get the current version of klaude-code."""
     try:
@@ -50,7 +64,7 @@ def render_welcome(e: events.WelcomeEvent) -> RenderableType:
     # Render config items with tree-style prefixes
     for i, param_str in enumerate(param_strings):
         is_last = i == len(param_strings) - 1
-        prefix = "└─ " if is_last else "├─ "
+        prefix = "╰─ " if is_last else "├─ "
         panel_content.append_text(
             Text.assemble(
                 ("\n", ThemeKey.WELCOME_INFO),
@@ -59,6 +73,37 @@ def render_welcome(e: events.WelcomeEvent) -> RenderableType:
             )
         )
 
+    # Loaded memories summary
+    work_dir = Path(e.work_dir)
+    loaded_memories = e.loaded_memories or {}
+    user_memories = loaded_memories.get("user") or []
+    project_memories = loaded_memories.get("project") or []
+
+    memory_groups: list[tuple[str, list[str]]] = []
+    if user_memories:
+        memory_groups.append(("user", user_memories))
+    if project_memories:
+        memory_groups.append(("project", project_memories))
+
+    if memory_groups:
+        panel_content.append_text(Text("\n\n", style=ThemeKey.WELCOME_INFO))
+        panel_content.append_text(Text("context", style=ThemeKey.WELCOME_HIGHLIGHT))
+
+        label_width = len("[project]")
+
+        for i, (group_name, paths) in enumerate(memory_groups):
+            is_last = i == len(memory_groups) - 1
+            prefix = "╰─ " if is_last else "├─ "
+            label = f"[{group_name}]"
+            formatted_paths = ", ".join(_format_memory_path(p, work_dir=work_dir) for p in paths)
+            panel_content.append_text(
+                Text.assemble(
+                    ("\n", ThemeKey.WELCOME_INFO),
+                    (prefix, ThemeKey.LINES),
+                    (f"{label.ljust(label_width)} {formatted_paths}", ThemeKey.WELCOME_INFO),
+                )
+            )
+
     # Loaded skills summary is provided by core via WelcomeEvent to keep TUI decoupled.
     loaded_skills = e.loaded_skills or {}
     user_skills = loaded_skills.get("user") or []
@@ -81,7 +126,7 @@ def render_welcome(e: events.WelcomeEvent) -> RenderableType:
 
         for i, (group_name, skills) in enumerate(skill_groups):
             is_last = i == len(skill_groups) - 1
-            prefix = "└─ " if is_last else "├─ "
+            prefix = "╰─ " if is_last else "├─ "
             label = f"[{group_name}]"
             panel_content.append_text(
                 Text.assemble(

klaude_code/tui/display.py

@@ -31,12 +31,20 @@ class TUIDisplay(DisplayABC):
     @override
     async def consume_event(self, event: events.Event) -> None:
         if isinstance(event, events.ReplayHistoryEvent):
-            await self._renderer.execute(self._machine.begin_replay())
-            for item in event.events:
-                commands = self._machine.transition_replay(item)
-                if commands:
-                    await self._renderer.execute(commands)
-            await self._renderer.execute(self._machine.end_replay())
+            # Replay does not need streaming UI; disable bottom Live rendering to avoid
+            # repaint overhead and flicker while reconstructing history.
+            self._renderer.stop_bottom_live()
+            self._renderer.set_stream_renderable(None)
+            self._renderer.set_replay_mode(True)
+            try:
+                await self._renderer.execute(self._machine.begin_replay())
+                for item in event.events:
+                    commands = self._machine.transition_replay(item)
+                    if commands:
+                        await self._renderer.execute(commands)
+                await self._renderer.execute(self._machine.end_replay())
+            finally:
+                self._renderer.set_replay_mode(False)
             return
 
         commands = self._machine.transition(event)

klaude_code/tui/input/completers.py

@@ -219,6 +219,14 @@ class _ComboCompleter(Completer):
         document: Document,
         complete_event,  # type: ignore[override]
     ) -> Iterable[Completion]:
+        # Bash mode: disable all completions.
+        # A command is considered bash mode only when the first character is `!` (or full-width `！`).
+        try:
+            if document.text.startswith(("!", "！")):
+                return
+        except Exception:
+            pass
+
         # Try slash command completion first (only on first line)
         if document.cursor_position_row == 0 and self._slash_completer.is_slash_command_context(document):
             yield from self._slash_completer.get_completions(document, complete_event)

klaude_code/tui/input/key_bindings.py

@@ -76,6 +76,9 @@ def create_key_bindings(
     term_program = os.environ.get("TERM_PROGRAM", "").lower()
     swallow_next_control_j = False
 
+    def _is_bash_mode_text(text: str) -> bool:
+        return text.startswith(("!", "！"))
+
     def _data_requests_newline(data: str) -> bool:
         """Return True when incoming key data should insert a newline.
 
@@ -374,6 +377,33 @@ def create_key_bindings(
         buf = event.current_buffer
         doc = buf.document  # type: ignore
 
+        # Normalize a leading full-width exclamation mark to ASCII so that:
+        # - UI echo shows `!cmd` consistently
+        # - history stores `!cmd` (not `！cmd`)
+        # - bash-mode detection is stable
+        try:
+            current_text = buf.text  # type: ignore[reportUnknownMemberType]
+            cursor_pos = int(buf.cursor_position)  # type: ignore[reportUnknownMemberType]
+        except Exception:
+            current_text = ""
+            cursor_pos = 0
+
+        if current_text.startswith("！"):
+            normalized = "!" + current_text[1:]
+            if normalized != current_text:
+                with contextlib.suppress(Exception):
+                    buf.text = normalized  # type: ignore[reportUnknownMemberType]
+                    buf.cursor_position = min(cursor_pos, len(normalized))  # type: ignore[reportUnknownMemberType]
+                current_text = normalized
+
+        # Bash mode: if there is no command after `!` (ignoring only space/tab),
+        # ignore Enter but keep the input text as-is.
+        if _is_bash_mode_text(current_text):
+            after_bang = current_text[1:]
+            command = after_bang.lstrip(" \t")
+            if command == "":
+                return
+
         data = getattr(event, "data", "")
         if isinstance(data, str) and _data_requests_newline(data):
             _insert_newline(event)
@@ -393,7 +423,13 @@ def create_key_bindings(
         # When completions are visible, Enter accepts the current selection.
         # This aligns with common TUI completion UX: navigation doesn't modify
         # the buffer, and Enter/Tab inserts the selected option.
-        if not _should_submit_instead_of_accepting_completion(buf) and _accept_current_completion(buf):
+        #
+        # Bash mode disables completions entirely, so always prefer submitting.
+        if (
+            not _is_bash_mode_text(current_text)
+            and not _should_submit_instead_of_accepting_completion(buf)
+            and _accept_current_completion(buf)
+        ):
             return
 
         # Before submitting, expand any folded paste markers so that:

klaude_code/tui/input/prompt_toolkit.py

@@ -62,12 +62,13 @@ COMPLETION_SELECTED_LIGHT_BG = "ansigreen"
 COMPLETION_SELECTED_UNKNOWN_BG = "ansigreen"
 COMPLETION_MENU = "ansibrightblack"
 INPUT_PROMPT_STYLE = "ansimagenta bold"
+INPUT_PROMPT_BASH_STYLE = "ansigreen bold"
 PLACEHOLDER_TEXT_STYLE_DARK_BG = "fg:#5a5a5a"
 PLACEHOLDER_TEXT_STYLE_LIGHT_BG = "fg:#7a7a7a"
 PLACEHOLDER_TEXT_STYLE_UNKNOWN_BG = "fg:#8a8a8a"
-PLACEHOLDER_SYMBOL_STYLE_DARK_BG = "bg:#2a2a2a fg:#5a5a5a"
-PLACEHOLDER_SYMBOL_STYLE_LIGHT_BG = "bg:#e6e6e6 fg:#7a7a7a"
-PLACEHOLDER_SYMBOL_STYLE_UNKNOWN_BG = "bg:#2a2a2a fg:#8a8a8a"
+PLACEHOLDER_SYMBOL_STYLE_DARK_BG = "fg:ansiblue"
+PLACEHOLDER_SYMBOL_STYLE_LIGHT_BG = "fg:ansiblue"
+PLACEHOLDER_SYMBOL_STYLE_UNKNOWN_BG = "fg:ansiblue"
 
 
 # ---------------------------------------------------------------------------
@@ -244,6 +245,7 @@ class PromptToolkitInput(InputProviderABC):
         get_current_llm_config: Callable[[], llm_param.LLMConfigParameter | None] | None = None,
         command_info_provider: Callable[[], list[CommandInfo]] | None = None,
     ):
+        self._prompt_text = prompt
         self._status_provider = status_provider
         self._pre_prompt = pre_prompt
         self._post_prompt = post_prompt
@@ -296,11 +298,11 @@ class PromptToolkitInput(InputProviderABC):
             completion_selected = COMPLETION_SELECTED_UNKNOWN_BG
 
         return PromptSession(
+            # Use a stable prompt string; we override the style dynamically in prompt_async.
             [(INPUT_PROMPT_STYLE, prompt)],
             history=FileHistory(str(history_path)),
             multiline=True,
             cursor=CursorShape.BLINKING_BEAM,
-            prompt_continuation=[(INPUT_PROMPT_STYLE, "  ")],
             key_bindings=kb,
             completer=ThreadedCompleter(create_repl_completer(command_info_provider=self._command_info_provider)),
             complete_while_typing=True,
@@ -340,6 +342,24 @@ class PromptToolkitInput(InputProviderABC):
             ),
         )
 
+    def _is_bash_mode_active(self) -> bool:
+        try:
+            text = self._session.default_buffer.text
+            return text.startswith(("!", "！"))
+        except Exception:
+            return False
+
+    def _get_prompt_message(self) -> FormattedText:
+        style = INPUT_PROMPT_BASH_STYLE if self._is_bash_mode_active() else INPUT_PROMPT_STYLE
+        return FormattedText([(style, self._prompt_text)])
+
+    def _bash_mode_toolbar_fragments(self) -> StyleAndTextTuples:
+        if not self._is_bash_mode_active():
+            return []
+        return [
+            ("fg:ansigreen", " bash mode"),
+        ]
+
     def _setup_model_picker(self) -> None:
         """Initialize the model picker overlay and attach it to the layout."""
         model_picker = SelectOverlay[str](
@@ -600,18 +620,32 @@ class PromptToolkitInput(InputProviderABC):
             display_text = f"Debug log: {debug_log_path}"
             text_style = "fg:ansibrightblack"
 
+        bash_frags = self._bash_mode_toolbar_fragments()
+        bash_plain = "".join(frag[1] for frag in bash_frags)
+
         if display_text:
             left_text = " " + display_text
             try:
                 terminal_width = shutil.get_terminal_size().columns
-                padding = " " * max(0, terminal_width - len(left_text))
             except (OSError, ValueError):
+                terminal_width = 0
+
+            if terminal_width > 0 and bash_plain:
+                # Keep the right-side bash mode hint visible by truncating the left side if needed.
+                reserved = len(bash_plain)
+                max_left = max(0, terminal_width - reserved)
+                if len(left_text) > max_left:
+                    left_text = left_text[: max_left - 1] + "…" if max_left >= 2 else ""
+                padding = " " * max(0, terminal_width - len(left_text) - reserved)
+            else:
                 padding = ""
 
-            toolbar_text = left_text + padding
-            return FormattedText([(text_style, toolbar_text)])
+            return FormattedText([(text_style, left_text + padding), *bash_frags])
 
-        # Show shortcut hints when nothing else to display
+        # Show shortcut hints when nothing else to display.
+        # In bash mode, prefer showing only the bash hint (no placeholder shortcuts).
+        if bash_frags:
+            return FormattedText([("fg:default", " "), *bash_frags])
         return self._render_shortcut_hints()
 
     # -------------------------------------------------------------------------
@@ -632,29 +666,20 @@ class PromptToolkitInput(InputProviderABC):
         return FormattedText(
             [
                 (text_style, " "),
-                (symbol_style, " @ "),
-                (text_style, " "),
-                (text_style, "files"),
-                (text_style, " • "),
-                (symbol_style, " $ "),
-                (text_style, " "),
-                (text_style, "skills"),
-                (text_style, " • "),
-                (symbol_style, " / "),
-                (text_style, " "),
-                (text_style, "commands"),
-                (text_style, " • "),
-                (symbol_style, " ctrl-l "),
-                (text_style, " "),
-                (text_style, "models"),
-                (text_style, " • "),
-                (symbol_style, " ctrl-t "),
-                (text_style, " "),
-                (text_style, "think"),
-                (text_style, " • "),
-                (symbol_style, " ctrl-v "),
-                (text_style, " "),
-                (text_style, "paste image"),
+                (symbol_style, "@"),
+                (text_style, " files • "),
+                (symbol_style, "$"),
+                (text_style, " skills • "),
+                (symbol_style, "/"),
+                (text_style, " commands • "),
+                (symbol_style, "!"),
+                (text_style, " shell • "),
+                (symbol_style, "ctrl-l"),
+                (text_style, " models • "),
+                (symbol_style, "ctrl-t"),
+                (text_style, " think • "),
+                (symbol_style, "ctrl-v"),
+                (text_style, " paste image"),
             ]
         )
 
@@ -680,6 +705,7 @@ class PromptToolkitInput(InputProviderABC):
             # proper styling instead of showing raw escape codes.
             with patch_stdout(raw=True):
                 line: str = await self._session.prompt_async(
+                    message=self._get_prompt_message,
                     bottom_toolbar=self._get_bottom_toolbar,
                 )
             if self._post_prompt is not None: