klaude-code 1.2.13__py3-none-any.whl → 1.2.14__py3-none-any.whl

klaude_code/cli/auth_cmd.py

@@ -0,0 +1,73 @@
+"""Authentication commands for CLI."""
+
+import datetime
+
+import typer
+
+from klaude_code.trace import log
+
+
+def login_command(
+    provider: str = typer.Argument("codex", help="Provider to login (codex)"),
+) -> None:
+    """Login to a provider using OAuth."""
+    if provider.lower() != "codex":
+        log((f"Error: Unknown provider '{provider}'. Currently only 'codex' is supported.", "red"))
+        raise typer.Exit(1)
+
+    from klaude_code.auth.codex.oauth import CodexOAuth
+    from klaude_code.auth.codex.token_manager import CodexTokenManager
+
+    token_manager = CodexTokenManager()
+
+    # Check if already logged in
+    if token_manager.is_logged_in():
+        state = token_manager.get_state()
+        if state and not state.is_expired():
+            log(("You are already logged in to Codex.", "green"))
+            log(f"  Account ID: {state.account_id[:8]}...")
+            expires_dt = datetime.datetime.fromtimestamp(state.expires_at, tz=datetime.UTC)
+            log(f"  Expires: {expires_dt.strftime('%Y-%m-%d %H:%M:%S UTC')}")
+            if not typer.confirm("Do you want to re-login?"):
+                return
+
+    log("Starting Codex OAuth login flow...")
+    log("A browser window will open for authentication.")
+
+    try:
+        oauth = CodexOAuth(token_manager)
+        state = oauth.login()
+        log(("Login successful!", "green"))
+        log(f"  Account ID: {state.account_id[:8]}...")
+        expires_dt = datetime.datetime.fromtimestamp(state.expires_at, tz=datetime.UTC)
+        log(f"  Expires: {expires_dt.strftime('%Y-%m-%d %H:%M:%S UTC')}")
+    except Exception as e:
+        log((f"Login failed: {e}", "red"))
+        raise typer.Exit(1) from None
+
+
+def logout_command(
+    provider: str = typer.Argument("codex", help="Provider to logout (codex)"),
+) -> None:
+    """Logout from a provider."""
+    if provider.lower() != "codex":
+        log((f"Error: Unknown provider '{provider}'. Currently only 'codex' is supported.", "red"))
+        raise typer.Exit(1)
+
+    from klaude_code.auth.codex.token_manager import CodexTokenManager
+
+    token_manager = CodexTokenManager()
+
+    if not token_manager.is_logged_in():
+        log("You are not logged in to Codex.")
+        return
+
+    if typer.confirm("Are you sure you want to logout from Codex?"):
+        token_manager.delete()
+        log(("Logged out from Codex.", "green"))
+
+
+def register_auth_commands(app: typer.Typer) -> None:
+    """Register auth commands to the given Typer app."""
+    app.command("login")(login_command)
+    app.command("logout")(logout_command)

klaude_code/cli/config_cmd.py

@@ -0,0 +1,88 @@
+"""Configuration commands for CLI."""
+
+import os
+import subprocess
+import sys
+
+import typer
+
+from klaude_code.config import config_path, load_config
+from klaude_code.trace import log
+
+
+def list_models() -> None:
+    """List all models and providers configuration"""
+    from klaude_code.config.list_model import display_models_and_providers
+    from klaude_code.ui.terminal.color import is_light_terminal_background
+
+    config = load_config()
+    if config is None:
+        raise typer.Exit(1)
+
+    # Auto-detect theme when not explicitly set in config, to match other CLI entrypoints.
+    if config.theme is None:
+        detected = is_light_terminal_background()
+        if detected is True:
+            config.theme = "light"
+        elif detected is False:
+            config.theme = "dark"
+
+    display_models_and_providers(config)
+
+
+def edit_config() -> None:
+    """Open the configuration file in $EDITOR or default system editor"""
+    editor = os.environ.get("EDITOR")
+
+    # If no EDITOR is set, prioritize TextEdit on macOS
+    if not editor:
+        # Try common editors in order of preference on other platforms
+        for cmd in [
+            "code",
+            "nvim",
+            "vim",
+            "nano",
+        ]:
+            try:
+                subprocess.run(["which", cmd], check=True, capture_output=True)
+                editor = cmd
+                break
+            except (subprocess.CalledProcessError, FileNotFoundError):
+                continue
+
+    # If no editor found, try platform-specific defaults
+    if not editor:
+        if sys.platform == "darwin":  # macOS
+            editor = "open"
+        elif sys.platform == "win32":  # Windows
+            editor = "notepad"
+        else:  # Linux and other Unix systems
+            editor = "xdg-open"
+
+    # Ensure config file exists
+    config = load_config()
+    if config is None:
+        raise typer.Exit(1)
+
+    try:
+        if editor == "open -a TextEdit":
+            subprocess.run(["open", "-a", "TextEdit", str(config_path)], check=True)
+        elif editor in ["open", "xdg-open"]:
+            # For open/xdg-open, we need to pass the file directly
+            subprocess.run([editor, str(config_path)], check=True)
+        else:
+            subprocess.run([editor, str(config_path)], check=True)
+    except subprocess.CalledProcessError as e:
+        log((f"Error: Failed to open editor: {e}", "red"))
+        raise typer.Exit(1) from None
+    except FileNotFoundError:
+        log((f"Error: Editor '{editor}' not found", "red"))
+        log("Please install a text editor or set your $EDITOR environment variable")
+        raise typer.Exit(1) from None
+
+
+def register_config_commands(app: typer.Typer) -> None:
+    """Register config commands to the given Typer app."""
+    app.command("list")(list_models)
+    app.command("config")(edit_config)
+    app.command("conf", hidden=True)(edit_config)

klaude_code/cli/debug.py

@@ -0,0 +1,72 @@
+"""Debug utilities for CLI."""
+
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+import typer
+
+from klaude_code.trace import DebugType, log
+
+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 open_log_file_in_editor(path: Path) -> None:
+    """Open the given log file in a text editor without blocking the CLI."""
+
+    editor = os.environ.get("EDITOR")
+
+    if not editor:
+        for cmd in ["open", "xdg-open", "code", "nvim", "vim", "nano"]:
+            try:
+                subprocess.run(["which", cmd], check=True, capture_output=True)
+                editor = cmd
+                break
+            except (subprocess.CalledProcessError, FileNotFoundError):
+                continue
+
+    if not editor:
+        if sys.platform == "darwin":
+            editor = "open"
+        elif sys.platform == "win32":
+            editor = "notepad"
+        else:
+            editor = "xdg-open"
+
+    try:
+        subprocess.Popen([editor, str(path)], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    except FileNotFoundError:
+        log((f"Error: Editor '{editor}' not found", "red"))
+    except Exception as exc:  # pragma: no cover - best effort
+        log((f"Warning: failed to open log file in editor: {exc}", "yellow"))

klaude_code/cli/main.py

@@ -1,19 +1,19 @@
 import asyncio
-import datetime
 import os
-import subprocess
 import sys
 from importlib.metadata import PackageNotFoundError
 from importlib.metadata import version as pkg_version
+from pathlib import Path
 
 import typer
 
-from klaude_code.cli.runtime import DEBUG_FILTER_HELP, AppInitConfig, resolve_debug_settings, run_exec, run_interactive
+from klaude_code.cli.auth_cmd import register_auth_commands
+from klaude_code.cli.config_cmd import register_config_commands
+from klaude_code.cli.debug import DEBUG_FILTER_HELP, open_log_file_in_editor, resolve_debug_settings
 from klaude_code.cli.session_cmd import register_session_commands
-from klaude_code.config import config_path, display_models_and_providers, load_config, select_model_from_config
+from klaude_code.config import load_config
 from klaude_code.session import Session, resume_select_session
-from klaude_code.trace import log
-from klaude_code.ui.terminal.color import is_light_terminal_background
+from klaude_code.trace import prepare_debug_log_file
 
 
 def set_terminal_title(title: str) -> None:
@@ -42,142 +42,10 @@ app = typer.Typer(
     no_args_is_help=False,
 )
 
-session_app = typer.Typer(help="Manage sessions for the current project")
-register_session_commands(session_app)
-app.add_typer(session_app, name="session")
-
-
-@app.command("login")
-def login_command(
-    provider: str = typer.Argument("codex", help="Provider to login (codex)"),
-) -> None:
-    """Login to a provider using OAuth."""
-    if provider.lower() != "codex":
-        log((f"Error: Unknown provider '{provider}'. Currently only 'codex' is supported.", "red"))
-        raise typer.Exit(1)
-
-    from klaude_code.auth.codex.oauth import CodexOAuth
-    from klaude_code.auth.codex.token_manager import CodexTokenManager
-
-    token_manager = CodexTokenManager()
-
-    # Check if already logged in
-    if token_manager.is_logged_in():
-        state = token_manager.get_state()
-        if state and not state.is_expired():
-            log(("You are already logged in to Codex.", "green"))
-            log(f"  Account ID: {state.account_id[:8]}...")
-            expires_dt = datetime.datetime.fromtimestamp(state.expires_at, tz=datetime.UTC)
-            log(f"  Expires: {expires_dt.strftime('%Y-%m-%d %H:%M:%S UTC')}")
-            if not typer.confirm("Do you want to re-login?"):
-                return
-
-    log("Starting Codex OAuth login flow...")
-    log("A browser window will open for authentication.")
-
-    try:
-        oauth = CodexOAuth(token_manager)
-        state = oauth.login()
-        log(("Login successful!", "green"))
-        log(f"  Account ID: {state.account_id[:8]}...")
-        expires_dt = datetime.datetime.fromtimestamp(state.expires_at, tz=datetime.UTC)
-        log(f"  Expires: {expires_dt.strftime('%Y-%m-%d %H:%M:%S UTC')}")
-    except Exception as e:
-        log((f"Login failed: {e}", "red"))
-        raise typer.Exit(1) from None
-
-
-@app.command("logout")
-def logout_command(
-    provider: str = typer.Argument("codex", help="Provider to logout (codex)"),
-) -> None:
-    """Logout from a provider."""
-    if provider.lower() != "codex":
-        log((f"Error: Unknown provider '{provider}'. Currently only 'codex' is supported.", "red"))
-        raise typer.Exit(1)
-
-    from klaude_code.auth.codex.token_manager import CodexTokenManager
-
-    token_manager = CodexTokenManager()
-
-    if not token_manager.is_logged_in():
-        log("You are not logged in to Codex.")
-        return
-
-    if typer.confirm("Are you sure you want to logout from Codex?"):
-        token_manager.delete()
-        log(("Logged out from Codex.", "green"))
-
-
-@app.command("list")
-def list_models() -> None:
-    """List all models and providers configuration"""
-    config = load_config()
-    if config is None:
-        raise typer.Exit(1)
-
-    # Auto-detect theme when not explicitly set in config, to match other CLI entrypoints.
-    if config.theme is None:
-        detected = is_light_terminal_background()
-        if detected is True:
-            config.theme = "light"
-        elif detected is False:
-            config.theme = "dark"
-
-    display_models_and_providers(config)
-
-
-@app.command("config")
-@app.command("conf", hidden=True)
-def edit_config() -> None:
-    """Open the configuration file in $EDITOR or default system editor"""
-    editor = os.environ.get("EDITOR")
-
-    # If no EDITOR is set, prioritize TextEdit on macOS
-    if not editor:
-        # Try common editors in order of preference on other platforms
-        for cmd in [
-            "code",
-            "nvim",
-            "vim",
-            "nano",
-        ]:
-            try:
-                subprocess.run(["which", cmd], check=True, capture_output=True)
-                editor = cmd
-                break
-            except (subprocess.CalledProcessError, FileNotFoundError):
-                continue
-
-    # If no editor found, try platform-specific defaults
-    if not editor:
-        if sys.platform == "darwin":  # macOS
-            editor = "open"
-        elif sys.platform == "win32":  # Windows
-            editor = "notepad"
-        else:  # Linux and other Unix systems
-            editor = "xdg-open"
-
-    # Ensure config file exists
-    config = load_config()
-    if config is None:
-        raise typer.Exit(1)
-
-    try:
-        if editor == "open -a TextEdit":
-            subprocess.run(["open", "-a", "TextEdit", str(config_path)], check=True)
-        elif editor in ["open", "xdg-open"]:
-            # For open/xdg-open, we need to pass the file directly
-            subprocess.run([editor, str(config_path)], check=True)
-        else:
-            subprocess.run([editor, str(config_path)], check=True)
-    except subprocess.CalledProcessError as e:
-        log((f"Error: Failed to open editor: {e}", "red"))
-        raise typer.Exit(1) from None
-    except FileNotFoundError:
-        log((f"Error: Editor '{editor}' not found", "red"))
-        log("Please install a text editor or set your $EDITOR environment variable")
-        raise typer.Exit(1) from None
+# Register subcommands from modules
+register_session_commands(app)
+register_auth_commands(app)
+register_config_commands(app)
 
 
 @app.command("exec")
@@ -222,6 +90,7 @@ def exec_command(
     ),
 ) -> None:
     """Execute non-interactively with provided input."""
+    from klaude_code.trace import log
 
     # Set terminal title with current folder name
     folder_name = os.path.basename(os.getcwd())
@@ -250,6 +119,9 @@ def exec_command(
         log(("Error: No input content provided", "red"))
         raise typer.Exit(1)
 
+    from klaude_code.cli.runtime import AppInitConfig, run_exec
+    from klaude_code.config.select_model import select_model_from_config
+
     chosen_model = model
     if select_model:
         # Prefer the explicitly provided model as default; otherwise main model
@@ -263,6 +135,10 @@ def exec_command(
 
     debug_enabled, debug_filters = resolve_debug_settings(debug, debug_filter)
 
+    log_path: Path | None = None
+    if debug_enabled:
+        log_path = prepare_debug_log_file()
+
     init_config = AppInitConfig(
         model=chosen_model,
         debug=debug_enabled,
@@ -272,6 +148,9 @@ def exec_command(
         stream_json=stream_json,
     )
 
+    if log_path:
+        open_log_file_in_editor(log_path)
+
     asyncio.run(
         run_exec(
             init_config=init_config,
@@ -328,6 +207,9 @@ def main_callback(
 ) -> None:
     # Only run interactive mode when no subcommand is invoked
     if ctx.invoked_subcommand is None:
+        from klaude_code.cli.runtime import AppInitConfig, run_interactive
+        from klaude_code.config.select_model import select_model_from_config
+
         # Set terminal title with current folder name
         folder_name = os.path.basename(os.getcwd())
         set_terminal_title(f"{folder_name}: klaude")
@@ -352,6 +234,10 @@ def main_callback(
 
         debug_enabled, debug_filters = resolve_debug_settings(debug, debug_filter)
 
+        log_path: Path | None = None
+        if debug_enabled:
+            log_path = prepare_debug_log_file()
+
         init_config = AppInitConfig(
             model=chosen_model,
             debug=debug_enabled,
@@ -359,6 +245,9 @@ def main_callback(
             debug_filters=debug_filters,
         )
 
+        if log_path:
+            open_log_file_in_editor(log_path)
+
         asyncio.run(
             run_interactive(
                 init_config=init_config,

klaude_code/cli/runtime.py

@@ -30,37 +30,6 @@ class PrintCapable(Protocol):
     def print(self, *objects: Any, style: Any | None = None, end: str = "\n") -> None: ...
 
 
-DEBUG_FILTER_HELP = "Comma-separated debug types: " + ", ".join(dt.value for dt in DebugType)
-
-
-def _parse_debug_filters(raw: str | None) -> set[DebugType] | None:
-    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]:
-    filters = _parse_debug_filters(raw_filters)
-    effective_flag = flag or (filters is not None)
-    return effective_flag, filters
-
-
 @dataclass
 class AppInitConfig:
     """Configuration for initializing the application components."""

klaude_code/cli/session_cmd.py

@@ -72,7 +72,9 @@ def session_clean_all(
     log(f"Deleted {deleted} session(s).")
 
 
-def register_session_commands(session_app: typer.Typer) -> None:
+def register_session_commands(app: typer.Typer) -> None:
     """Register session subcommands to the given Typer app."""
+    session_app = typer.Typer(help="Manage sessions for the current project")
     session_app.command("clean")(session_clean)
     session_app.command("clean-all")(session_clean_all)
+    app.add_typer(session_app, name="session")

klaude_code/command/model_cmd.py

@@ -2,7 +2,7 @@ import asyncio
 from typing import TYPE_CHECKING
 
 from klaude_code.command.command_abc import CommandABC, CommandResult, InputAction
-from klaude_code.config import select_model_from_config
+from klaude_code.config.select_model import select_model_from_config
 from klaude_code.protocol import commands, events, model
 
 if TYPE_CHECKING:

klaude_code/config/__init__.py

@@ -1,11 +1,7 @@
 from .config import Config, config_path, load_config
-from .list_model import display_models_and_providers
-from .select_model import select_model_from_config
 
 __all__ = [
     "Config",
     "config_path",
-    "display_models_and_providers",
     "load_config",
-    "select_model_from_config",
 ]

klaude_code/config/config.py

@@ -71,7 +71,8 @@ class Config(BaseModel):
 
         def _save_config() -> None:
             config_path.parent.mkdir(parents=True, exist_ok=True)
-            _ = config_path.write_text(yaml.dump(config_dict, default_flow_style=False, sort_keys=False))
+            yaml_content = yaml.dump(config_dict, default_flow_style=False, sort_keys=False)
+            _ = config_path.write_text(str(yaml_content or ""))
 
         await asyncio.to_thread(_save_config)
 
@@ -142,8 +143,7 @@ def get_example_config() -> Config:
     )
 
 
-@lru_cache(maxsize=1)
-def load_config() -> Config | None:
+def _load_config_uncached() -> Config | None:
     if not config_path.exists():
         log(f"Config file not found: {config_path}")
         example_config = get_example_config()
@@ -151,7 +151,7 @@ def load_config() -> Config | None:
         config_dict = example_config.model_dump(mode="json", exclude_none=True)
 
         # Comment out all example config lines
-        yaml_str = yaml.dump(config_dict, default_flow_style=False, sort_keys=False)
+        yaml_str = yaml.dump(config_dict, default_flow_style=False, sort_keys=False) or ""
         commented_yaml = "\n".join(f"# {line}" if line.strip() else "#" for line in yaml_str.splitlines())
         _ = config_path.write_text(commented_yaml)
 
@@ -175,3 +175,30 @@ def load_config() -> Config | None:
         raise ValueError(f"Invalid config file: {config_path}") from e
 
     return config
+
+
+@lru_cache(maxsize=1)
+def _load_config_cached() -> Config | None:
+    return _load_config_uncached()
+
+
+def load_config() -> Config | None:
+    """Load config from disk, caching only successful parses.
+
+    Returns:
+        Config object on success, or None when the config is missing/empty/commented out.
+    """
+
+    try:
+        config = _load_config_cached()
+    except ValueError:
+        _load_config_cached.cache_clear()
+        raise
+
+    if config is None:
+        _load_config_cached.cache_clear()
+    return config
+
+
+# Expose cache control for tests and callers that need to invalidate the cache.
+load_config.cache_clear = _load_config_cached.cache_clear  # type: ignore[attr-defined]

klaude_code/const/__init__.py

@@ -4,6 +4,8 @@ This module consolidates all magic numbers and configuration values
 that were previously scattered across the codebase.
 """
 
+from pathlib import Path
+
 # =============================================================================
 # Agent Configuration
 # =============================================================================
@@ -116,15 +118,18 @@ STATUS_SHIMMER_ALPHA_SCALE = 0.7
 # Spinner breathing animation
 # Duration in seconds for one full breathe-in + breathe-out cycle
 # Keep in sync with STATUS_SHIMMER_SWEEP_SECONDS for visual consistency
-SPINNER_BREATH_PERIOD_SECONDS = 2
+SPINNER_BREATH_PERIOD_SECONDS: float = 2.0
 
 
 # =============================================================================
 # Debug / Logging
 # =============================================================================
 
-# Default debug log file path
-DEFAULT_DEBUG_LOG_FILE = "debug.log"
+# Default debug log directory (user cache)
+DEFAULT_DEBUG_LOG_DIR = Path.home() / ".klaude" / "logs"
+
+# Default debug log file path (symlink to latest session)
+DEFAULT_DEBUG_LOG_FILE = DEFAULT_DEBUG_LOG_DIR / "debug.log"
 
 # Maximum log file size before rotation (10MB)
 LOG_MAX_BYTES = 10 * 1024 * 1024

klaude_code/core/agent.py

@@ -46,7 +46,7 @@ class DefaultModelProfileProvider(ModelProfileProvider):
         model_name = llm_client.model_name
         return AgentProfile(
             llm_client=llm_client,
-            system_prompt=load_system_prompt(model_name, sub_agent_type),
+            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),
         )