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

klaude_code/tui/components/rich/markdown.py

@@ -5,6 +5,7 @@ import io
 import re
 import time
 from collections.abc import Callable
+from pathlib import Path
 from typing import Any, ClassVar
 
 from markdown_it import MarkdownIt
@@ -12,7 +13,7 @@ from markdown_it.token import Token
 from rich import box
 from rich._loop import loop_first
 from rich.console import Console, ConsoleOptions, RenderableType, RenderResult
-from rich.markdown import CodeBlock, Heading, ListItem, Markdown, MarkdownElement, TableElement
+from rich.markdown import CodeBlock, Heading, ImageItem, ListItem, Markdown, MarkdownElement, TableElement
 from rich.rule import Rule
 from rich.segment import Segment
 from rich.style import Style, StyleType
@@ -207,6 +208,25 @@ class CheckboxListItem(ListItem):
             yield new_line
 
 
+class LocalImageItem(ImageItem):
+    """Image element that collects local file paths for external rendering."""
+
+    @classmethod
+    def create(cls, markdown: Markdown, token: Token) -> MarkdownElement:
+        src = str(token.attrs.get("src", ""))
+        instance = cls(src, markdown.hyperlinks)
+        if src.startswith("/") and Path(src).exists():
+            collected = getattr(markdown, "collected_images", None)
+            if collected is not None:
+                collected.append(src)
+        return instance
+
+    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
+        if self.destination.startswith("/") and Path(self.destination).exists():
+            return
+        yield from super().__rich_console__(console, options)
+
+
 class NoInsetMarkdown(Markdown):
     """Markdown with code blocks that have no padding and left-justified headings."""
 
@@ -219,8 +239,13 @@ class NoInsetMarkdown(Markdown):
         "table_open": MarkdownTable,
         "html_block": ThinkingHTMLBlock,
         "list_item_open": CheckboxListItem,
+        "image": LocalImageItem,
     }
 
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self.collected_images: list[str] = []
+
 
 class ThinkingMarkdown(Markdown):
     """Markdown for thinking content with grey-styled code blocks and left-justified headings."""
@@ -234,8 +259,13 @@ class ThinkingMarkdown(Markdown):
         "table_open": MarkdownTable,
         "html_block": ThinkingHTMLBlock,
         "list_item_open": CheckboxListItem,
+        "image": LocalImageItem,
     }
 
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self.collected_images: list[str] = []
+
 
 class MarkdownStream:
     """Block-based streaming Markdown renderer.
@@ -260,6 +290,7 @@ class MarkdownStream:
         left_margin: int = 0,
         right_margin: int = MARKDOWN_RIGHT_MARGIN,
         markdown_class: Callable[..., Markdown] | None = None,
+        image_callback: Callable[[str], None] | None = None,
     ) -> None:
         """Initialize the markdown stream.
 
@@ -272,6 +303,7 @@ class MarkdownStream:
             left_margin (int, optional): Number of columns to reserve on the left side
             right_margin (int, optional): Number of columns to reserve on the right side
             markdown_class: Markdown class to use for rendering (defaults to NoInsetMarkdown)
+            image_callback: Callback to display local images (called with file path)
         """
         self._stable_rendered_lines: list[str] = []
         self._stable_source_line_count: int = 0
@@ -282,6 +314,8 @@ class MarkdownStream:
             self.mdargs = {}
 
         self._live_sink = live_sink
+        self._image_callback = image_callback
+        self._displayed_images: set[str] = set()
 
         # Streaming control
         self.when: float = 0.0  # Timestamp of last update
@@ -298,11 +332,6 @@ class MarkdownStream:
         self.right_margin: int = max(right_margin, 0)
         self.markdown_class: Callable[..., Markdown] = markdown_class or NoInsetMarkdown
 
-    @property
-    def _live_started(self) -> bool:
-        """Check if Live display has been started (derived from self.live)."""
-        return self._live_sink is not None
-
     def _get_base_width(self) -> int:
         return self.console.options.max_width
 
@@ -416,66 +445,21 @@ class MarkdownStream:
             return "", text, 0
         return stable_source, live_source, stable_line
 
-    def render_ansi(self, text: str, *, apply_mark: bool) -> str:
-        """Render markdown source to an ANSI string.
+    def render_stable_ansi(self, stable_source: str, *, has_live_suffix: bool, final: bool) -> tuple[str, list[str]]:
+        """Render stable prefix to ANSI, preserving inter-block spacing.
 
-        This is primarily intended for internal debugging and tests.
+        Returns:
+            tuple: (ANSI string, collected local image paths)
         """
-
-        return "".join(self._render_markdown_to_lines(text, apply_mark=apply_mark))
-
-    def render_stable_ansi(self, stable_source: str, *, has_live_suffix: bool, final: bool) -> str:
-        """Render stable prefix to ANSI, preserving inter-block spacing."""
-
         if not stable_source:
-            return ""
+            return "", []
 
         render_source = stable_source
         if not final and has_live_suffix:
             render_source = self._append_nonfinal_sentinel(stable_source)
 
-        return self.render_ansi(render_source, apply_mark=True)
-
-    @staticmethod
-    def normalize_live_ansi_for_boundary(*, stable_ansi: str, live_ansi: str) -> str:
-        """Normalize whitespace at the stable/live boundary.
-
-        Some Rich Markdown blocks (e.g. lists) render with a leading blank line.
-        If the stable prefix already renders a trailing blank line, rendering the
-        live suffix separately may introduce an extra blank line that wouldn't
-        appear when rendering the full document.
-
-        This function removes *overlapping* blank lines from the live ANSI when
-        the stable ANSI already ends with one or more blank lines.
-
-        Important: don't remove *all* leading blank lines from the live suffix.
-        In some incomplete-block cases, the live render may begin with multiple
-        blank lines while the full-document render would keep one of them.
-        """
-
-        stable_lines = stable_ansi.splitlines(keepends=True)
-        if not stable_lines:
-            return live_ansi
-
-        stable_trailing_blank = 0
-        for line in reversed(stable_lines):
-            if line.strip():
-                break
-            stable_trailing_blank += 1
-        if stable_trailing_blank <= 0:
-            return live_ansi
-
-        live_lines = live_ansi.splitlines(keepends=True)
-        live_leading_blank = 0
-        for line in live_lines:
-            if line.strip():
-                break
-            live_leading_blank += 1
-
-        drop = min(stable_trailing_blank, live_leading_blank)
-        if drop > 0:
-            live_lines = live_lines[drop:]
-        return "".join(live_lines)
+        lines, images = self._render_markdown_to_lines(render_source, apply_mark=True)
+        return "".join(lines), images
 
     def _append_nonfinal_sentinel(self, stable_source: str) -> str:
         """Make Rich render stable content as if it isn't the last block.
@@ -497,14 +481,14 @@ class MarkdownStream:
             return stable_source + "\n<!-- -->"
         return stable_source + "\n\n<!-- -->"
 
-    def _render_markdown_to_lines(self, text: str, *, apply_mark: bool) -> list[str]:
+    def _render_markdown_to_lines(self, text: str, *, apply_mark: bool) -> tuple[list[str], list[str]]:
         """Render markdown text to a list of lines.
 
         Args:
             text (str): Markdown text to render
 
         Returns:
-            list: List of rendered lines with line endings preserved
+            tuple: (lines with line endings preserved, collected local image paths)
         """
         # Render the markdown to a string buffer
         string_io = io.StringIO()
@@ -526,6 +510,8 @@ class MarkdownStream:
         temp_console.print(markdown)
         output = string_io.getvalue()
 
+        collected_images = getattr(markdown, "collected_images", [])
+
         # Split rendered output into lines, strip trailing spaces, and apply left margin.
         lines = output.splitlines(keepends=True)
         indent_prefix = " " * self.left_margin if self.left_margin > 0 else ""
@@ -559,7 +545,7 @@ class MarkdownStream:
                 stripped += "\n"
             processed_lines.append(stripped)
 
-        return processed_lines
+        return processed_lines, list(collected_images)
 
     def __del__(self) -> None:
         """Destructor to ensure Live display is properly cleaned up."""
@@ -587,15 +573,22 @@ class MarkdownStream:
         start = time.time()
 
         stable_chunk_to_print: str | None = None
+        new_images: list[str] = []
         stable_changed = final or stable_line > self._stable_source_line_count
         if stable_changed and stable_source:
-            stable_ansi = self.render_stable_ansi(stable_source, has_live_suffix=bool(live_source), final=final)
+            stable_ansi, collected_images = self.render_stable_ansi(
+                stable_source, has_live_suffix=bool(live_source), final=final
+            )
             stable_lines = stable_ansi.splitlines(keepends=True)
             new_lines = stable_lines[len(self._stable_rendered_lines) :]
             if new_lines:
                 stable_chunk_to_print = "".join(new_lines)
             self._stable_rendered_lines = stable_lines
             self._stable_source_line_count = stable_line
+            for img in collected_images:
+                if img not in self._displayed_images:
+                    new_images.append(img)
+                    self._displayed_images.add(img)
         elif final and not stable_source:
             self._stable_rendered_lines = []
             self._stable_source_line_count = stable_line
@@ -603,7 +596,7 @@ class MarkdownStream:
         live_text_to_set: Text | None = None
         if not final and MARKDOWN_STREAM_LIVE_REPAINT_ENABLED and self._live_sink is not None:
             apply_mark_live = self._stable_source_line_count == 0
-            live_lines = self._render_markdown_to_lines(live_source, apply_mark=apply_mark_live)
+            live_lines, _ = self._render_markdown_to_lines(live_source, apply_mark=apply_mark_live)
 
             if self._stable_rendered_lines:
                 stable_trailing_blank = 0
@@ -629,6 +622,10 @@ class MarkdownStream:
             if stable_chunk_to_print:
                 self.console.print(Text.from_ansi(stable_chunk_to_print), end="\n")
 
+            if new_images and self._image_callback:
+                for img_path in new_images:
+                    self._image_callback(img_path)
+
             if final:
                 if self._live_sink is not None:
                     self._live_sink(None)

klaude_code/tui/components/rich/theme.py

@@ -109,6 +109,7 @@ DARK_PALETTE = Palette(
 
 class ThemeKey(str, Enum):
     LINES = "lines"
+    LINES_DIM = "lines.dim"
 
     # CODE
     CODE_BACKGROUND = "code_background"
@@ -233,6 +234,7 @@ def get_theme(theme: str | None = None) -> Themes:
         app_theme=Theme(
             styles={
                 ThemeKey.LINES.value: palette.grey3,
+                ThemeKey.LINES_DIM.value: "dim " + palette.grey3,
                 # CODE
                 ThemeKey.CODE_BACKGROUND.value: f"on {palette.code_background}",
                 # PANEL

klaude_code/tui/components/sub_agent.py

@@ -1,5 +1,5 @@
 import json
-from typing import Any, cast
+from typing import Any
 
 from rich.console import Group, RenderableType
 from rich.json import JSON
@@ -7,8 +7,7 @@ from rich.style import Style
 from rich.text import Text
 
 from klaude_code.const import SUB_AGENT_RESULT_MAX_LINES
-from klaude_code.protocol import events, model
-from klaude_code.protocol.sub_agent import get_sub_agent_profile_by_tool
+from klaude_code.protocol import model
 from klaude_code.tui.components.common import truncate_head
 from klaude_code.tui.components.rich.theme import ThemeKey
 
@@ -125,46 +124,3 @@ def render_sub_agent_result(
         elements.append(Text(agent_id_footer, style=ThemeKey.SUB_AGENT_FOOTER))
 
     return Group(*elements)
-
-
-def build_sub_agent_state_from_tool_call(e: events.ToolCallEvent) -> model.SubAgentState | None:
-    """Build SubAgentState from a tool call event for replay rendering."""
-    profile = get_sub_agent_profile_by_tool(e.tool_name)
-    if profile is None:
-        return None
-    description = profile.name
-    prompt = ""
-    output_schema: dict[str, Any] | None = None
-    generation: dict[str, Any] | None = None
-    resume: str | None = None
-    if e.arguments:
-        try:
-            payload: dict[str, object] = json.loads(e.arguments)
-        except json.JSONDecodeError:
-            payload = {}
-        desc_value = payload.get("description")
-        if isinstance(desc_value, str) and desc_value.strip():
-            description = desc_value.strip()
-        prompt_value = payload.get("prompt") or payload.get("task")
-        if isinstance(prompt_value, str):
-            prompt = prompt_value.strip()
-        resume_value = payload.get("resume")
-        if isinstance(resume_value, str) and resume_value.strip():
-            resume = resume_value.strip()
-        # Extract output_schema if profile supports it
-        if profile.output_schema_arg:
-            schema_value = payload.get(profile.output_schema_arg)
-            if isinstance(schema_value, dict):
-                output_schema = cast(dict[str, Any], schema_value)
-        # Extract generation config for ImageGen
-        generation_value = payload.get("generation")
-        if isinstance(generation_value, dict):
-            generation = cast(dict[str, Any], generation_value)
-    return model.SubAgentState(
-        sub_agent_type=profile.name,
-        sub_agent_desc=description,
-        sub_agent_prompt=prompt,
-        resume=resume,
-        output_schema=output_schema,
-        generation=generation,
-    )

klaude_code/tui/components/thinking.py

@@ -1,14 +1,5 @@
 import re
 
-from rich.console import RenderableType
-from rich.padding import Padding
-from rich.text import Text
-
-from klaude_code.const import MARKDOWN_RIGHT_MARGIN
-from klaude_code.tui.components.common import create_grid
-from klaude_code.tui.components.rich.markdown import ThinkingMarkdown
-from klaude_code.tui.components.rich.theme import ThemeKey
-
 # UI markers
 THINKING_MESSAGE_MARK = "∴"
 
@@ -70,27 +61,3 @@ def extract_last_bold_header(text: str) -> str | None:
         i = end + 2
 
     return last
-
-
-def render_thinking(content: str, *, code_theme: str, style: str) -> RenderableType | None:
-    """Render thinking content as markdown with left mark.
-
-    Returns None if content is empty.
-    Note: Caller should push thinking_markdown_theme before printing.
-    """
-    if len(content.strip()) == 0:
-        return None
-
-    grid = create_grid()
-    grid.add_row(
-        Text(THINKING_MESSAGE_MARK, style=ThemeKey.THINKING),
-        Padding(
-            ThinkingMarkdown(
-                normalize_thinking_content(content),
-                code_theme=code_theme,
-                style=style,
-            ),
-            (0, MARKDOWN_RIGHT_MARGIN, 0, 0),
-        ),
-    )
-    return grid

klaude_code/tui/components/tools.py

@@ -48,6 +48,33 @@ def is_sub_agent_tool(tool_name: str) -> bool:
     return _is_sub_agent_tool(tool_name)
 
 
+def get_task_active_form(arguments: str) -> str:
+    """Return active form text for Task tool based on its arguments."""
+    import json
+
+    try:
+        parsed = json.loads(arguments)
+    except json.JSONDecodeError:
+        return "Tasking"
+
+    if not isinstance(parsed, dict):
+        return "Tasking"
+
+    args = cast(dict[str, Any], parsed)
+
+    type_raw = args.get("type")
+    if not isinstance(type_raw, str):
+        return "Tasking"
+
+    match type_raw.strip():
+        case "explore":
+            return "Exploring"
+        case "web":
+            return "Surfing"
+        case _:
+            return "Tasking"
+
+
 def render_path(path: str, style: str, is_directory: bool = False) -> Text:
     if path.startswith(str(Path().cwd())):
         path = path.replace(str(Path().cwd()), "").lstrip("/")
@@ -173,7 +200,7 @@ def render_bash_tool_call(arguments: str) -> RenderableType:
 
 
 def render_update_plan_tool_call(arguments: str) -> RenderableType:
-    tool_name = "Update Plan"
+    tool_name = "Plan"
     details: RenderableType | None = None
 
     if arguments:
@@ -273,7 +300,7 @@ def render_write_tool_call(arguments: str) -> RenderableType:
 
 
 def render_apply_patch_tool_call(arguments: str) -> RenderableType:
-    tool_name = "Apply Patch"
+    tool_name = "Patch"
 
     try:
         payload = json.loads(arguments)
@@ -299,21 +326,22 @@ def render_apply_patch_tool_call(arguments: str) -> RenderableType:
             elif line.startswith("*** Delete File:"):
                 delete_files.append(line[len("*** Delete File:") :].strip())
 
-        parts: list[str] = []
+        details = Text("", ThemeKey.TOOL_PARAM)
         if update_files:
-            parts.append(f"Update File × {len(update_files)}" if len(update_files) > 1 else "Update File")
+            details.append(f"Edit × {len(update_files)}")
         if add_files:
+            if details.plain:
+                details.append(", ")
             # For single .md file addition, show filename in parentheses
             if len(add_files) == 1 and add_files[0].endswith(".md"):
-                file_name = Path(add_files[0]).name
-                parts.append(f"Add File ({file_name})")
+                details.append("Create ")
+                details.append_text(render_path(add_files[0], ThemeKey.TOOL_PARAM_FILE_PATH))
             else:
-                parts.append(f"Add File × {len(add_files)}" if len(add_files) > 1 else "Add File")
+                details.append(f"Create × {len(add_files)}")
         if delete_files:
-            parts.append(f"Delete File × {len(delete_files)}" if len(delete_files) > 1 else "Delete File")
-
-        if parts:
-            details = Text(", ".join(parts), ThemeKey.TOOL_PARAM)
+            if details.plain:
+                details.append(", ")
+            details.append(f"Delete × {len(delete_files)}")
     else:
         details = Text(
             str(patch_content)[:INVALID_TOOL_CALL_MAX_LENGTH],
@@ -434,7 +462,7 @@ def _render_mermaid_viewer_link(
 
 
 def render_web_fetch_tool_call(arguments: str) -> RenderableType:
-    tool_name = "Fetch"
+    tool_name = "Fetch Web"
 
     try:
         payload: dict[str, str] = json.loads(arguments)
@@ -452,7 +480,7 @@ def render_web_fetch_tool_call(arguments: str) -> RenderableType:
 
 
 def render_web_search_tool_call(arguments: str) -> RenderableType:
-    tool_name = "Web Search"
+    tool_name = "Search Web"
 
     try:
         payload: dict[str, Any] = json.loads(arguments)
@@ -516,6 +544,7 @@ _TOOL_ACTIVE_FORM: dict[str, str] = {
     tools.WEB_FETCH: "Fetching Web",
     tools.WEB_SEARCH: "Searching Web",
     tools.REPORT_BACK: "Reporting",
+    tools.IMAGE_GEN: "Generating Image",
 }
 
 
@@ -527,13 +556,6 @@ def get_tool_active_form(tool_name: str) -> str:
     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}"
 
 
@@ -558,7 +580,7 @@ def render_tool_call(e: events.ToolCallEvent) -> RenderableType | None:
         case tools.APPLY_PATCH:
             return render_apply_patch_tool_call(e.arguments)
         case tools.TODO_WRITE:
-            return render_generic_tool_call("Update Todos", "", MARK_PLAN)
+            return render_generic_tool_call("Update To-Dos", "", MARK_PLAN)
         case tools.UPDATE_PLAN:
             return render_update_plan_tool_call(e.arguments)
         case tools.MERMAID:

klaude_code/tui/input/images.py

@@ -17,11 +17,10 @@ import shutil
 import subprocess
 import sys
 import uuid
-from base64 import b64encode
 from pathlib import Path
 
 from klaude_code.const import get_system_temp
-from klaude_code.protocol.message import ImageURLPart
+from klaude_code.protocol.message import ImageFilePart
 
 # ---------------------------------------------------------------------------
 # Constants and marker syntax
@@ -183,36 +182,40 @@ def capture_clipboard_tag() -> str | None:
 # ---------------------------------------------------------------------------
 
 
-def _encode_image_file(file_path: str) -> ImageURLPart | None:
-    """Encode an image file as base64 data URL and create ImageURLPart."""
+_MIME_TYPES: dict[str, str] = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+}
+
+
+def _create_image_file_part(file_path: str) -> ImageFilePart | None:
+    """Create an ImageFilePart from a file path."""
     try:
         path = Path(file_path)
         if not path.exists():
             return None
-        with open(path, "rb") as f:
-            encoded = b64encode(f.read()).decode("ascii")
 
         suffix = path.suffix.lower()
-        mime = {
-            ".png": "image/png",
-            ".jpg": "image/jpeg",
-            ".jpeg": "image/jpeg",
-            ".gif": "image/gif",
-            ".webp": "image/webp",
-        }.get(suffix)
+        mime = _MIME_TYPES.get(suffix)
         if mime is None:
             return None
 
-        data_url = f"data:{mime};base64,{encoded}"
-        return ImageURLPart(url=data_url, id=None)
+        return ImageFilePart(
+            file_path=str(path),
+            mime_type=mime,
+            byte_size=path.stat().st_size,
+        )
     except OSError:
         return None
 
 
-def extract_images_from_text(text: str) -> list[ImageURLPart]:
+def extract_images_from_text(text: str) -> list[ImageFilePart]:
     """Extract images referenced by [image ...] markers in text."""
 
-    images: list[ImageURLPart] = []
+    images: list[ImageFilePart] = []
     for m in IMAGE_MARKER_RE.finditer(text):
         raw = m.group("path")
         path_str = parse_image_marker_path(raw)
@@ -221,7 +224,7 @@ def extract_images_from_text(text: str) -> list[ImageURLPart]:
         p = Path(path_str).expanduser()
         if not p.is_absolute():
             p = (Path.cwd() / p).resolve()
-        image_part = _encode_image_file(str(p))
+        image_part = _create_image_file_part(str(p))
         if image_part:
             images.append(image_part)
     return images

klaude_code/tui/input/key_bindings.py

@@ -19,7 +19,7 @@ from typing import cast
 from prompt_toolkit.application.current import get_app
 from prompt_toolkit.buffer import Buffer
 from prompt_toolkit.filters import Always, Condition, Filter
-from prompt_toolkit.filters.app import has_completions
+from prompt_toolkit.filters.app import has_completions, is_searching
 from prompt_toolkit.key_binding import KeyBindings
 from prompt_toolkit.key_binding.key_processor import KeyPressEvent
 from prompt_toolkit.keys import Keys
@@ -367,7 +367,7 @@ def create_key_bindings(
 
         _insert_newline(event)
 
-    @kb.add("enter", filter=enabled)
+    @kb.add("enter", filter=enabled & ~is_searching)
     def _(event: KeyPressEvent) -> None:
         nonlocal swallow_next_control_j