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

klaude_code/app/runtime.py

@@ -178,6 +178,6 @@ async def handle_keyboard_interrupt(executor: Executor) -> None:
     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"))
+        log(("Resume with:", "dim"), (f"klaude --resume {session_id}", "green"))
     with contextlib.suppress(Exception):
         await executor.submit(op.InterruptOperation(target_session_id=None))

klaude_code/auth/env.py

@@ -1,7 +1,7 @@
 """Environment variable configuration stored in klaude-auth.json."""
 
 import json
-from typing import Any
+from typing import Any, cast
 
 from klaude_code.auth.base import KLAUDE_AUTH_FILE
 
@@ -11,9 +11,9 @@ def _load_store() -> dict[str, Any]:
     if not KLAUDE_AUTH_FILE.exists():
         return {}
     try:
-        data: Any = json.loads(KLAUDE_AUTH_FILE.read_text())
+        data = json.loads(KLAUDE_AUTH_FILE.read_text())
         if isinstance(data, dict):
-            return dict(data)
+            return cast(dict[str, Any], data)
         return {}
     except (json.JSONDecodeError, ValueError):
         return {}
@@ -25,26 +25,31 @@ def _save_store(data: dict[str, Any]) -> None:
     KLAUDE_AUTH_FILE.write_text(json.dumps(data, indent=2))
 
 
+def _get_env_section(store: dict[str, Any]) -> dict[str, Any] | None:
+    """Extract and validate the 'env' section from store."""
+    env_section = store.get("env")
+    if isinstance(env_section, dict):
+        return cast(dict[str, Any], env_section)
+    return None
+
+
 def get_auth_env(env_var: str) -> str | None:
     """Get environment variable value from klaude-auth.json 'env' section.
 
     This provides a fallback for API keys when real environment variables are not set.
     Priority: os.environ > klaude-auth.json env
     """
-    store = _load_store()
-    env_section: Any = store.get("env")
-    if not isinstance(env_section, dict):
+    env_section = _get_env_section(_load_store())
+    if env_section is None:
         return None
-    value: Any = env_section.get(env_var)
+    value = env_section.get(env_var)
     return str(value) if value is not None else None
 
 
 def set_auth_env(env_var: str, value: str) -> None:
     """Set environment variable value in klaude-auth.json 'env' section."""
     store = _load_store()
-    env_section: Any = store.get("env")
-    if not isinstance(env_section, dict):
-        env_section = {}
+    env_section = _get_env_section(store) or {}
     env_section[env_var] = value
     store["env"] = env_section
     _save_store(store)
@@ -53,8 +58,8 @@ def set_auth_env(env_var: str, value: str) -> None:
 def delete_auth_env(env_var: str) -> None:
     """Delete environment variable from klaude-auth.json 'env' section."""
     store = _load_store()
-    env_section: Any = store.get("env")
-    if not isinstance(env_section, dict):
+    env_section = _get_env_section(store)
+    if env_section is None:
         return
     env_section.pop(env_var, None)
     if len(env_section) == 0:
@@ -70,8 +75,7 @@ def delete_auth_env(env_var: str) -> None:
 
 def list_auth_env() -> dict[str, str]:
     """List all environment variables in klaude-auth.json 'env' section."""
-    store = _load_store()
-    env_section: Any = store.get("env")
-    if not isinstance(env_section, dict):
+    env_section = _get_env_section(_load_store())
+    if env_section is None:
         return {}
     return {k: str(v) for k, v in env_section.items() if v is not None}

klaude_code/cli/auth_cmd.py

@@ -212,7 +212,7 @@ def register_auth_commands(app: typer.Typer) -> None:
     auth_app = typer.Typer(help="Login/logout", invoke_without_command=True)
 
     @auth_app.callback()
-    def auth_callback(ctx: typer.Context) -> None:
+    def auth_callback(ctx: typer.Context) -> None:  # pyright: ignore[reportUnusedFunction]
         """Authentication commands for managing provider logins."""
         if ctx.invoked_subcommand is None:
             typer.echo(ctx.get_help())

klaude_code/cli/main.py

@@ -1,7 +1,10 @@
 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
@@ -40,7 +43,88 @@ def _build_env_help() -> str:
 
 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,
@@ -69,21 +153,27 @@ def main_callback(
         None,
         "--model",
         "-m",
-        help="Select model by name",
+        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="Resume latest session"),
-    resume: bool = typer.Option(False, "--resume", "-r", help="Pick a session to resume"),
+    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 session by ID",
+        hidden=True,
     ),
     select_model: bool = typer.Option(
         False,
-        "--select-model",
-        "-s",
-        help="Choose model interactively",
+        "--model-select",
+        help="Choose model interactively (same as --model with no value)",
+        hidden=True,
         rich_help_panel="LLM",
     ),
     debug: bool = typer.Option(
@@ -107,7 +197,7 @@ def main_callback(
     banana: bool = typer.Option(
         False,
         "--banana",
-        help="Image generation mode",
+        help="Image generation mode (alias for --model banana)",
         rich_help_panel="LLM",
     ),
     version: bool = typer.Option(
@@ -130,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/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

@@ -196,7 +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([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)
 

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"

klaude_code/skill/loader.py

@@ -209,22 +209,21 @@ class SkillLoader:
         """Get list of all loaded skill names"""
         return list(self.loaded_skills.keys())
 
-    def get_skills_xml(self) -> str:
-        """Generate Level 1 metadata in XML format for tool description
+    def get_skills_yaml(self) -> str:
+        """Generate skill metadata in YAML format for system prompt.
 
         Returns:
-            XML string with all skill metadata
+            YAML string with all skill metadata
         """
-        xml_parts: list[str] = []
-        # Prefer showing higher-priority skills first (project > user > system).
+        yaml_parts: list[str] = []
         location_order = {"project": 0, "user": 1, "system": 2}
         for skill in sorted(self.loaded_skills.values(), key=lambda s: location_order.get(s.location, 3)):
-            xml_parts.append(
-                f"""<skill>
-<name>{skill.name}</name>
-<description>{skill.description}</description>
-<scope>{skill.location}</scope>
-<location>{skill.skill_path}</location>
-</skill>"""
+            # Escape description for YAML (handle multi-line and special chars)
+            desc = skill.description.replace("\n", " ").strip()
+            yaml_parts.append(
+                f"- name: {skill.name}\n"
+                f"  description: {desc}\n"
+                f"  scope: {skill.location}\n"
+                f"  location: {skill.skill_path}"
             )
-        return "\n".join(xml_parts)
+        return "\n".join(yaml_parts)

klaude_code/skill/manager.py

@@ -80,8 +80,8 @@ def format_available_skills_for_system_prompt() -> str:
 
     try:
         loader = _ensure_initialized()
-        skills_xml = loader.get_skills_xml().strip()
-        if not skills_xml:
+        skills_yaml = loader.get_skills_yaml().strip()
+        if not skills_yaml:
             return ""
 
         return f"""
@@ -102,7 +102,7 @@ Important:
 The list below is metadata only (name/description/location). The full instructions live in the referenced file.
 
 <available_skills>
-{skills_xml}
+{skills_yaml}
 </available_skills>"""
     except Exception:
         # Skills are an optional enhancement; do not fail prompt construction if discovery breaks.

klaude_code/tui/command/__init__.py

@@ -40,7 +40,6 @@ def ensure_commands_loaded() -> None:
     from .resume_cmd import ResumeCommand
     from .status_cmd import StatusCommand
     from .sub_agent_model_cmd import SubAgentModelCommand
-    from .terminal_setup_cmd import TerminalSetupCommand
     from .thinking_cmd import ThinkingCommand
 
     # Register in desired display order
@@ -55,7 +54,6 @@ def ensure_commands_loaded() -> None:
     register(StatusCommand())
     register(ResumeCommand())
     register(ExportOnlineCommand())
-    register(TerminalSetupCommand())
     register(DebugCommand())
     register(ClearCommand())
 
@@ -76,7 +74,6 @@ def __getattr__(name: str) -> object:
         "ResumeCommand": "resume_cmd",
         "StatusCommand": "status_cmd",
         "SubAgentModelCommand": "sub_agent_model_cmd",
-        "TerminalSetupCommand": "terminal_setup_cmd",
         "ThinkingCommand": "thinking_cmd",
     }
     if name in _commands_map:
@@ -91,7 +88,7 @@ __all__ = [
     # Command classes are lazily loaded via __getattr__
     # "ClearCommand", "DiffCommand", "HelpCommand", "ModelCommand",
     # "ExportCommand", "RefreshTerminalCommand", "ReleaseNotesCommand",
-    # "StatusCommand", "TerminalSetupCommand",
+    # "StatusCommand",
     "CommandABC",
     "CommandResult",
     "dispatch_command",

klaude_code/tui/command/copy_cmd.py

@@ -1,5 +1,5 @@
 from klaude_code.protocol import commands, events, message
-from klaude_code.tui.input.clipboard import copy_to_clipboard
+from klaude_code.tui.input.key_bindings import copy_to_clipboard
 
 from .command_abc import Agent, CommandABC, CommandResult
 

klaude_code/tui/command/fork_session_cmd.py

@@ -6,7 +6,7 @@ from typing import Literal
 from prompt_toolkit.styles import Style, merge_styles
 
 from klaude_code.protocol import commands, events, message, model
-from klaude_code.tui.input.clipboard import copy_to_clipboard
+from klaude_code.tui.input.key_bindings import copy_to_clipboard
 from klaude_code.tui.terminal.selector import DEFAULT_PICKER_STYLE, SelectItem, select_one
 
 from .command_abc import Agent, CommandABC, CommandResult
@@ -194,7 +194,7 @@ class ForkSessionCommand(CommandABC):
 
     @property
     def summary(self) -> str:
-        return "Fork the current session and show a resume-by-id command"
+        return "Fork the current session and show a resume command"
 
     @property
     def is_interactive(self) -> bool:
@@ -220,7 +220,7 @@ class ForkSessionCommand(CommandABC):
             new_session = agent.session.fork()
             await new_session.wait_for_flush()
 
-            resume_cmd = f"klaude --resume-by-id {new_session.id}"
+            resume_cmd = f"klaude --resume {new_session.id}"
             copy_to_clipboard(resume_cmd)
 
             event = events.CommandOutputEvent(
@@ -249,7 +249,7 @@ class ForkSessionCommand(CommandABC):
         # Build result message
         fork_description = "entire conversation" if selected == -1 else f"up to message index {selected}"
 
-        resume_cmd = f"klaude --resume-by-id {new_session.id}"
+        resume_cmd = f"klaude --resume {new_session.id}"
         copy_to_clipboard(resume_cmd)
 
         event = events.CommandOutputEvent(

klaude_code/tui/components/command_output.py

@@ -50,7 +50,7 @@ def _render_fork_session_output(e: events.CommandOutputEvent) -> RenderableType:
     grid.add_column(style=ThemeKey.TOOL_RESULT, overflow="fold")
 
     grid.add_row(Text("Session forked. Resume command copied to clipboard:", style=ThemeKey.TOOL_RESULT))
-    grid.add_row(Text(f"  klaude --resume-by-id {session_id}", style=ThemeKey.TOOL_RESULT_BOLD))
+    grid.add_row(Text(f"  klaude --resume {session_id}", style=ThemeKey.TOOL_RESULT_BOLD))
 
     return Padding.indent(grid, level=2)
 

klaude_code/tui/components/rich/markdown.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import contextlib
 import io
+import re
 import time
 from collections.abc import Callable
 from typing import Any, ClassVar
@@ -26,6 +27,63 @@ from klaude_code.const import (
 )
 from klaude_code.tui.components.rich.code_panel import CodePanel
 
+_THINKING_HTML_BLOCK_RE = re.compile(
+    r"\A\s*<thinking>\s*\n?(?P<body>.*?)(?:\n\s*)?</thinking>\s*\Z",
+    flags=re.IGNORECASE | re.DOTALL,
+)
+
+_HTML_COMMENT_BLOCK_RE = re.compile(r"\A\s*<!--.*?-->\s*\Z", flags=re.DOTALL)
+
+
+class ThinkingHTMLBlock(MarkdownElement):
+    """Render `<thinking>...</thinking>` HTML blocks as Rich Markdown.
+
+    markdown-it-py treats custom tags like `<thinking>` as HTML blocks, and Rich
+    Markdown ignores HTML blocks by default. This element restores visibility by
+    re-parsing the inner content as Markdown and applying a dedicated style.
+
+    Non-thinking HTML blocks (including comment sentinels like `<!-- -->`) render
+    no visible output, matching Rich's default behavior.
+    """
+
+    new_line: ClassVar[bool] = True
+
+    @classmethod
+    def create(cls, markdown: Markdown, token: Token) -> ThinkingHTMLBlock:
+        return cls(content=token.content or "", code_theme=markdown.code_theme)
+
+    def __init__(self, *, content: str, code_theme: str) -> None:
+        self._content = content
+        self._code_theme = code_theme
+
+    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
+        stripped = self._content.strip()
+
+        # Keep HTML comments invisible. MarkdownStream relies on a comment sentinel
+        # (`<!-- -->`) to preserve inter-block spacing in some streaming frames.
+        if _HTML_COMMENT_BLOCK_RE.match(stripped):
+            return
+
+        match = _THINKING_HTML_BLOCK_RE.match(stripped)
+        if match is None:
+            return
+
+        body = match.group("body").strip("\n")
+        if not body.strip():
+            return
+
+        # Render as a single line to avoid the extra blank lines produced by
+        # paragraph/block rendering.
+        collapsed = " ".join(body.split())
+        if not collapsed:
+            return
+
+        text = Text()
+        text.append("<thinking>", style="markdown.thinking.tag")
+        text.append(collapsed, style="markdown.thinking")
+        text.append("</thinking>", style="markdown.thinking.tag")
+        yield text
+
 
 class NoInsetCodeBlock(CodeBlock):
     """A code block with syntax highlighting and no padding."""
@@ -105,6 +163,7 @@ class NoInsetMarkdown(Markdown):
         "heading_open": LeftHeading,
         "hr": Divider,
         "table_open": MarkdownTable,
+        "html_block": ThinkingHTMLBlock,
     }
 
 
@@ -118,6 +177,7 @@ class ThinkingMarkdown(Markdown):
         "heading_open": LeftHeading,
         "hr": Divider,
         "table_open": MarkdownTable,
+        "html_block": ThinkingHTMLBlock,
     }
 
 

klaude_code/tui/components/rich/theme.py

@@ -331,7 +331,14 @@ def get_theme(theme: str | None = None) -> Themes:
         markdown_theme=Theme(
             styles={
                 "markdown.code": palette.purple,
+                # Render degraded `<thinking>...</thinking>` blocks inside assistant markdown.
+                # This must live in markdown_theme (not just thinking_markdown_theme) because
+                # it is used while rendering assistant output.
+                "markdown.thinking": "italic " + palette.grey2,
+                "markdown.thinking.tag": palette.grey2,
                 "markdown.code.border": palette.grey3,
+                # Used by ThinkingMarkdown when rendering `<thinking>` blocks.
+                "markdown.code.block": palette.grey1,
                 "markdown.h1": "bold reverse",
                 "markdown.h1.border": palette.grey3,
                 "markdown.h2": "bold underline",
@@ -353,6 +360,7 @@ def get_theme(theme: str | None = None) -> Themes:
                 "markdown.code": palette.grey1 + " italic on " + palette.code_background,
                 "markdown.code.block": palette.grey1,
                 "markdown.code.border": palette.grey3,
+                "markdown.thinking.tag": palette.grey2 + " dim",
                 "markdown.h1": "bold reverse",
                 "markdown.h1.border": palette.grey3,
                 "markdown.h3": "bold " + palette.grey1,