kimi-cli 0.41__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:
@@ -31,13 +35,17 @@ class ShellApp:
             logger.info("Running agent with command: {command}", command=command)
             return await self._run_soul_command(command)
 
-        self._start_auto_update_task()
+        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,13 +204,10 @@ 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
 
-    def _start_auto_update_task(self) -> None:
-        self._add_background_task(self._auto_update_background())
-
-    async def _auto_update_background(self) -> None:
+    async def _auto_update(self) -> None:
         toast("checking for updates...", duration=2.0)
         result = await do_update(print=False, check_only=True)
         if result == UpdateResult.UPDATE_AVAILABLE:
@@ -204,7 +217,7 @@ class ShellApp:
         elif result == UpdateResult.UPDATED:
             toast("auto updated, restart to use the new version", duration=5.0)
 
-    def _add_background_task(self, coro: Coroutine[Any, Any, Any]) -> asyncio.Task[Any]:
+    def _start_background_task(self, coro: Coroutine[Any, Any, Any]) -> asyncio.Task[Any]:
         task = asyncio.create_task(coro)
         self._background_tasks.add(task)
 
@@ -230,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]")
 
@@ -244,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/metacmd.py

@@ -9,9 +9,9 @@ from rich.panel import Panel
 
 import kimi_cli.prompts as prompts
 from kimi_cli.soul.context import Context
-from kimi_cli.soul.globals import load_agents_md
 from kimi_cli.soul.kimisoul import KimiSoul
 from kimi_cli.soul.message import system
+from kimi_cli.soul.runtime import load_agents_md
 from kimi_cli.ui.shell.console import console
 from kimi_cli.utils.changelog import CHANGELOG, format_release_notes
 from kimi_cli.utils.logging import logger
@@ -206,12 +206,7 @@ async def init(app: "ShellApp", args: list[str]):
         logger.info("Running `/init`")
         console.print("Analyzing the codebase...")
         tmp_context = Context(file_backend=Path(temp_dir) / "context.jsonl")
-        app.soul = KimiSoul(
-            soul_bak._agent,
-            soul_bak._agent_globals,
-            context=tmp_context,
-            loop_control=soul_bak._loop_control,
-        )
+        app.soul = KimiSoul(soul_bak._agent, soul_bak._runtime, context=tmp_context)
         ok = await app._run_soul_command(prompts.INIT)
 
         if ok:
@@ -223,7 +218,7 @@ async def init(app: "ShellApp", args: list[str]):
             console.print("[red]Failed to analyze the codebase.[/red]")
 
     app.soul = soul_bak
-    agents_md = load_agents_md(soul_bak._agent_globals.builtin_args.KIMI_WORK_DIR)
+    agents_md = load_agents_md(soul_bak._runtime.builtin_args.KIMI_WORK_DIR)
     system_message = system(
         "The user just ran `/init` meta command. "
         "The system has analyzed the codebase and generated an `AGENTS.md` file. "