klaude-code 2.0.1__tar.gz → 2.1.0__tar.gz

{klaude_code-2.0.1 → klaude_code-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: klaude-code
-Version: 2.0.1
+Version: 2.1.0
 Summary: Minimal code agent CLI
 Requires-Dist: anthropic>=0.66.0
 Requires-Dist: chardet>=5.2.0

{klaude_code-2.0.1 → klaude_code-2.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "klaude-code"
-version = "2.0.1"
+version = "2.1.0"
 description = "Minimal code agent CLI"
 readme = "README.md"
 requires-python = ">=3.13"
@@ -83,7 +83,8 @@ name = "Layered architecture"
 type = "layers"
 layers = [
     "klaude_code.cli",
-    "klaude_code.command",
+    "klaude_code.tui",
+    "klaude_code.app",
     "klaude_code.ui",
     "klaude_code.core",
     "klaude_code.skill",
@@ -91,7 +92,7 @@ layers = [
     "klaude_code.config",
     "klaude_code.llm",
     "klaude_code.protocol",
-    "klaude_code.trace",
     "klaude_code.auth",
+    "klaude_code.log",
     "klaude_code.const",
 ]

klaude_code-2.1.0/src/klaude_code/app/__init__.py

@@ -0,0 +1,12 @@
+"""Application-layer runtime helpers.
+
+This package coordinates core execution (Executor) with frontend displays.
+Terminal-specific rendering and input handling live in `klaude_code.tui`.
+"""
+
+from .runtime import AppInitConfig, run_exec
+
+__all__ = [
+    "AppInitConfig",
+    "run_exec",
+]

klaude_code-2.1.0/src/klaude_code/app/runtime.py

@@ -0,0 +1,215 @@
+import asyncio
+import contextlib
+import sys
+from collections.abc import Callable
+from dataclasses import dataclass
+
+import typer
+
+from klaude_code import ui
+from klaude_code.config import Config, load_config
+from klaude_code.core.agent import Agent
+from klaude_code.core.agent_profile import DefaultModelProfileProvider, VanillaModelProfileProvider
+from klaude_code.core.executor import Executor
+from klaude_code.core.manager import build_llm_clients
+from klaude_code.log import DebugType, log, set_debug_logging
+from klaude_code.protocol import events, op
+from klaude_code.protocol.message import UserInputPayload
+from klaude_code.session.session import Session, close_default_store
+
+
+@dataclass
+class AppInitConfig:
+    """Configuration for initializing the application runtime."""
+
+    model: str | None
+    debug: bool
+    vanilla: bool
+    debug_filters: set[DebugType] | None = None
+    stream_json: bool = False
+
+
+@dataclass
+class AppComponents:
+    """Initialized runtime components."""
+
+    config: Config
+    executor: Executor
+    executor_task: asyncio.Task[None]
+    event_queue: asyncio.Queue[events.Event]
+    display: ui.DisplayABC
+    display_task: asyncio.Task[None]
+
+
+async def initialize_app_components(
+    *,
+    init_config: AppInitConfig,
+    display: ui.DisplayABC,
+    on_model_change: Callable[[str], None] | None = None,
+) -> AppComponents:
+    """Initialize LLM clients, executor, and display task."""
+    set_debug_logging(init_config.debug, filters=init_config.debug_filters)
+
+    config = load_config()
+
+    try:
+        llm_clients = build_llm_clients(
+            config,
+            model_override=init_config.model,
+        )
+    except ValueError as exc:
+        if init_config.model:
+            log(
+                (
+                    f"Error: model '{init_config.model}' is not defined in the config",
+                    "red",
+                )
+            )
+            log(("Hint: run `klaude list` to view available models", "yellow"))
+        else:
+            log((f"Error: failed to load the default model configuration: {exc}", "red"))
+        raise typer.Exit(2) from None
+
+    model_profile_provider = VanillaModelProfileProvider() if init_config.vanilla else DefaultModelProfileProvider()
+
+    event_queue: asyncio.Queue[events.Event] = asyncio.Queue()
+
+    executor = Executor(
+        event_queue,
+        llm_clients,
+        model_profile_provider=model_profile_provider,
+        on_model_change=on_model_change,
+    )
+
+    if on_model_change is not None:
+        on_model_change(llm_clients.main.model_name)
+
+    executor_task = asyncio.create_task(executor.start())
+
+    def _drain_background_task_exception(task: asyncio.Task[None], *, label: str) -> None:
+        def _on_done(t: asyncio.Task[None]) -> None:
+            with contextlib.suppress(asyncio.CancelledError):
+                exc = t.exception()
+                if exc is None:
+                    return
+                if isinstance(exc, KeyboardInterrupt):
+                    return
+                log((f"Background task '{label}' failed: {exc}", "red"))
+
+        task.add_done_callback(_on_done)
+
+    _drain_background_task_exception(executor_task, label="executor")
+
+    display_task = asyncio.create_task(display.consume_event_loop(event_queue))
+    _drain_background_task_exception(display_task, label="display")
+
+    return AppComponents(
+        config=config,
+        executor=executor,
+        executor_task=executor_task,
+        event_queue=event_queue,
+        display=display,
+        display_task=display_task,
+    )
+
+
+async def initialize_session(
+    executor: Executor,
+    event_queue: asyncio.Queue[events.Event],
+    session_id: str | None = None,
+) -> str | None:
+    """Initialize a session and return the active session id."""
+    await executor.submit_and_wait(op.InitAgentOperation(session_id=session_id))
+    await event_queue.join()
+
+    active_session_id = executor.context.current_session_id()
+    return active_session_id or session_id
+
+
+def backfill_session_model_config(
+    agent: Agent | None,
+    model_override: str | None,
+    default_model: str | None,
+    *,
+    is_new_session: bool,
+) -> None:
+    """Backfill model_config_name and model_thinking on newly created sessions."""
+    if agent is None or agent.session.model_config_name is not None:
+        return
+
+    if model_override is not None:
+        agent.session.model_config_name = model_override
+    elif is_new_session and default_model is not None:
+        agent.session.model_config_name = default_model
+    else:
+        return
+
+    if agent.session.model_thinking is None and agent.profile:
+        agent.session.model_thinking = agent.profile.llm_client.get_llm_config().thinking
+
+
+async def cleanup_app_components(components: AppComponents) -> None:
+    """Clean up all runtime components."""
+    try:
+        await components.executor.stop()
+        components.executor_task.cancel()
+        with contextlib.suppress(asyncio.CancelledError):
+            await components.executor_task
+        with contextlib.suppress(Exception):
+            await close_default_store()
+
+        await components.event_queue.put(events.EndEvent())
+        await components.display_task
+    finally:
+        # Ensure the terminal cursor is visible even if Rich's spinner did not stop cleanly.
+        with contextlib.suppress(Exception):
+            stream = getattr(sys, "__stdout__", None) or sys.stdout
+            stream.write("\033[?25h")
+            stream.flush()
+
+
+async def handle_keyboard_interrupt(executor: Executor) -> None:
+    """Handle Ctrl+C by logging and sending a global interrupt."""
+    log("Bye!")
+    session_id = executor.context.current_session_id()
+    if session_id and Session.exists(session_id):
+        log(("Resume with:", "dim"), (f"klaude --resume-by-id {session_id}", "green"))
+    with contextlib.suppress(Exception):
+        await executor.submit(op.InterruptOperation(target_session_id=None))
+
+
+async def run_exec(init_config: AppInitConfig, input_content: str) -> None:
+    """Run a single task non-interactively (exec mode)."""
+    from klaude_code.ui.terminal.title import update_terminal_title
+
+    display = ui.create_exec_display(debug=init_config.debug, stream_json=init_config.stream_json)
+    components = await initialize_app_components(
+        init_config=init_config,
+        display=display,
+        on_model_change=update_terminal_title,
+    )
+
+    try:
+        session_id = await initialize_session(components.executor, components.event_queue)
+        backfill_session_model_config(
+            components.executor.context.current_agent,
+            init_config.model,
+            components.config.main_model,
+            is_new_session=True,
+        )
+
+        if session_id is None:
+            raise RuntimeError("No active session")
+
+        op_id = await components.executor.submit(
+            op.RunAgentOperation(
+                session_id=session_id,
+                input=UserInputPayload(text=input_content),
+            )
+        )
+        await components.executor.wait_for(op_id)
+        await components.event_queue.join()
+    except KeyboardInterrupt:
+        await handle_keyboard_interrupt(components.executor)
+    finally:
+        await cleanup_app_components(components)

{klaude_code-2.0.1 → klaude_code-2.1.0}/src/klaude_code/cli/auth_cmd.py

@@ -6,8 +6,8 @@ import webbrowser
 import typer
 from prompt_toolkit.styles import Style
 
-from klaude_code.trace import log
-from klaude_code.ui.terminal.selector import SelectItem, select_one
+from klaude_code.log import log
+from klaude_code.tui.terminal.selector import SelectItem, select_one
 
 _SELECT_STYLE = Style(
     [

{klaude_code-2.0.1 → klaude_code-2.1.0}/src/klaude_code/cli/config_cmd.py

@@ -7,7 +7,7 @@ import sys
 import typer
 
 from klaude_code.config import config_path, create_example_config, example_config_path, load_config
-from klaude_code.trace import log
+from klaude_code.log import log
 
 
 def list_models(
@@ -15,7 +15,7 @@ def list_models(
 ) -> None:
     """List all models and providers configuration"""
     from klaude_code.cli.list_model import display_models_and_providers
-    from klaude_code.ui.terminal.color import is_light_terminal_background
+    from klaude_code.tui.terminal.color import is_light_terminal_background
 
     config = load_config()
 

{klaude_code-2.0.1 → klaude_code-2.1.0}/src/klaude_code/cli/cost_cmd.py

@@ -10,9 +10,9 @@ from rich.box import Box
 from rich.console import Console
 from rich.table import Table
 
-from klaude_code.command.status_cmd import format_cost, format_tokens
 from klaude_code.protocol import model
 from klaude_code.session.codec import decode_jsonl_line
+from klaude_code.tui.command.status_cmd import format_cost, format_tokens
 
 ASCII_HORIZONAL = Box(" -- \n    \n -- \n    \n -- \n -- \n    \n -- \n")
 

klaude_code-2.1.0/src/klaude_code/cli/debug.py

@@ -0,0 +1,54 @@
+"""Debug utilities for CLI."""
+
+from pathlib import Path
+
+import typer
+
+from klaude_code.log import DebugType, log, prepare_debug_log_file
+
+DEBUG_FILTER_HELP = "Comma-separated debug types: " + ", ".join(dt.value for dt in DebugType)
+
+
+def parse_debug_filters(raw: str | None) -> set[DebugType] | None:
+    """Parse comma-separated debug filter string into a set of DebugType."""
+    if raw is None:
+        return None
+    filters: set[DebugType] = set()
+    for chunk in raw.split(","):
+        normalized = chunk.strip().lower().replace("-", "_")
+        if not normalized:
+            continue
+        try:
+            filters.add(DebugType(normalized))
+        except ValueError:  # pragma: no cover - user input validation
+            valid_options = ", ".join(dt.value for dt in DebugType)
+            log(
+                (
+                    f"Invalid debug filter '{normalized}'. Valid options: {valid_options}",
+                    "red",
+                )
+            )
+            raise typer.Exit(2) from None
+    return filters or None
+
+
+def resolve_debug_settings(flag: bool, raw_filters: str | None) -> tuple[bool, set[DebugType] | None]:
+    """Resolve debug flag and filters into effective settings."""
+    filters = parse_debug_filters(raw_filters)
+    effective_flag = flag or (filters is not None)
+    return effective_flag, filters
+
+
+def prepare_debug_logging(debug: bool, debug_filter: str | None) -> tuple[bool, set[DebugType] | None, Path | None]:
+    """Resolve debug settings and prepare log file if enabled.
+
+    Returns:
+        A tuple of (debug_enabled, debug_filters, log_path).
+        log_path is None if debugging is disabled.
+    """
+
+    debug_enabled, debug_filters = resolve_debug_settings(debug, debug_filter)
+    log_path: Path | None = None
+    if debug_enabled:
+        log_path = prepare_debug_log_file()
+    return debug_enabled, debug_filters, log_path

{klaude_code-2.0.1 → klaude_code-2.1.0}/src/klaude_code/cli/list_model.py

@@ -9,9 +9,9 @@ from klaude_code.config import Config
 from klaude_code.config.config import ModelConfig, ProviderConfig, parse_env_var_syntax
 from klaude_code.protocol.llm_param import LLMClientProtocol
 from klaude_code.protocol.sub_agent import iter_sub_agent_profiles
-from klaude_code.ui.rich.quote import Quote
-from klaude_code.ui.rich.theme import ThemeKey, get_theme
-from klaude_code.ui.utils.common import format_model_params
+from klaude_code.tui.components.rich.quote import Quote
+from klaude_code.tui.components.rich.theme import ThemeKey, get_theme
+from klaude_code.ui.common import format_model_params
 
 
 def _get_codex_status_rows() -> list[tuple[Text, Text]]:

{klaude_code-2.0.1 → klaude_code-2.1.0}/src/klaude_code/cli/main.py

@@ -1,62 +1,17 @@
 import asyncio
-import contextlib
-import os
 import sys
-from pathlib import Path
 
 import typer
 
 from klaude_code.cli.auth_cmd import register_auth_commands
 from klaude_code.cli.config_cmd import register_config_commands
 from klaude_code.cli.cost_cmd import register_cost_commands
-from klaude_code.cli.debug import DEBUG_FILTER_HELP, open_log_file_in_editor, resolve_debug_settings
+from klaude_code.cli.debug import DEBUG_FILTER_HELP, prepare_debug_logging
 from klaude_code.cli.self_update import register_self_update_commands, version_option_callback
 from klaude_code.cli.session_cmd import register_session_commands
-from klaude_code.command.resume_cmd import select_session_sync
 from klaude_code.session import Session
-from klaude_code.trace import DebugType, prepare_debug_log_file
-
-
-def set_terminal_title(title: str) -> None:
-    """Set terminal window title using ANSI escape sequence."""
-    # Never write terminal control sequences when stdout is not a TTY (pipes/CI/redirects).
-    # This avoids corrupting machine-readable output (e.g., JSON streaming) and log captures.
-    #
-    # Use the original stdout to bypass prompt_toolkit's `patch_stdout()`. Writing OSC
-    # sequences to the patched stdout can cause them to appear as visible text.
-    stream = getattr(sys, "__stdout__", None) or sys.stdout
-    try:
-        if not stream.isatty():
-            return
-    except Exception:
-        return
-
-    stream.write(f"\033]0;{title}\007")
-    with contextlib.suppress(Exception):
-        stream.flush()
-
-
-def update_terminal_title(model_name: str | None = None) -> None:
-    """Update terminal title with folder name and optional model name."""
-    folder_name = os.path.basename(os.getcwd())
-    if model_name:
-        set_terminal_title(f"{folder_name}: klaude ✳ {model_name}")
-    else:
-        set_terminal_title(f"{folder_name}: klaude")
-
-
-def prepare_debug_logging(debug: bool, debug_filter: str | None) -> tuple[bool, set[DebugType] | None, Path | None]:
-    """Resolve debug settings and prepare log file if debugging is enabled.
-
-    Returns:
-        A tuple of (debug_enabled, debug_filters, log_path).
-        log_path is None if debugging is disabled.
-    """
-    debug_enabled, debug_filters = resolve_debug_settings(debug, debug_filter)
-    log_path: Path | None = None
-    if debug_enabled:
-        log_path = prepare_debug_log_file()
-    return debug_enabled, debug_filters, log_path
+from klaude_code.tui.command.resume_cmd import select_session_sync
+from klaude_code.ui.terminal.title import update_terminal_title
 
 
 def read_input_content(cli_argument: str) -> str | None:
@@ -68,7 +23,7 @@ def read_input_content(cli_argument: str) -> str | None:
     Returns:
         The merged input content, or None if no input was provided.
     """
-    from klaude_code.trace import log
+    from klaude_code.log import log
 
     parts: list[str] = []
 
@@ -169,9 +124,9 @@ def exec_command(
     if merged_input is None:
         raise typer.Exit(1)
 
-    from klaude_code.cli.runtime import AppInitConfig, run_exec
-    from klaude_code.command.model_select import select_model_interactive
+    from klaude_code.app.runtime import AppInitConfig, run_exec
     from klaude_code.config import load_config
+    from klaude_code.tui.command.model_select import select_model_interactive
 
     chosen_model = model
     if model or select_model:
@@ -188,7 +143,7 @@ def exec_command(
             # Save the selection as default
             config.main_model = chosen_model
             from klaude_code.config.config import config_path
-            from klaude_code.trace import log
+            from klaude_code.log import log
 
             asyncio.run(config.save())
             log(f"Saved main_model={chosen_model} to {config_path}", style="cyan")
@@ -199,13 +154,14 @@ def exec_command(
         model=chosen_model,
         debug=debug_enabled,
         vanilla=vanilla,
-        is_exec_mode=True,
         debug_filters=debug_filters,
         stream_json=stream_json,
     )
 
     if log_path:
-        open_log_file_in_editor(log_path)
+        from klaude_code.log import log
+
+        log(f"Debug log: {log_path}", style="dim")
 
     asyncio.run(
         run_exec(
@@ -269,7 +225,7 @@ def main_callback(
 ) -> None:
     # Only run interactive mode when no subcommand is invoked
     if ctx.invoked_subcommand is None:
-        from klaude_code.trace import log
+        from klaude_code.log import log
 
         resume_by_id_value = resume_by_id.strip() if resume_by_id is not None else None
         if resume_by_id_value == "":
@@ -304,8 +260,9 @@ def main_callback(
             )
             return
 
-        from klaude_code.cli.runtime import AppInitConfig, run_interactive
-        from klaude_code.command.model_select import select_model_interactive
+        from klaude_code.app.runtime import AppInitConfig
+        from klaude_code.tui.command.model_select import select_model_interactive
+        from klaude_code.tui.runner import run_interactive
 
         update_terminal_title()
 
@@ -333,7 +290,7 @@ def main_callback(
 
         if session_id is not None and chosen_model is None:
             from klaude_code.config import load_config
-            from klaude_code.trace import log
+            from klaude_code.log import log
 
             session_meta = Session.load_meta(session_id)
             cfg = load_config()
@@ -372,7 +329,7 @@ def main_callback(
                 # Save the selection as default
                 cfg.main_model = chosen_model
                 from klaude_code.config.config import config_path
-                from klaude_code.trace import log
+                from klaude_code.log import log
 
                 asyncio.run(cfg.save())
                 log(f"Saved main_model={chosen_model} to {config_path}", style="dim")
@@ -387,7 +344,7 @@ def main_callback(
         )
 
         if log_path:
-            open_log_file_in_editor(log_path)
+            log(f"Debug log: {log_path}", style="dim")
 
         asyncio.run(
             run_interactive(

klaude_code-2.1.0/src/klaude_code/cli/self_update.py

@@ -0,0 +1,87 @@
+"""Self-update and version utilities for klaude-code."""
+
+import shutil
+import subprocess
+from importlib.metadata import PackageNotFoundError
+from importlib.metadata import version as pkg_version
+
+import typer
+
+from klaude_code.log import log
+from klaude_code.update import PACKAGE_NAME, check_for_updates_blocking
+
+
+def _print_version() -> None:
+    try:
+        ver = pkg_version(PACKAGE_NAME)
+    except PackageNotFoundError:
+        ver = "unknown"
+    except (ValueError, TypeError):
+        # Catch invalid package name format or type errors
+        ver = "unknown"
+    print(f"{PACKAGE_NAME} {ver}")
+
+
+def version_option_callback(value: bool) -> None:
+    """Show version and exit."""
+    if value:
+        _print_version()
+        raise typer.Exit(0)
+
+
+def version_command() -> None:
+    """Show version and exit."""
+
+    _print_version()
+
+
+def update_command(
+    check: bool = typer.Option(
+        False,
+        "--check",
+        help="Check for updates and exit without upgrading",
+    ),
+) -> None:
+    """Upgrade klaude-code when installed via `uv tool`."""
+
+    info = check_for_updates_blocking()
+
+    if check:
+        if info is None:
+            log(("Error: `uv` is not available; cannot check for updates.", "red"))
+            log(f"Install uv, then run `uv tool upgrade {PACKAGE_NAME}`.")
+            raise typer.Exit(1)
+
+        installed_display = info.installed or "unknown"
+        latest_display = info.latest or "unknown"
+        status = "update available" if info.update_available else "up to date"
+
+        log(f"{PACKAGE_NAME} installed: {installed_display}")
+        log(f"{PACKAGE_NAME} latest:    {latest_display}")
+        log(f"Status: {status}")
+
+        if info.update_available:
+            log("Run `klaude upgrade` to upgrade.")
+
+        return
+
+    if shutil.which("uv") is None:
+        log(("Error: `uv` not found in PATH.", "red"))
+        log(f"To update, install uv and run `uv tool upgrade {PACKAGE_NAME}`.")
+        raise typer.Exit(1)
+
+    log(f"Running `uv tool upgrade {PACKAGE_NAME}`…")
+    result = subprocess.run(["uv", "tool", "upgrade", PACKAGE_NAME], check=False)
+    if result.returncode != 0:
+        log((f"Error: update failed (exit code {result.returncode}).", "red"))
+        raise typer.Exit(result.returncode or 1)
+
+    log("Update complete. Please re-run `klaude` to use the new version.")
+
+
+def register_self_update_commands(app: typer.Typer) -> None:
+    """Register self-update and version subcommands to the given Typer app."""
+
+    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)

{klaude_code-2.0.1 → klaude_code-2.1.0}/src/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-2.0.1 → klaude_code-2.1.0}/src/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-2.0.1 → klaude_code-2.1.0}/src/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: