klaude-code 2.9.0__py3-none-any.whl → 2.10.0__py3-none-any.whl

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,25 @@ 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"),
+            ("fg:ansibrightblack", " (type ! at start; backspace first char to exit)"),
+        ]
+
     def _setup_model_picker(self) -> None:
         """Initialize the model picker overlay and attach it to the layout."""
         model_picker = SelectOverlay[str](
@@ -600,18 +621,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 +667,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 +706,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:

klaude_code/tui/machine.py

@@ -9,20 +9,23 @@ from klaude_code.const import (
     STATUS_COMPACTING_TEXT,
     STATUS_COMPOSING_TEXT,
     STATUS_DEFAULT_TEXT,
+    STATUS_RUNNING_TEXT,
     STATUS_SHOW_BUFFER_LENGTH,
     STATUS_THINKING_TEXT,
 )
 from klaude_code.protocol import events, model, tools
 from klaude_code.tui.commands import (
     AppendAssistant,
+    AppendBashCommandOutput,
     AppendThinking,
     EmitOsc94Error,
     EmitTmuxSignal,
     EndAssistantStream,
     EndThinkingStream,
     PrintBlankLine,
-    PrintRuleLine,
     RenderAssistantImage,
+    RenderBashCommandEnd,
+    RenderBashCommandStart,
     RenderCommand,
     RenderCommandOutput,
     RenderCompactionSummary,
@@ -32,7 +35,6 @@ from klaude_code.tui.commands import (
     RenderTaskFinish,
     RenderTaskMetadata,
     RenderTaskStart,
-    RenderThinkingHeader,
     RenderToolCall,
     RenderToolResult,
     RenderTurnStart,
@@ -68,25 +70,6 @@ FAST_TOOLS: frozenset[str] = frozenset(
 )
 
 
-@dataclass
-class SubAgentThinkingHeaderState:
-    buffer: str = ""
-    last_header: str | None = None
-
-    def append_and_extract_new_header(self, content: str) -> str | None:
-        self.buffer += content
-
-        max_chars = 8192
-        if len(self.buffer) > max_chars:
-            self.buffer = self.buffer[-max_chars:]
-
-        header = extract_last_bold_header(normalize_thinking_content(self.buffer))
-        if header and header != self.last_header:
-            self.last_header = header
-            return header
-        return None
-
-
 class ActivityState:
     """Tracks composing/tool activity for spinner display."""
 
@@ -110,7 +93,10 @@ class ActivityState:
 
     def add_sub_agent_tool_call(self, tool_call_id: str, tool_name: str) -> None:
         if tool_call_id in self._sub_agent_tool_calls_by_id:
-            return
+            old_tool_name = self._sub_agent_tool_calls_by_id[tool_call_id]
+            self._sub_agent_tool_calls[old_tool_name] = self._sub_agent_tool_calls.get(old_tool_name, 0) - 1
+            if self._sub_agent_tool_calls[old_tool_name] <= 0:
+                self._sub_agent_tool_calls.pop(old_tool_name, None)
         self._sub_agent_tool_calls_by_id[tool_call_id] = tool_name
         self._sub_agent_tool_calls[tool_name] = self._sub_agent_tool_calls.get(tool_name, 0) + 1
 
@@ -262,7 +248,7 @@ class SpinnerStatusState:
 
         if base_status:
             # Default "Thinking ..." uses normal style; custom headers use bold italic
-            is_default_reasoning = base_status == STATUS_THINKING_TEXT
+            is_default_reasoning = base_status in {STATUS_THINKING_TEXT, STATUS_RUNNING_TEXT}
             status_style = ThemeKey.STATUS_TEXT if is_default_reasoning else ThemeKey.STATUS_TEXT_BOLD_ITALIC
             if activity_text:
                 result = Text()
@@ -303,7 +289,6 @@ class SpinnerStatusState:
 class _SessionState:
     session_id: str
     sub_agent_state: model.SubAgentState | None = None
-    sub_agent_thinking_header: SubAgentThinkingHeaderState | None = None
     model_id: str | None = None
     assistant_stream_active: bool = False
     thinking_stream_active: bool = False
@@ -410,6 +395,37 @@ class DisplayStateMachine:
                 cmds.append(RenderUserMessage(e))
                 return cmds
 
+            case events.BashCommandStartEvent() as e:
+                if s.is_sub_agent:
+                    return []
+                if not is_replay:
+                    self._spinner.set_reasoning_status(STATUS_RUNNING_TEXT)
+                    cmds.append(TaskClockStart())
+                    cmds.append(SpinnerStart())
+                    cmds.extend(self._spinner_update_commands())
+
+                cmds.append(RenderBashCommandStart(e))
+                return cmds
+
+            case events.BashCommandOutputDeltaEvent() as e:
+                if s.is_sub_agent:
+                    return []
+                cmds.append(AppendBashCommandOutput(e))
+                return cmds
+
+            case events.BashCommandEndEvent() as e:
+                if s.is_sub_agent:
+                    return []
+                cmds.append(RenderBashCommandEnd(e))
+
+                if not is_replay:
+                    self._spinner.set_reasoning_status(None)
+                    cmds.append(TaskClockClear())
+                    cmds.append(SpinnerStop())
+                    cmds.extend(self._spinner_update_commands())
+
+                return cmds
+
             case events.TaskStartEvent() as e:
                 s.sub_agent_state = e.sub_agent_state
                 s.model_id = e.model_id
@@ -418,8 +434,6 @@ class DisplayStateMachine:
                     self._set_primary_if_needed(e.session_id)
                     if not is_replay:
                         cmds.append(TaskClockStart())
-                else:
-                    s.sub_agent_thinking_header = SubAgentThinkingHeaderState()
 
                 if not is_replay:
                     cmds.append(SpinnerStart())
@@ -465,7 +479,11 @@ class DisplayStateMachine:
 
             case events.ThinkingStartEvent() as e:
                 if s.is_sub_agent:
-                    return []
+                    if not s.should_show_sub_agent_thinking_header:
+                        return []
+                    s.thinking_stream_active = True
+                    cmds.append(StartThinkingStream(session_id=e.session_id))
+                    return cmds
                 if not self._is_primary(e.session_id):
                     return []
                 s.thinking_stream_active = True
@@ -483,11 +501,7 @@ class DisplayStateMachine:
                 if s.is_sub_agent:
                     if not s.should_show_sub_agent_thinking_header:
                         return []
-                    if s.sub_agent_thinking_header is None:
-                        s.sub_agent_thinking_header = SubAgentThinkingHeaderState()
-                    header = s.sub_agent_thinking_header.append_and_extract_new_header(e.content)
-                    if header:
-                        cmds.append(RenderThinkingHeader(session_id=e.session_id, header=header))
+                    cmds.append(AppendThinking(session_id=e.session_id, content=e.content))
                     return cmds
 
                 if not self._is_primary(e.session_id):
@@ -507,7 +521,11 @@ class DisplayStateMachine:
 
             case events.ThinkingEndEvent() as e:
                 if s.is_sub_agent:
-                    return []
+                    if not s.should_show_sub_agent_thinking_header:
+                        return []
+                    s.thinking_stream_active = False
+                    cmds.append(EndThinkingStream(session_id=e.session_id))
+                    return cmds
                 if not self._is_primary(e.session_id):
                     return []
                 s.thinking_stream_active = False
@@ -579,6 +597,31 @@ class DisplayStateMachine:
                     return []
                 if not self._is_primary(e.session_id):
                     return []
+
+                # Some providers/models may not emit fine-grained AssistantText* deltas.
+                # In that case, ResponseCompleteEvent.content is the only assistant text we get.
+                # Render it as a single assistant stream to avoid dropping the entire message.
+                content = e.content
+                if content.strip():
+                    # If we saw no streamed assistant text for this response, render from the final snapshot.
+                    if s.assistant_char_count == 0:
+                        if not s.assistant_stream_active:
+                            s.assistant_stream_active = True
+                            cmds.append(StartAssistantStream(session_id=e.session_id))
+                        cmds.append(AppendAssistant(session_id=e.session_id, content=content))
+                        s.assistant_char_count += len(content)
+
+                    # Ensure any active assistant stream is finalized.
+                    if s.assistant_stream_active:
+                        s.assistant_stream_active = False
+                        cmds.append(EndAssistantStream(session_id=e.session_id))
+                else:
+                    # If there is an active stream but the final snapshot has no text,
+                    # still finalize to flush any pending markdown rendering.
+                    if s.assistant_stream_active:
+                        s.assistant_stream_active = False
+                        cmds.append(EndAssistantStream(session_id=e.session_id))
+
                 if not is_replay:
                     self._spinner.set_composing(False)
                     cmds.append(SpinnerStart())
@@ -603,14 +646,11 @@ class DisplayStateMachine:
                 # Skip activity state for fast tools on non-streaming models (e.g., Gemini)
                 # to avoid flash-and-disappear effect
                 if not is_replay and not s.should_skip_tool_activity(e.tool_name):
-                    if e.tool_name == tools.TASK:
-                        pass
+                    tool_active_form = get_tool_active_form(e.tool_name)
+                    if is_sub_agent_tool(e.tool_name):
+                        self._spinner.add_sub_agent_tool_call(e.tool_call_id, tool_active_form)
                     else:
-                        tool_active_form = get_tool_active_form(e.tool_name)
-                        if is_sub_agent_tool(e.tool_name):
-                            self._spinner.add_sub_agent_tool_call(e.tool_call_id, tool_active_form)
-                        else:
-                            self._spinner.add_tool_call(tool_active_form)
+                        self._spinner.add_tool_call(tool_active_form)
 
                 if not is_replay:
                     cmds.extend(self._spinner_update_commands())
@@ -651,6 +691,8 @@ class DisplayStateMachine:
                 cmds.append(EndThinkingStream(e.session_id))
                 cmds.append(EndAssistantStream(e.session_id))
                 cmds.append(RenderTaskMetadata(e))
+                if is_replay:
+                    cmds.append(PrintBlankLine())
                 return cmds
 
             case events.TodoChangeEvent() as e:
@@ -679,15 +721,11 @@ class DisplayStateMachine:
             case events.TaskFinishEvent() as e:
                 s.task_active = False
                 cmds.append(RenderTaskFinish(e))
-                if not s.is_sub_agent:
-                    if not is_replay:
-                        cmds.append(TaskClockClear())
-                        self._spinner.reset()
-                        cmds.append(SpinnerStop())
-                        cmds.append(PrintRuleLine())
-                        cmds.append(EmitTmuxSignal())
-                else:
-                    s.sub_agent_thinking_header = None
+                if not s.is_sub_agent and not is_replay:
+                    cmds.append(TaskClockClear())
+                    self._spinner.reset()
+                    cmds.append(SpinnerStop())
+                    cmds.append(EmitTmuxSignal())
                 return cmds
 
             case events.InterruptEvent() as e: