klaude-code 2.5.3__py3-none-any.whl → 2.7.0__py3-none-any.whl

klaude_code/cli/main.py

@@ -1,114 +1,186 @@
 import asyncio
 import sys
+from collections.abc import Sequence
+from typing import Any
 
 import typer
+from typer.core import TyperGroup
 
 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, 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.cli.self_update import register_self_upgrade_commands, version_option_callback
 from klaude_code.session import Session
 from klaude_code.tui.command.resume_cmd import select_session_sync
 from klaude_code.ui.terminal.title import update_terminal_title
 
-ENV_HELP_LINES = [
-    "Environment Variables:",
-    "",
-    "Provider API keys (built-in config):",
-    "  ANTHROPIC_API_KEY             Anthropic API key",
-    "  OPENAI_API_KEY                OpenAI API key",
-    "  OPENROUTER_API_KEY            OpenRouter API key",
-    "  GOOGLE_API_KEY                Google API key (Gemini)",
-    "  DEEPSEEK_API_KEY              DeepSeek API key",
-    "  MOONSHOT_API_KEY              Moonshot API key (Kimi)",
-    "",
-    "AWS credentials (Bedrock):",
-    "  AWS_ACCESS_KEY_ID             AWS access key id",
-    "  AWS_SECRET_ACCESS_KEY         AWS secret access key",
-    "  AWS_REGION                    AWS region",
-    "",
-    "Tool limits (Read):",
-    "  KLAUDE_READ_GLOBAL_LINE_CAP    Max lines to read (default: 2000)",
-    "  KLAUDE_READ_MAX_CHARS          Max total chars to read (default: 50000)",
-    "  KLAUDE_READ_MAX_IMAGE_BYTES    Max image bytes to read (default: 4MB)",
-    "  KLAUDE_IMAGE_OUTPUT_MAX_BYTES  Max decoded image bytes (default: 64MB)",
-    "",
-    "Notifications / testing:",
-    "  KLAUDE_NOTIFY                 Set to 0/off/false/disable(d) to disable task notifications",
-    "  KLAUDE_TEST_SIGNAL            In tmux, emit `tmux wait-for -S <channel>` on task completion",
-    "  TMUX                          Auto-detected; required for KLAUDE_TEST_SIGNAL",
-    "",
-    "Editor / terminal integration:",
-    "  EDITOR                        Preferred editor for `klaude config`",
-    "  TERM                          Terminal identification (auto-detected)",
-    "  TERM_PROGRAM                  Terminal identification (auto-detected)",
-    "  WT_SESSION                    Terminal hint (auto-detected)",
-    "  VTE_VERSION                   Terminal hint (auto-detected)",
-    "  GHOSTTY_RESOURCES_DIR         Ghostty detection (auto-detected)",
-    "",
-    "Compatibility:",
-    "  ANTHROPIC_AUTH_TOKEN          Reserved by anthropic SDK; temporarily unset during client init",
-]
-
-ENV_HELP = "\n\n".join(ENV_HELP_LINES)
+
+def _build_env_help() -> str:
+    from klaude_code.config.builtin_config import SUPPORTED_API_KEYS
+
+    lines = [
+        "Environment Variables:",
+        "",
+        "Provider API keys (built-in config):",
+    ]
+    # Calculate max env_var length for alignment
+    max_len = max(len(k.env_var) for k in SUPPORTED_API_KEYS)
+    for k in SUPPORTED_API_KEYS:
+        lines.append(f"  {k.env_var:<{max_len}}  {k.description}")
+    lines.extend(
+        [
+            "",
+            "Tool limits (Read):",
+            "  KLAUDE_READ_GLOBAL_LINE_CAP    Max lines to read (default: 2000)",
+            "  KLAUDE_READ_MAX_CHARS          Max total chars to read (default: 50000)",
+            "  KLAUDE_READ_MAX_IMAGE_BYTES    Max image bytes to read (default: 4MB)",
+            "  KLAUDE_IMAGE_OUTPUT_MAX_BYTES  Max decoded image bytes (default: 64MB)",
+        ]
+    )
+    return "\n\n".join(lines)
+
+
+ENV_HELP = _build_env_help()
+
+
+def _looks_like_flag(token: str) -> bool:
+    return token.startswith("-") and token != "-"
+
+
+def _preprocess_cli_args(args: list[str]) -> list[str]:
+    """Rewrite CLI args to support optional values for selected options.
+
+    Supported rewrites:
+    - --model / -m with no value -> --model-select
+    - --resume / -r with value -> --resume-by-id <value>
+    """
+
+    rewritten: list[str] = []
+    i = 0
+    while i < len(args):
+        token = args[i]
+
+        if token in {"--model", "-m"}:
+            next_token = args[i + 1] if i + 1 < len(args) else None
+            if next_token is None or next_token == "--" or _looks_like_flag(next_token):
+                rewritten.append("--model-select")
+                i += 1
+                continue
+            rewritten.append(token)
+            i += 1
+            continue
+
+        if token.startswith("--model="):
+            value = token.split("=", 1)[1]
+            if value == "":
+                rewritten.append("--model-select")
+            else:
+                rewritten.append(token)
+            i += 1
+            continue
+
+        if token in {"--resume", "-r"}:
+            next_token = args[i + 1] if i + 1 < len(args) else None
+            if next_token is not None and next_token != "--" and not _looks_like_flag(next_token):
+                rewritten.extend(["--resume-by-id", next_token])
+                i += 2
+                continue
+            rewritten.append(token)
+            i += 1
+            continue
+
+        if token.startswith("--resume="):
+            value = token.split("=", 1)[1]
+            rewritten.extend(["--resume-by-id", value])
+            i += 1
+            continue
+
+        rewritten.append(token)
+        i += 1
+
+    return rewritten
+
+
+class _PreprocessingTyperGroup(TyperGroup):
+    def main(
+        self,
+        args: Sequence[str] | None = None,
+        prog_name: str | None = None,
+        complete_var: str | None = None,
+        standalone_mode: bool = True,
+        windows_expand_args: bool = True,
+        **extra: Any,
+    ) -> Any:
+        click_args = _preprocess_cli_args(list(args) if args is not None else sys.argv[1:])
+        return super().main(
+            args=click_args,
+            prog_name=prog_name,
+            complete_var=complete_var,
+            standalone_mode=standalone_mode,
+            windows_expand_args=windows_expand_args,
+            **extra,
+        )
+
 
 app = typer.Typer(
+    cls=_PreprocessingTyperGroup,
     add_completion=False,
     pretty_exceptions_enable=False,
     no_args_is_help=False,
     rich_markup_mode="rich",
     epilog=ENV_HELP,
+    context_settings={"help_option_names": ["-h", "--help"]},
 )
 
 # Register subcommands from modules
-register_session_commands(app)
 register_auth_commands(app)
 register_config_commands(app)
 register_cost_commands(app)
+register_self_upgrade_commands(app)
 
-register_self_update_commands(app)
+
+@app.command("help", hidden=True)
+def help_command(ctx: typer.Context) -> None:
+    """Show help message."""
+    print(ctx.parent.get_help() if ctx.parent else ctx.get_help())
 
 
 @app.callback(invoke_without_command=True)
 def main_callback(
     ctx: typer.Context,
-    version: bool = typer.Option(
-        False,
-        "--version",
-        "-V",
-        "-v",
-        help="Show version and exit",
-        callback=version_option_callback,
-        is_eager=True,
-    ),
     model: str | None = typer.Option(
         None,
         "--model",
         "-m",
-        help="Override model config name (uses main model by default)",
+        help="Select model by name; use --model with no value to choose interactively",
         rich_help_panel="LLM",
     ),
-    continue_: bool = typer.Option(False, "--continue", "-c", help="Continue from latest session"),
-    resume: bool = typer.Option(False, "--resume", "-r", help="Select a session to resume for this project"),
+    continue_: bool = typer.Option(False, "--continue", "-c", help="Resume latest session"),
+    resume: bool = typer.Option(
+        False,
+        "--resume",
+        "-r",
+        help="Resume a session; use --resume <id> to resume directly, or --resume to pick interactively",
+    ),
     resume_by_id: str | None = typer.Option(
         None,
         "--resume-by-id",
-        help="Resume a session by its ID (must exist)",
+        help="Resume session by ID",
+        hidden=True,
     ),
     select_model: bool = typer.Option(
         False,
-        "--select-model",
-        "-s",
-        help="Interactively choose a model at startup",
+        "--model-select",
+        help="Choose model interactively (same as --model with no value)",
+        hidden=True,
         rich_help_panel="LLM",
     ),
     debug: bool = typer.Option(
         False,
         "--debug",
         "-d",
-        help="Enable debug mode",
+        help="Enable debug logging",
         rich_help_panel="Debug",
     ),
     debug_filter: str | None = typer.Option(
@@ -120,14 +192,23 @@ def main_callback(
     vanilla: bool = typer.Option(
         False,
         "--vanilla",
-        help="Vanilla mode exposes the model's raw API behavior: it provides only minimal tools (Bash, Read, Write & Edit) and omits system prompts and reminders.",
+        help="Minimal mode: basic tools only, no system prompts",
     ),
     banana: bool = typer.Option(
         False,
         "--banana",
-        help="Image generation mode with Nano Banana",
+        help="Image generation mode (alias for --model banana)",
         rich_help_panel="LLM",
     ),
+    version: bool = typer.Option(
+        False,
+        "--version",
+        "-V",
+        "-v",
+        help="Show version and exit",
+        callback=version_option_callback,
+        is_eager=True,
+    ),
 ) -> None:
     # Only run interactive mode when no subcommand is invoked
     if ctx.invoked_subcommand is None:
@@ -139,11 +220,11 @@ def main_callback(
 
         resume_by_id_value = resume_by_id.strip() if resume_by_id is not None else None
         if resume_by_id_value == "":
-            log(("Error: --resume-by-id cannot be empty", "red"))
+            log(("Error: --resume <id> cannot be empty", "red"))
             raise typer.Exit(2)
 
         if resume_by_id_value is not None and (resume or continue_):
-            log(("Error: --resume-by-id cannot be combined with --resume/--continue", "red"))
+            log(("Error: --resume <id> cannot be combined with --continue or interactive --resume", "red"))
             raise typer.Exit(2)
 
         if resume_by_id_value is not None and not Session.exists(resume_by_id_value):

klaude_code/cli/self_update.py

@@ -35,14 +35,14 @@ def version_command() -> None:
     _print_version()
 
 
-def update_command(
+def upgrade_command(
     check: bool = typer.Option(
         False,
         "--check",
-        help="Check for updates and exit without upgrading",
+        help="Check only, don't upgrade",
     ),
 ) -> None:
-    """Upgrade klaude-code when installed via `uv tool`."""
+    """Upgrade to latest version"""
 
     info = check_for_updates_blocking()
 
@@ -79,9 +79,9 @@ def update_command(
     log("Update complete. Please re-run `klaude` to use the new version.")
 
 
-def register_self_update_commands(app: typer.Typer) -> None:
+def register_self_upgrade_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)
+    app.command("upgrade")(upgrade_command)
+    app.command("update", hidden=True)(upgrade_command)
+    app.command("version", hidden=True)(version_command)

klaude_code/config/builtin_config.py

@@ -5,6 +5,7 @@ environment variables (ANTHROPIC_API_KEY, OPENAI_API_KEY, etc.) without
 manually configuring providers.
 """
 
+from dataclasses import dataclass
 from functools import lru_cache
 from importlib import resources
 from typing import TYPE_CHECKING, Any
@@ -14,15 +15,28 @@ import yaml
 if TYPE_CHECKING:
     from klaude_code.config.config import ProviderConfig
 
-# All supported API key environment variables
-SUPPORTED_API_KEY_ENVS = [
-    "ANTHROPIC_API_KEY",
-    "GOOGLE_API_KEY",
-    "OPENAI_API_KEY",
-    "OPENROUTER_API_KEY",
-    "DEEPSEEK_API_KEY",
-    "MOONSHOT_API_KEY",
-]
+
+@dataclass(frozen=True)
+class ApiKeyInfo:
+    """Information about a supported API key."""
+
+    env_var: str
+    name: str
+    description: str
+
+
+# All supported API keys with their metadata
+SUPPORTED_API_KEYS: tuple[ApiKeyInfo, ...] = (
+    ApiKeyInfo("ANTHROPIC_API_KEY", "Anthropic", "Anthropic API key"),
+    ApiKeyInfo("OPENAI_API_KEY", "OpenAI", "OpenAI API key"),
+    ApiKeyInfo("OPENROUTER_API_KEY", "OpenRouter", "OpenRouter API key"),
+    ApiKeyInfo("GOOGLE_API_KEY", "Google Gemini", "Google API key (Gemini)"),
+    ApiKeyInfo("DEEPSEEK_API_KEY", "DeepSeek", "DeepSeek API key"),
+    ApiKeyInfo("MOONSHOT_API_KEY", "Moonshot Kimi", "Moonshot API key (Kimi)"),
+)
+
+# For backwards compatibility
+SUPPORTED_API_KEY_ENVS = [k.env_var for k in SUPPORTED_API_KEYS]
 
 
 @lru_cache(maxsize=1)

klaude_code/config/config.py

@@ -8,8 +8,9 @@ from typing import Any, cast
 import yaml
 from pydantic import BaseModel, Field, ValidationError, model_validator
 
+from klaude_code.auth.env import get_auth_env
 from klaude_code.config.builtin_config import (
-    SUPPORTED_API_KEY_ENVS,
+    SUPPORTED_API_KEYS,
     get_builtin_provider_configs,
     get_builtin_sub_agent_models,
 )
@@ -26,7 +27,8 @@ def parse_env_var_syntax(value: str | None) -> tuple[str | None, str | None]:
 
     Returns:
         A tuple of (env_var_name, resolved_value).
-        - If value uses ${ENV_VAR} syntax: (env_var_name, os.environ.get(env_var_name))
+        - If value uses ${ENV_VAR} syntax: (env_var_name, resolved_value)
+          Priority: os.environ > klaude-auth.json env section
         - If value is a plain string: (None, value)
         - If value is None: (None, None)
     """
@@ -36,7 +38,9 @@ def parse_env_var_syntax(value: str | None) -> tuple[str | None, str | None]:
     match = _ENV_VAR_PATTERN.match(value)
     if match:
         env_var_name = match.group(1)
-        return env_var_name, os.environ.get(env_var_name)
+        # Priority: real env var > auth.json env section
+        resolved = os.environ.get(env_var_name) or get_auth_env(env_var_name)
+        return env_var_name, resolved
 
     return None, value
 
@@ -613,17 +617,23 @@ def load_config() -> Config:
 
 def print_no_available_models_hint() -> None:
     """Print helpful message when no models are available due to missing API keys."""
-    log("No available models. Please set one of the following environment variables:", style="yellow")
+    log("No available models. Configure an API key using one of these methods:", style="yellow")
     log("")
-    for env_var in SUPPORTED_API_KEY_ENVS:
-        current_value = os.environ.get(env_var)
+    log("Option 1: Use klaude auth login", style="bold")
+    # Use first word of name for brevity
+    names = [k.name.split()[0].lower() for k in SUPPORTED_API_KEYS]
+    log(f"  klaude auth login <provider>  (providers: {', '.join(names)})", style="dim")
+    log("")
+    log("Option 2: Set environment variables", style="bold")
+    max_len = max(len(k.env_var) for k in SUPPORTED_API_KEYS)
+    for key_info in SUPPORTED_API_KEYS:
+        current_value = os.environ.get(key_info.env_var) or get_auth_env(key_info.env_var)
         if current_value:
-            log(f"  {env_var} = (set)", style="green")
+            log(f"  {key_info.env_var:<{max_len}}  (set)", style="green")
         else:
-            log(f"  export {env_var}=<your-api-key>", style="dim")
+            log(f"  {key_info.env_var:<{max_len}}  {key_info.description}", style="dim")
     log("")
     log(f"Or add custom providers in: {config_path}", style="dim")
-    log(f"See example config: {example_config_path}", style="dim")
 
 
 # Expose cache control for tests and callers that need to invalidate the cache.

klaude_code/const.py

@@ -7,6 +7,8 @@ that were previously scattered across the codebase.
 from __future__ import annotations
 
 import os
+import sys
+import tempfile
 from dataclasses import dataclass
 from pathlib import Path
 
@@ -22,6 +24,13 @@ def _get_int_env(name: str, default: int) -> int:
         return default
 
 
+def get_system_temp() -> str:
+    """Return system-level temp directory: /tmp on Unix, system temp on Windows."""
+    if sys.platform == "win32":
+        return tempfile.gettempdir()
+    return "/tmp"
+
+
 # =============================================================================
 # Agent / LLM Configuration
 # =============================================================================
@@ -115,7 +124,7 @@ TOOL_OUTPUT_DISPLAY_TAIL = 10000  # Characters to show from the end of truncated
 TOOL_OUTPUT_MAX_LINES = 2000  # Maximum lines for tool output before truncation
 TOOL_OUTPUT_DISPLAY_HEAD_LINES = 1000  # Lines to show from the beginning of truncated output
 TOOL_OUTPUT_DISPLAY_TAIL_LINES = 1000  # Lines to show from the end of truncated output
-TOOL_OUTPUT_TRUNCATION_DIR = "/tmp"  # Directory for saving full truncated output
+TOOL_OUTPUT_TRUNCATION_DIR = get_system_temp()  # Directory for saving full truncated output
 
 
 # =============================================================================

klaude_code/core/reminders.py

@@ -17,8 +17,8 @@ from klaude_code.skill import get_skill
 # Match @ preceded by whitespace, start of line, or → (ReadTool line number arrow)
 AT_FILE_PATTERN = re.compile(r'(?:(?<!\S)|(?<=\u2192))@("(?P<quoted>[^\"]+)"|(?P<plain>\S+))')
 
-# Match $skill or ¥skill at the beginning of the first line
-SKILL_PATTERN = re.compile(r"^[$¥](?P<skill>\S+)")
+# Match $skill or ¥skill inline (at start of line or after whitespace)
+SKILL_PATTERN = re.compile(r"(?:^|\s)[$¥](?P<skill>\S+)")
 
 
 def get_last_new_user_input(session: Session) -> str | None:
@@ -79,14 +79,13 @@ def get_at_patterns_with_source(session: Session) -> list[AtPatternSource]:
 
 
 def get_skill_from_user_input(session: Session) -> str | None:
-    """Get $skill reference from the first line of last user input."""
+    """Get $skill reference from last user input (first match wins)."""
     for item in reversed(session.conversation_history):
         if isinstance(item, message.ToolResultMessage):
             return None
         if isinstance(item, message.UserMessage):
             content = message.join_text_parts(item.parts)
-            first_line = content.split("\n", 1)[0]
-            m = SKILL_PATTERN.match(first_line)
+            m = SKILL_PATTERN.search(content)
             if m:
                 return m.group("skill")
             return None

klaude_code/core/turn.py

@@ -25,10 +25,12 @@ from klaude_code.log import DebugType, log_debug
 from klaude_code.protocol import events, llm_param, message, model, tools
 
 # Protocols that support prefill (continuing from partial assistant message)
-_PREFILL_SUPPORTED_PROTOCOLS = frozenset({
-    "anthropic",
-    "claude_oauth",
-})
+_PREFILL_SUPPORTED_PROTOCOLS = frozenset(
+    {
+        "anthropic",
+        "claude_oauth",
+    }
+)
 
 
 class TurnError(Exception):
@@ -183,6 +185,7 @@ class TurnExecutor:
 
         if self._turn_result.stream_error is not None:
             # Save accumulated content for potential prefill on retry (only for supported protocols)
+            session_ctx.append_history([self._turn_result.stream_error])
             protocol = ctx.llm_client.get_llm_config().protocol
             supports_prefill = protocol.value in _PREFILL_SUPPORTED_PROTOCOLS
             if (
@@ -193,8 +196,7 @@ class TurnExecutor:
             ):
                 session_ctx.append_history([self._turn_result.assistant_message])
                 # Add continuation prompt to avoid Anthropic thinking block requirement
-                session_ctx.append_history([message.UserMessage(parts=[message.TextPart(text="continue")])])
-            session_ctx.append_history([self._turn_result.stream_error])
+                session_ctx.append_history([message.UserMessage(parts=[message.TextPart(text="<system>continue</system>")])])
             yield events.TurnEndEvent(session_id=session_ctx.session_id)
             raise TurnError(self._turn_result.stream_error.error)
 
@@ -249,9 +251,6 @@ class TurnExecutor:
             image_size = generation.get("image_size")
             if image_size in SUPPORTED_IMAGE_SIZES:
                 image_config.image_size = image_size
-            extra = generation.get("extra")
-            if isinstance(extra, dict) and extra:
-                image_config.extra = extra
             if image_config.model_dump(exclude_none=True):
                 call_param.image_config = image_config
 

klaude_code/llm/google/client.py

@@ -25,6 +25,9 @@ from google.genai.types import (
     ThinkingLevel,
     ToolConfig,
 )
+from google.genai.types import (
+    ImageConfig as GoogleImageConfig,
+)
 
 from klaude_code.llm.client import LLMClientABC, LLMStreamABC
 from klaude_code.llm.google.input import convert_history_to_contents, convert_tool_schema
@@ -91,6 +94,14 @@ def _build_config(param: llm_param.LLMCallParameter) -> GenerateContentConfig:
             if param.thinking.reasoning_effort:
                 thinking_config.thinking_level = convert_gemini_thinking_level(param.thinking.reasoning_effort)
 
+    # ImageGen per-call overrides
+    image_config: GoogleImageConfig | None = None
+    if param.image_config is not None:
+        image_config = GoogleImageConfig(
+            aspect_ratio=param.image_config.aspect_ratio,
+            image_size=param.image_config.image_size,
+        )
+
     return GenerateContentConfig(
         system_instruction=param.system,
         temperature=param.temperature,
@@ -98,6 +109,7 @@ def _build_config(param: llm_param.LLMCallParameter) -> GenerateContentConfig:
         tools=cast(Any, tool_list) if tool_list else None,
         tool_config=tool_config,
         thinking_config=thinking_config,
+        image_config=image_config,
     )
 
 

klaude_code/llm/openai_compatible/stream.py

@@ -199,6 +199,7 @@ async def parse_chat_completions_stream(
     metadata_tracker: MetadataTracker,
     reasoning_handler: ReasoningHandlerABC,
     on_event: Callable[[object], None] | None = None,
+    provider_prefix: str = "",
 ) -> AsyncGenerator[message.LLMStreamItem]:
     """Parse OpenAI Chat Completions stream into stream items.
 
@@ -235,7 +236,7 @@ async def parse_chat_completions_stream(
             if event_model := getattr(event, "model", None):
                 metadata_tracker.set_model_name(str(event_model))
             if provider := getattr(event, "provider", None):
-                metadata_tracker.set_provider(str(provider))
+                metadata_tracker.set_provider(f"{provider_prefix}{provider}")
 
             choices = cast(Any, getattr(event, "choices", None))
             if not choices:
@@ -364,12 +365,14 @@ class OpenAILLMStream(LLMStreamABC):
         metadata_tracker: MetadataTracker,
         reasoning_handler: ReasoningHandlerABC,
         on_event: Callable[[object], None] | None = None,
+        provider_prefix: str = "",
     ) -> None:
         self._stream = stream
         self._param = param
         self._metadata_tracker = metadata_tracker
         self._reasoning_handler = reasoning_handler
         self._on_event = on_event
+        self._provider_prefix = provider_prefix
         self._state = StreamStateManager(
             param_model=str(param.model_id),
         )
@@ -386,6 +389,7 @@ class OpenAILLMStream(LLMStreamABC):
             metadata_tracker=self._metadata_tracker,
             reasoning_handler=self._reasoning_handler,
             on_event=self._on_event,
+            provider_prefix=self._provider_prefix,
         ):
             if isinstance(item, message.AssistantMessage):
                 self._completed = True

klaude_code/llm/openrouter/client.py

@@ -145,4 +145,5 @@ class OpenRouterClient(LLMClientABC):
             metadata_tracker=metadata_tracker,
             reasoning_handler=reasoning_handler,
             on_event=on_event,
+            provider_prefix="openrouter/",
         )

klaude_code/protocol/commands.py

@@ -20,7 +20,6 @@ class CommandName(str, Enum):
     COMPACT = "compact"
     REFRESH_TERMINAL = "refresh-terminal"
     CLEAR = "clear"
-    TERMINAL_SETUP = "terminal-setup"
     EXPORT = "export"
     EXPORT_ONLINE = "export-online"
     STATUS = "status"