klaude-code 2.0.2__py3-none-any.whl → 2.1.0__py3-none-any.whl

klaude_code/cli/self_update.py

@@ -1,172 +1,14 @@
 """Self-update and version utilities for klaude-code."""
 
-from __future__ import annotations
-
-import json
 import shutil
 import subprocess
-import threading
-import time
-import urllib.request
 from importlib.metadata import PackageNotFoundError
 from importlib.metadata import version as pkg_version
-from typing import NamedTuple
 
 import typer
 
-from klaude_code.trace import log
-
-PACKAGE_NAME = "klaude-code"
-PYPI_URL = f"https://pypi.org/pypi/{PACKAGE_NAME}/json"
-CHECK_INTERVAL_SECONDS = 3600  # Check at most once per hour
-
-
-class VersionInfo(NamedTuple):
-    """Version check result."""
-
-    installed: str | None
-    latest: str | None
-    update_available: bool
-
-
-# Async check state
-_cached_version_info: VersionInfo | None = None
-_last_check_time: float = 0.0
-_check_lock = threading.Lock()
-_check_in_progress = False
-
-
-def _has_uv() -> bool:
-    """Check if uv command is available."""
-    return shutil.which("uv") is not None
-
-
-def _get_installed_version() -> str | None:
-    """Get installed version of klaude-code via uv tool list."""
-    try:
-        result = subprocess.run(
-            ["uv", "tool", "list"],
-            capture_output=True,
-            text=True,
-            timeout=5,
-        )
-        if result.returncode != 0:
-            return None
-        # Parse output like "klaude-code v0.1.0"
-        for line in result.stdout.splitlines():
-            if line.startswith(PACKAGE_NAME):
-                parts = line.split()
-                if len(parts) >= 2:
-                    ver = parts[1]
-                    # Remove 'v' prefix if present
-                    if ver.startswith("v"):
-                        ver = ver[1:]
-                    return ver
-        return None
-    except (OSError, subprocess.SubprocessError):
-        return None
-
-
-def _get_latest_version() -> str | None:
-    """Get latest version from PyPI."""
-    try:
-        with urllib.request.urlopen(PYPI_URL, timeout=5) as response:
-            data = json.loads(response.read().decode())
-            return data.get("info", {}).get("version")
-    except (OSError, json.JSONDecodeError, ValueError):
-        return None
-
-
-def _parse_version(v: str) -> tuple[int, ...]:
-    """Parse version string into comparable tuple of integers."""
-    parts: list[int] = []
-    for part in v.split("."):
-        # Extract leading digits
-        digits = ""
-        for c in part:
-            if c.isdigit():
-                digits += c
-            else:
-                break
-        if digits:
-            parts.append(int(digits))
-    return tuple(parts)
-
-
-def _compare_versions(installed: str, latest: str) -> bool:
-    """Return True if latest is newer than installed."""
-    try:
-        installed_tuple = _parse_version(installed)
-        latest_tuple = _parse_version(latest)
-        return latest_tuple > installed_tuple
-    except ValueError:
-        return False
-
-
-def _do_version_check() -> None:
-    """Perform version check in background thread."""
-    global _cached_version_info, _last_check_time, _check_in_progress
-
-    try:
-        installed = _get_installed_version()
-        latest = _get_latest_version()
-
-        update_available = False
-        if installed and latest:
-            update_available = _compare_versions(installed, latest)
-
-        with _check_lock:
-            _cached_version_info = VersionInfo(
-                installed=installed,
-                latest=latest,
-                update_available=update_available,
-            )
-            _last_check_time = time.time()
-    finally:
-        with _check_lock:
-            _check_in_progress = False
-
-
-def check_for_updates() -> VersionInfo | None:
-    """Check for updates to klaude-code asynchronously.
-
-    Returns cached VersionInfo immediately if available.
-    Triggers background check if cache is stale or missing.
-    Returns None if uv is not available or no cached result yet.
-    """
-    global _check_in_progress
-
-    if not _has_uv():
-        return None
-
-    now = time.time()
-
-    with _check_lock:
-        cache_valid = _cached_version_info is not None and (now - _last_check_time) < CHECK_INTERVAL_SECONDS
-
-        if cache_valid:
-            return _cached_version_info
-
-        # Start background check if not already in progress
-        if not _check_in_progress:
-            _check_in_progress = True
-            thread = threading.Thread(target=_do_version_check, daemon=True)
-            thread.start()
-
-        # Return cached result (may be stale) or None if no cache yet
-        return _cached_version_info
-
-
-def get_update_message() -> str | None:
-    """Get update message if an update is available.
-
-    Returns immediately with cached result. Triggers async check if needed.
-    Returns None if no update, uv unavailable, or check not complete yet.
-    """
-    info = check_for_updates()
-    if info is None or not info.update_available:
-        return None
-    return f"New version available: {info.latest}. Please run `klaude upgrade` to upgrade."
+from klaude_code.log import log
+from klaude_code.update import PACKAGE_NAME, check_for_updates_blocking
 
 
 def _print_version() -> None:
@@ -243,30 +85,3 @@ def register_self_update_commands(app: typer.Typer) -> None:
     app.command("update")(update_command)
     app.command("upgrade", help="Alias for `klaude update`.")(update_command)
     app.command("version", help="Alias for `klaude --version`.")(version_command)
-
-
-def check_for_updates_blocking() -> VersionInfo | None:
-    """Check for updates to klaude-code synchronously.
-
-    This is intended for CLI commands (e.g. `klaude update --check`) that need
-    a deterministic result instead of the async cached behavior.
-
-    Returns:
-        VersionInfo if uv is available, otherwise None.
-    """
-
-    if not _has_uv():
-        return None
-
-    installed = _get_installed_version()
-    latest = _get_latest_version()
-
-    update_available = False
-    if installed and latest:
-        update_available = _compare_versions(installed, latest)
-
-    return VersionInfo(
-        installed=installed,
-        latest=latest,
-        update_available=update_available,
-    )

klaude_code/cli/session_cmd.py

@@ -2,8 +2,8 @@ import time
 
 import typer
 
+from klaude_code.log import log
 from klaude_code.session import Session
-from klaude_code.trace import log
 
 
 def _session_confirm(sessions: list[Session.SessionMetaBrief], message: str) -> bool:
@@ -11,7 +11,7 @@ def _session_confirm(sessions: list[Session.SessionMetaBrief], message: str) ->
 
     from prompt_toolkit.styles import Style
 
-    from klaude_code.ui.terminal.selector import SelectItem, select_one
+    from klaude_code.tui.terminal.selector import SelectItem, select_one
 
     def _fmt(ts: float) -> str:
         try:

klaude_code/config/config.py

@@ -13,9 +13,9 @@ from klaude_code.config.builtin_config import (
     get_builtin_provider_configs,
     get_builtin_sub_agent_models,
 )
+from klaude_code.log import log
 from klaude_code.protocol import llm_param
 from klaude_code.protocol.sub_agent import iter_sub_agent_profiles
-from klaude_code.trace import log
 
 # Pattern to match ${ENV_VAR} syntax
 _ENV_VAR_PATTERN = re.compile(r"^\$\{([A-Za-z_][A-Za-z0-9_]*)\}$")

klaude_code/config/select_model.py

@@ -1,7 +1,7 @@
 from dataclasses import dataclass
 
 from klaude_code.config.config import ModelEntry, load_config, print_no_available_models_hint
-from klaude_code.trace import log
+from klaude_code.log import log
 
 
 def _normalize_model_key(value: str) -> str:

klaude_code/const.py

@@ -153,7 +153,15 @@ MARKDOWN_RIGHT_MARGIN = 2  # Right margin (columns) for markdown rendering
 # =============================================================================
 
 STATUS_HINT_TEXT = " (esc to interrupt)"  # Status hint text shown after spinner
-STATUS_DEFAULT_TEXT = "Thinking …"  # Default spinner status text
+
+# Spinner status texts
+STATUS_WAITING_TEXT = "Awaiting …"
+STATUS_THINKING_TEXT = "Reasoning …"
+STATUS_COMPOSING_TEXT = "Generating"
+
+# Backwards-compatible alias for the default spinner status text.
+STATUS_DEFAULT_TEXT = STATUS_WAITING_TEXT
+SIGINT_DOUBLE_PRESS_EXIT_TEXT = "Press ctrl+c again to exit"  # Toast shown on first Ctrl+C during task waits
 SPINNER_BREATH_PERIOD_SECONDS: float = 2.0  # Spinner breathing animation period (seconds)
 STATUS_SHIMMER_PADDING = 10  # Horizontal padding for shimmer band position
 STATUS_SHIMMER_BAND_HALF_WIDTH = 5.0  # Half-width of shimmer band in characters

klaude_code/core/agent.py

@@ -1,72 +1,16 @@
 from __future__ import annotations
 
 from collections.abc import AsyncGenerator, Iterable
-from dataclasses import dataclass
-from typing import Protocol
 
-from klaude_code.core.prompt import load_system_prompt
-from klaude_code.core.reminders import Reminder, load_agent_reminders
+from klaude_code.core.agent_profile import AgentProfile, Reminder
 from klaude_code.core.task import SessionContext, TaskExecutionContext, TaskExecutor
-from klaude_code.core.tool import build_todo_context, get_registry, load_agent_tools
+from klaude_code.core.tool import build_todo_context, get_registry
+from klaude_code.core.tool.context import RunSubtask
 from klaude_code.llm import LLMClientABC
-from klaude_code.protocol import events, llm_param, tools
+from klaude_code.log import DebugType, log_debug
+from klaude_code.protocol import events
 from klaude_code.protocol.message import UserInputPayload
 from klaude_code.session import Session
-from klaude_code.trace import DebugType, log_debug
-
-
-@dataclass(frozen=True)
-class AgentProfile:
-    """Encapsulates the active LLM client plus prompts/tools/reminders."""
-
-    llm_client: LLMClientABC
-    system_prompt: str | None
-    tools: list[llm_param.ToolSchema]
-    reminders: list[Reminder]
-
-
-class ModelProfileProvider(Protocol):
-    """Strategy interface for constructing agent profiles."""
-
-    def build_profile(
-        self,
-        llm_client: LLMClientABC,
-        sub_agent_type: tools.SubAgentType | None = None,
-    ) -> AgentProfile: ...
-
-
-class DefaultModelProfileProvider(ModelProfileProvider):
-    """Default provider backed by global prompts/tool/reminder registries."""
-
-    def build_profile(
-        self,
-        llm_client: LLMClientABC,
-        sub_agent_type: tools.SubAgentType | None = None,
-    ) -> AgentProfile:
-        model_name = llm_client.model_name
-        return AgentProfile(
-            llm_client=llm_client,
-            system_prompt=load_system_prompt(model_name, llm_client.protocol, sub_agent_type),
-            tools=load_agent_tools(model_name, sub_agent_type),
-            reminders=load_agent_reminders(model_name, sub_agent_type),
-        )
-
-
-class VanillaModelProfileProvider(ModelProfileProvider):
-    """Provider that strips prompts, reminders, and tools for vanilla mode."""
-
-    def build_profile(
-        self,
-        llm_client: LLMClientABC,
-        sub_agent_type: tools.SubAgentType | None = None,
-    ) -> AgentProfile:
-        model_name = llm_client.model_name
-        return AgentProfile(
-            llm_client=llm_client,
-            system_prompt=None,
-            tools=load_agent_tools(model_name, vanilla=True),
-            reminders=load_agent_reminders(model_name, vanilla=True),
-        )
 
 
 class Agent:
@@ -94,13 +38,16 @@ class Agent:
             debug_type=DebugType.EXECUTION,
         )
 
-    async def run_task(self, user_input: UserInputPayload) -> AsyncGenerator[events.Event]:
+    async def run_task(
+        self, user_input: UserInputPayload, *, run_subtask: RunSubtask | None = None
+    ) -> AsyncGenerator[events.Event]:
         session_ctx = SessionContext(
             session_id=self.session.id,
             get_conversation_history=lambda: self.session.conversation_history,
             append_history=self.session.append_history,
             file_tracker=self.session.file_tracker,
             todo_context=build_todo_context(self.session),
+            run_subtask=run_subtask,
         )
         context = TaskExecutionContext(
             session_ctx=session_ctx,

klaude_code/core/agent_profile.py

@@ -0,0 +1,284 @@
+from __future__ import annotations
+
+import datetime
+import shutil
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass
+from functools import cache
+from importlib.resources import files
+from pathlib import Path
+from typing import Any, Protocol
+
+from klaude_code.core.reminders import (
+    at_file_reader_reminder,
+    empty_todo_reminder,
+    file_changed_externally_reminder,
+    image_reminder,
+    last_path_memory_reminder,
+    memory_reminder,
+    skill_reminder,
+    todo_not_used_recently_reminder,
+)
+from klaude_code.core.tool.report_back_tool import ReportBackTool
+from klaude_code.core.tool.tool_registry import get_tool_schemas
+from klaude_code.llm import LLMClientABC
+from klaude_code.protocol import llm_param, message, tools
+from klaude_code.protocol.sub_agent import get_sub_agent_profile, sub_agent_tool_names
+from klaude_code.session import Session
+
+type Reminder = Callable[[Session], Awaitable[message.DeveloperMessage | None]]
+
+
+@dataclass(frozen=True)
+class AgentProfile:
+    """Encapsulates the active LLM client plus prompts/tools/reminders."""
+
+    llm_client: LLMClientABC
+    system_prompt: str | None
+    tools: list[llm_param.ToolSchema]
+    reminders: list[Reminder]
+
+
+COMMAND_DESCRIPTIONS: dict[str, str] = {
+    "rg": "ripgrep - fast text search",
+    "fd": "simple and fast alternative to find",
+    "tree": "directory listing as a tree",
+    "sg": "ast-grep - AST-aware code search",
+    "jj": "jujutsu - Git-compatible version control system",
+}
+
+
+# Mapping from logical prompt keys to resource file paths under the core/prompt directory.
+PROMPT_FILES: dict[str, str] = {
+    "main_codex": "prompts/prompt-codex.md",
+    "main_gpt_5_1_codex_max": "prompts/prompt-codex-gpt-5-1-codex-max.md",
+    "main_gpt_5_2_codex": "prompts/prompt-codex-gpt-5-2-codex.md",
+    "main": "prompts/prompt-claude-code.md",
+    "main_gemini": "prompts/prompt-gemini.md",  # https://ai.google.dev/gemini-api/docs/prompting-strategies?hl=zh-cn#agentic-si-template
+}
+
+
+STRUCTURED_OUTPUT_PROMPT = """\
+
+# Structured Output
+You have a `report_back` tool available. When you complete the task,\
+you MUST call `report_back` with the structured result matching the required schema.\
+Only the content passed to `report_back` will be returned to user.\
+"""
+
+
+@cache
+def _load_prompt_by_path(prompt_path: str) -> str:
+    """Load and cache prompt content from a file path relative to core package."""
+
+    return files(__package__).joinpath(prompt_path).read_text(encoding="utf-8").strip()
+
+
+def _load_base_prompt(file_key: str) -> str:
+    """Load and cache the base prompt content from file."""
+
+    try:
+        prompt_path = PROMPT_FILES[file_key]
+    except KeyError as exc:
+        raise ValueError(f"Unknown prompt key: {file_key}") from exc
+
+    return _load_prompt_by_path(prompt_path)
+
+
+def _get_file_key(model_name: str, protocol: llm_param.LLMClientProtocol) -> str:
+    """Determine which prompt file to use based on model."""
+
+    match model_name:
+        case name if "gpt-5.2-codex" in name:
+            return "main_gpt_5_2_codex"
+        case name if "gpt-5.1-codex-max" in name:
+            return "main_gpt_5_1_codex_max"
+        case name if "gpt-5" in name:
+            return "main_codex"
+        case name if "gemini" in name:
+            return "main_gemini"
+        case _:
+            return "main"
+
+
+def _build_env_info(model_name: str) -> str:
+    """Build environment info section with dynamic runtime values."""
+
+    cwd = Path.cwd()
+    today = datetime.datetime.now().strftime("%Y-%m-%d")
+    is_git_repo = (cwd / ".git").exists()
+    is_empty_dir = not any(cwd.iterdir())
+
+    available_tools: list[str] = []
+    for command, desc in COMMAND_DESCRIPTIONS.items():
+        if shutil.which(command) is not None:
+            available_tools.append(f"{command}: {desc}")
+
+    cwd_display = f"{cwd} (empty)" if is_empty_dir else str(cwd)
+    env_lines: list[str] = [
+        "",
+        "",
+        "Here is useful information about the environment you are running in:",
+        "<env>",
+        f"Working directory: {cwd_display}",
+        f"Today's Date: {today}",
+        f"Is directory a git repo: {is_git_repo}",
+        f"You are powered by the model: {model_name}",
+    ]
+
+    if available_tools:
+        env_lines.append("Prefer to use the following CLI utilities:")
+        for tool in available_tools:
+            env_lines.append(f"- {tool}")
+
+    env_lines.append("</env>")
+    return "\n".join(env_lines)
+
+
+def load_system_prompt(
+    model_name: str,
+    protocol: llm_param.LLMClientProtocol,
+    sub_agent_type: str | None = None,
+) -> str:
+    """Get system prompt content for the given model and sub-agent type."""
+
+    if sub_agent_type is not None:
+        profile = get_sub_agent_profile(sub_agent_type)
+        base_prompt = _load_prompt_by_path(profile.prompt_file)
+    else:
+        file_key = _get_file_key(model_name, protocol)
+        base_prompt = _load_base_prompt(file_key)
+
+    if protocol == llm_param.LLMClientProtocol.CODEX_OAUTH:
+        # Do not append environment info for Codex protocol
+        return base_prompt
+
+    return base_prompt + _build_env_info(model_name)
+
+
+def load_agent_tools(
+    model_name: str,
+    sub_agent_type: tools.SubAgentType | None = None,
+) -> list[llm_param.ToolSchema]:
+    """Get tools for an agent based on model and agent type.
+
+    Args:
+        model_name: The model name.
+        sub_agent_type: If None, returns main agent tools. Otherwise returns sub-agent tools.
+    """
+
+    if sub_agent_type is not None:
+        profile = get_sub_agent_profile(sub_agent_type)
+        return get_tool_schemas(list(profile.tool_set))
+
+    # Main agent tools
+    if "gpt-5" in model_name:
+        tool_names = [tools.BASH, tools.READ, tools.APPLY_PATCH, tools.UPDATE_PLAN]
+    elif "gemini-3" in model_name:
+        tool_names = [tools.BASH, tools.READ, tools.EDIT, tools.WRITE]
+    else:
+        tool_names = [tools.BASH, tools.READ, tools.EDIT, tools.WRITE, tools.TODO_WRITE]
+
+    tool_names.extend(sub_agent_tool_names(enabled_only=True, model_name=model_name))
+    tool_names.extend([tools.SKILL, tools.MERMAID])
+    # tool_names.extend([tools.MEMORY])
+    return get_tool_schemas(tool_names)
+
+
+def load_agent_reminders(
+    model_name: str,
+    sub_agent_type: str | None = None,
+) -> list[Reminder]:
+    """Get reminders for an agent based on model and agent type.
+
+    Args:
+        model_name: The model name.
+        sub_agent_type: If None, returns main agent reminders. Otherwise returns sub-agent reminders.
+    """
+
+    reminders: list[Reminder] = []
+
+    # Only main agent (not sub-agent) gets todo reminders, and not for GPT-5
+    if sub_agent_type is None and ("gpt-5" not in model_name and "gemini" not in model_name):
+        reminders.append(empty_todo_reminder)
+        reminders.append(todo_not_used_recently_reminder)
+
+    reminders.extend(
+        [
+            memory_reminder,
+            at_file_reader_reminder,
+            last_path_memory_reminder,
+            file_changed_externally_reminder,
+            image_reminder,
+            skill_reminder,
+        ]
+    )
+
+    return reminders
+
+
+def with_structured_output(profile: AgentProfile, output_schema: dict[str, Any]) -> AgentProfile:
+    report_back_tool_class = ReportBackTool.for_schema(output_schema)
+    base_prompt = profile.system_prompt or ""
+    return AgentProfile(
+        llm_client=profile.llm_client,
+        system_prompt=base_prompt + STRUCTURED_OUTPUT_PROMPT,
+        tools=[*profile.tools, report_back_tool_class.schema()],
+        reminders=profile.reminders,
+    )
+
+
+class ModelProfileProvider(Protocol):
+    """Strategy interface for constructing agent profiles."""
+
+    def build_profile(
+        self,
+        llm_client: LLMClientABC,
+        sub_agent_type: tools.SubAgentType | None = None,
+        *,
+        output_schema: dict[str, Any] | None = None,
+    ) -> AgentProfile: ...
+
+
+class DefaultModelProfileProvider(ModelProfileProvider):
+    """Default provider backed by global prompts/tool/reminder registries."""
+
+    def build_profile(
+        self,
+        llm_client: LLMClientABC,
+        sub_agent_type: tools.SubAgentType | None = None,
+        *,
+        output_schema: dict[str, Any] | None = None,
+    ) -> AgentProfile:
+        model_name = llm_client.model_name
+        profile = AgentProfile(
+            llm_client=llm_client,
+            system_prompt=load_system_prompt(model_name, llm_client.protocol, sub_agent_type),
+            tools=load_agent_tools(model_name, sub_agent_type),
+            reminders=load_agent_reminders(model_name, sub_agent_type),
+        )
+        if output_schema:
+            return with_structured_output(profile, output_schema)
+        return profile
+
+
+class VanillaModelProfileProvider(ModelProfileProvider):
+    """Provider that strips prompts, reminders, and tools for vanilla mode."""
+
+    def build_profile(
+        self,
+        llm_client: LLMClientABC,
+        sub_agent_type: tools.SubAgentType | None = None,
+        *,
+        output_schema: dict[str, Any] | None = None,
+    ) -> AgentProfile:
+        del sub_agent_type
+        profile = AgentProfile(
+            llm_client=llm_client,
+            system_prompt=None,
+            tools=get_tool_schemas([tools.BASH, tools.EDIT, tools.WRITE, tools.READ]),
+            reminders=[],
+        )
+        if output_schema:
+            return with_structured_output(profile, output_schema)
+        return profile