klaude-code 1.2.27__py3-none-any.whl → 1.2.29__py3-none-any.whl

klaude_code/trace/log.py

@@ -302,6 +302,12 @@ def _trash_path(path: Path) -> None:
     """Send a path to trash, falling back to unlink if trash is unavailable."""
 
     try:
-        subprocess.run(["trash", str(path)], check=False, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        subprocess.run(
+            ["trash", str(path)],
+            stdin=subprocess.DEVNULL,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            check=False,
+        )
     except FileNotFoundError:
         path.unlink(missing_ok=True)

klaude_code/ui/modes/repl/__init__.py

@@ -1,47 +1,6 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-from klaude_code.protocol import model
 from klaude_code.ui.modes.repl.input_prompt_toolkit import REPLStatusSnapshot
 
-if TYPE_CHECKING:
-    from klaude_code.core.agent import Agent
-
-
-def build_repl_status_snapshot(agent: Agent | None, update_message: str | None) -> REPLStatusSnapshot:
-    """Build a status snapshot for the REPL bottom toolbar.
-
-    Aggregates model name, context usage, and basic call counts from the
-    provided agent's session history.
-    """
-
-    model_name = ""
-    context_usage_percent: float | None = None
-    llm_calls = 0
-    tool_calls = 0
-
-    if agent is not None:
-        model_name = agent.profile.llm_client.model_name or ""
-
-        history = agent.session.conversation_history
-        for item in history:
-            if isinstance(item, model.AssistantMessageItem):
-                llm_calls += 1
-            elif isinstance(item, model.ToolCallItem):
-                tool_calls += 1
-
-        for item in reversed(history):
-            if isinstance(item, model.ResponseMetadataItem):
-                usage = item.usage
-                if usage is not None and hasattr(usage, "context_usage_percent"):
-                    context_usage_percent = usage.context_usage_percent
-                break
 
-    return REPLStatusSnapshot(
-        model_name=model_name,
-        context_usage_percent=context_usage_percent,
-        llm_calls=llm_calls,
-        tool_calls=tool_calls,
-        update_message=update_message,
-    )
+def build_repl_status_snapshot(update_message: str | None) -> REPLStatusSnapshot:
+    """Build a status snapshot for the REPL bottom toolbar."""
+    return REPLStatusSnapshot(update_message=update_message)

klaude_code/ui/modes/repl/completers.py

@@ -398,8 +398,14 @@ class _AtFilesCompleter(Completer):
 
         if not results:
             if self._has_cmd("fd"):
+                # First, get immediate children matching the keyword (depth=0).
+                # fd's traversal order is not depth-first, so --max-results may
+                # truncate shallow matches. We ensure depth=0 items are always included.
+                immediate = self._get_immediate_matches(cwd, key_norm)
                 # Use fd to search anywhere in full path (files and directories), case-insensitive
-                results, truncated = self._run_fd_search(cwd, key_norm, max_results=max_scan_results)
+                fd_results, truncated = self._run_fd_search(cwd, key_norm, max_results=max_scan_results)
+                # Merge: immediate matches first, then fd results (deduped in _filter_and_format)
+                results = immediate + fd_results
             elif self._has_cmd("rg"):
                 # Use rg to search only in current directory
                 rg_cache_ttl = max(self._cache_ttl, 30.0)
@@ -451,10 +457,11 @@ class _AtFilesCompleter(Completer):
         keyword_norm: str,
     ) -> list[str]:
         # Filter to keyword (case-insensitive) and rank by:
-        # 1. Basename hit first, then path hit position, then length
+        # 1. Directory depth (shallower first)
+        # 2. Basename hit first, then path hit position, then length
         # Since both fd and rg now search from current directory, all paths are relative to cwd
         kn = keyword_norm
-        out: list[tuple[str, tuple[int, int, int, int]]] = []
+        out: list[tuple[str, tuple[int, int, int, int, int]]] = []
         for p in paths_from_root:
             pl = p.lower()
             if kn not in pl:
@@ -469,7 +476,9 @@ class _AtFilesCompleter(Completer):
             base = os.path.basename(rel_to_cwd.rstrip("/")).lower()
             base_pos = base.find(kn)
             path_pos = pl.find(kn)
+            depth = rel_to_cwd.rstrip("/").count("/")
             score = (
+                depth,
                 0 if base_pos != -1 else 1,
                 base_pos if base_pos != -1 else 10_000,
                 path_pos,
@@ -684,6 +693,28 @@ class _AtFilesCompleter(Completer):
             return []
         return items[: min(self._max_results, 100)]
 
+    def _get_immediate_matches(self, cwd: Path, keyword_norm: str) -> list[str]:
+        """Get immediate children of cwd that match the keyword (case-insensitive).
+
+        This ensures depth=0 matches are always included, even when fd's
+        --max-results truncates before reaching them.
+        """
+        excluded = {".git", ".venv", "node_modules"}
+        items: list[str] = []
+        try:
+            for p in cwd.iterdir():
+                name = p.name
+                if name in excluded:
+                    continue
+                if keyword_norm in name.lower():
+                    rel = name
+                    if p.is_dir():
+                        rel += "/"
+                    items.append(rel)
+        except OSError:
+            return []
+        return items
+
     def _run_cmd(self, cmd: list[str], cwd: Path | None = None, *, timeout_sec: float) -> _CmdResult:
         cmd_str = " ".join(cmd)
         start = time.monotonic()
@@ -691,6 +722,7 @@ class _AtFilesCompleter(Completer):
             p = subprocess.run(
                 cmd,
                 cwd=str(cwd) if cwd else None,
+                stdin=subprocess.DEVNULL,
                 stdout=subprocess.PIPE,
                 stderr=subprocess.DEVNULL,
                 text=True,

klaude_code/ui/modes/repl/event_handler.py

@@ -167,10 +167,10 @@ class ActivityState:
             return activity_text
         if self._composing:
             # Main status text with creative verb
-            text = Text.assemble(
-                ("Composing ", ThemeKey.STATUS_TEXT_BOLD),
-                (f"({self._buffer_length:,})", ThemeKey.STATUS_TEXT),
-            )
+            text = Text()
+            text.append("Composing", style=ThemeKey.STATUS_TEXT_BOLD)
+            if self._buffer_length > 0:
+                text.append(f" ({self._buffer_length:,})", style=ThemeKey.STATUS_TEXT)
             return text
         return None
 
@@ -249,10 +249,13 @@ class SpinnerStatusState:
         base_status = self._reasoning_status or self._todo_status
 
         if base_status:
-            result = Text(base_status, style=ThemeKey.STATUS_TEXT_BOLD)
             if activity_text:
+                result = Text()
+                result.append(base_status, style=ThemeKey.STATUS_TEXT_BOLD_ITALIC)
                 result.append(" | ")
                 result.append_text(activity_text)
+            else:
+                result = Text(base_status, style=ThemeKey.STATUS_TEXT_BOLD_ITALIC)
         elif activity_text:
             activity_text.append(" …")
             result = activity_text
@@ -361,6 +364,7 @@ class DisplayEventHandler:
         emit_osc94(OSC94States.INDETERMINATE)
         self.renderer.display_turn_start(event)
         self.spinner_status.clear_for_new_turn()
+        self.spinner_status.set_reasoning_status(None)
         self._update_spinner()
 
     async def _on_thinking(self, event: events.ThinkingEvent) -> None:

klaude_code/ui/modes/repl/input_prompt_toolkit.py

@@ -21,16 +21,11 @@ from klaude_code.ui.modes.repl.completers import AT_TOKEN_PATTERN, create_repl_c
 from klaude_code.ui.modes.repl.key_bindings import create_key_bindings
 from klaude_code.ui.renderers.user_input import USER_MESSAGE_MARK
 from klaude_code.ui.terminal.color import is_light_terminal_background
-from klaude_code.ui.utils.common import get_current_git_branch, show_path_with_tilde
 
 
 class REPLStatusSnapshot(NamedTuple):
     """Snapshot of REPL status for bottom toolbar display."""
 
-    model_name: str
-    context_usage_percent: float | None
-    llm_calls: int
-    tool_calls: int
     update_message: str | None = None
 
 
@@ -54,11 +49,16 @@ class PromptToolkitInput(InputProviderABC):
         status_provider: Callable[[], REPLStatusSnapshot] | None = None,
         pre_prompt: Callable[[], None] | None = None,
         post_prompt: Callable[[], None] | None = None,
+        is_light_background: bool | None = None,
     ):  # ▌
         self._status_provider = status_provider
         self._pre_prompt = pre_prompt
         self._post_prompt = post_prompt
-        self._is_light_terminal_background = is_light_terminal_background(timeout=0.2)
+        # Use provided value if available to avoid redundant TTY queries that may interfere
+        # with prompt_toolkit's terminal state after questionary has been used.
+        self._is_light_terminal_background = (
+            is_light_background if is_light_background is not None else is_light_terminal_background(timeout=0.2)
+        )
 
         project = str(Path.cwd()).strip("/").replace("/", "-")
         history_path = Path.home() / ".klaude" / "projects" / project / "input" / "input_history.txt"
@@ -91,7 +91,6 @@ class PromptToolkitInput(InputProviderABC):
             completer=ThreadedCompleter(create_repl_completer()),
             complete_while_typing=True,
             erase_when_done=True,
-            bottom_toolbar=self._render_bottom_toolbar,
             mouse_support=False,
             style=Style.from_dict(
                 {
@@ -107,68 +106,29 @@ class PromptToolkitInput(InputProviderABC):
             ),
         )
 
-    def _render_bottom_toolbar(self) -> FormattedText:
-        """Render bottom toolbar with working directory, git branch on left, model name and context usage on right.
-
-        If an update is available, only show the update message on the left side.
-        """
-        # Check for update message first
-        update_message: str | None = None
-        if self._status_provider:
-            try:
-                status = self._status_provider()
-                update_message = status.update_message
-            except (AttributeError, RuntimeError):
-                pass
-
-        # If update available, show only the update message
-        if update_message:
-            left_text = " " + update_message
-            try:
-                terminal_width = shutil.get_terminal_size().columns
-                padding = " " * max(0, terminal_width - len(left_text))
-            except (OSError, ValueError):
-                padding = ""
-            toolbar_text = left_text + padding
-            return FormattedText([("#ansiyellow", toolbar_text)])
-
-        # Normal mode: Left side: path and git branch
-        left_parts: list[str] = []
-        left_parts.append(show_path_with_tilde())
-
-        git_branch = get_current_git_branch()
-        if git_branch:
-            left_parts.append(git_branch)
-
-        # Right side: status info
-        right_parts: list[str] = []
-        if self._status_provider:
-            try:
-                status = self._status_provider()
-                model_name = status.model_name or "N/A"
-                right_parts.append(model_name)
-
-                # Add context if available
-                if status.context_usage_percent is not None:
-                    right_parts.append(f"context {status.context_usage_percent:.1f}%")
-            except (AttributeError, RuntimeError):
-                pass
-
-        # Build left and right text with borders
-        left_text = " " + " · ".join(left_parts)
-        right_text = (" · ".join(right_parts) + " ") if right_parts else " "
-
-        # Calculate padding
+    def _get_bottom_toolbar(self) -> FormattedText | None:
+        """Return bottom toolbar content only when there's an update message available."""
+        if not self._status_provider:
+            return None
+
+        try:
+            status = self._status_provider()
+            update_message = status.update_message
+        except (AttributeError, RuntimeError):
+            return None
+
+        if not update_message:
+            return None
+
+        left_text = " " + update_message
         try:
             terminal_width = shutil.get_terminal_size().columns
-            used_width = len(left_text) + len(right_text)
-            padding = " " * max(0, terminal_width - used_width)
+            padding = " " * max(0, terminal_width - len(left_text))
         except (OSError, ValueError):
             padding = ""
 
-        # Build result with style
-        toolbar_text = left_text + padding + right_text
-        return FormattedText([("#2c7eac", toolbar_text)])
+        toolbar_text = left_text + padding
+        return FormattedText([("#ansiyellow", toolbar_text)])
 
     def _render_input_placeholder(self) -> FormattedText:
         if self._is_light_terminal_background is True:
@@ -210,8 +170,15 @@ class PromptToolkitInput(InputProviderABC):
             if self._pre_prompt is not None:
                 with contextlib.suppress(Exception):
                     self._pre_prompt()
+
+            # Only show bottom toolbar if there's an update message
+            bottom_toolbar = self._get_bottom_toolbar()
+
             with patch_stdout():
-                line: str = await self._session.prompt_async(placeholder=self._render_input_placeholder())
+                line: str = await self._session.prompt_async(
+                    placeholder=self._render_input_placeholder(),
+                    bottom_toolbar=bottom_toolbar,
+                )
             if self._post_prompt is not None:
                 with contextlib.suppress(Exception):
                     self._post_prompt()

klaude_code/ui/modes/repl/renderer.py

@@ -266,12 +266,7 @@ class REPLRenderer:
         self.print(r_user_input.render_interrupt())
 
     def display_error(self, event: events.ErrorEvent) -> None:
-        self.print(
-            r_errors.render_error(
-                truncate_display(event.error_message),
-                indent=0,
-            )
-        )
+        self.print(r_errors.render_error(truncate_display(event.error_message)))
 
     # -------------------------------------------------------------------------
     # Spinner control methods

klaude_code/ui/renderers/assistant.py

@@ -1,12 +1,14 @@
 from rich.console import RenderableType
 from rich.padding import Padding
+from rich.text import Text
 
 from klaude_code import const
 from klaude_code.ui.renderers.common import create_grid
 from klaude_code.ui.rich.markdown import NoInsetMarkdown
+from klaude_code.ui.rich.theme import ThemeKey
 
 # UI markers
-ASSISTANT_MESSAGE_MARK = "◆"
+ASSISTANT_MESSAGE_MARK = "•"
 
 
 def render_assistant_message(content: str, *, code_theme: str) -> RenderableType | None:
@@ -20,7 +22,7 @@ def render_assistant_message(content: str, *, code_theme: str) -> RenderableType
 
     grid = create_grid()
     grid.add_row(
-        ASSISTANT_MESSAGE_MARK,
+        Text(ASSISTANT_MESSAGE_MARK, style=ThemeKey.ASSISTANT_MESSAGE_MARK),
         Padding(NoInsetMarkdown(stripped, code_theme=code_theme), (0, const.MARKDOWN_RIGHT_MARGIN, 0, 0)),
     )
     return grid

klaude_code/ui/renderers/common.py

@@ -37,10 +37,17 @@ def truncate_display(
 
     if len(lines) > max_lines:
         truncated_lines = len(lines) - max_lines
-        head_count = max_lines // 2
-        tail_count = max_lines - head_count
-        head_lines = lines[:head_count]
-        tail_lines = lines[-tail_count:]
+
+        # If the hidden section is too small, show everything instead of inserting
+        # the "(more N lines)" indicator.
+        if truncated_lines < 5:
+            truncated_lines = 0
+            head_lines = lines
+        else:
+            head_count = max_lines // 2
+            tail_count = max_lines - head_count
+            head_lines = lines[:head_count]
+            tail_lines = lines[-tail_count:]
     else:
         head_lines = lines
 

klaude_code/ui/renderers/developer.py

@@ -9,6 +9,8 @@ from klaude_code.ui.renderers.tools import render_path
 from klaude_code.ui.rich.markdown import NoInsetMarkdown
 from klaude_code.ui.rich.theme import ThemeKey
 
+REMINDER_BULLET = "  ⧉"
+
 
 def need_render_developer_message(e: events.DeveloperMessageEvent) -> bool:
     return bool(
@@ -32,7 +34,7 @@ def render_developer_message(e: events.DeveloperMessageEvent) -> RenderableType:
     if mp := e.item.memory_paths:
         grid = create_grid()
         grid.add_row(
-            Text("  +", style=ThemeKey.REMINDER),
+            Text(REMINDER_BULLET, style=ThemeKey.REMINDER),
             Text.assemble(
                 ("Load memory ", ThemeKey.REMINDER),
                 Text(", ", ThemeKey.REMINDER).join(
@@ -46,7 +48,7 @@ def render_developer_message(e: events.DeveloperMessageEvent) -> RenderableType:
         grid = create_grid()
         for file_path in fc:
             grid.add_row(
-                Text("  +", style=ThemeKey.REMINDER),
+                Text(REMINDER_BULLET, style=ThemeKey.REMINDER),
                 Text.assemble(
                     ("Read ", ThemeKey.REMINDER),
                     render_path(file_path, ThemeKey.REMINDER_BOLD),
@@ -58,7 +60,7 @@ def render_developer_message(e: events.DeveloperMessageEvent) -> RenderableType:
     if e.item.todo_use:
         grid = create_grid()
         grid.add_row(
-            Text("  +", style=ThemeKey.REMINDER),
+            Text(REMINDER_BULLET, style=ThemeKey.REMINDER),
             Text("Todo hasn't been updated recently", ThemeKey.REMINDER),
         )
         parts.append(grid)
@@ -68,7 +70,7 @@ def render_developer_message(e: events.DeveloperMessageEvent) -> RenderableType:
         for at_file in e.item.at_files:
             if at_file.mentioned_in:
                 grid.add_row(
-                    Text("  +", style=ThemeKey.REMINDER),
+                    Text(REMINDER_BULLET, style=ThemeKey.REMINDER),
                     Text.assemble(
                         (f"{at_file.operation} ", ThemeKey.REMINDER),
                         render_path(at_file.path, ThemeKey.REMINDER_BOLD),
@@ -78,7 +80,7 @@ def render_developer_message(e: events.DeveloperMessageEvent) -> RenderableType:
                 )
             else:
                 grid.add_row(
-                    Text("  +", style=ThemeKey.REMINDER),
+                    Text(REMINDER_BULLET, style=ThemeKey.REMINDER),
                     Text.assemble(
                         (f"{at_file.operation} ", ThemeKey.REMINDER),
                         render_path(at_file.path, ThemeKey.REMINDER_BOLD),
@@ -89,7 +91,7 @@ def render_developer_message(e: events.DeveloperMessageEvent) -> RenderableType:
     if uic := e.item.user_image_count:
         grid = create_grid()
         grid.add_row(
-            Text("  +", style=ThemeKey.REMINDER),
+            Text(REMINDER_BULLET, style=ThemeKey.REMINDER),
             Text(f"Attached {uic} image{'s' if uic > 1 else ''}", style=ThemeKey.REMINDER),
         )
         parts.append(grid)
@@ -97,7 +99,7 @@ def render_developer_message(e: events.DeveloperMessageEvent) -> RenderableType:
     if sn := e.item.skill_name:
         grid = create_grid()
         grid.add_row(
-            Text("  +", style=ThemeKey.REMINDER),
+            Text(REMINDER_BULLET, style=ThemeKey.REMINDER),
             Text.assemble(
                 ("Activated skill ", ThemeKey.REMINDER),
                 (sn, ThemeKey.REMINDER_BOLD),
@@ -120,6 +122,8 @@ def render_command_output(e: events.DeveloperMessageEvent) -> RenderableType:
             return _render_status_output(e.item.command_output)
         case commands.CommandName.RELEASE_NOTES:
             return Padding.indent(NoInsetMarkdown(e.item.content or ""), level=2)
+        case commands.CommandName.FORK_SESSION:
+            return _render_fork_session_output(e.item.command_output)
         case _:
             content = e.item.content or "(no content)"
             style = ThemeKey.TOOL_RESULT if not e.item.command_output.is_error else ThemeKey.ERROR
@@ -145,6 +149,21 @@ def _format_cost(cost: float | None, currency: str = "USD") -> str:
     return f"{symbol}{cost:.2f}"
 
 
+def _render_fork_session_output(command_output: model.CommandOutput) -> RenderableType:
+    """Render fork session output with usage instructions."""
+    if not isinstance(command_output.ui_extra, model.SessionIdUIExtra):
+        return Text("(no session id)", style=ThemeKey.METADATA)
+
+    session_id = command_output.ui_extra.session_id
+    grid = Table.grid(padding=(0, 1))
+    grid.add_column(style=ThemeKey.METADATA, overflow="fold")
+
+    grid.add_row(Text("Session forked. To continue in a new conversation:", style=ThemeKey.METADATA))
+    grid.add_row(Text(f"  klaude --resume-by-id {session_id}", style=ThemeKey.METADATA_BOLD))
+
+    return Padding.indent(grid, level=2)
+
+
 def _render_status_output(command_output: model.CommandOutput) -> RenderableType:
     """Render session status with total cost and per-model breakdown."""
     if not isinstance(command_output.ui_extra, model.SessionStatusUIExtra):

klaude_code/ui/renderers/errors.py

@@ -5,12 +5,17 @@ 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.
+def render_error(error_msg: Text) -> RenderableType:
+    """Render error with X mark for error events."""
+    grid = create_grid()
+    error_msg.style = ThemeKey.ERROR
+    grid.add_row(Text("✘", style=ThemeKey.ERROR_BOLD), error_msg)
+    return grid
+
 
-    Shows a two-column grid with an error mark and truncated message.
-    """
+def render_tool_error(error_msg: Text) -> RenderableType:
+    """Render error with indent for tool results."""
     grid = create_grid()
     error_msg.style = ThemeKey.ERROR
-    grid.add_row(Text(" " * indent + "✘", style=ThemeKey.ERROR_BOLD), error_msg)
+    grid.add_row(Text("  "), error_msg)
     return grid

klaude_code/ui/renderers/mermaid_viewer.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+import html
+import importlib.resources
+from functools import lru_cache
+from pathlib import Path
+
+from klaude_code import const
+
+
+def artifacts_dir() -> Path:
+    return Path(const.TOOL_OUTPUT_TRUNCATION_DIR) / "mermaid"
+
+
+@lru_cache(maxsize=1)
+def load_template() -> str:
+    template_file = importlib.resources.files("klaude_code.session.templates").joinpath("mermaid_viewer.html")
+    return template_file.read_text(encoding="utf-8")
+
+
+def ensure_viewer_file(*, code: str, link: str, tool_call_id: str) -> Path | None:
+    """Create a local HTML viewer with large preview + editor."""
+
+    if not tool_call_id:
+        return None
+
+    safe_id = tool_call_id.replace("/", "_")
+    path = artifacts_dir() / f"mermaid-viewer-{safe_id}.html"
+    if path.exists():
+        return path
+
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+
+        escaped_code = html.escape(code)
+        escaped_view_link = html.escape(link, quote=True)
+        escaped_edit_link = html.escape(link.replace("/view#pako:", "/edit#pako:"), quote=True)
+
+        template = load_template()
+        content = (
+            template.replace("__KLAUDE_VIEW_LINK__", escaped_view_link)
+            .replace("__KLAUDE_EDIT_LINK__", escaped_edit_link)
+            .replace("__KLAUDE_CODE__", escaped_code)
+        )
+        path.write_text(content, encoding="utf-8")
+    except OSError:
+        return None
+
+    return path
+
+
+def build_viewer(*, code: str, link: str, tool_call_id: str) -> Path | None:
+    """Create a local Mermaid viewer HTML file.
+    """
+
+    if not code:
+        return None
+    return ensure_viewer_file(code=code, link=link, tool_call_id=tool_call_id)