kimi-cli 0.42__py3-none-any.whl → 0.43__py3-none-any.whl

kimi_cli/ui/shell/__init__.py

@@ -1,28 +1,32 @@
 import asyncio
-import signal
 from collections.abc import Awaitable, Coroutine
+from dataclasses import dataclass
+from enum import Enum
 from typing import Any
 
+from kosong.base.message import ContentPart
 from kosong.chat_provider import APIStatusError, ChatProviderError
 from rich.console import Group, RenderableType
 from rich.panel import Panel
 from rich.table import Table
 from rich.text import Text
 
-from kimi_cli.soul import LLMNotSet, MaxStepsReached, RunCancelled, Soul, run_soul
+from kimi_cli.soul import LLMNotSet, LLMNotSupported, MaxStepsReached, RunCancelled, Soul, run_soul
 from kimi_cli.soul.kimisoul import KimiSoul
 from kimi_cli.ui.shell.console import console
 from kimi_cli.ui.shell.metacmd import get_meta_command
-from kimi_cli.ui.shell.prompt import CustomPromptSession, PromptMode, toast
+from kimi_cli.ui.shell.prompt import CustomPromptSession, PromptMode, ensure_new_line, toast
+from kimi_cli.ui.shell.replay import replay_recent_history
 from kimi_cli.ui.shell.update import LATEST_VERSION_FILE, UpdateResult, do_update, semver_tuple
 from kimi_cli.ui.shell.visualize import visualize
 from kimi_cli.utils.logging import logger
+from kimi_cli.utils.signals import install_sigint_handler
 
 
 class ShellApp:
-    def __init__(self, soul: Soul, welcome_info: dict[str, str] | None = None):
+    def __init__(self, soul: Soul, welcome_info: list["WelcomeInfoItem"] | None = None):
         self.soul = soul
-        self.welcome_info = welcome_info or {}
+        self._welcome_info = list(welcome_info or [])
         self._background_tasks: set[asyncio.Task[Any]] = set()
 
     async def run(self, command: str | None = None) -> bool:
@@ -33,11 +37,15 @@ class ShellApp:
 
         self._start_background_task(self._auto_update())
 
-        _print_welcome_info(self.soul.name or "Kimi CLI", self.soul.model, self.welcome_info)
+        _print_welcome_info(self.soul.name or "Kimi CLI", self._welcome_info)
+
+        if isinstance(self.soul, KimiSoul):
+            await replay_recent_history(self.soul.context.history)
 
         with CustomPromptSession(lambda: self.soul.status) as prompt_session:
             while True:
                 try:
+                    ensure_new_line()
                     user_input = await prompt_session.prompt()
                 except KeyboardInterrupt:
                     logger.debug("Exiting by KeyboardInterrupt")
@@ -62,14 +70,13 @@ class ShellApp:
                     await self._run_shell_command(user_input.command)
                     continue
 
-                command = user_input.command
-                if command.startswith("/"):
-                    logger.debug("Running meta command: {command}", command=command)
-                    await self._run_meta_command(command[1:])
+                if user_input.command.startswith("/"):
+                    logger.debug("Running meta command: {command}", command=user_input.command)
+                    await self._run_meta_command(user_input.command[1:])
                     continue
 
-                logger.info("Running agent command: {command}", command=command)
-                await self._run_soul_command(command)
+                logger.info("Running agent command: {command}", command=user_input.content)
+                await self._run_soul_command(user_input.content)
 
         return True
 
@@ -79,24 +86,26 @@ class ShellApp:
             return
 
         logger.info("Running shell command: {cmd}", cmd=command)
+
+        proc: asyncio.subprocess.Process | None = None
+
+        def _handler():
+            logger.debug("SIGINT received.")
+            if proc:
+                proc.terminate()
+
         loop = asyncio.get_running_loop()
+        remove_sigint = install_sigint_handler(loop, _handler)
         try:
             # TODO: For the sake of simplicity, we now use `create_subprocess_shell`.
             # Later we should consider making this behave like a real shell.
             proc = await asyncio.create_subprocess_shell(command)
-
-            def _handler():
-                logger.debug("SIGINT received.")
-                proc.terminate()
-
-            loop.add_signal_handler(signal.SIGINT, _handler)
-
             await proc.wait()
         except Exception as e:
             logger.exception("Failed to run shell command:")
             console.print(f"[red]Failed to run shell command: {e}[/red]")
         finally:
-            loop.remove_signal_handler(signal.SIGINT)
+            remove_sigint()
 
     async def _run_meta_command(self, command_str: str):
         from kimi_cli.cli import Reload
@@ -137,7 +146,7 @@ class ShellApp:
             console.print(f"[red]Unknown error: {e}[/red]")
             raise  # re-raise unknown error
 
-    async def _run_soul_command(self, command: str) -> bool:
+    async def _run_soul_command(self, user_input: str | list[ContentPart]) -> bool:
         """
         Run the soul and handle any known exceptions.
 
@@ -151,13 +160,13 @@ class ShellApp:
             cancel_event.set()
 
         loop = asyncio.get_running_loop()
-        loop.add_signal_handler(signal.SIGINT, _handler)
+        remove_sigint = install_sigint_handler(loop, _handler)
 
         try:
             # Use lambda to pass cancel_event via closure
             await run_soul(
                 self.soul,
-                command,
+                user_input,
                 lambda wire: visualize(
                     wire, initial_status=self.soul.status, cancel_event=cancel_event
                 ),
@@ -167,6 +176,13 @@ class ShellApp:
         except LLMNotSet:
             logger.error("LLM not set")
             console.print("[red]LLM not set, send /setup to configure[/red]")
+        except LLMNotSupported as e:
+            logger.error(
+                "LLM model '{model_name}' does not support required capabilities: {capabilities}",
+                model_name=e.llm.model_name,
+                capabilities=", ".join(e.capabilities),
+            )
+            console.print(f"[red]{e}[/red]")
         except ChatProviderError as e:
             logger.exception("LLM provider error:")
             if isinstance(e, APIStatusError) and e.status_code == 401:
@@ -188,7 +204,7 @@ class ShellApp:
             console.print(f"[red]Unknown error: {e}[/red]")
             raise  # re-raise unknown error
         finally:
-            loop.remove_signal_handler(signal.SIGINT)
+            remove_sigint()
         return False
 
     async def _auto_update(self) -> None:
@@ -227,7 +243,19 @@ _LOGO = f"""\
 """
 
 
-def _print_welcome_info(name: str, model: str, info_items: dict[str, str]) -> None:
+@dataclass(slots=True)
+class WelcomeInfoItem:
+    class Level(Enum):
+        INFO = "grey50"
+        WARN = "yellow"
+        ERROR = "red"
+
+    name: str
+    value: str
+    level: Level = Level.INFO
+
+
+def _print_welcome_info(name: str, info_items: list[WelcomeInfoItem]) -> None:
     head = Text.from_markup(f"[bold]Welcome to {name}![/bold]")
     help_text = Text.from_markup("[grey50]Send /help for help information.[/grey50]")
 
@@ -241,17 +269,8 @@ def _print_welcome_info(name: str, model: str, info_items: dict[str, str]) -> No
     rows: list[RenderableType] = [table]
 
     rows.append(Text(""))  # Empty line
-    rows.extend(
-        Text.from_markup(f"[grey50]{key}: {value}[/grey50]") for key, value in info_items.items()
-    )
-    if model:
-        rows.append(Text.from_markup(f"[grey50]Model: {model}[/grey50]"))
-    else:
-        rows.append(
-            Text.from_markup(
-                "[grey50]Model:[/grey50] [yellow]not set, send /setup to configure[/yellow]"
-            )
-        )
+    for item in info_items:
+        rows.append(Text(f"{item.name}: {item.value}", style=item.level.value))
 
     if LATEST_VERSION_FILE.exists():
         from kimi_cli.constant import VERSION as current_version

kimi_cli/ui/shell/keyboard.py

@@ -1,6 +1,5 @@
 import asyncio
 import sys
-import termios
 import threading
 import time
 from collections.abc import AsyncGenerator, Callable
@@ -47,6 +46,21 @@ def _listen_for_keyboard_thread(
     cancel: threading.Event,
     emit: Callable[[KeyEvent], None],
 ) -> None:
+    if sys.platform == "win32":
+        _listen_for_keyboard_windows(cancel, emit)
+    else:
+        _listen_for_keyboard_unix(cancel, emit)
+
+
+def _listen_for_keyboard_unix(
+    cancel: threading.Event,
+    emit: Callable[[KeyEvent], None],
+) -> None:
+    if sys.platform == "win32":
+        raise RuntimeError("Unix keyboard listener requires a non-Windows platform")
+
+    import termios
+
     # make stdin raw and non-blocking
     fd = sys.stdin.fileno()
     oldterm = termios.tcgetattr(fd)
@@ -59,9 +73,9 @@ def _listen_for_keyboard_thread(
     try:
         while not cancel.is_set():
             try:
-                c = sys.stdin.read(1)
+                c = sys.stdin.buffer.read(1)
             except (OSError, ValueError):
-                c = ""
+                c = b""
 
             if not c:
                 if cancel.is_set():
@@ -69,15 +83,15 @@ def _listen_for_keyboard_thread(
                 time.sleep(0.01)
                 continue
 
-            if c == "\x1b":
+            if c == b"\x1b":
                 sequence = c
                 for _ in range(2):
                     if cancel.is_set():
                         break
                     try:
-                        fragment = sys.stdin.read(1)
+                        fragment = sys.stdin.buffer.read(1)
                     except (OSError, ValueError):
-                        fragment = ""
+                        fragment = b""
                     if not fragment:
                         break
                     sequence += fragment
@@ -87,22 +101,76 @@ def _listen_for_keyboard_thread(
                 event = _ARROW_KEY_MAP.get(sequence)
                 if event is not None:
                     emit(event)
-                elif sequence == "\x1b":
+                elif sequence == b"\x1b":
                     emit(KeyEvent.ESCAPE)
-            elif c in ("\r", "\n"):
+            elif c in (b"\r", b"\n"):
                 emit(KeyEvent.ENTER)
-            elif c == "\t":
+            elif c == b"\t":
                 emit(KeyEvent.TAB)
     finally:
         # restore the terminal settings
         termios.tcsetattr(fd, termios.TCSAFLUSH, oldterm)
 
 
-_ARROW_KEY_MAP: dict[str, KeyEvent] = {
-    "\x1b[A": KeyEvent.UP,
-    "\x1b[B": KeyEvent.DOWN,
-    "\x1b[C": KeyEvent.RIGHT,
-    "\x1b[D": KeyEvent.LEFT,
+def _listen_for_keyboard_windows(
+    cancel: threading.Event,
+    emit: Callable[[KeyEvent], None],
+) -> None:
+    if sys.platform != "win32":
+        raise RuntimeError("Windows keyboard listener requires a Windows platform")
+
+    import msvcrt
+
+    while not cancel.is_set():
+        if msvcrt.kbhit():
+            c = msvcrt.getch()
+
+            # Handle special keys (arrow keys, etc.)
+            if c in (b"\x00", b"\xe0"):
+                # Extended key, read the next byte
+                extended = msvcrt.getch()
+                event = _WINDOWS_KEY_MAP.get(extended)
+                if event is not None:
+                    emit(event)
+            elif c == b"\x1b":
+                sequence = c
+                for _ in range(2):
+                    if cancel.is_set():
+                        break
+                    fragment = msvcrt.getch() if msvcrt.kbhit() else b""
+                    if not fragment:
+                        break
+                    sequence += fragment
+                    if sequence in _ARROW_KEY_MAP:
+                        break
+
+                event = _ARROW_KEY_MAP.get(sequence)
+                if event is not None:
+                    emit(event)
+                elif sequence == b"\x1b":
+                    emit(KeyEvent.ESCAPE)
+            elif c in (b"\r", b"\n"):
+                emit(KeyEvent.ENTER)
+            elif c == b"\t":
+                emit(KeyEvent.TAB)
+        else:
+            if cancel.is_set():
+                break
+            time.sleep(0.01)
+
+
+_ARROW_KEY_MAP: dict[bytes, KeyEvent] = {
+    b"\x1b[A": KeyEvent.UP,
+    b"\x1b[B": KeyEvent.DOWN,
+    b"\x1b[C": KeyEvent.RIGHT,
+    b"\x1b[D": KeyEvent.LEFT,
+}
+
+_WINDOWS_KEY_MAP: dict[bytes, KeyEvent] = {
+    b"H": KeyEvent.UP,  # Up arrow
+    b"P": KeyEvent.DOWN,  # Down arrow
+    b"M": KeyEvent.RIGHT,  # Right arrow
+    b"K": KeyEvent.LEFT,  # Left arrow
 }
 
 

kimi_cli/ui/shell/prompt.py

@@ -1,19 +1,25 @@
 import asyncio
+import base64
 import contextlib
 import getpass
 import json
 import os
 import re
+import sys
 import time
 from collections.abc import Callable
 from datetime import datetime
 from enum import Enum
 from hashlib import md5
+from io import BytesIO
 from pathlib import Path
 from typing import override
 
+from kosong.base.message import ContentPart, ImageURLPart, TextPart
+from PIL import Image, ImageGrab
 from prompt_toolkit import PromptSession
 from prompt_toolkit.application.current import get_app_or_none
+from prompt_toolkit.clipboard.pyperclip import PyperclipClipboard
 from prompt_toolkit.completion import (
     Completer,
     Completion,
@@ -34,6 +40,9 @@ from kimi_cli.share import get_share_dir
 from kimi_cli.soul import StatusSnapshot
 from kimi_cli.ui.shell.metacmd import get_meta_commands
 from kimi_cli.utils.logging import logger
+from kimi_cli.utils.string import random_string
+
+PROMPT_SYMBOL = "✨"
 
 
 class MetaCommandCompleter(Completer):
@@ -360,6 +369,9 @@ class PromptMode(Enum):
 class UserInput(BaseModel):
     mode: PromptMode
     command: str
+    """The plain text representation of the user input."""
+    content: list[ContentPart]
+    """The rich content parts."""
 
     def __str__(self) -> str:
         return self.command
@@ -377,6 +389,11 @@ def toast(message: str, duration: float = 5.0) -> None:
     _toast_queue.put_nowait((message, duration))
 
 
+_ATTACHMENT_PLACEHOLDER_RE = re.compile(
+    r"\[(?P<type>image):(?P<id>[a-zA-Z0-9_\-\.]+)(?:,(?P<width>\d+)x(?P<height>\d+))?\]"
+)
+
+
 class CustomPromptSession:
     def __init__(self, status_provider: Callable[[], StatusSnapshot]):
         history_dir = get_share_dir() / "user-history"
@@ -386,6 +403,8 @@ class CustomPromptSession:
         self._status_provider = status_provider
         self._last_history_content: str | None = None
         self._mode: PromptMode = PromptMode.AGENT
+        self._attachment_parts: dict[str, ContentPart] = {}
+        """Mapping from attachment id to ContentPart."""
 
         history_entries = _load_history_entries(self._history_file)
         history = InMemoryHistory()
@@ -433,12 +452,20 @@ class CustomPromptSession:
             # Redraw UI
             event.app.invalidate()
 
+        @_kb.add("c-v", eager=True)
+        def _paste(event: KeyPressEvent) -> None:
+            if self._try_paste_image(event):
+                return
+            clipboard_data = event.app.clipboard.get_data()
+            event.current_buffer.paste_clipboard_data(clipboard_data)
+
         self._session = PromptSession(
             message=self._render_message,
-            prompt_continuation=FormattedText([("fg:#4d4d4d", "... ")]),
+            # prompt_continuation=FormattedText([("fg:#4d4d4d", "... ")]),
             completer=self._agent_mode_completer,
             complete_while_typing=True,
             key_bindings=_kb,
+            clipboard=PyperclipClipboard(),
             history=history,
             bottom_toolbar=self._render_bottom_toolbar,
         )
@@ -448,7 +475,7 @@ class CustomPromptSession:
         self._current_toast_duration: float = 0.0
 
     def _render_message(self) -> FormattedText:
-        symbol = "✨" if self._mode == PromptMode.AGENT else "$"
+        symbol = PROMPT_SYMBOL if self._mode == PromptMode.AGENT else "$"
         return FormattedText([("bold", f"{getpass.getuser()}{symbol} ")])
 
     def _apply_mode(self, event: KeyPressEvent | None = None) -> None:
@@ -501,12 +528,75 @@ class CustomPromptSession:
         if self._status_refresh_task is not None and not self._status_refresh_task.done():
             self._status_refresh_task.cancel()
         self._status_refresh_task = None
+        self._attachment_parts.clear()
+
+    def _try_paste_image(self, event: KeyPressEvent) -> bool:
+        """Try to paste an image from the clipboard. Return True if successful."""
+        # Try get image from clipboard
+        image = ImageGrab.grabclipboard()
+        if isinstance(image, list):
+            for item in image:
+                try:
+                    with Image.open(item) as img:
+                        image = img.copy()
+                    break
+                except Exception:
+                    continue
+            else:
+                image = None
+
+        if image is None:
+            return False
+
+        attachment_id = f"{random_string(8)}.png"
+        png_bytes = BytesIO()
+        image.save(png_bytes, format="PNG")
+        png_base64 = base64.b64encode(png_bytes.getvalue()).decode("ascii")
+        image_part = ImageURLPart(
+            image_url=ImageURLPart.ImageURL(
+                url=f"data:image/png;base64,{png_base64}", id=attachment_id
+            )
+        )
+        self._attachment_parts[attachment_id] = image_part
+        logger.debug(
+            "Pasted image from clipboard: {attachment_id}, {image_size}",
+            attachment_id=attachment_id,
+            image_size=image.size,
+        )
+
+        placeholder = f"[image:{attachment_id},{image.width}x{image.height}]"
+        event.current_buffer.insert_text(placeholder)
+        event.app.invalidate()
+        return True
 
     async def prompt(self) -> UserInput:
         with patch_stdout():
             command = str(await self._session.prompt_async()).strip()
         self._append_history_entry(command)
-        return UserInput(mode=self._mode, command=command)
+
+        # Parse rich content parts
+        content: list[ContentPart] = []
+        remaining_command = command
+        while match := _ATTACHMENT_PLACEHOLDER_RE.search(remaining_command):
+            start, end = match.span()
+            if start > 0:
+                content.append(TextPart(text=remaining_command[:start]))
+            attachment_id = match.group("id")
+            part = self._attachment_parts.get(attachment_id)
+            if part is not None:
+                content.append(part)
+            else:
+                logger.warning(
+                    "Attachment placeholder found but no matching attachment part: {placeholder}",
+                    placeholder=match.group(0),
+                )
+                content.append(TextPart(text=match.group(0)))
+            remaining_command = remaining_command[end:]
+
+        if remaining_command.strip():
+            content.append(TextPart(text=remaining_command.strip()))
+
+        return UserInput(mode=self._mode, content=content, command=command)
 
     def _append_history_entry(self, text: str) -> None:
         entry = _HistoryEntry(content=text.strip())
@@ -557,6 +647,7 @@ class CustomPromptSession:
             shortcuts = [
                 "ctrl-x: switch mode",
                 "ctrl-j: newline",
+                "ctrl-v: paste",
                 "ctrl-d: exit",
             ]
             for shortcut in shortcuts:
@@ -579,3 +670,107 @@ class CustomPromptSession:
     def _format_status(status: StatusSnapshot) -> str:
         bounded = max(0.0, min(status.context_usage, 1.0))
         return f"context: {bounded:.1%}"
+
+
+def ensure_new_line() -> None:
+    """Ensure the next prompt starts at column 0 regardless of prior command output."""
+
+    if not sys.stdout.isatty() or not sys.stdin.isatty():
+        return
+
+    needs_break = True
+    if sys.platform == "win32":
+        column = _cursor_column_windows()
+        needs_break = column not in (None, 0)
+    else:
+        column = _cursor_column_unix()
+        needs_break = column not in (None, 1)
+
+    if needs_break:
+        _write_newline()
+
+
+def _cursor_column_unix() -> int | None:
+    assert sys.platform != "win32"
+
+    import select
+    import termios
+    import tty
+
+    _CURSOR_QUERY = "\x1b[6n"
+    _CURSOR_POSITION_RE = re.compile(r"\x1b\[(\d+);(\d+)R")
+
+    fd = sys.stdin.fileno()
+    oldterm = termios.tcgetattr(fd)
+
+    try:
+        tty.setcbreak(fd)
+        sys.stdout.write(_CURSOR_QUERY)
+        sys.stdout.flush()
+
+        response = ""
+        deadline = time.monotonic() + 0.2
+        while time.monotonic() < deadline:
+            timeout = max(0.01, deadline - time.monotonic())
+            ready, _, _ = select.select([sys.stdin], [], [], timeout)
+            if not ready:
+                continue
+            try:
+                chunk = os.read(fd, 32)
+            except OSError:
+                break
+            if not chunk:
+                break
+            response += chunk.decode(errors="ignore")
+            match = _CURSOR_POSITION_RE.search(response)
+            if match:
+                return int(match.group(2))
+    finally:
+        termios.tcsetattr(fd, termios.TCSADRAIN, oldterm)
+
+    return None
+
+
+def _cursor_column_windows() -> int | None:
+    assert sys.platform == "win32"
+
+    import ctypes
+    from ctypes import wintypes
+
+    kernel32 = ctypes.windll.kernel32
+    _STD_OUTPUT_HANDLE = -11  # Windows API constant for standard output handle
+    handle = kernel32.GetStdHandle(_STD_OUTPUT_HANDLE)
+    invalid_handle_value = ctypes.c_void_p(-1).value
+    if handle in (0, invalid_handle_value):
+        return None
+
+    class COORD(ctypes.Structure):
+        _fields_ = [("X", wintypes.SHORT), ("Y", wintypes.SHORT)]
+
+    class SMALL_RECT(ctypes.Structure):
+        _fields_ = [
+            ("Left", wintypes.SHORT),
+            ("Top", wintypes.SHORT),
+            ("Right", wintypes.SHORT),
+            ("Bottom", wintypes.SHORT),
+        ]
+
+    class CONSOLE_SCREEN_BUFFER_INFO(ctypes.Structure):
+        _fields_ = [
+            ("dwSize", COORD),
+            ("dwCursorPosition", COORD),
+            ("wAttributes", wintypes.WORD),
+            ("srWindow", SMALL_RECT),
+            ("dwMaximumWindowSize", COORD),
+        ]
+
+    csbi = CONSOLE_SCREEN_BUFFER_INFO()
+    if not kernel32.GetConsoleScreenBufferInfo(handle, ctypes.byref(csbi)):
+        return None
+
+    return int(csbi.dwCursorPosition.X)
+
+
+def _write_newline() -> None:
+    sys.stdout.write("\n")
+    sys.stdout.flush()