kimi-cli 0.35__py3-none-any.whl → 0.52__py3-none-any.whl

kimi_cli/ui/shell/__init__.py

@@ -1,60 +1,56 @@
 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, TextPart, ToolCall, ToolCallPart
 from kosong.chat_provider import APIStatusError, ChatProviderError
-from kosong.tooling import ToolResult
+from kosong.message import ContentPart
 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, Soul
+from kimi_cli.soul import LLMNotSet, LLMNotSupported, MaxStepsReached, RunCancelled, Soul, run_soul
 from kimi_cli.soul.kimisoul import KimiSoul
-from kimi_cli.soul.wire import (
-    ApprovalRequest,
-    ApprovalResponse,
-    StatusUpdate,
-    StepBegin,
-    StepInterrupted,
-    Wire,
-)
-from kimi_cli.ui import RunCancelled, run_soul
 from kimi_cli.ui.shell.console import console
-from kimi_cli.ui.shell.liveview import StepLiveView
 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.update import UpdateResult, do_update
+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
-
-
-class Reload(Exception):
-    """Reload configuration."""
-
-    pass
+from kimi_cli.utils.signals import install_sigint_handler
+from kimi_cli.utils.term import ensure_new_line
 
 
 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:
         if command is not None:
             # run single command and exit
             logger.info("Running agent with command: {command}", command=command)
-            return await self._run(command)
+            return await self._run_soul_command(command)
+
+        self._start_background_task(self._auto_update())
 
-        self._start_auto_update_task()
+        _print_welcome_info(self.soul.name or "Kimi CLI", self._welcome_info)
 
-        _print_welcome_info(self.soul.name or "Kimi CLI", self.soul.model, 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:
+        with CustomPromptSession(
+            status_provider=lambda: self.soul.status,
+            model_capabilities=self.soul.model_capabilities or set(),
+            initial_thinking=isinstance(self.soul, KimiSoul) and self.soul.thinking,
+        ) as prompt_session:
             while True:
                 try:
+                    ensure_new_line()
                     user_input = await prompt_session.prompt()
                 except KeyboardInterrupt:
                     logger.debug("Exiting by KeyboardInterrupt")
@@ -79,14 +75,17 @@ 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(command)
+                logger.info(
+                    "Running agent command: {command} with thinking {thinking}",
+                    command=user_input.content,
+                    thinking="on" if user_input.thinking else "off",
+                )
+                await self._run_soul_command(user_input.content, user_input.thinking)
 
         return True
 
@@ -96,26 +95,71 @@ 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
+
+        parts = command_str.split(" ")
+        command_name = parts[0]
+        command_args = parts[1:]
+        command = get_meta_command(command_name)
+        if command is None:
+            console.print(f"Meta command /{command_name} not found")
+            return
+        if command.kimi_soul_only and not isinstance(self.soul, KimiSoul):
+            console.print(f"Meta command /{command_name} not supported")
+            return
+        logger.debug(
+            "Running meta command: {command_name} with args: {command_args}",
+            command_name=command_name,
+            command_args=command_args,
+        )
+        try:
+            ret = command.func(self, command_args)
+            if isinstance(ret, Awaitable):
+                await ret
+        except LLMNotSet:
+            logger.error("LLM not set")
+            console.print("[red]LLM not set, send /setup to configure[/red]")
+        except ChatProviderError as e:
+            logger.exception("LLM provider error:")
+            console.print(f"[red]LLM provider error: {e}[/red]")
+        except asyncio.CancelledError:
+            logger.info("Interrupted by user")
+            console.print("[red]Interrupted by user[/red]")
+        except Reload:
+            # just propagate
+            raise
+        except BaseException as e:
+            logger.exception("Unknown error:")
+            console.print(f"[red]Unknown error: {e}[/red]")
+            raise  # re-raise unknown error
 
-    async def _run(self, command: str) -> bool:
+    async def _run_soul_command(
+        self,
+        user_input: str | list[ContentPart],
+        thinking: bool | None = None,
+    ) -> bool:
         """
         Run the soul and handle any known exceptions.
 
@@ -129,14 +173,35 @@ 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:
-            await run_soul(self.soul, command, self._visualize, cancel_event)
+            if isinstance(self.soul, KimiSoul) and thinking is not None:
+                self.soul.set_thinking(thinking)
+
+            # Use lambda to pass cancel_event via closure
+            await run_soul(
+                self.soul,
+                user_input,
+                lambda wire: visualize(
+                    wire,
+                    initial_status=self.soul.status,
+                    cancel_event=cancel_event,
+                ),
+                cancel_event,
+            )
             return True
         except LLMNotSet:
             logger.error("LLM not set")
             console.print("[red]LLM not set, send /setup to configure[/red]")
+        except LLMNotSupported as e:
+            # actually unsupported input/mode should already be blocked by prompt session
+            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:
@@ -153,31 +218,29 @@ class ShellApp:
         except RunCancelled:
             logger.info("Cancelled by user")
             console.print("[red]Interrupted by user[/red]")
-        except Reload:
-            # just propagate
-            raise
         except BaseException as e:
             logger.exception("Unknown error:")
             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:
-        toast("checking for updates...", duration=2.0)
+    async def _auto_update(self) -> None:
+        toast("checking for updates...", topic="update", duration=2.0)
         result = await do_update(print=False, check_only=True)
         if result == UpdateResult.UPDATE_AVAILABLE:
             while True:
-                toast("new version found, run `uv tool upgrade ikimi` to upgrade", duration=30.0)
+                toast(
+                    "new version found, run `uv tool upgrade kimi-cli` to upgrade",
+                    topic="update",
+                    duration=30.0,
+                )
                 await asyncio.sleep(60.0)
         elif result == UpdateResult.UPDATED:
-            toast("auto updated, restart to use the new version", duration=5.0)
+            toast("auto updated, restart to use the new version", topic="update", 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)
 
@@ -193,93 +256,6 @@ class ShellApp:
         task.add_done_callback(_cleanup)
         return task
 
-    async def _visualize(self, wire: Wire):
-        """
-        A loop to consume agent events and visualize the agent behavior.
-        This loop never raise any exception except asyncio.CancelledError.
-        """
-        try:
-            # expect a StepBegin
-            assert isinstance(await wire.receive(), StepBegin)
-
-            while True:
-                # spin the moon at the beginning of each step
-                with console.status("", spinner="moon"):
-                    msg = await wire.receive()
-
-                with StepLiveView(self.soul.status) as step:
-                    # visualization loop for one step
-                    while True:
-                        match msg:
-                            case TextPart(text=text):
-                                step.append_text(text)
-                            case ContentPart():
-                                # TODO: support more content parts
-                                step.append_text(f"[{msg.__class__.__name__}]")
-                            case ToolCall():
-                                step.append_tool_call(msg)
-                            case ToolCallPart():
-                                step.append_tool_call_part(msg)
-                            case ToolResult():
-                                step.append_tool_result(msg)
-                            case ApprovalRequest():
-                                msg.resolve(ApprovalResponse.APPROVE)
-                                # TODO(approval): handle approval request
-                            case StatusUpdate(status=status):
-                                step.update_status(status)
-                            case _:
-                                break  # break the step loop
-                        msg = await wire.receive()
-
-                    # cleanup the step live view
-                    if isinstance(msg, StepInterrupted):
-                        step.interrupt()
-                    else:
-                        step.finish()
-
-                if isinstance(msg, StepInterrupted):
-                    # for StepInterrupted, the visualization loop should end immediately
-                    break
-
-                assert isinstance(msg, StepBegin), "expect a StepBegin"
-                # start a new step
-        except asyncio.QueueShutDown:
-            logger.debug("Visualization loop shutting down")
-
-    async def _run_meta_command(self, command_str: str):
-        parts = command_str.split(" ")
-        command_name = parts[0]
-        command_args = parts[1:]
-        command = get_meta_command(command_name)
-        if command is None:
-            console.print(f"Meta command /{command_name} not found")
-            return
-        if command.kimi_soul_only and not isinstance(self.soul, KimiSoul):
-            console.print(f"Meta command /{command_name} not supported")
-            return
-        logger.debug(
-            "Running meta command: {command_name} with args: {command_args}",
-            command_name=command_name,
-            command_args=command_args,
-        )
-        try:
-            ret = command.func(self, command_args)
-            if isinstance(ret, Awaitable):
-                await ret
-        except LLMNotSet:
-            logger.error("LLM not set")
-            console.print("[red]LLM not set, send /setup to configure[/red]")
-        except ChatProviderError as e:
-            logger.exception("LLM provider error:")
-            console.print(f"[red]LLM provider error: {e}[/red]")
-        except Reload:
-            # just propagate
-            raise
-        except BaseException as e:
-            logger.exception("Unknown error:")
-            console.print(f"[red]Unknown error: {e}[/red]")
-            raise  # re-raise unknown error
-
 
 _KIMI_BLUE = "dodger_blue1"
 _LOGO = f"""\
@@ -290,7 +266,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]")
 
@@ -304,17 +292,20 @@ 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
+
+        latest_version = LATEST_VERSION_FILE.read_text(encoding="utf-8").strip()
+        if semver_tuple(latest_version) > semver_tuple(current_version):
+            rows.append(
+                Text.from_markup(
+                    f"\n[yellow]New version available: {latest_version}. "
+                    "Please run `uv tool upgrade kimi-cli` to upgrade.[/yellow]"
+                )
             )
-        )
 
     console.print(
         Panel(

kimi_cli/ui/shell/console.py

@@ -1,3 +1,29 @@
 from rich.console import Console
+from rich.theme import Theme
 
-console = Console(highlight=False)
+_NEUTRAL_MARKDOWN_THEME = Theme(
+    {
+        "markdown.paragraph": "none",
+        "markdown.block_quote": "none",
+        "markdown.hr": "none",
+        "markdown.item": "none",
+        "markdown.item.bullet": "none",
+        "markdown.item.number": "none",
+        "markdown.link": "none",
+        "markdown.link_url": "none",
+        "markdown.h1": "none",
+        "markdown.h1.border": "none",
+        "markdown.h2": "none",
+        "markdown.h3": "none",
+        "markdown.h4": "none",
+        "markdown.h5": "none",
+        "markdown.h6": "none",
+        "markdown.em": "none",
+        "markdown.strong": "none",
+        "markdown.s": "none",
+        "status.spinner": "none",
+    },
+    inherit=True,
+)
+
+console = Console(highlight=False, theme=_NEUTRAL_MARKDOWN_THEME)

kimi_cli/ui/shell/debug.py

@@ -0,0 +1,187 @@
+import json
+from typing import TYPE_CHECKING
+
+from kosong.message import (
+    AudioURLPart,
+    ContentPart,
+    ImageURLPart,
+    Message,
+    TextPart,
+    ThinkPart,
+    ToolCall,
+)
+from rich.console import Group
+from rich.panel import Panel
+from rich.rule import Rule
+from rich.syntax import Syntax
+from rich.text import Text
+
+from kimi_cli.soul.kimisoul import KimiSoul
+from kimi_cli.ui.shell.console import console
+from kimi_cli.ui.shell.metacmd import meta_command
+
+if TYPE_CHECKING:
+    from kimi_cli.ui.shell import ShellApp
+
+
+def _format_content_part(part: ContentPart) -> Text | Panel | Group:
+    """Format a single content part."""
+    match part:
+        case TextPart(text=text):
+            # Check if it looks like a system tag
+            if text.strip().startswith("<system>") and text.strip().endswith("</system>"):
+                return Panel(
+                    text.strip()[8:-9].strip(),
+                    title="[dim]system[/dim]",
+                    border_style="dim yellow",
+                    padding=(0, 1),
+                )
+            return Text(text, style="white")
+
+        case ThinkPart(think=think):
+            return Panel(
+                think,
+                title="[dim]thinking[/dim]",
+                border_style="dim cyan",
+                padding=(0, 1),
+            )
+
+        case ImageURLPart(image_url=img):
+            url_display = img.url[:80] + "..." if len(img.url) > 80 else img.url
+            id_text = f" (id: {img.id})" if img.id else ""
+            return Text(f"[Image{id_text}] {url_display}", style="blue")
+
+        case AudioURLPart(audio_url=audio):
+            url_display = audio.url[:80] + "..." if len(audio.url) > 80 else audio.url
+            id_text = f" (id: {audio.id})" if audio.id else ""
+            return Text(f"[Audio{id_text}] {url_display}", style="blue")
+
+        case _:
+            return Text(f"[Unknown content type: {type(part).__name__}]", style="red")
+
+
+def _format_tool_call(tool_call: ToolCall) -> Panel:
+    """Format a tool call."""
+    args = tool_call.function.arguments or "{}"
+    try:
+        args_formatted = json.dumps(json.loads(args), indent=2)
+        args_syntax = Syntax(args_formatted, "json", theme="monokai", padding=(0, 1))
+    except json.JSONDecodeError:
+        args_syntax = Text(args, style="red")
+
+    content = Group(
+        Text(f"Function: {tool_call.function.name}", style="bold cyan"),
+        Text(f"Call ID: {tool_call.id}", style="dim"),
+        Text("Arguments:", style="bold"),
+        args_syntax,
+    )
+
+    return Panel(
+        content,
+        title="[bold yellow]Tool Call[/bold yellow]",
+        border_style="yellow",
+        padding=(0, 1),
+    )
+
+
+def _format_message(msg: Message, index: int) -> Panel:
+    """Format a single message."""
+    # Role styling
+    role_colors = {
+        "system": "magenta",
+        "developer": "magenta",
+        "user": "green",
+        "assistant": "blue",
+        "tool": "yellow",
+    }
+    role_color = role_colors.get(msg.role, "white")
+    role_text = f"[bold {role_color}]{msg.role.upper()}[/bold {role_color}]"
+
+    # Add name if present
+    if msg.name:
+        role_text += f" [dim]({msg.name})[/dim]"
+
+    # Add tool call ID for tool messages
+    if msg.tool_call_id:
+        role_text += f" [dim]→ {msg.tool_call_id}[/dim]"
+
+    # Format content
+    content_items: list = []
+
+    if isinstance(msg.content, str):
+        content_items.append(Text(msg.content, style="white"))
+    else:
+        for part in msg.content:
+            formatted = _format_content_part(part)
+            content_items.append(formatted)
+
+    # Add tool calls if present
+    if msg.tool_calls:
+        if content_items:
+            content_items.append(Text())  # Empty line
+        for tool_call in msg.tool_calls:
+            content_items.append(_format_tool_call(tool_call))
+
+    # Combine all content
+    if not content_items:
+        content_items.append(Text("[empty message]", style="dim italic"))
+
+    group = Group(*content_items)
+
+    # Create panel
+    title = f"#{index + 1} {role_text}"
+    if msg.partial:
+        title += " [dim italic](partial)[/dim italic]"
+
+    return Panel(
+        group,
+        title=title,
+        border_style=role_color,
+        padding=(0, 1),
+    )
+
+
+@meta_command(kimi_soul_only=True)
+def debug(app: "ShellApp", args: list[str]):
+    """Debug the context"""
+    assert isinstance(app.soul, KimiSoul)
+
+    context = app.soul._context
+    history = context.history
+
+    if not history:
+        console.print(
+            Panel(
+                "Context is empty - no messages yet",
+                border_style="yellow",
+                padding=(1, 2),
+            )
+        )
+        return
+
+    # Build the debug output
+    output_items = [
+        Panel(
+            Group(
+                Text(f"Total messages: {len(history)}", style="bold"),
+                Text(f"Token count: {context.token_count:,}", style="bold"),
+                Text(f"Checkpoints: {context.n_checkpoints}", style="bold"),
+                Text(f"Trajectory: {context._file_backend}", style="dim"),
+            ),
+            title="[bold]Context Info[/bold]",
+            border_style="cyan",
+            padding=(0, 1),
+        ),
+        Rule(style="dim"),
+    ]
+
+    # Add all messages
+    for idx, msg in enumerate(history):
+        output_items.append(_format_message(msg, idx))
+
+    # Display using rich pager
+    display_group = Group(*output_items)
+
+    # Use pager to display
+    with console.pager(styles=True):
+        console.print(display_group)