klaude-code 1.2.25__tar.gz → 1.2.26__tar.gz

{klaude_code-1.2.25 → klaude_code-1.2.26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: klaude-code
-Version: 1.2.25
+Version: 1.2.26
 Summary: Add your description here
 Requires-Dist: anthropic>=0.66.0
 Requires-Dist: chardet>=5.2.0

{klaude_code-1.2.25 → klaude_code-1.2.26}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "klaude-code"
-version = "1.2.25"
+version = "1.2.26"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.13"

{klaude_code-1.2.25 → klaude_code-1.2.26}/src/klaude_code/const.py

@@ -97,7 +97,11 @@ SUB_AGENT_RESULT_MAX_LINES = 50
 
 
 # UI refresh rate (frames per second) for debounced content streaming
-UI_REFRESH_RATE_FPS = 20
+UI_REFRESH_RATE_FPS = 10
+
+# Enable live area for streaming markdown (shows incomplete blocks being typed)
+# When False, only completed markdown blocks are displayed (more stable, less flicker)
+MARKDOWN_STREAM_LIVE_REPAINT_ENABLED = False
 
 # Number of lines to keep visible at bottom of markdown streaming window
 MARKDOWN_STREAM_LIVE_WINDOW = 6

{klaude_code-1.2.25 → klaude_code-1.2.26}/src/klaude_code/core/tool/file/apply_patch_tool.py

@@ -20,7 +20,7 @@ class ApplyPatchHandler:
     @classmethod
     async def handle_apply_patch(cls, patch_text: str) -> model.ToolResultItem:
         try:
-            output, diff_ui = await asyncio.to_thread(cls._apply_patch_in_thread, patch_text)
+            output, ui_extra = await asyncio.to_thread(cls._apply_patch_in_thread, patch_text)
         except apply_patch_module.DiffError as error:
             return model.ToolResultItem(status="error", output=str(error))
         except Exception as error:  # pragma: no cover  # unexpected errors bubbled to tool result
@@ -28,11 +28,11 @@ class ApplyPatchHandler:
         return model.ToolResultItem(
             status="success",
             output=output,
-            ui_extra=diff_ui,
+            ui_extra=ui_extra,
         )
 
     @staticmethod
-    def _apply_patch_in_thread(patch_text: str) -> tuple[str, model.DiffUIExtra]:
+    def _apply_patch_in_thread(patch_text: str) -> tuple[str, model.ToolResultUIExtra]:
         ap = apply_patch_module
         normalized_start = patch_text.lstrip()
         if not normalized_start.startswith("*** Begin Patch"):
@@ -69,6 +69,16 @@ class ApplyPatchHandler:
         commit = ap.patch_to_commit(patch, orig)
         diff_ui = ApplyPatchHandler._commit_to_structured_diff(commit)
 
+        md_items: list[model.MarkdownDocUIExtra] = []
+        for change_path, change in commit.changes.items():
+            if change.type == apply_patch_module.ActionType.ADD and change_path.endswith(".md"):
+                md_items.append(
+                    model.MarkdownDocUIExtra(
+                        file_path=resolve_path(change_path),
+                        content=change.new_content or "",
+                    )
+                )
+
         def write_fn(path: str, content: str) -> None:
             resolved = resolve_path(path)
             if os.path.isdir(resolved):
@@ -102,6 +112,16 @@ class ApplyPatchHandler:
                     file_tracker.pop(resolved, None)
 
         ap.apply_commit(commit, write_fn, remove_fn)
+
+        # apply_patch can include multiple operations. If we added markdown files,
+        # return a MultiUIExtra so UI can render markdown previews (without showing a diff for those markdown adds).
+        if md_items:
+            items: list[model.MultiUIExtraItem] = []
+            items.extend(md_items)
+            if diff_ui.files:
+                items.append(diff_ui)
+            return "Done!", model.MultiUIExtra(items=items)
+
         return "Done!", diff_ui
 
     @staticmethod
@@ -110,6 +130,9 @@ class ApplyPatchHandler:
         for path in sorted(commit.changes):
             change = commit.changes[path]
             if change.type == apply_patch_module.ActionType.ADD:
+                # For markdown files created via Add File, we render content via MarkdownDocUIExtra instead of a diff.
+                if path.endswith(".md"):
+                    continue
                 files.append(build_structured_file_diff("", change.new_content or "", file_path=path))
             elif change.type == apply_patch_module.ActionType.DELETE:
                 files.append(build_structured_file_diff(change.old_content or "", "", file_path=path))

{klaude_code-1.2.25 → klaude_code-1.2.26}/src/klaude_code/protocol/model.py

@@ -151,6 +151,28 @@ class SessionStatusUIExtra(BaseModel):
     by_model: list["TaskMetadata"] = []
 
 
+MultiUIExtraItem = (
+    DiffUIExtra
+    | TodoListUIExtra
+    | SessionIdUIExtra
+    | MermaidLinkUIExtra
+    | TruncationUIExtra
+    | MarkdownDocUIExtra
+    | SessionStatusUIExtra
+)
+
+
+class MultiUIExtra(BaseModel):
+    """A container UIExtra that can render multiple UI blocks for a single tool result.
+
+    This is primarily used by tools like apply_patch which can perform multiple
+    operations in one invocation.
+    """
+
+    type: Literal["multi"] = "multi"
+    items: list[MultiUIExtraItem]
+
+
 ToolResultUIExtra = Annotated[
     DiffUIExtra
     | TodoListUIExtra
@@ -158,7 +180,8 @@ ToolResultUIExtra = Annotated[
     | MermaidLinkUIExtra
     | TruncationUIExtra
     | MarkdownDocUIExtra
-    | SessionStatusUIExtra,
+    | SessionStatusUIExtra
+    | MultiUIExtra,
     Field(discriminator="type"),
 ]
 

{klaude_code-1.2.25 → klaude_code-1.2.26}/src/klaude_code/ui/modes/repl/event_handler.py

@@ -122,6 +122,7 @@ class ActivityState:
 
     def __init__(self) -> None:
         self._composing: bool = False
+        self._buffer_length: int = 0
         self._tool_calls: dict[str, int] = {}
 
     @property
@@ -134,6 +135,11 @@ class ActivityState:
 
     def set_composing(self, composing: bool) -> None:
         self._composing = composing
+        if not composing:
+            self._buffer_length = 0
+
+    def set_buffer_length(self, length: int) -> None:
+        self._buffer_length = length
 
     def add_tool_call(self, tool_name: str) -> None:
         self._tool_calls[tool_name] = self._tool_calls.get(tool_name, 0) + 1
@@ -143,6 +149,7 @@ class ActivityState:
 
     def reset(self) -> None:
         self._composing = False
+        self._buffer_length = 0
         self._tool_calls = {}
 
     def get_activity_text(self) -> Text | None:
@@ -159,7 +166,12 @@ class ActivityState:
                 first = False
             return activity_text
         if self._composing:
-            return Text("Composing")
+            # Main status text with creative verb
+            text = Text.assemble(
+                ("Composing ", ThemeKey.STATUS_TEXT_BOLD),
+                (f"({self._buffer_length:,})", ThemeKey.STATUS_TEXT),
+            )
+            return text
         return None
 
 
@@ -206,6 +218,10 @@ class SpinnerStatusState:
             self._reasoning_status = None
         self._activity.set_composing(composing)
 
+    def set_buffer_length(self, length: int) -> None:
+        """Set buffer length for composing state display."""
+        self._activity.set_buffer_length(length)
+
     def add_tool_call(self, tool_name: str) -> None:
         """Add a tool call to the accumulator."""
         self._activity.add_tool_call(tool_name)
@@ -375,7 +391,7 @@ class DisplayEventHandler:
                 },
                 theme=self.renderer.themes.thinking_markdown_theme,
                 console=self.renderer.console,
-                live_sink=self.renderer.set_stream_renderable,
+                live_sink=self.renderer.set_stream_renderable if const.MARKDOWN_STREAM_LIVE_REPAINT_ENABLED else None,
                 mark=THINKING_MESSAGE_MARK,
                 mark_style=ThemeKey.THINKING,
                 left_margin=const.MARKDOWN_LEFT_MARGIN,
@@ -412,12 +428,15 @@ class DisplayEventHandler:
                 mdargs={"code_theme": self.renderer.themes.code_theme},
                 theme=self.renderer.themes.markdown_theme,
                 console=self.renderer.console,
-                live_sink=self.renderer.set_stream_renderable,
+                live_sink=self.renderer.set_stream_renderable if const.MARKDOWN_STREAM_LIVE_REPAINT_ENABLED else None,
                 mark=ASSISTANT_MESSAGE_MARK,
                 left_margin=const.MARKDOWN_LEFT_MARGIN,
             )
             self.assistant_stream.start(mdstream)
         self.assistant_stream.append(event.content)
+        self.spinner_status.set_buffer_length(len(self.assistant_stream.buffer))
+        if not first_delta:
+            self._update_spinner()
         if first_delta and self.assistant_stream.mdstream is not None:
             self.assistant_stream.mdstream.update(self.assistant_stream.buffer)
         await self.stage_manager.transition_to(Stage.ASSISTANT)

{klaude_code-1.2.25 → klaude_code-1.2.26}/src/klaude_code/ui/modes/repl/renderer.py

@@ -332,23 +332,28 @@ class REPLRenderer:
         self._bottom_live.start()
 
     def _bottom_renderable(self) -> RenderableType:
-        stream = self._stream_renderable
-        if stream is not None:
-            current_width = self.console.size.width
-            if self._stream_last_width != current_width:
-                height = len(self.console.render_lines(stream, self.console.options, pad=False))
-                self._stream_last_height = height
-                self._stream_last_width = current_width
-                self._stream_max_height = max(self._stream_max_height, height)
-            else:
-                height = self._stream_last_height
-
-            pad_lines = max(self._stream_max_height - height, 0)
-            if pad_lines:
-                stream = Padding(stream, (0, 0, pad_lines, 0))
-
-        stream_part: RenderableType = stream if stream is not None else Group()
-        gap_part: RenderableType = Text("") if self._spinner_visible else Group()
+        stream_part: RenderableType = Group()
+        gap_part: RenderableType = Group()
+
+        if const.MARKDOWN_STREAM_LIVE_REPAINT_ENABLED:
+            stream = self._stream_renderable
+            if stream is not None:
+                current_width = self.console.size.width
+                if self._stream_last_width != current_width:
+                    height = len(self.console.render_lines(stream, self.console.options, pad=False))
+                    self._stream_last_height = height
+                    self._stream_last_width = current_width
+                    self._stream_max_height = max(self._stream_max_height, height)
+                else:
+                    height = self._stream_last_height
+
+                pad_lines = max(self._stream_max_height - height, 0)
+                if pad_lines:
+                    stream = Padding(stream, (0, 0, pad_lines, 0))
+                stream_part = stream
+
+            gap_part = Text("") if self._spinner_visible else Group()
+
         status_part: RenderableType = SingleLine(self._status_spinner) if self._spinner_visible else Group()
         return Group(stream_part, gap_part, status_part)
 

{klaude_code-1.2.25 → klaude_code-1.2.26}/src/klaude_code/ui/renderers/sub_agent.py

@@ -68,24 +68,22 @@ def render_sub_agent_result(
     panel_style: Style | None = None,
 ) -> RenderableType:
     stripped_result = result.strip()
-
-    # Add markdown heading if description is provided
-    if description:
-        stripped_result = f"# {description}\n\n{stripped_result}"
-
     result_panel_style = panel_style or ThemeKey.SUB_AGENT_RESULT_PANEL
 
     # Use rich JSON for structured output
     if has_structured_output:
         try:
-            return Panel.fit(
-                Group(
-                    Text(
-                        "use /export to view full output",
-                        style=ThemeKey.TOOL_RESULT,
-                    ),
-                    JSON(stripped_result),
+            group_elements: list[RenderableType] = [
+                Text(
+                    "use /export to view full output",
+                    style=ThemeKey.TOOL_RESULT,
                 ),
+                JSON(stripped_result),
+            ]
+            if description:
+                group_elements.insert(0, NoInsetMarkdown(f"# {description}", code_theme=code_theme, style=style or ""))
+            return Panel.fit(
+                Group(*group_elements),
                 box=box.SIMPLE,
                 border_style=ThemeKey.LINES,
                 style=result_panel_style,
@@ -94,6 +92,10 @@ def render_sub_agent_result(
             # Fall back to markdown if not valid JSON
             pass
 
+    # Add markdown heading if description is provided for non-structured output
+    if description:
+        stripped_result = f"# {description}\n\n{stripped_result}"
+
     lines = stripped_result.splitlines()
     if len(lines) > const.SUB_AGENT_RESULT_MAX_LINES:
         hidden_count = len(lines) - const.SUB_AGENT_RESULT_MAX_LINES

{klaude_code-1.2.25 → klaude_code-1.2.26}/src/klaude_code/ui/renderers/thinking.py

@@ -10,7 +10,7 @@ from klaude_code.ui.rich.markdown import ThinkingMarkdown
 from klaude_code.ui.rich.theme import ThemeKey
 
 # UI markers
-THINKING_MESSAGE_MARK = "⠶"
+THINKING_MESSAGE_MARK = "⸫"
 
 
 def normalize_thinking_content(content: str) -> str:

{klaude_code-1.2.25 → klaude_code-1.2.26}/src/klaude_code/ui/renderers/tools.py

@@ -19,7 +19,7 @@ from klaude_code.ui.rich.theme import ThemeKey
 # Tool markers (Unicode symbols for UI display)
 MARK_GENERIC = "⚒"
 MARK_BASH = "→"
-MARK_PLAN = "▪"
+MARK_PLAN = "Ξ"
 MARK_READ = "←"
 MARK_EDIT = "±"
 MARK_WRITE = "+"
@@ -528,19 +528,28 @@ def render_tool_call(e: events.ToolCallEvent) -> RenderableType | None:
 def _extract_diff(ui_extra: model.ToolResultUIExtra | None) -> model.DiffUIExtra | None:
     if isinstance(ui_extra, model.DiffUIExtra):
         return ui_extra
+    if isinstance(ui_extra, model.MultiUIExtra):
+        for item in ui_extra.items:
+            if isinstance(item, model.DiffUIExtra):
+                return item
     return None
 
 
 def _extract_markdown_doc(ui_extra: model.ToolResultUIExtra | None) -> model.MarkdownDocUIExtra | None:
     if isinstance(ui_extra, model.MarkdownDocUIExtra):
         return ui_extra
+    if isinstance(ui_extra, model.MultiUIExtra):
+        for item in ui_extra.items:
+            if isinstance(item, model.MarkdownDocUIExtra):
+                return item
     return None
 
 
 def render_markdown_doc(md_ui: model.MarkdownDocUIExtra, *, code_theme: str) -> RenderableType:
     """Render markdown document content in a panel."""
+    header = render_path(md_ui.file_path, ThemeKey.TOOL_PARAM_FILE_PATH)
     return Panel.fit(
-        NoInsetMarkdown(md_ui.content, code_theme=code_theme),
+        Group(header, Text(""), NoInsetMarkdown(md_ui.content, code_theme=code_theme)),
         box=box.SIMPLE,
         border_style=ThemeKey.LINES,
         style=ThemeKey.WRITE_MARKDOWN_PANEL,
@@ -562,6 +571,19 @@ def render_tool_result(e: events.ToolResultEvent, *, code_theme: str = "monokai"
         error_msg = truncate_display(e.result)
         return r_errors.render_error(error_msg)
 
+    # Render multiple ui blocks if present
+    if isinstance(e.ui_extra, model.MultiUIExtra) and e.ui_extra.items:
+        rendered: list[RenderableType] = []
+        for item in e.ui_extra.items:
+            if isinstance(item, model.MarkdownDocUIExtra):
+                rendered.append(Padding.indent(render_markdown_doc(item, code_theme=code_theme), level=2))
+            elif isinstance(item, model.DiffUIExtra):
+                show_file_name = e.tool_name == tools.APPLY_PATCH
+                rendered.append(
+                    Padding.indent(r_diffs.render_structured_diff(item, show_file_name=show_file_name), level=2)
+                )
+        return Group(*rendered) if rendered else None
+
     # Show truncation info if output was truncated and saved to file
     truncation_info = get_truncation_info(e)
     if truncation_info:
@@ -580,6 +602,8 @@ def render_tool_result(e: events.ToolResultEvent, *, code_theme: str = "monokai"
                 return Padding.indent(render_markdown_doc(md_ui, code_theme=code_theme), level=2)
             return Padding.indent(r_diffs.render_structured_diff(diff_ui) if diff_ui else Text(""), level=2)
         case tools.APPLY_PATCH:
+            if md_ui:
+                return Padding.indent(render_markdown_doc(md_ui, code_theme=code_theme), level=2)
             if diff_ui:
                 return Padding.indent(r_diffs.render_structured_diff(diff_ui, show_file_name=True), level=2)
             if len(e.result.strip()) == 0:

{klaude_code-1.2.25 → klaude_code-1.2.26}/src/klaude_code/ui/rich/markdown.py

@@ -1,4 +1,3 @@
-# copy from https://github.com/Aider-AI/aider/blob/main/aider/mdstream.py
 from __future__ import annotations
 
 import contextlib
@@ -9,11 +8,13 @@ from typing import Any, ClassVar
 
 from markdown_it import MarkdownIt
 from markdown_it.token import Token
+from rich import box
 from rich.console import Console, ConsoleOptions, RenderableType, RenderResult
-from rich.markdown import CodeBlock, Heading, Markdown, MarkdownElement
+from rich.markdown import CodeBlock, Heading, Markdown, MarkdownElement, TableElement
 from rich.rule import Rule
 from rich.style import Style, StyleType
 from rich.syntax import Syntax
+from rich.table import Table
 from rich.text import Text
 from rich.theme import Theme
 
@@ -53,6 +54,24 @@ class Divider(MarkdownElement):
         yield Rule(style=style, characters="-")
 
 
+class MinimalHeavyHeadTable(TableElement):
+    """A table element with MINIMAL_HEAVY_HEAD box style."""
+
+    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
+        table = Table(box=box.MARKDOWN)
+
+        if self.header is not None and self.header.row is not None:
+            for column in self.header.row.cells:
+                table.add_column(column.content)
+
+        if self.body is not None:
+            for row in self.body.rows:
+                row_content = [element.content for element in row.cells]
+                table.add_row(*row_content)
+
+        yield table
+
+
 class LeftHeading(Heading):
     """A heading class that renders left-justified."""
 
@@ -64,7 +83,7 @@ class LeftHeading(Heading):
             yield h1_text
         elif self.tag == "h2":
             text.stylize(Style(bold=True, underline=False))
-            yield Rule(title=text, characters="·", style="markdown.h2.border", align="left")
+            yield text
         else:
             yield text
 
@@ -78,6 +97,7 @@ class NoInsetMarkdown(Markdown):
         "code_block": NoInsetCodeBlock,
         "heading_open": LeftHeading,
         "hr": Divider,
+        "table_open": MinimalHeavyHeadTable,
     }
 
 
@@ -90,6 +110,7 @@ class ThinkingMarkdown(Markdown):
         "code_block": ThinkingCodeBlock,
         "heading_open": LeftHeading,
         "hr": Divider,
+        "table_open": MinimalHeavyHeadTable,
     }
 
 
@@ -341,9 +362,6 @@ class MarkdownStream:
     def update(self, text: str, final: bool = False) -> None:
         """Update the display with the latest full markdown buffer."""
 
-        if self._live_sink is None:
-            return
-
         now = time.time()
         if not final and now - self.when < self.min_delay:
             return
@@ -374,18 +392,20 @@ class MarkdownStream:
             self._stable_source_line_count = stable_line
 
         if final:
-            self._live_sink(None)
+            if self._live_sink is not None:
+                self._live_sink(None)
             return
 
-        apply_mark_live = self._stable_source_line_count == 0
-        live_lines = self._render_markdown_to_lines(live_source, apply_mark=apply_mark_live)
+        if const.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)
 
-        if self._stable_rendered_lines and not self._stable_rendered_lines[-1].strip():
-            while live_lines and not live_lines[0].strip():
-                live_lines.pop(0)
+            if self._stable_rendered_lines and not self._stable_rendered_lines[-1].strip():
+                while live_lines and not live_lines[0].strip():
+                    live_lines.pop(0)
 
-        live_text = Text.from_ansi("".join(live_lines))
-        self._live_sink(live_text)
+            live_text = Text.from_ansi("".join(live_lines))
+            self._live_sink(live_text)
 
         elapsed = time.time() - start
         self.min_delay = min(max(elapsed * 6, 1.0 / 30), 0.5)

{klaude_code-1.2.25 → klaude_code-1.2.26}/src/klaude_code/ui/rich/theme.py

@@ -291,7 +291,7 @@ def get_theme(theme: str | None = None) -> Themes:
                 "markdown.code.border": palette.grey3,
                 "markdown.h1": "bold reverse",
                 "markdown.h1.border": palette.grey3,
-                "markdown.h2.border": palette.grey3,
+                "markdown.h2": "bold underline",
                 "markdown.h3": "bold " + palette.grey1,
                 "markdown.h4": "bold " + palette.grey2,
                 "markdown.hr": palette.grey3,
@@ -311,7 +311,6 @@ def get_theme(theme: str | None = None) -> Themes:
                 "markdown.code.border": palette.grey3,
                 "markdown.h1": "bold reverse",
                 "markdown.h1.border": palette.grey3,
-                "markdown.h2.border": palette.grey3,
                 "markdown.h3": "bold " + palette.grey1,
                 "markdown.h4": "bold " + palette.grey2,
                 "markdown.hr": palette.grey3,
@@ -329,7 +328,6 @@ def get_theme(theme: str | None = None) -> Themes:
             Style(color=palette.blue),
             Style(color=palette.purple),
             Style(color=palette.orange),
-            Style(color=palette.red),
             Style(color=palette.grey1),
             Style(color=palette.yellow),
         ],
@@ -339,7 +337,6 @@ def get_theme(theme: str | None = None) -> Themes:
             Style(bgcolor=palette.blue_sub_background),
             Style(bgcolor=palette.purple_background),
             Style(bgcolor=palette.orange_background),
-            Style(bgcolor=palette.red_background),
             Style(bgcolor=palette.grey_background),
             Style(bgcolor=palette.yellow_background),
         ],