PyPI - klaude-code - Versions diffs - 2.9.1__py3-none-any.whl → 2.10.0__py3-none-any.whl - Mend

klaude-code 2.9.1py3-none-any.whl → 2.10.0py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (40) hide show

klaude_code/app/runtime.py +1 -1
klaude_code/cli/cost_cmd.py +4 -4
klaude_code/cli/list_model.py +1 -2
klaude_code/const.py +4 -3
klaude_code/core/bash_mode.py +276 -0
klaude_code/core/executor.py +40 -7
klaude_code/core/manager/llm_clients.py +1 -0
klaude_code/core/manager/llm_clients_builder.py +2 -2
klaude_code/core/memory.py +140 -0
klaude_code/core/reminders.py +17 -89
klaude_code/core/turn.py +10 -4
klaude_code/protocol/events.py +17 -0
klaude_code/protocol/op.py +12 -0
klaude_code/protocol/op_handler.py +5 -0
klaude_code/tui/command/resume_cmd.py +1 -1
klaude_code/tui/commands.py +15 -0
klaude_code/tui/components/command_output.py +4 -5
klaude_code/tui/components/developer.py +1 -3
klaude_code/tui/components/metadata.py +23 -23
klaude_code/tui/components/rich/code_panel.py +31 -16
klaude_code/tui/components/rich/markdown.py +53 -124
klaude_code/tui/components/rich/theme.py +19 -10
klaude_code/tui/components/tools.py +1 -0
klaude_code/tui/components/user_input.py +48 -59
klaude_code/tui/components/welcome.py +47 -2
klaude_code/tui/display.py +15 -7
klaude_code/tui/input/completers.py +8 -0
klaude_code/tui/input/key_bindings.py +37 -1
klaude_code/tui/input/prompt_toolkit.py +58 -31
klaude_code/tui/machine.py +63 -3
klaude_code/tui/renderer.py +113 -19
klaude_code/tui/runner.py +22 -0
klaude_code/tui/terminal/notifier.py +11 -12
klaude_code/tui/terminal/selector.py +1 -1
klaude_code/ui/terminal/title.py +4 -2
{klaude_code-2.9.1.dist-info → klaude_code-2.10.0.dist-info}/METADATA +1 -1
{klaude_code-2.9.1.dist-info → klaude_code-2.10.0.dist-info}/RECORD +39 -38
klaude_code/tui/components/assistant.py +0 -2
{klaude_code-2.9.1.dist-info → klaude_code-2.10.0.dist-info}/WHEEL +0 -0
{klaude_code-2.9.1.dist-info → klaude_code-2.10.0.dist-info}/entry_points.txt +0 -0

klaude_code/tui/components/rich/markdown.py CHANGED Viewed

@@ -22,12 +22,10 @@ from rich.text import Text
 from rich.theme import Theme
 from klaude_code.const import (
-    MARKDOWN_RIGHT_MARGIN,
     MARKDOWN_STREAM_LIVE_REPAINT_ENABLED,
     MARKDOWN_STREAM_SYNCHRONIZED_OUTPUT_ENABLED,
     UI_REFRESH_RATE_FPS,
 )
-from klaude_code.tui.components.rich.code_panel import CodePanel
 _THINKING_HTML_BLOCK_RE = re.compile(
     r"\A\s*<thinking>\s*\n?(?P<body>.*?)(?:\n\s*)?</thinking>\s*\Z",
@@ -91,10 +89,15 @@ class ThinkingHTMLBlock(MarkdownElement):
 class NoInsetCodeBlock(CodeBlock):
-    """A code block with syntax highlighting and no padding."""
+    """A code block with syntax highlighting using markdown fence style."""
     def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
         code = str(self.text).rstrip()
+        lang = self.lexer_name if self.lexer_name != "text" else ""
+        fence_style = console.get_style("markdown.code.fence", default="none")
+        fence_title_style = console.get_style("markdown.code.fence.title", default="none")
+        yield Text.assemble(("```", fence_style), (lang, fence_title_style))
         syntax = Syntax(
             code,
             self.lexer_name,
@@ -102,16 +105,21 @@ class NoInsetCodeBlock(CodeBlock):
             word_wrap=True,
             padding=(0, 0),
         )
-        yield CodePanel(syntax, border_style="markdown.code.border")
+        yield syntax
+        yield Text("```", style=fence_style)
 class ThinkingCodeBlock(CodeBlock):
-    """A code block for thinking content that uses grey styling instead of syntax highlighting."""
+    """A code block for thinking content that uses simple ``` delimiters."""
     def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
         code = str(self.text).rstrip()
-        text = Text(code, "markdown.code.block")
-        yield CodePanel(text, border_style="markdown.code.border")
+        fence_style = "markdown.code.fence"
+        code_style = "markdown.code.block"
+        lang = self.lexer_name if self.lexer_name != "text" else ""
+        yield Text(f"```{lang}", style=fence_style)
+        yield Text(code, style=code_style)
+        yield Text("```", style=fence_style)
 class Divider(MarkdownElement):
@@ -289,7 +297,7 @@ class MarkdownStream:
         mark: str | None = None,
         mark_style: StyleType | None = None,
         left_margin: int = 0,
-        right_margin: int = MARKDOWN_RIGHT_MARGIN,
+        right_margin: int = 0,
         markdown_class: Callable[..., Markdown] | None = None,
         image_callback: Callable[[str], None] | None = None,
     ) -> None:
@@ -325,10 +333,10 @@ class MarkdownStream:
         self.theme = theme
         self.console = console
-        self.mark: str | None = mark
-        self.mark_style: StyleType | None = mark_style
         self.left_margin: int = max(left_margin, 0)
+        # Default mark "•" when left_margin >= 2 and no mark specified
+        self.mark: str | None = mark if mark is not None else ("•" if self.left_margin >= 2 else None)
+        self.mark_style: StyleType | None = mark_style
         self.right_margin: int = max(right_margin, 0)
         self.markdown_class: Callable[..., Markdown] = markdown_class or NoInsetMarkdown
@@ -395,25 +403,12 @@ class MarkdownStream:
             return 0
         top_level: list[Token] = [token for token in tokens if token.level == 0 and token.map is not None]
-        if not top_level:
+        if len(top_level) < 2:
             return 0
         last = top_level[-1]
         assert last.map is not None
-        # Lists are a special case: markdown-it-py treats the whole list as one
-        # top-level block, which would keep the entire list in the live area
-        # until the list ends.
-        #
-        # For streaming UX, we want all but the final list item to be eligible
-        # for stabilization, leaving only the *last* item in the live area.
-        if last.type in {"bullet_list_open", "ordered_list_open"}:
-            stable_line = self._compute_list_item_boundary(tokens, last)
-            return max(stable_line, 0)
-        if len(top_level) < 2:
-            return 0
         # When the buffer ends mid-line, markdown-it-py can temporarily classify
         # some lines as a thematic break (hr). For example, a trailing "- --"
         # parses as an hr, but appending a non-hr character ("- --0") turns it
@@ -430,59 +425,6 @@ class MarkdownStream:
         start_line = last.map[0]
         return max(start_line, 0)
-    def _compute_list_item_boundary(self, tokens: list[Token], list_open: Token) -> int:
-        """Return the start line of the last list item in a list.
-        This allows stabilizing all list items except the final one.
-        """
-        if list_open.map is None:
-            return 0
-        list_start, list_end = list_open.map
-        item_level = list_open.level + 1
-        last_item_start: int | None = None
-        for token in tokens:
-            if token.type != "list_item_open":
-                continue
-            if token.level != item_level:
-                continue
-            if token.map is None:
-                continue
-            start_line = token.map[0]
-            if start_line < list_start or start_line >= list_end:
-                continue
-            last_item_start = start_line
-        return last_item_start if last_item_start is not None else list_start
-    def _stable_boundary_continues_list(self, text: str, stable_line: int, *, final: bool) -> bool:
-        """Whether the stable/live split point is inside the final top-level list."""
-        if final:
-            return False
-        if stable_line <= 0:
-            return False
-        try:
-            tokens = self._parser.parse(text)
-        except Exception:
-            return False
-        top_level: list[Token] = [token for token in tokens if token.level == 0 and token.map is not None]
-        if not top_level:
-            return False
-        last = top_level[-1]
-        if last.type not in {"bullet_list_open", "ordered_list_open"}:
-            return False
-        if last.map is None:
-            return False
-        list_start, list_end = last.map
-        return list_start < stable_line < list_end
     def split_blocks(self, text: str, *, min_stable_line: int = 0, final: bool = False) -> tuple[str, str, int]:
         """Split full markdown into stable and live sources.
@@ -512,14 +454,7 @@ class MarkdownStream:
             return "", text, 0
         return stable_source, live_source, stable_line
-    def render_stable_ansi(
-        self,
-        stable_source: str,
-        *,
-        has_live_suffix: bool,
-        final: bool,
-        continues_list: bool = False,
-    ) -> tuple[str, list[str]]:
+    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.
         Returns:
@@ -529,14 +464,10 @@ class MarkdownStream:
             return "", []
         render_source = stable_source
-        if not final and has_live_suffix and not continues_list:
+        if not final and has_live_suffix:
             render_source = self._append_nonfinal_sentinel(stable_source)
         lines, images = self._render_markdown_to_lines(render_source, apply_mark=True)
-        if continues_list:
-            while lines and not lines[-1].strip():
-                lines.pop()
         return "".join(lines), images
     def _append_nonfinal_sentinel(self, stable_source: str) -> str:
@@ -590,12 +521,17 @@ class MarkdownStream:
         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 ""
+        use_mark = apply_mark and bool(self.mark) and self.left_margin >= 2
+        # Fast path: no margin, no mark -> just rstrip each line
+        if self.left_margin == 0 and not use_mark:
+            processed_lines = [line.rstrip() + "\n" if line.endswith("\n") else line.rstrip() for line in lines]
+            return processed_lines, list(collected_images)
+        indent_prefix = " " * self.left_margin
         processed_lines: list[str] = []
         mark_applied = False
-        use_mark = apply_mark and bool(self.mark) and self.left_margin >= 2
         # Pre-render styled mark if needed
         styled_mark: str | None = None
@@ -616,7 +552,7 @@ class MarkdownStream:
             if use_mark and not mark_applied and stripped:
                 stripped = f"{styled_mark} {stripped}"
                 mark_applied = True
-            elif indent_prefix:
+            else:
                 stripped = indent_prefix + stripped
             if line.endswith("\n"):
@@ -648,8 +584,6 @@ class MarkdownStream:
             final=final,
         )
-        continues_list = self._stable_boundary_continues_list(text, stable_line, final=final) and bool(live_source)
         start = time.time()
         stable_chunk_to_print: str | None = None
@@ -657,10 +591,7 @@ class MarkdownStream:
         stable_changed = final or stable_line > self._stable_source_line_count
         if stable_changed and stable_source:
             stable_ansi, collected_images = self.render_stable_ansi(
-                stable_source,
-                has_live_suffix=bool(live_source),
-                final=final,
-                continues_list=continues_list,
+                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) :]
@@ -678,33 +609,31 @@ 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:
-            if continues_list and self._stable_rendered_lines:
-                full_lines, _ = self._render_markdown_to_lines(text, apply_mark=True)
-                skip = min(len(self._stable_rendered_lines), len(full_lines))
-                live_text_to_set = Text.from_ansi("".join(full_lines[skip:]))
-            else:
-                apply_mark = not self._stable_rendered_lines
-                live_lines, _ = self._render_markdown_to_lines(live_source, apply_mark=apply_mark)
-                if self._stable_rendered_lines:
-                    stable_trailing_blank = 0
-                    for line in reversed(self._stable_rendered_lines):
+            # When nothing is stable yet, we still want to show incremental output.
+            # Apply the mark only for the first (all-live) frame so it stays anchored
+            # to the first visible line of the full message.
+            apply_mark_to_live = stable_line == 0
+            live_lines, _ = self._render_markdown_to_lines(live_source, apply_mark=apply_mark_to_live)
+            if self._stable_rendered_lines:
+                stable_trailing_blank = 0
+                for line in reversed(self._stable_rendered_lines):
+                    if line.strip():
+                        break
+                    stable_trailing_blank += 1
+                if stable_trailing_blank > 0:
+                    live_leading_blank = 0
+                    for line in live_lines:
                         if line.strip():
                             break
-                        stable_trailing_blank += 1
-                    if stable_trailing_blank > 0:
-                        live_leading_blank = 0
-                        for line in live_lines:
-                            if line.strip():
-                                break
-                            live_leading_blank += 1
+                        live_leading_blank += 1
-                        drop = min(stable_trailing_blank, live_leading_blank)
-                        if drop > 0:
-                            live_lines = live_lines[drop:]
+                    drop = min(stable_trailing_blank, live_leading_blank)
+                    if drop > 0:
+                        live_lines = live_lines[drop:]
-                live_text_to_set = Text.from_ansi("".join(live_lines))
+            live_text_to_set = Text.from_ansi("".join(live_lines))
         with self._synchronized_output():
             # Update/clear live area first to avoid blank padding when stable block appears

klaude_code/tui/components/rich/theme.py CHANGED Viewed

@@ -39,6 +39,7 @@ class Palette:
     red_background: str
     grey_background: str
     yellow_background: str
+    user_message_background: str
 LIGHT_PALETTE = Palette(
@@ -73,6 +74,7 @@ LIGHT_PALETTE = Palette(
     red_background="#f9ecec",
     grey_background="#f0f0f0",
     yellow_background="#f9f9ec",
+    user_message_background="#f0f0f0",
 )
 DARK_PALETTE = Palette(
@@ -107,6 +109,7 @@ DARK_PALETTE = Palette(
     red_background="#3d1f23",
     grey_background="#2a2d30",
     yellow_background="#3d3a1a",
+    user_message_background="#2a2d30",
 )
@@ -116,6 +119,7 @@ class ThemeKey(str, Enum):
     # CODE
     CODE_BACKGROUND = "code_background"
+    CODE_PANEL_TITLE = "code_panel.title"
     # PANEL
     SUB_AGENT_RESULT_PANEL = "panel.sub_agent_result"
@@ -258,18 +262,18 @@ def get_theme(theme: str | None = None) -> Themes:
                 ThemeKey.ERROR_DIM.value: "dim " + palette.red,
                 ThemeKey.INTERRUPT.value: palette.red,
                 # USER_INPUT
-                ThemeKey.USER_INPUT.value: palette.magenta,
-                ThemeKey.USER_INPUT_PROMPT.value: "bold " + palette.magenta,
-                ThemeKey.USER_INPUT_AT_PATTERN.value: palette.purple,
-                ThemeKey.USER_INPUT_SLASH_COMMAND.value: "bold " + palette.blue,
-                ThemeKey.USER_INPUT_SKILL.value: "bold " + palette.green,
+                ThemeKey.USER_INPUT.value: f"{palette.magenta} on {palette.user_message_background}",
+                ThemeKey.USER_INPUT_PROMPT.value: f"bold {palette.magenta} on {palette.user_message_background}",
+                ThemeKey.USER_INPUT_AT_PATTERN.value: f"{palette.purple} on {palette.user_message_background}",
+                ThemeKey.USER_INPUT_SLASH_COMMAND.value: f"bold {palette.blue} on {palette.user_message_background}",
+                ThemeKey.USER_INPUT_SKILL.value: f"bold {palette.green} on {palette.user_message_background}",
                 # ASSISTANT
                 ThemeKey.ASSISTANT_MESSAGE_MARK.value: "bold",
                 # METADATA
-                ThemeKey.METADATA.value: palette.lavender,
-                ThemeKey.METADATA_DIM.value: "dim " + palette.lavender,
-                ThemeKey.METADATA_BOLD.value: "bold " + palette.lavender,
-                ThemeKey.METADATA_ITALIC.value: "italic " + palette.lavender,
+                ThemeKey.METADATA.value: palette.blue,
+                ThemeKey.METADATA_DIM.value: "dim " + palette.blue,
+                ThemeKey.METADATA_BOLD.value: "bold " + palette.blue,
+                ThemeKey.METADATA_ITALIC.value: "italic " + palette.blue,
                 # STATUS
                 ThemeKey.STATUS_SPINNER.value: palette.blue,
                 ThemeKey.STATUS_TEXT.value: palette.blue,
@@ -348,6 +352,8 @@ def get_theme(theme: str | None = None) -> Themes:
                 "markdown.thinking": "italic " + palette.grey2,
                 "markdown.thinking.tag": palette.grey2,
                 "markdown.code.border": palette.grey3,
+                "markdown.code.fence": palette.grey3,
+                "markdown.code.fence.title": palette.grey1,
                 # Used by ThinkingMarkdown when rendering `<thinking>` blocks.
                 "markdown.code.block": palette.grey1,
                 "markdown.h1": "bold reverse " + palette.black,
@@ -362,6 +368,7 @@ def get_theme(theme: str | None = None) -> Themes:
                 "markdown.link_url": "underline " + palette.blue,
                 "markdown.table.border": palette.grey2,
                 "markdown.checkbox.checked": palette.green,
+                "markdown.block_quote": palette.cyan,
             }
         ),
         thinking_markdown_theme=Theme(
@@ -371,7 +378,8 @@ def get_theme(theme: str | None = None) -> Themes:
                 ThemeKey.THINKING_BOLD.value: "italic " + palette.grey1,
                 "markdown.strong": "italic " + palette.grey1,
                 "markdown.code": palette.grey1 + " italic on " + palette.code_background,
-                "markdown.code.block": palette.grey1,
+                "markdown.code.block": palette.grey2,
+                "markdown.code.fence": palette.grey3,
                 "markdown.code.border": palette.grey3,
                 "markdown.thinking.tag": palette.grey2 + " dim",
                 "markdown.h1": "bold reverse",
@@ -385,6 +393,7 @@ def get_theme(theme: str | None = None) -> Themes:
                 "markdown.link_url": "underline " + palette.blue,
                 "markdown.table.border": palette.grey2,
                 "markdown.checkbox.checked": palette.green,
+                "markdown.block_quote": palette.grey1,
             }
         ),
         code_theme=palette.code_theme,

klaude_code/tui/components/tools.py CHANGED Viewed

@@ -565,6 +565,7 @@ _TOOL_ACTIVE_FORM: dict[str, str] = {
     tools.WEB_SEARCH: "Searching Web",
     tools.REPORT_BACK: "Reporting",
     tools.IMAGE_GEN: "Generating Image",
+    tools.TASK: "Spawning Task",
 }

klaude_code/tui/components/user_input.py CHANGED Viewed

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

klaude_code/tui/components/welcome.py CHANGED Viewed

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

klaude_code/tui/display.py CHANGED Viewed

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

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

klaude-code 2.9.1py3-none-any.whl → 2.10.0py3-none-any.whl