klaude-code 1.2.8__py3-none-any.whl → 1.2.10__py3-none-any.whl

klaude_code/auth/codex/__init__.py

@@ -17,4 +17,4 @@ __all__ = [
     "CodexOAuthError",
     "CodexTokenExpiredError",
     "CodexTokenManager",
-]
+]

klaude_code/cli/main.py

@@ -4,6 +4,7 @@ import os
 import subprocess
 import sys
 import uuid
+from importlib.metadata import PackageNotFoundError
 from importlib.metadata import version as pkg_version
 
 import typer
@@ -27,6 +28,9 @@ def _version_callback(value: bool) -> None:
     if value:
         try:
             ver = pkg_version("klaude-code")
+        except PackageNotFoundError:
+            # Package is not installed or has no metadata; show a generic version string.
+            ver = "unknown"
         except Exception:
             ver = "unknown"
         print(f"klaude-code {ver}")
@@ -232,8 +236,12 @@ def exec_command(
             stdin = sys.stdin.read().rstrip("\n")
             if stdin:
                 parts.append(stdin)
-        except Exception as e:
+        except (OSError, ValueError) as e:
+            # Expected I/O-related errors when reading from stdin (e.g. broken pipe, closed stream).
             log((f"Error reading from stdin: {e}", "red"))
+        except Exception as e:
+            # Unexpected errors are still reported but kept from crashing the CLI.
+            log((f"Unexpected error reading from stdin: {e}", "red"))
 
     if input_content:
         parts.append(input_content)
@@ -333,6 +341,7 @@ def main_callback(
 
         # Resolve session id before entering asyncio loop
         session_id: str | None = None
+        is_new_session = False
         if resume:
             session_id = resume_select_session()
             if session_id is None:
@@ -343,6 +352,7 @@ def main_callback(
         # If still no session_id, generate a new one for a new session
         if session_id is None:
             session_id = uuid.uuid4().hex
+            is_new_session = True
 
         debug_enabled, debug_filters = resolve_debug_settings(debug, debug_filter)
 
@@ -357,5 +367,6 @@ def main_callback(
             run_interactive(
                 init_config=init_config,
                 session_id=session_id,
+                is_new_session=is_new_session,
             )
         )

klaude_code/cli/runtime.py

@@ -13,7 +13,6 @@ from klaude_code.config import Config, load_config
 from klaude_code.core.agent import Agent, DefaultModelProfileProvider, VanillaModelProfileProvider
 from klaude_code.core.executor import Executor
 from klaude_code.core.manager import build_llm_clients
-from klaude_code.core.tool import SkillLoader, SkillTool
 from klaude_code.protocol import events, op
 from klaude_code.protocol.model import UserInputPayload
 from klaude_code.protocol.sub_agent import iter_sub_agent_profiles
@@ -96,11 +95,6 @@ async def initialize_app_components(init_config: AppInitConfig) -> AppComponents
     if config is None:
         raise typer.Exit(1)
 
-    # Initialize skills
-    skill_loader = SkillLoader()
-    skill_loader.discover_skills()
-    SkillTool.set_skill_loader(skill_loader)
-
     # Initialize LLM clients
     try:
         enabled_sub_agents = [p.name for p in iter_sub_agent_profiles()]
@@ -216,8 +210,7 @@ async def run_exec(init_config: AppInitConfig, input_content: str) -> None:
         # Generate a new session ID for exec mode
         session_id = uuid.uuid4().hex
 
-        # Init Agent
-        await components.executor.submit_and_wait(op.InitAgentOperation(session_id=session_id))
+        await components.executor.submit_and_wait(op.InitAgentOperation(session_id=session_id, is_new_session=True))
         await components.event_queue.join()
 
         # Submit the input content directly
@@ -231,7 +224,9 @@ async def run_exec(init_config: AppInitConfig, input_content: str) -> None:
         await cleanup_app_components(components)
 
 
-async def run_interactive(init_config: AppInitConfig, session_id: str | None = None) -> None:
+async def run_interactive(
+    init_config: AppInitConfig, session_id: str | None = None, *, is_new_session: bool = False
+) -> None:
     """Run the interactive REPL using the provided configuration."""
 
     components = await initialize_app_components(init_config)
@@ -284,8 +279,9 @@ async def run_interactive(init_config: AppInitConfig, session_id: str | None = N
     restore_sigint = install_sigint_double_press_exit(_show_toast_once, _hide_progress)
 
     try:
-        # Init Agent
-        await components.executor.submit_and_wait(op.InitAgentOperation(session_id=session_id))
+        await components.executor.submit_and_wait(
+            op.InitAgentOperation(session_id=session_id, is_new_session=is_new_session)
+        )
         await components.event_queue.join()
         # Input
         await input_provider.start()

klaude_code/command/__init__.py

@@ -1,13 +1,4 @@
-from .clear_cmd import ClearCommand
 from .command_abc import CommandABC, CommandResult, InputAction, InputActionType
-from .diff_cmd import DiffCommand
-from .export_cmd import ExportCommand
-from .help_cmd import HelpCommand
-
-# InitCommand is now dynamically loaded via prompt_init.md
-# from .init_cmd import InitCommand
-from .model_cmd import ModelCommand
-from .refresh_cmd import RefreshTerminalCommand
 from .registry import (
     dispatch_command,
     get_commands,
@@ -16,21 +7,76 @@ from .registry import (
     load_prompt_commands,
     register_command,
 )
-from .status_cmd import StatusCommand
-from .terminal_setup_cmd import TerminalSetupCommand
 
-# Dynamically load prompt commands
-load_prompt_commands()
+# Lazy load commands to avoid heavy imports at module load time
+_commands_loaded = False
+
+
+def ensure_commands_loaded() -> None:
+    """Ensure all commands are loaded (lazy initialization).
+
+    This function is called internally by registry functions like get_commands(),
+    dispatch_command(), etc. It can also be called explicitly if early loading is desired.
+    """
+    global _commands_loaded
+    if _commands_loaded:
+        return
+    _commands_loaded = True
+
+    # Import command modules to trigger @register_command decorators
+    from . import clear_cmd as _clear_cmd  # noqa: F401
+    from . import diff_cmd as _diff_cmd  # noqa: F401
+    from . import export_cmd as _export_cmd  # noqa: F401
+    from . import help_cmd as _help_cmd  # noqa: F401
+    from . import model_cmd as _model_cmd  # noqa: F401
+    from . import refresh_cmd as _refresh_cmd  # noqa: F401
+    from . import release_notes_cmd as _release_notes_cmd  # noqa: F401
+    from . import status_cmd as _status_cmd  # noqa: F401
+    from . import terminal_setup_cmd as _terminal_setup_cmd  # noqa: F401
+
+    # Suppress unused variable warnings
+    _ = (
+        _clear_cmd,
+        _diff_cmd,
+        _export_cmd,
+        _help_cmd,
+        _model_cmd,
+        _refresh_cmd,
+        _release_notes_cmd,
+        _status_cmd,
+        _terminal_setup_cmd,
+    )
+
+    # Load prompt-based commands
+    load_prompt_commands()
+
+
+# Lazy accessors for command classes
+def __getattr__(name: str) -> object:
+    _commands_map = {
+        "ClearCommand": "clear_cmd",
+        "DiffCommand": "diff_cmd",
+        "ExportCommand": "export_cmd",
+        "HelpCommand": "help_cmd",
+        "ModelCommand": "model_cmd",
+        "RefreshTerminalCommand": "refresh_cmd",
+        "ReleaseNotesCommand": "release_notes_cmd",
+        "StatusCommand": "status_cmd",
+        "TerminalSetupCommand": "terminal_setup_cmd",
+    }
+    if name in _commands_map:
+        import importlib
+
+        module = importlib.import_module(f".{_commands_map[name]}", __package__)
+        return getattr(module, name)
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
 
 __all__ = [
-    "ClearCommand",
-    "DiffCommand",
-    "HelpCommand",
-    "ModelCommand",
-    "ExportCommand",
-    "RefreshTerminalCommand",
-    "StatusCommand",
-    "TerminalSetupCommand",
+    # Command classes are lazily loaded via __getattr__
+    # "ClearCommand", "DiffCommand", "HelpCommand", "ModelCommand",
+    # "ExportCommand", "RefreshTerminalCommand", "ReleaseNotesCommand",
+    # "StatusCommand", "TerminalSetupCommand",
     "register_command",
     "CommandABC",
     "CommandResult",
@@ -40,4 +86,5 @@ __all__ = [
     "get_commands",
     "is_slash_command_name",
     "has_interactive_command",
+    "ensure_commands_loaded",
 ]

klaude_code/command/clear_cmd.py

@@ -1,8 +1,12 @@
+from typing import TYPE_CHECKING
+
 from klaude_code.command.command_abc import CommandABC, CommandResult, InputAction
 from klaude_code.command.registry import register_command
-from klaude_code.core.agent import Agent
 from klaude_code.protocol import commands
 
+if TYPE_CHECKING:
+    from klaude_code.core.agent import Agent
+
 
 @register_command
 class ClearCommand(CommandABC):
@@ -16,5 +20,5 @@ class ClearCommand(CommandABC):
     def summary(self) -> str:
         return "Clear conversation history and free up context"
 
-    async def run(self, raw: str, agent: Agent) -> CommandResult:
+    async def run(self, raw: str, agent: "Agent") -> CommandResult:
         return CommandResult(actions=[InputAction.clear()])

klaude_code/command/command_abc.py

@@ -1,12 +1,15 @@
 from abc import ABC, abstractmethod
 from enum import Enum
+from typing import TYPE_CHECKING
 
 from pydantic import BaseModel
 
-from klaude_code.core.agent import Agent
 from klaude_code.protocol import commands
 from klaude_code.protocol import events as protocol_events
 
+if TYPE_CHECKING:
+    from klaude_code.core.agent import Agent
+
 
 class InputActionType(str, Enum):
     """Supported input action kinds."""
@@ -78,7 +81,7 @@ class CommandABC(ABC):
         return False
 
     @abstractmethod
-    async def run(self, raw: str, agent: Agent) -> CommandResult:
+    async def run(self, raw: str, agent: "Agent") -> CommandResult:
         """
         Execute the command.
 

klaude_code/command/diff_cmd.py

@@ -1,11 +1,14 @@
 import subprocess
 from pathlib import Path
+from typing import TYPE_CHECKING
 
 from klaude_code.command.command_abc import CommandABC, CommandResult
 from klaude_code.command.registry import register_command
-from klaude_code.core.agent import Agent
 from klaude_code.protocol import commands, events, model
 
+if TYPE_CHECKING:
+    from klaude_code.core.agent import Agent
+
 
 @register_command
 class DiffCommand(CommandABC):
@@ -19,7 +22,7 @@ class DiffCommand(CommandABC):
     def summary(self) -> str:
         return "Show git diff"
 
-    async def run(self, raw: str, agent: Agent) -> CommandResult:
+    async def run(self, raw: str, agent: "Agent") -> CommandResult:
         try:
             # Check if current directory is in a git repository
             git_check = subprocess.run(

klaude_code/command/export_cmd.py

@@ -2,13 +2,16 @@ from __future__ import annotations
 
 import subprocess
 from pathlib import Path
+from typing import TYPE_CHECKING
 
 from klaude_code.command.command_abc import CommandABC, CommandResult
 from klaude_code.command.registry import register_command
-from klaude_code.core.agent import Agent
 from klaude_code.protocol import commands, events, model
 from klaude_code.session.export import build_export_html, get_default_export_path
 
+if TYPE_CHECKING:
+    from klaude_code.core.agent import Agent
+
 
 @register_command
 class ExportCommand(CommandABC):
@@ -30,7 +33,7 @@ class ExportCommand(CommandABC):
     def is_interactive(self) -> bool:
         return False
 
-    async def run(self, raw: str, agent: Agent) -> CommandResult:
+    async def run(self, raw: str, agent: "Agent") -> CommandResult:
         try:
             output_path = self._resolve_output_path(raw, agent)
             html_doc = self._build_html(agent)
@@ -57,7 +60,7 @@ class ExportCommand(CommandABC):
             )
             return CommandResult(events=[event])
 
-    def _resolve_output_path(self, raw: str, agent: Agent) -> Path:
+    def _resolve_output_path(self, raw: str, agent: "Agent") -> Path:
         trimmed = raw.strip()
         if trimmed:
             candidate = Path(trimmed).expanduser()
@@ -78,7 +81,7 @@ class ExportCommand(CommandABC):
             msg = f"Failed to open HTML with `open`: {exc}"
             raise RuntimeError(msg) from exc
 
-    def _build_html(self, agent: Agent) -> str:
+    def _build_html(self, agent: "Agent") -> str:
         profile = agent.profile
         system_prompt = (profile.system_prompt if profile else "") or ""
         tools = profile.tools if profile else []

klaude_code/command/help_cmd.py

@@ -1,8 +1,12 @@
+from typing import TYPE_CHECKING
+
 from klaude_code.command.command_abc import CommandABC, CommandResult
 from klaude_code.command.registry import register_command
-from klaude_code.core.agent import Agent
 from klaude_code.protocol import commands, events, model
 
+if TYPE_CHECKING:
+    from klaude_code.core.agent import Agent
+
 
 @register_command
 class HelpCommand(CommandABC):
@@ -16,7 +20,7 @@ class HelpCommand(CommandABC):
     def summary(self) -> str:
         return "Show help and available commands"
 
-    async def run(self, raw: str, agent: Agent) -> CommandResult:
+    async def run(self, raw: str, agent: "Agent") -> CommandResult:
         lines: list[str] = [
             """
 Usage:

klaude_code/command/model_cmd.py

@@ -1,11 +1,14 @@
 import asyncio
+from typing import TYPE_CHECKING
 
 from klaude_code.command.command_abc import CommandABC, CommandResult, InputAction
 from klaude_code.command.registry import register_command
 from klaude_code.config import select_model_from_config
-from klaude_code.core.agent import Agent
 from klaude_code.protocol import commands, events, model
 
+if TYPE_CHECKING:
+    from klaude_code.core.agent import Agent
+
 
 @register_command
 class ModelCommand(CommandABC):
@@ -23,7 +26,7 @@ class ModelCommand(CommandABC):
     def is_interactive(self) -> bool:
         return True
 
-    async def run(self, raw: str, agent: Agent) -> CommandResult:
+    async def run(self, raw: str, agent: "Agent") -> CommandResult:
         selected_model = await asyncio.to_thread(select_model_from_config, preferred=raw)
 
         current_model = agent.profile.llm_client.model_name if agent.profile else None

klaude_code/command/prompt-deslop.md

@@ -0,0 +1,14 @@
+---
+description: Remove AI code slop
+from: https://cursor.com/cn/link/command?name=deslop&text=%23%20Remove%20AI%20code%20slop%0A%0ACheck%20the%20diff%20against%20main%2C%20and%20remove%20all%20AI%20generated%20slop%20introduced%20in%20this%20branch.%0A%0AThis%20includes%3A%0A-%20Extra%20comments%20that%20a%20human%20wouldn%27t%20add%20or%20is%20inconsistent%20with%20the%20rest%20of%20the%20file%0A-%20Extra%20defensive%20checks%20or%20try%2Fcatch%20blocks%20that%20are%20abnormal%20for%20that%20area%20of%20the%20codebase%20(especially%20if%20called%20by%20trusted%20%2F%20validated%20codepaths)%0A-%20Casts%20to%20any%20to%20get%20around%20type%20issues%0A-%20Any%20other%20style%20that%20is%20inconsistent%20with%20the%20file%0A%0AReport%20at%20the%20end%20with%20only%20a%201-3%20sentence%20summary%20of%20what%20you%20changed
+---
+
+Check the diff against main, and remove all AI generated slop introduced in this branch.
+
+This includes:
+- Extra comments that a human wouldn't add or is inconsistent with the rest of the file
+- Extra defensive checks or try/catch blocks that are abnormal for that area of the codebase (especially if called by trusted / validated codepaths)
+- Casts to any to get around type issues
+- Any other style that is inconsistent with the file
+
+Report at the end with only a 1-3 sentence summary of what you changed

klaude_code/command/prompt_command.py

@@ -1,10 +1,14 @@
 from importlib.resources import files
+from typing import TYPE_CHECKING
 
 import yaml
 
 from klaude_code.command.command_abc import CommandABC, CommandResult, InputAction
-from klaude_code.core.agent import Agent
 from klaude_code.protocol import commands
+from klaude_code.trace import log_debug
+
+if TYPE_CHECKING:
+    from klaude_code.core.agent import Agent
 
 
 class PromptCommand(CommandABC):
@@ -41,7 +45,8 @@ class PromptCommand(CommandABC):
 
             self._metadata = {}
             self._content = raw_text
-        except Exception:
+        except (OSError, yaml.YAMLError) as e:
+            log_debug(f"Failed to load prompt template {self.template_name}: {e}")
             self._metadata = {"description": "Error loading template"}
             self._content = f"Error loading template: {self.template_name}"
 
@@ -54,7 +59,7 @@ class PromptCommand(CommandABC):
     def support_addition_params(self) -> bool:
         return True
 
-    async def run(self, raw: str, agent: Agent) -> CommandResult:
+    async def run(self, raw: str, agent: "Agent") -> CommandResult:
         self._ensure_loaded()
         template_content = self._content or ""
         user_input = raw.strip() or "<none>"

klaude_code/command/refresh_cmd.py

@@ -1,8 +1,12 @@
+from typing import TYPE_CHECKING
+
 from klaude_code.command.command_abc import CommandABC, CommandResult
 from klaude_code.command.registry import register_command
-from klaude_code.core.agent import Agent
 from klaude_code.protocol import commands, events
 
+if TYPE_CHECKING:
+    from klaude_code.core.agent import Agent
+
 
 @register_command
 class RefreshTerminalCommand(CommandABC):
@@ -20,7 +24,7 @@ class RefreshTerminalCommand(CommandABC):
     def is_interactive(self) -> bool:
         return True
 
-    async def run(self, raw: str, agent: Agent) -> CommandResult:
+    async def run(self, raw: str, agent: "Agent") -> CommandResult:
         import os
 
         os.system("cls" if os.name == "nt" else "clear")

klaude_code/command/registry.py

@@ -3,10 +3,12 @@ from typing import TYPE_CHECKING, TypeVar
 
 from klaude_code.command.command_abc import CommandResult, InputAction
 from klaude_code.command.prompt_command import PromptCommand
-from klaude_code.core.agent import Agent
 from klaude_code.protocol import commands, events, model
+from klaude_code.trace import log_debug
 
 if TYPE_CHECKING:
+    from klaude_code.core.agent import Agent
+
     from .command_abc import CommandABC
 
 _COMMANDS: dict[commands.CommandName | str, "CommandABC"] = {}
@@ -30,21 +32,30 @@ def load_prompt_commands():
             if (name.startswith("prompt_") or name.startswith("prompt-")) and name.endswith(".md"):
                 cmd = PromptCommand(name)
                 _COMMANDS[cmd.name] = cmd
-    except Exception:
-        # If resource loading fails, just ignore
-        pass
+    except OSError as e:
+        log_debug(f"Failed to load prompt commands: {e}")
+
+
+def _ensure_commands_loaded() -> None:
+    """Ensure all commands are loaded (lazy initialization)."""
+    from klaude_code.command import ensure_commands_loaded
+
+    ensure_commands_loaded()
 
 
 def get_commands() -> dict[commands.CommandName | str, "CommandABC"]:
     """Get all registered commands."""
+    _ensure_commands_loaded()
     return _COMMANDS.copy()
 
 
 def is_slash_command_name(name: str) -> bool:
+    _ensure_commands_loaded()
     return name in _COMMANDS
 
 
-async def dispatch_command(raw: str, agent: Agent) -> CommandResult:
+async def dispatch_command(raw: str, agent: "Agent") -> CommandResult:
+    _ensure_commands_loaded()
     # Detect command name
     if not raw.startswith("/"):
         return CommandResult(actions=[InputAction.run_agent(raw)])
@@ -96,6 +107,7 @@ async def dispatch_command(raw: str, agent: Agent) -> CommandResult:
 
 
 def has_interactive_command(raw: str) -> bool:
+    _ensure_commands_loaded()
     if not raw.startswith("/"):
         return False
     splits = raw.split(" ", maxsplit=1)

klaude_code/command/release_notes_cmd.py

@@ -0,0 +1,89 @@
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from klaude_code.command.command_abc import CommandABC, CommandResult
+from klaude_code.command.registry import register_command
+from klaude_code.protocol import commands, events, model
+
+if TYPE_CHECKING:
+    from klaude_code.core.agent import Agent
+
+
+def _read_changelog() -> str:
+    """Read CHANGELOG.md from project root."""
+    changelog_path = Path(__file__).parent.parent.parent.parent / "CHANGELOG.md"
+    if not changelog_path.exists():
+        return "CHANGELOG.md not found"
+    return changelog_path.read_text(encoding="utf-8")
+
+
+def _extract_releases(changelog: str, count: int = 1) -> str:
+    """Extract release sections from changelog in reverse order (oldest first).
+
+    Args:
+        changelog: The full changelog content.
+        count: Number of releases to extract (default 1).
+
+    Returns:
+        The content of the specified number of releases, with newest at bottom.
+    """
+    lines = changelog.split("\n")
+    releases: list[list[str]] = []
+    current_release: list[str] = []
+    version_count = 0
+
+    for line in lines:
+        # Skip [Unreleased] section header
+        if line.startswith("## [Unreleased]"):
+            continue
+
+        # Check for version header (e.g., ## [1.2.8] - 2025-12-01)
+        if line.startswith("## [") and "]" in line:
+            if current_release:
+                releases.append(current_release)
+            version_count += 1
+            if version_count > count:
+                break
+            current_release = [line]
+            continue
+
+        if version_count > 0:
+            current_release.append(line)
+
+    # Append the last release if exists
+    if current_release and version_count <= count:
+        releases.append(current_release)
+
+    if not releases:
+        return "No release notes found"
+
+    # Reverse to show oldest first, newest last
+    releases.reverse()
+    return "\n".join("\n".join(release) for release in releases).strip()
+
+
+@register_command
+class ReleaseNotesCommand(CommandABC):
+    """Display the latest release notes from CHANGELOG.md."""
+
+    @property
+    def name(self) -> commands.CommandName:
+        return commands.CommandName.RELEASE_NOTES
+
+    @property
+    def summary(self) -> str:
+        return "Show the latest release notes"
+
+    async def run(self, raw: str, agent: "Agent") -> CommandResult:
+        changelog = _read_changelog()
+        content = _extract_releases(changelog, count=10)
+
+        event = events.DeveloperMessageEvent(
+            session_id=agent.session.id,
+            item=model.DeveloperMessageItem(
+                content=content,
+                command_output=model.CommandOutput(command_name=self.name),
+            ),
+        )
+
+        return CommandResult(events=[event])