klaude-code 1.2.22__py3-none-any.whl → 1.2.24__py3-none-any.whl

klaude_code/skill/system_skills.py

@@ -0,0 +1,192 @@
+"""System skills management - install built-in skills to user directory.
+
+This module handles extracting bundled skills from the package to ~/.klaude/skills/.system/
+on application startup. It uses a fingerprint mechanism to avoid unnecessary re-extraction.
+"""
+
+import hashlib
+import shutil
+from collections.abc import Iterator
+from contextlib import contextmanager
+from importlib import resources
+from pathlib import Path
+
+from klaude_code.trace import log_debug
+
+# Marker file name for tracking installed skills version
+SYSTEM_SKILLS_MARKER_FILENAME = ".klaude-system-skills.marker"
+
+# Salt for fingerprint calculation (increment to force re-extraction)
+SYSTEM_SKILLS_MARKER_SALT = "v1"
+
+
+def get_system_skills_dir() -> Path:
+    """Get the system skills installation directory.
+
+    Returns:
+        Path to ~/.klaude/skills/.system/
+    """
+    return Path.home() / ".klaude" / "skills" / ".system"
+
+
+def _calculate_fingerprint(assets_dir: Path) -> str:
+    """Calculate a fingerprint hash for the embedded skills assets.
+
+    The fingerprint is based on all file paths and their contents.
+
+    Args:
+        assets_dir: Path to the assets directory
+
+    Returns:
+        Hex string of the hash
+    """
+    hasher = hashlib.sha256()
+    hasher.update(SYSTEM_SKILLS_MARKER_SALT.encode())
+
+    if not assets_dir.exists():
+        return hasher.hexdigest()
+
+    # Sort entries for consistent ordering
+    for entry in sorted(assets_dir.rglob("*")):
+        if entry.is_file():
+            # Hash the relative path
+            rel_path = entry.relative_to(assets_dir)
+            hasher.update(str(rel_path).encode())
+            # Hash the file contents
+            hasher.update(entry.read_bytes())
+
+    return hasher.hexdigest()
+
+
+def _read_marker(marker_path: Path) -> str | None:
+    """Read the fingerprint from the marker file.
+
+    Args:
+        marker_path: Path to the marker file
+
+    Returns:
+        The stored fingerprint, or None if the file doesn't exist or is invalid
+    """
+    try:
+        if marker_path.exists():
+            return marker_path.read_text(encoding="utf-8").strip()
+    except OSError:
+        pass
+    return None
+
+
+def _write_marker(marker_path: Path, fingerprint: str) -> None:
+    """Write the fingerprint to the marker file.
+
+    Args:
+        marker_path: Path to the marker file
+        fingerprint: The fingerprint to store
+    """
+    marker_path.write_text(f"{fingerprint}\n", encoding="utf-8")
+
+
+@contextmanager
+def _with_embedded_assets_dir() -> Iterator[Path | None]:
+    """Resolve the embedded assets directory as a real filesystem path.
+
+    Uses `importlib.resources.as_file()` so it works for both normal installs
+    and zipimport-style environments.
+    """
+    try:
+        assets_ref = resources.files("klaude_code.skill").joinpath("assets")
+        with resources.as_file(assets_ref) as assets_path:
+            p = Path(assets_path)
+            yield p if p.exists() else None
+            return
+    except (TypeError, AttributeError, ImportError, FileNotFoundError, OSError):
+        pass
+
+    try:
+        module_dir = Path(__file__).parent
+        assets_path = module_dir / "assets"
+        yield assets_path if assets_path.exists() else None
+    except (TypeError, NameError, OSError):
+        yield None
+
+
+def install_system_skills() -> bool:
+    """Install system skills from the embedded assets to the user directory.
+
+    This function:
+    1. Calculates a fingerprint of the embedded assets
+    2. Checks if the installed skills match (via marker file)
+    3. If they don't match, clears and re-extracts the skills
+
+    Returns:
+        True if skills were installed/updated, False if already up-to-date
+    """
+    dest_dir = get_system_skills_dir()
+    marker_path = dest_dir / SYSTEM_SKILLS_MARKER_FILENAME
+
+    with _with_embedded_assets_dir() as assets_path:
+        if assets_path is None or not assets_path.exists():
+            log_debug("No embedded system skills found")
+            return False
+
+        # Calculate fingerprint of embedded assets
+        expected_fingerprint = _calculate_fingerprint(assets_path)
+
+        # Check if already installed with matching fingerprint
+        current_fingerprint = _read_marker(marker_path)
+        if current_fingerprint == expected_fingerprint and dest_dir.exists():
+            log_debug("System skills already up-to-date")
+            return False
+
+        log_debug(f"Installing system skills to {dest_dir}")
+
+        # Clear existing installation
+        if dest_dir.exists():
+            try:
+                shutil.rmtree(dest_dir)
+            except OSError as e:
+                log_debug(f"Failed to clear existing system skills: {e}")
+                return False
+
+        # Create destination directory
+        dest_dir.mkdir(parents=True, exist_ok=True)
+
+        # Copy all skill directories from assets
+        try:
+            for item in assets_path.iterdir():
+                if item.is_dir() and not item.name.startswith("."):
+                    dest_skill_dir = dest_dir / item.name
+                    shutil.copytree(item, dest_skill_dir)
+                    log_debug(f"Installed system skill: {item.name}")
+        except OSError as e:
+            log_debug(f"Failed to copy system skills: {e}")
+            return False
+
+        # Write marker file
+        try:
+            _write_marker(marker_path, expected_fingerprint)
+        except OSError as e:
+            log_debug(f"Failed to write marker file: {e}")
+            # Installation succeeded, just marker failed
+
+        log_debug("System skills installation complete")
+        return True
+
+
+def get_installed_system_skills() -> list[Path]:
+    """Get list of installed system skill directories.
+
+    Returns:
+        List of paths to installed skill directories
+    """
+    dest_dir = get_system_skills_dir()
+    if not dest_dir.exists():
+        return []
+
+    skills: list[Path] = []
+    for item in dest_dir.iterdir():
+        if item.is_dir() and not item.name.startswith("."):
+            skill_file = item / "SKILL.md"
+            if skill_file.exists():
+                skills.append(item)
+
+    return skills

klaude_code/ui/core/stage_manager.py

@@ -20,12 +20,10 @@ class StageManager:
         *,
         finish_assistant: Callable[[], Awaitable[None]],
         finish_thinking: Callable[[], Awaitable[None]],
-        on_enter_thinking: Callable[[], None],
     ):
         self._stage = Stage.WAITING
         self._finish_assistant = finish_assistant
         self._finish_thinking = finish_thinking
-        self._on_enter_thinking = on_enter_thinking
 
     @property
     def current_stage(self) -> Stage:
@@ -41,7 +39,6 @@ class StageManager:
         if self._stage == Stage.THINKING:
             return
         await self.transition_to(Stage.THINKING)
-        self._on_enter_thinking()
 
     async def finish_assistant(self) -> None:
         if self._stage != Stage.ASSISTANT:

klaude_code/ui/modes/repl/completers.py

@@ -1,13 +1,15 @@
-"""REPL completion handlers for @ file paths and / slash commands.
+"""REPL completion handlers for @ file paths, / slash commands, and $ skills.
 
 This module provides completers for the REPL input:
 - _SlashCommandCompleter: Completes slash commands on the first line
+- _SkillCompleter: Completes skill names on the first line with $ prefix
 - _AtFilesCompleter: Completes @path segments using fd or ripgrep
-- _ComboCompleter: Combines both completers with priority logic
+- _ComboCompleter: Combines all completers with priority logic
 
 Public API:
 - create_repl_completer(): Factory function to create the combined completer
 - AT_TOKEN_PATTERN: Regex pattern for @token matching (used by key bindings)
+- SKILL_TOKEN_PATTERN: Regex pattern for $skill matching (used by key bindings)
 """
 
 from __future__ import annotations
@@ -34,6 +36,9 @@ from klaude_code.trace.log import DebugType, log_debug
 # single logical token.
 AT_TOKEN_PATTERN = re.compile(r'(^|\s)@(?P<frag>"[^"]*"|[^\s]*)$')
 
+# Pattern to match $skill or ¥skill token for skill completion (used by key bindings).
+SKILL_TOKEN_PATTERN = re.compile(r"^[$¥](?P<frag>\S*)$")
+
 
 def create_repl_completer() -> Completer:
     """Create and return the combined REPL completer.
@@ -121,12 +126,102 @@ class _SlashCommandCompleter(Completer):
         return bool(self._SLASH_TOKEN_RE.search(text_before))
 
 
+class _SkillCompleter(Completer):
+    """Complete skill names at the beginning of the first line.
+
+    Behavior:
+    - Only triggers when cursor is on first line and text matches $ or ¥...
+    - Shows available skills with descriptions
+    - Inserts trailing space after completion
+    """
+
+    _SKILL_TOKEN_RE = SKILL_TOKEN_PATTERN
+
+    def get_completions(
+        self,
+        document: Document,
+        complete_event,  # type: ignore[override]
+    ) -> Iterable[Completion]:
+        # Only complete on first line
+        if document.cursor_position_row != 0:
+            return
+
+        text_before = document.current_line_before_cursor
+        m = self._SKILL_TOKEN_RE.search(text_before)
+        if not m:
+            return
+
+        frag = m.group("frag").lower()
+        # Get the prefix character ($ or ¥)
+        prefix_char = text_before[0]
+        token_start = len(text_before) - len(f"{prefix_char}{m.group('frag')}")
+        start_position = token_start - len(text_before)  # negative offset
+
+        # Get available skills from SkillTool
+        skills = self._get_available_skills()
+        if not skills:
+            return
+
+        # Filter skills that match the fragment (case-insensitive)
+        matched: list[tuple[str, str, str]] = []  # (name, description, location)
+        for name, desc, location in skills:
+            if frag in name.lower() or frag in desc.lower():
+                matched.append((name, desc, location))
+
+        if not matched:
+            return
+
+        # Calculate max width for alignment
+        max_name_len = max(len(name) for name, _, _ in matched)
+        align_width = max(max_name_len, 20) + 2
+
+        for name, desc, location in matched:
+            # Format: name  [location]  description
+            # Align location tags (max length is "project" = 7, plus brackets = 9)
+            padding_name = " " * (align_width - len(name))
+            location_tag = f"[{location}]".ljust(9)
+
+            # Using HTML for formatting: bold skill name, cyan location tag, gray description
+            display_text = HTML(
+                f"<b>{name}</b>{padding_name}<style color='ansicyan'>{location_tag}</style> "
+                f"<style color='ansibrightblack'>{desc}</style>"
+            )
+            completion_text = f"${name} "
+            yield Completion(
+                text=completion_text,
+                start_position=start_position,
+                display=display_text,
+            )
+
+    def _get_available_skills(self) -> list[tuple[str, str, str]]:
+        """Get available skills from skill module.
+
+        Returns:
+            List of (name, description, location) tuples
+        """
+        try:
+            # Import here to avoid circular imports
+            from klaude_code.skill import get_available_skills
+
+            return get_available_skills()
+        except Exception:
+            return []
+
+    def is_skill_context(self, document: Document) -> bool:
+        """Check if current context is a skill completion."""
+        if document.cursor_position_row != 0:
+            return False
+        text_before = document.current_line_before_cursor
+        return bool(self._SKILL_TOKEN_RE.search(text_before))
+
+
 class _ComboCompleter(Completer):
-    """Combined completer that handles both @ file paths and / slash commands."""
+    """Combined completer that handles @ file paths, / slash commands, and $ skills."""
 
     def __init__(self) -> None:
         self._at_completer = _AtFilesCompleter()
         self._slash_completer = _SlashCommandCompleter()
+        self._skill_completer = _SkillCompleter()
 
     def get_completions(
         self,
@@ -138,6 +233,11 @@ class _ComboCompleter(Completer):
             yield from self._slash_completer.get_completions(document, complete_event)
             return
 
+        # Try skill completion (only on first line with $ prefix)
+        if document.cursor_position_row == 0 and self._skill_completer.is_skill_context(document):
+            yield from self._skill_completer.get_completions(document, complete_event)
+            return
+
         # Fall back to @ file completion
         yield from self._at_completer.get_completions(document, complete_event)
 

klaude_code/ui/modes/repl/event_handler.py

@@ -2,19 +2,57 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 
+from rich.cells import cell_len
+from rich.rule import Rule
 from rich.text import Text
 
 from klaude_code import const
 from klaude_code.protocol import events
 from klaude_code.ui.core.stage_manager import Stage, StageManager
 from klaude_code.ui.modes.repl.renderer import REPLRenderer
-from klaude_code.ui.renderers.thinking import normalize_thinking_content
+from klaude_code.ui.renderers.assistant import ASSISTANT_MESSAGE_MARK
+from klaude_code.ui.renderers.thinking import THINKING_MESSAGE_MARK, normalize_thinking_content
 from klaude_code.ui.rich.markdown import MarkdownStream, ThinkingMarkdown
 from klaude_code.ui.rich.theme import ThemeKey
 from klaude_code.ui.terminal.notifier import Notification, NotificationType, TerminalNotifier
 from klaude_code.ui.terminal.progress_bar import OSC94States, emit_osc94
 
 
+def extract_last_bold_header(text: str) -> str | None:
+    """Extract the latest complete bold header ("**...**") from text.
+
+    We treat a bold segment as a "header" only if it appears at the beginning
+    of a line (ignoring leading whitespace). This avoids picking up incidental
+    emphasis inside paragraphs.
+
+    Returns None if no complete bold segment is available yet.
+    """
+
+    last: str | None = None
+    i = 0
+    while True:
+        start = text.find("**", i)
+        if start < 0:
+            break
+
+        line_start = text.rfind("\n", 0, start) + 1
+        if text[line_start:start].strip():
+            i = start + 2
+            continue
+
+        end = text.find("**", start + 2)
+        if end < 0:
+            break
+
+        inner = " ".join(text[start + 2 : end].split())
+        if inner and "\n" not in inner:
+            last = inner
+
+        i = end + 2
+
+    return last
+
+
 @dataclass
 class ActiveStream:
     """Active streaming state containing buffer and markdown renderer.
@@ -115,7 +153,7 @@ class ActivityState:
             for name, count in self._tool_calls.items():
                 if not first:
                     activity_text.append(", ")
-                activity_text.append(Text(name, style=ThemeKey.SPINNER_STATUS_TEXT_BOLD))
+                activity_text.append(Text(name, style=ThemeKey.STATUS_TEXT_BOLD))
                 if count > 1:
                     activity_text.append(f" x {count}")
                 first = False
@@ -128,8 +166,9 @@ class ActivityState:
 class SpinnerStatusState:
     """Multi-layer spinner status state management.
 
-    Composed of two independent layers:
-    - base_status: Set by TodoChange, persistent within a turn
+    Layers:
+    - todo_status: Set by TodoChange (preferred when present)
+    - reasoning_status: Derived from Thinking/ThinkingDelta bold headers
     - activity: Current activity (composing or tool_calls), mutually exclusive
     - context_percent: Context usage percentage, updated during task execution
 
@@ -140,25 +179,31 @@ class SpinnerStatusState:
     - Context percent is appended at the end if available
     """
 
-    DEFAULT_STATUS = "Thinking …"
-
     def __init__(self) -> None:
-        self._base_status: str | None = None
+        self._todo_status: str | None = None
+        self._reasoning_status: str | None = None
         self._activity = ActivityState()
         self._context_percent: float | None = None
 
     def reset(self) -> None:
         """Reset all layers."""
-        self._base_status = None
+        self._todo_status = None
+        self._reasoning_status = None
         self._activity.reset()
         self._context_percent = None
 
-    def set_base_status(self, status: str | None) -> None:
+    def set_todo_status(self, status: str | None) -> None:
         """Set base status from TodoChange."""
-        self._base_status = status
+        self._todo_status = status
+
+    def set_reasoning_status(self, status: str | None) -> None:
+        """Set reasoning-derived base status from ThinkingDelta bold headers."""
+        self._reasoning_status = status
 
     def set_composing(self, composing: bool) -> None:
         """Set composing state when assistant is streaming."""
+        if composing:
+            self._reasoning_status = None
         self._activity.set_composing(composing)
 
     def add_tool_call(self, tool_name: str) -> None:
@@ -185,8 +230,10 @@ class SpinnerStatusState:
         """Get current spinner status as rich Text (without context)."""
         activity_text = self._activity.get_activity_text()
 
-        if self._base_status:
-            result = Text(self._base_status)
+        base_status = self._todo_status or self._reasoning_status
+
+        if base_status:
+            result = Text(base_status, style=ThemeKey.STATUS_TEXT_BOLD)
             if activity_text:
                 result.append(" | ")
                 result.append_text(activity_text)
@@ -194,7 +241,7 @@ class SpinnerStatusState:
             activity_text.append(" …")
             result = activity_text
         else:
-            result = Text(self.DEFAULT_STATUS)
+            result = Text(const.STATUS_DEFAULT_TEXT, style=ThemeKey.STATUS_TEXT)
 
         return result
 
@@ -218,7 +265,6 @@ class DisplayEventHandler:
         self.stage_manager = StageManager(
             finish_assistant=self._finish_assistant_stream,
             finish_thinking=self._finish_thinking_stream,
-            on_enter_thinking=self._print_thinking_prefix,
         )
 
     async def consume_event(self, event: events.Event) -> None:
@@ -309,6 +355,10 @@ class DisplayEventHandler:
             await self._finish_thinking_stream()
         else:
             # Non-streaming path (history replay or models without delta support)
+            reasoning_status = extract_last_bold_header(normalize_thinking_content(event.content))
+            if reasoning_status:
+                self.spinner_status.set_reasoning_status(reasoning_status)
+                self._update_spinner()
             await self.stage_manager.enter_thinking_stage()
             self.renderer.display_thinking(event.content)
 
@@ -327,7 +377,9 @@ class DisplayEventHandler:
                 theme=self.renderer.themes.thinking_markdown_theme,
                 console=self.renderer.console,
                 spinner=self.renderer.spinner_renderable(),
-                indent=2,
+                mark=THINKING_MESSAGE_MARK,
+                mark_style=ThemeKey.THINKING,
+                left_margin=const.MARKDOWN_LEFT_MARGIN,
                 markdown_class=ThinkingMarkdown,
             )
             self.thinking_stream.start(mdstream)
@@ -335,6 +387,11 @@ class DisplayEventHandler:
 
         self.thinking_stream.append(event.content)
 
+        reasoning_status = extract_last_bold_header(normalize_thinking_content(self.thinking_stream.buffer))
+        if reasoning_status:
+            self.spinner_status.set_reasoning_status(reasoning_status)
+            self._update_spinner()
+
         if first_delta and self.thinking_stream.mdstream is not None:
             self.thinking_stream.mdstream.update(normalize_thinking_content(self.thinking_stream.buffer))
 
@@ -358,8 +415,8 @@ class DisplayEventHandler:
                 theme=self.renderer.themes.markdown_theme,
                 console=self.renderer.console,
                 spinner=self.renderer.spinner_renderable(),
-                mark="➤",
-                indent=2,
+                mark=ASSISTANT_MESSAGE_MARK,
+                left_margin=const.MARKDOWN_LEFT_MARGIN,
             )
             self.assistant_stream.start(mdstream)
         self.assistant_stream.append(event.content)
@@ -413,7 +470,7 @@ class DisplayEventHandler:
 
     def _on_todo_change(self, event: events.TodoChangeEvent) -> None:
         active_form_status_text = self._extract_active_form_text(event)
-        self.spinner_status.set_base_status(active_form_status_text if active_form_status_text else None)
+        self.spinner_status.set_todo_status(active_form_status_text if active_form_status_text else None)
         # Clear tool calls when todo changes, as the tool execution has advanced
         self.spinner_status.clear_for_new_turn()
         self._update_spinner()
@@ -430,6 +487,8 @@ class DisplayEventHandler:
             emit_osc94(OSC94States.HIDDEN)
             self.spinner_status.reset()
             self.renderer.spinner_stop()
+            self.renderer.console.print(Rule(characters="-", style=ThemeKey.LINES))
+            self.renderer.print()
         await self.stage_manager.transition_to(Stage.WAITING)
         self._maybe_notify_task_finish(event)
 
@@ -465,14 +524,14 @@ class DisplayEventHandler:
             mdstream.update(self.assistant_stream.buffer, final=True)
             self.assistant_stream.finish()
 
-    def _print_thinking_prefix(self) -> None:
-        self.renderer.display_thinking_prefix()
-
     def _update_spinner(self) -> None:
         """Update spinner text from current status state."""
+        status_text = self.spinner_status.get_status()
+        context_text = self.spinner_status.get_context_text()
+        status_text = self._truncate_spinner_status_text(status_text, right_text=context_text)
         self.renderer.spinner_update(
-            self.spinner_status.get_status(),
-            self.spinner_status.get_context_text(),
+            status_text,
+            context_text,
         )
 
     async def _flush_assistant_buffer(self, state: StreamState) -> None:
@@ -530,35 +589,28 @@ class DisplayEventHandler:
                     status_text = todo.active_form
                 if len(todo.content) > 0:
                     status_text = todo.content
-        status_text = status_text.replace("\n", "")
-        max_length = self._calculate_base_status_max_length()
-        return self._truncate_status_text(status_text, max_length=max_length)
-
-    def _calculate_base_status_max_length(self) -> int:
-        """Calculate max length for base_status based on terminal width.
-
-        Reserve space for:
-        - Spinner glyph + space + context text: 2 chars + context text length 10 chars
-        - " | " separator: 3 chars (only if activity text present)
-        - Activity text: actual length (only if present)
-        - Status hint text (esc to interrupt)
+        return status_text.replace("\n", " ").strip()
+
+    def _truncate_spinner_status_text(self, status_text: Text, *, right_text: Text | None) -> Text:
+        """Truncate spinner status to a single line based on terminal width.
+
+        Rich wraps based on terminal cell width (CJK chars count as 2). Use
+        cell-aware truncation to prevent the status from wrapping into two lines.
         """
+
         terminal_width = self.renderer.console.size.width
 
-        # Base reserved space: spinner + context + status hint
-        reserved_space = 12 + len(const.STATUS_HINT_TEXT)
+        # BreathingSpinner renders as a 2-column Table.grid(padding=1):
+        # 1 cell for glyph + 1 cell of padding between columns (collapsed).
+        spinner_prefix_cells = 2
 
-        # Add space for activity text if present
-        activity_text = self.spinner_status.get_activity_text()
-        if activity_text:
-            # " | " separator + actual activity text length
-            reserved_space += 3 + len(activity_text.plain)
+        hint_cells = cell_len(const.STATUS_HINT_TEXT)
+        right_cells = cell_len(right_text.plain) if right_text is not None else 0
 
-        max_length = max(10, terminal_width - reserved_space)
-        return max_length
+        max_main_cells = terminal_width - spinner_prefix_cells - hint_cells - right_cells - 1
+        # rich.text.Text.truncate behaves unexpectedly for 0; clamp to at least 1.
+        max_main_cells = max(1, max_main_cells)
 
-    def _truncate_status_text(self, text: str, max_length: int) -> str:
-        if len(text) <= max_length:
-            return text
-        truncated = text[:max_length]
-        return truncated + "…"
+        truncated = status_text.copy()
+        truncated.truncate(max_main_cells, overflow="ellipsis", pad=False)
+        return truncated