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

klaude_code/tui/runner.py

@@ -16,8 +16,9 @@ from klaude_code.app.runtime import (
 )
 from klaude_code.config import load_config
 from klaude_code.const import SIGINT_DOUBLE_PRESS_EXIT_TEXT
+from klaude_code.core.compaction import should_compact_threshold
 from klaude_code.core.executor import Executor
-from klaude_code.log import log
+from klaude_code.log import get_current_log_file, log
 from klaude_code.protocol import events, llm_param, op
 from klaude_code.protocol.message import UserInputPayload
 from klaude_code.session.session import Session
@@ -80,6 +81,19 @@ async def submit_user_input_payload(
         for evt in cmd_result.events:
             await executor.context.emit_event(evt)
 
+    if run_ops and should_compact_threshold(
+        session=agent.session,
+        config=None,
+        llm_config=agent.profile.llm_client.get_llm_config(),
+    ):
+        await executor.submit_and_wait(
+            op.CompactSessionOperation(
+                session_id=agent.session.id,
+                reason="threshold",
+                will_retry=False,
+            )
+        )
+
     submitted_ids: list[str] = []
     for operation_item in operations:
         submitted_ids.append(await executor.submit(operation_item))
@@ -124,7 +138,9 @@ async def run_interactive(init_config: AppInitConfig, session_id: str | None = N
 
     def _status_provider() -> REPLStatusSnapshot:
         update_message = get_update_message()
-        return build_repl_status_snapshot(update_message)
+        debug_log = get_current_log_file()
+        debug_log_path = str(debug_log) if debug_log else None
+        return build_repl_status_snapshot(update_message, debug_log_path=debug_log_path)
 
     def _stop_rich_bottom_ui() -> None:
         active_display = components.display
@@ -312,4 +328,4 @@ async def run_interactive(init_config: AppInitConfig, session_id: str | None = N
             active_session_id = components.executor.context.current_session_id()
             if active_session_id and Session.exists(active_session_id):
                 log(f"Session ID: {active_session_id}")
-                log(f"Resume with: klaude --resume-by-id {active_session_id}")
+                log(f"Resume with: klaude --resume {active_session_id}")

klaude_code/tui/terminal/image.py

@@ -1,34 +1,127 @@
 from __future__ import annotations
 
+import base64
+import shutil
+import struct
+import subprocess
 import sys
+import tempfile
 from pathlib import Path
 from typing import IO
 
+# Kitty graphics protocol chunk size (4096 is the recommended max)
+_CHUNK_SIZE = 4096
 
-def print_kitty_image(file_path: str | Path, *, height: int | None = None, file: IO[str] | None = None) -> None:
+# Max columns for non-wide images
+_MAX_COLS = 120
+
+# Image formats that need conversion to PNG
+_NEEDS_CONVERSION = {".jpg", ".jpeg", ".gif", ".bmp", ".webp", ".tiff", ".tif"}
+
+
+def _convert_to_png(path: Path) -> bytes | None:
+    """Convert image to PNG using sips (macOS) or convert (ImageMagick)."""
+    with tempfile.NamedTemporaryFile(suffix=".png", delete=True) as tmp:
+        tmp_path = tmp.name
+        # Try sips first (macOS built-in)
+        result = subprocess.run(
+            ["sips", "-s", "format", "png", str(path), "--out", tmp_path],
+            capture_output=True,
+        )
+        if result.returncode == 0:
+            return Path(tmp_path).read_bytes()
+        # Fallback to ImageMagick convert
+        result = subprocess.run(
+            ["convert", str(path), tmp_path],
+            capture_output=True,
+        )
+        if result.returncode == 0:
+            return Path(tmp_path).read_bytes()
+    return None
+
+
+def _get_png_dimensions(data: bytes) -> tuple[int, int] | None:
+    """Extract width and height from PNG file header."""
+    # PNG: 8-byte signature + IHDR chunk (4 len + 4 type + 4 width + 4 height)
+    if len(data) < 24 or data[:8] != b"\x89PNG\r\n\x1a\n":
+        return None
+    width, height = struct.unpack(">II", data[16:24])
+    return width, height
+
+
+def print_kitty_image(file_path: str | Path, *, file: IO[str] | None = None) -> None:
     """Print an image to the terminal using Kitty graphics protocol.
 
     This intentionally bypasses Rich rendering to avoid interleaving Live refreshes
-    with raw escape sequences.
-    """
+    with raw escape sequences. Image size adapts based on aspect ratio:
+    - Landscape images: fill terminal width
+    - Portrait images: limit height to avoid oversized display
 
+    Args:
+        file_path: Path to the image file (PNG recommended).
+        file: Output file stream. Defaults to stdout.
+    """
     path = Path(file_path) if isinstance(file_path, str) else file_path
     if not path.exists():
         print(f"Image not found: {path}", file=file or sys.stdout, flush=True)
         return
 
     try:
-        from term_image.image import KittyImage  # type: ignore[import-untyped]
-
-        KittyImage.forced_support = True  # type: ignore[reportUnknownMemberType]
-        img = KittyImage.from_file(path)  # type: ignore[reportUnknownMemberType]
-        if height is not None:
-            img.height = height  # type: ignore[reportUnknownMemberType]
+        # Convert non-PNG formats to PNG for Kitty graphics protocol compatibility
+        if path.suffix.lower() in _NEEDS_CONVERSION:
+            data = _convert_to_png(path)
+            if data is None:
+                print(f"Saved image: {path}", file=file or sys.stdout, flush=True)
+                return
+        else:
+            data = path.read_bytes()
 
+        encoded = base64.standard_b64encode(data).decode("ascii")
         out = file or sys.stdout
+
+        term_size = shutil.get_terminal_size()
+        dimensions = _get_png_dimensions(data)
+
+        # Determine sizing strategy based on aspect ratio
+        if dimensions is not None:
+            img_width, img_height = dimensions
+            if img_width > 2 * img_height:
+                # Wide landscape (width > 2x height): fill terminal width
+                size_param = f"c={term_size.columns}"
+            else:
+                # Other images: limit width to 80% of terminal
+                size_param = f"c={min(_MAX_COLS, term_size.columns * 4 // 5)}"
+        else:
+            # Fallback: limit width to 80% of terminal
+            size_param = f"c={min(_MAX_COLS, term_size.columns * 4 // 5)}"
         print("", file=out)
-        print(str(img), file=out)
+        _write_kitty_graphics(out, encoded, size_param=size_param)
         print("", file=out)
         out.flush()
     except Exception:
         print(f"Saved image: {path}", file=file or sys.stdout, flush=True)
+
+
+def _write_kitty_graphics(out: IO[str], encoded_data: str, *, size_param: str) -> None:
+    """Write Kitty graphics protocol escape sequences.
+
+    Protocol format: ESC _ G <control>;<payload> ESC \\
+    - a=T: direct transmission (data in payload)
+    - f=100: PNG format (auto-detected by Kitty)
+    - c=N: display width in columns
+    - r=N: display height in rows
+    - m=1: more data follows, m=0: last chunk
+    """
+    total_len = len(encoded_data)
+
+    for i in range(0, total_len, _CHUNK_SIZE):
+        chunk = encoded_data[i : i + _CHUNK_SIZE]
+        is_last = i + _CHUNK_SIZE >= total_len
+
+        if i == 0:
+            # First chunk: include control parameters
+            ctrl = f"a=T,f=100,{size_param},m={0 if is_last else 1}"
+            out.write(f"\033_G{ctrl};{chunk}\033\\")
+        else:
+            # Subsequent chunks: only m parameter needed
+            out.write(f"\033_Gm={0 if is_last else 1};{chunk}\033\\")

klaude_code/tui/terminal/selector.py

@@ -81,13 +81,13 @@ def build_model_select_items(models: list[Any]) -> list[SelectItem[str]]:
 
     items: list[SelectItem[str]] = []
     model_idx = 0
-    separator_base_len = 40
+    separator_base_len = 80
     for provider, provider_models in grouped.items():
         provider_text = provider.lower()
         count_text = f"({len(provider_models)})"
         header_len = len(provider_text) + 1 + len(count_text)
         separator_len = separator_base_len + max_header_len - header_len
-        separator = "─" * separator_len
+        separator = "-" * separator_len
         items.append(
             SelectItem(
                 title=[
@@ -389,7 +389,7 @@ def _build_search_container(
     frame: bool = True,
 ) -> tuple[Window, Container]:
     """Build the search input container with placeholder."""
-    placeholder_text = f"{search_placeholder} · ↑↓ to select · esc to quit"
+    placeholder_text = f"{search_placeholder} · ↑↓ to select · enter/tab to confirm · esc to quit"
 
     search_prefix_window = Window(
         FormattedTextControl([("class:search_prefix", "/ ")]),
@@ -522,6 +522,23 @@ def select_one[T](
             return
         event.app.exit(result=value)
 
+    @kb.add(Keys.Tab, eager=True)
+    def _(event: KeyPressEvent) -> None:
+        """Accept the currently pointed item."""
+        indices, _ = _filter_items(items, get_filter_text())
+        if not indices:
+            event.app.exit(result=None)
+            return
+
+        nonlocal pointed_at
+        pointed_at = _coerce_pointed_at_to_selectable(items, indices, pointed_at)
+        idx = indices[pointed_at % len(indices)]
+        value = items[idx].value
+        if value is None:
+            event.app.exit(result=None)
+            return
+        event.app.exit(result=value)
+
     @kb.add(Keys.Escape, eager=True)
     def _(event: KeyPressEvent) -> None:
         nonlocal pointed_at
@@ -557,7 +574,10 @@ def select_one[T](
     )
     list_window = Window(
         FormattedTextControl(get_choices_tokens),
-        scroll_offsets=ScrollOffsets(top=0, bottom=2),
+        # Keep 1 line of context above the cursor so non-selectable header rows
+        # (e.g. provider group labels) remain visible when wrapping back to the
+        # first selectable item in a scrolled list.
+        scroll_offsets=ScrollOffsets(top=1, bottom=2),
         allow_scroll_beyond_bottom=True,
         dont_extend_height=Always(),
         always_hide_cursor=Always(),
@@ -702,6 +722,28 @@ class SelectOverlay[T]:
             if hasattr(result, "__await__"):
                 event.app.create_background_task(cast(Coroutine[Any, Any, None], result))
 
+        @kb.add(Keys.Tab, filter=is_open_filter, eager=True)
+        def _(event: KeyPressEvent) -> None:
+            indices, _ = self._get_visible_indices()
+            if not indices:
+                self.close()
+                return
+
+            self._pointed_at = _coerce_pointed_at_to_selectable(self._items, indices, self._pointed_at)
+            idx = indices[self._pointed_at % len(indices)]
+            value = self._items[idx].value
+            if value is None:
+                self.close()
+                return
+            self.close()
+
+            if self._on_select is None:
+                return
+
+            result = self._on_select(value)
+            if hasattr(result, "__await__"):
+                event.app.create_background_task(cast(Coroutine[Any, Any, None], result))
+
         @kb.add(Keys.Escape, filter=is_open_filter, eager=True)
         def _(event: KeyPressEvent) -> None:
             if self._use_search_filter and self._search_buffer is not None and self._search_buffer.text:
@@ -757,11 +799,43 @@ class SelectOverlay[T]:
             dont_extend_height=Always(),
             always_hide_cursor=Always(),
         )
+
+        def get_list_height() -> int:
+            # Dynamic height: min of configured height and available terminal space
+            # Overhead: header(1) + spacer(1) + search(1) + frame borders(2) + prompt area(3)
+            overhead = 8
+            try:
+                terminal_height = get_app().output.get_size().rows
+                available = max(3, terminal_height - overhead)
+                cap = min(self._list_height, available)
+            except Exception:
+                cap = self._list_height
+
+            # Shrink list height when content is shorter than the configured cap.
+            # This is especially helpful for small pickers (e.g. thinking level)
+            # where a fixed list_height would otherwise render extra blank rows.
+            indices, _ = self._get_visible_indices()
+            if not indices:
+                return max(1, cap)
+
+            visible_lines = 0
+            for idx in indices:
+                item = self._items[idx]
+                newlines = sum(text.count("\n") for _style, text in item.title)
+                visible_lines += max(1, newlines)
+                if visible_lines >= cap:
+                    break
+
+            return max(1, min(cap, visible_lines))
+
         list_window = Window(
             FormattedTextControl(get_choices_tokens),
-            height=self._list_height,
-            scroll_offsets=ScrollOffsets(top=0, bottom=2),
-            allow_scroll_beyond_bottom=True,
+            height=get_list_height,
+            # See select_one(): keep header rows visible when wrapping.
+            # For embedded overlays, avoid reserving extra blank lines near the
+            # bottom when the list height is tight (e.g. short pickers).
+            scroll_offsets=ScrollOffsets(top=1, bottom=0),
+            allow_scroll_beyond_bottom=False,
             dont_extend_height=Always(),
             always_hide_cursor=Always(),
         )

{klaude_code-2.6.0.dist-info → klaude_code-2.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: klaude-code
-Version: 2.6.0
+Version: 2.8.0
 Summary: Minimal code agent CLI
 Requires-Dist: anthropic>=0.66.0
 Requires-Dist: chardet>=5.2.0
@@ -9,15 +9,13 @@ Requires-Dist: diff-match-patch>=20241021
 Requires-Dist: google-genai>=1.56.0
 Requires-Dist: markdown-it-py>=4.0.0
 Requires-Dist: openai>=1.102.0
-Requires-Dist: pillow>=9.1,<11.0
 Requires-Dist: prompt-toolkit>=3.0.52
 Requires-Dist: pydantic>=2.11.7
 Requires-Dist: pyyaml>=6.0.2
 Requires-Dist: rich>=14.1.0
-Requires-Dist: term-image>=0.7.2
 Requires-Dist: trafilatura>=2.0.0
 Requires-Dist: typer>=0.17.3
-Requires-Python: >=3.13, <3.14
+Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 
 # Klaude Code
@@ -61,20 +59,22 @@ klaude upgrade
 ## Usage
 
 ```bash
-klaude [--model <name>] [--select-model]
+klaude [--model [<name>]] [--continue] [--resume [<id>]]
 ```
 
 **Options:**
-- `--model`/`-m`: Preferred model name (exact match picks immediately; otherwise opens the interactive selector filtered by this value).
-- `--select-model`/`-s`: Open the interactive model selector at startup (shows all models unless `--model` is also provided).
+- `--model`/`-m`: Choose a model.
+  - `--model` (no value): opens the interactive selector.
+  - `--model <value>`: resolves `<value>` to a single model; if it can't, it opens the interactive selector filtered by `<value>`.
 - `--continue`/`-c`: Resume the most recent session.
-- `--resume`/`-r`: Select a session to resume for this project.
-- `--resume-by-id <id>`: Resume a session by its ID directly.
+- `--resume`/`-r`: Resume a session.
+  - `--resume` (no value): select a session to resume for this project.
+  - `--resume <id>`: resume a session by its ID directly.
 - `--vanilla`: Minimal mode with only basic tools (Bash, Read, Edit, Write) and no system prompts.
 
 **Model selection behavior:**
 - Default: uses `main_model` from config.
-- `--select-model`: always prompts you to pick.
+- `--model` (no value): always prompts you to pick.
 - `--model <value>`: tries to resolve `<value>` to a single model; if it can't, it prompts with a filtered list (and falls back to showing all models if there are no matches).
 
 **Debug Options:**