klaude-code 1.2.6__py3-none-any.whl → 1.8.0__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/trace/__init__.py

@@ -1,3 +1,21 @@
-from .log import DebugType, is_debug_enabled, log, log_debug, logger, set_debug_logging
+from .log import (
+    DebugType,
+    get_current_log_file,
+    is_debug_enabled,
+    log,
+    log_debug,
+    logger,
+    prepare_debug_log_file,
+    set_debug_logging,
+)
 
-__all__ = ["log", "log_debug", "logger", "set_debug_logging", "DebugType", "is_debug_enabled"]
+__all__ = [
+    "DebugType",
+    "get_current_log_file",
+    "is_debug_enabled",
+    "log",
+    "log_debug",
+    "logger",
+    "prepare_debug_log_file",
+    "set_debug_logging",
+]

klaude_code/trace/log.py

@@ -1,7 +1,13 @@
+import gzip
 import logging
+import os
+import shutil
+import subprocess
+from collections.abc import Iterable
+from datetime import datetime, timedelta
 from enum import Enum
 from logging.handlers import RotatingFileHandler
-from typing import Iterable
+from pathlib import Path
 
 from rich.console import Console
 from rich.logging import RichHandler
@@ -49,6 +55,26 @@ _file_handler: RotatingFileHandler | None = None
 _console_handler: RichHandler | None = None
 _debug_filter: DebugTypeFilter | None = None
 _debug_enabled = False
+_current_log_file: Path | None = None
+
+LOG_RETENTION_DAYS = 3
+LOG_MAX_TOTAL_BYTES = 200 * 1024 * 1024
+
+
+class GzipRotatingFileHandler(RotatingFileHandler):
+    """Rotating file handler that gzips rolled files."""
+
+    def rotation_filename(self, default_name: str) -> str:
+        """Append .gz to rotation targets."""
+
+        return f"{default_name}.gz"
+
+    def rotate(self, source: str, dest: str) -> None:
+        """Compress the rotated file and remove the original."""
+
+        with open(source, "rb") as source_file, gzip.open(dest, "wb") as dest_file:
+            shutil.copyfileobj(source_file, dest_file)
+        Path(source).unlink(missing_ok=True)
 
 
 def set_debug_logging(
@@ -66,7 +92,7 @@ def set_debug_logging(
         log_file: Path to the log file (default: debug.log)
         filters: Set of DebugType to include; None means all types
     """
-    global _file_handler, _console_handler, _debug_filter, _debug_enabled
+    global _file_handler, _console_handler, _debug_filter, _debug_enabled, _current_log_file
 
     _debug_enabled = enabled
 
@@ -80,6 +106,7 @@ def set_debug_logging(
         _console_handler = None
 
     if not enabled:
+        _current_log_file = None
         return
 
     # Create filter
@@ -87,10 +114,19 @@ def set_debug_logging(
 
     # Determine output mode
     use_file = write_to_file if write_to_file is not None else True
-    file_path = log_file if log_file is not None else const.DEFAULT_DEBUG_LOG_FILE
-
     if use_file:
-        _file_handler = RotatingFileHandler(
+        if _current_log_file is None:
+            _current_log_file = _resolve_log_file(log_file)
+        file_path = _current_log_file
+    else:
+        _current_log_file = None
+        file_path = None
+
+    if use_file and file_path is not None:
+        _prune_old_logs(const.DEFAULT_DEBUG_LOG_DIR, LOG_RETENTION_DAYS, LOG_MAX_TOTAL_BYTES)
+
+    if use_file and file_path is not None:
+        _file_handler = GzipRotatingFileHandler(
             file_path,
             maxBytes=const.LOG_MAX_BYTES,
             backupCount=const.LOG_BACKUP_COUNT,
@@ -166,3 +202,112 @@ def _build_message(objects: Iterable[str | tuple[str, str]]) -> str:
 def is_debug_enabled() -> bool:
     """Check if debug logging is currently enabled."""
     return _debug_enabled
+
+
+def prepare_debug_log_file(log_file: str | os.PathLike[str] | None = None) -> Path:
+    """Prepare and remember the log file path for this session."""
+
+    global _current_log_file
+    _current_log_file = _resolve_log_file(log_file)
+    return _current_log_file
+
+
+def get_current_log_file() -> Path | None:
+    """Return the currently active log file path, if any."""
+
+    return _current_log_file
+
+
+def _resolve_log_file(log_file: str | os.PathLike[str] | None) -> Path:
+    """Resolve the log file path and ensure directories exist."""
+
+    if log_file:
+        path = Path(log_file).expanduser()
+        path.parent.mkdir(parents=True, exist_ok=True)
+        return path
+    else:
+        path = _build_default_log_file_path()
+
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.touch(exist_ok=True)
+    _refresh_latest_symlink(path)
+    return path
+
+
+def _build_default_log_file_path() -> Path:
+    """Build a per-session log path under the default log directory."""
+
+    now = datetime.now()
+    session_dir = const.DEFAULT_DEBUG_LOG_DIR / now.strftime("%Y-%m-%d")
+    session_dir.mkdir(parents=True, exist_ok=True)
+    filename = f"{now.strftime('%H%M%S')}-{os.getpid()}.log"
+    return session_dir / filename
+
+
+def _refresh_latest_symlink(target: Path) -> None:
+    """Point the debug.log symlink at the latest session file."""
+
+    latest = const.DEFAULT_DEBUG_LOG_FILE
+    try:
+        latest.unlink(missing_ok=True)
+        latest.symlink_to(target)
+    except OSError:
+        # Non-blocking best-effort; logging should still proceed
+        return
+
+
+def _prune_old_logs(log_root: Path, keep_days: int, max_total_bytes: int) -> None:
+    """Remove logs older than keep_days or when exceeding max_total_bytes."""
+
+    if not log_root.exists():
+        return
+
+    cutoff = datetime.now() - timedelta(days=keep_days)
+    files: list[Path] = [p for p in log_root.rglob("*") if p.is_file() and not p.is_symlink()]
+
+    # Remove by age
+    for path in files:
+        try:
+            mtime = datetime.fromtimestamp(path.stat().st_mtime)
+        except OSError:
+            continue
+        if mtime < cutoff:
+            _trash_path(path)
+
+    # Recompute remaining files and sizes
+    remaining: list[tuple[Path, float, int]] = []
+    total_size = 0
+    for path in log_root.rglob("*"):
+        if not path.is_file() or path.is_symlink():
+            continue
+        try:
+            stat = path.stat()
+        except OSError:
+            continue
+        remaining.append((path, stat.st_mtime, stat.st_size))
+        total_size += stat.st_size
+
+    if total_size <= max_total_bytes:
+        return
+
+    remaining.sort(key=lambda item: item[1])
+    for path, _, size in remaining:
+        _trash_path(path)
+        total_size -= size
+        if total_size <= max_total_bytes:
+            break
+
+
+def _trash_path(path: Path) -> None:
+    """Send a path to trash, falling back to unlink if trash is unavailable."""
+
+    try:
+        subprocess.run(
+            ["trash", str(path)],
+            stdin=subprocess.DEVNULL,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            check=False,
+        )
+    except FileNotFoundError:
+        path.unlink(missing_ok=True)

klaude_code/ui/__init__.py

@@ -73,19 +73,14 @@ def create_exec_display(debug: bool = False, stream_json: bool = False) -> Displ
 
 
 __all__ = [
-    # Abstract interfaces
+    "DebugEventDisplay",
     "DisplayABC",
+    "ExecDisplay",
     "InputProviderABC",
-    # Display mode implementations
+    "PromptToolkitInput",
     "REPLDisplay",
-    "ExecDisplay",
     "StreamJsonDisplay",
-    "DebugEventDisplay",
-    # Input implementations
-    "PromptToolkitInput",
-    # Factory functions
+    "TerminalNotifier",
     "create_default_display",
     "create_exec_display",
-    # Supporting types
-    "TerminalNotifier",
 ]

klaude_code/ui/core/input.py

@@ -68,4 +68,4 @@ class InputProviderABC(ABC):
             UserInputPayload with text and optional images.
         """
         raise NotImplementedError
-        yield UserInputPayload(text="")  # pyright: ignore[reportUnreachable]
+        yield UserInputPayload(text="")

klaude_code/ui/core/stage_manager.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
+from collections.abc import Awaitable, Callable
 from enum import Enum
-from typing import Awaitable, Callable
 
 
 class Stage(Enum):
@@ -19,11 +19,11 @@ class StageManager:
         self,
         *,
         finish_assistant: Callable[[], Awaitable[None]],
-        on_enter_thinking: Callable[[], None],
+        finish_thinking: Callable[[], Awaitable[None]],
     ):
         self._stage = Stage.WAITING
         self._finish_assistant = finish_assistant
-        self._on_enter_thinking = on_enter_thinking
+        self._finish_thinking = finish_thinking
 
     @property
     def current_stage(self) -> Stage:
@@ -39,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:
@@ -49,7 +48,8 @@ class StageManager:
         self._stage = Stage.WAITING
 
     async def _leave_current_stage(self) -> None:
-        if self._stage == Stage.ASSISTANT:
+        if self._stage == Stage.THINKING:
+            await self._finish_thinking()
+        elif self._stage == Stage.ASSISTANT:
             await self.finish_assistant()
-        elif self._stage != Stage.WAITING:
-            self._stage = Stage.WAITING
+        self._stage = Stage.WAITING

klaude_code/ui/modes/debug/display.py

@@ -1,3 +1,4 @@
+import os
 from typing import override
 
 from klaude_code import const
@@ -10,7 +11,7 @@ class DebugEventDisplay(DisplayABC):
     def __init__(
         self,
         wrapped_display: DisplayABC | None = None,
-        log_file: str = const.DEFAULT_DEBUG_LOG_FILE,
+        log_file: str | os.PathLike[str] = const.DEFAULT_DEBUG_LOG_FILE,
     ):
         self.wrapped_display = wrapped_display
         self.log_file = log_file

klaude_code/ui/modes/repl/__init__.py

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

klaude_code/ui/modes/repl/clipboard.py

@@ -40,19 +40,19 @@ class ClipboardCaptureState:
         """Capture image from clipboard, save to disk, and return a tag like [Image #N]."""
         try:
             clipboard_data = ImageGrab.grabclipboard()
-        except Exception:
+        except OSError:
             return None
         if not isinstance(clipboard_data, Image.Image):
             return None
         try:
             self._images_dir.mkdir(parents=True, exist_ok=True)
-        except Exception:
+        except OSError:
             return None
         filename = f"clipboard_{uuid.uuid4().hex[:8]}.png"
         path = self._images_dir / filename
         try:
             clipboard_data.save(path, "PNG")
-        except Exception:
+        except OSError:
             return None
         tag = f"[Image #{self._counter}]"
         self._counter += 1
@@ -123,7 +123,7 @@ def _encode_image_file(file_path: str) -> ImageURLPart | None:
         # Clipboard images are always saved as PNG
         data_url = f"data:image/png;base64,{encoded}"
         return ImageURLPart(image_url=ImageURLPart.ImageURL(url=data_url, id=None))
-    except Exception:
+    except OSError:
         return None
 
 
@@ -148,5 +148,5 @@ def copy_to_clipboard(text: str) -> None:
                     input=text.encode("utf-8"),
                     check=True,
                 )
-    except Exception:
+    except (OSError, subprocess.SubprocessError):
         pass