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

kimi_cli/ui/shell/__init__.py

@@ -1,11 +1,10 @@
 import asyncio
 import signal
 from collections.abc import Awaitable, Coroutine
+from functools import partial
 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 rich.console import Group, RenderableType
 from rich.panel import Panel
 from rich.table import Table
@@ -13,20 +12,12 @@ from rich.text import Text
 
 from kimi_cli.soul import LLMNotSet, MaxStepsReached, 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.visualize import visualize
 from kimi_cli.utils.logging import logger
 
 
@@ -46,7 +37,7 @@ class ShellApp:
         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_auto_update_task()
 
@@ -86,7 +77,7 @@ class ShellApp:
                     continue
 
                 logger.info("Running agent command: {command}", command=command)
-                await self._run(command)
+                await self._run_soul_command(command)
 
         return True
 
@@ -115,7 +106,44 @@ class ShellApp:
         finally:
             loop.remove_signal_handler(signal.SIGINT)
 
-    async def _run(self, command: str) -> bool:
+    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 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_soul_command(self, command: str) -> bool:
         """
         Run the soul and handle any known exceptions.
 
@@ -132,7 +160,12 @@ class ShellApp:
         loop.add_signal_handler(signal.SIGINT, _handler)
 
         try:
-            await run_soul(self.soul, command, self._visualize, cancel_event)
+            await run_soul(
+                self.soul,
+                command,
+                partial(visualize, initial_status=self.soul.status),
+                cancel_event,
+            )
             return True
         except LLMNotSet:
             logger.error("LLM not set")
@@ -193,93 +226,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"""\

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.base.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)

kimi_cli/ui/shell/keyboard.py

@@ -0,0 +1,115 @@
+import asyncio
+import sys
+import termios
+import threading
+import time
+from collections.abc import AsyncGenerator, Callable
+from enum import Enum, auto
+
+
+class KeyEvent(Enum):
+    UP = auto()
+    DOWN = auto()
+    LEFT = auto()
+    RIGHT = auto()
+    ENTER = auto()
+    ESCAPE = auto()
+    TAB = auto()
+
+
+async def listen_for_keyboard() -> AsyncGenerator[KeyEvent]:
+    loop = asyncio.get_running_loop()
+    queue = asyncio.Queue[KeyEvent]()
+    cancel_event = threading.Event()
+
+    def emit(event: KeyEvent) -> None:
+        # print(f"emit: {event}")
+        loop.call_soon_threadsafe(queue.put_nowait, event)
+
+    listener = threading.Thread(
+        target=_listen_for_keyboard_thread,
+        args=(cancel_event, emit),
+        name="kimi-cli-keyboard-listener",
+        daemon=True,
+    )
+    listener.start()
+
+    try:
+        while True:
+            yield await queue.get()
+    finally:
+        cancel_event.set()
+        if listener.is_alive():
+            await asyncio.to_thread(listener.join)
+
+
+def _listen_for_keyboard_thread(
+    cancel: threading.Event,
+    emit: Callable[[KeyEvent], None],
+) -> None:
+    # make stdin raw and non-blocking
+    fd = sys.stdin.fileno()
+    oldterm = termios.tcgetattr(fd)
+    newattr = termios.tcgetattr(fd)
+    newattr[3] = newattr[3] & ~termios.ICANON & ~termios.ECHO
+    newattr[6][termios.VMIN] = 0
+    newattr[6][termios.VTIME] = 0
+    termios.tcsetattr(fd, termios.TCSANOW, newattr)
+
+    try:
+        while not cancel.is_set():
+            try:
+                c = sys.stdin.read(1)
+            except (OSError, ValueError):
+                c = ""
+
+            if not c:
+                if cancel.is_set():
+                    break
+                time.sleep(0.01)
+                continue
+
+            if c == "\x1b":
+                sequence = c
+                for _ in range(2):
+                    if cancel.is_set():
+                        break
+                    try:
+                        fragment = sys.stdin.read(1)
+                    except (OSError, ValueError):
+                        fragment = ""
+                    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 == "\x1b":
+                    emit(KeyEvent.ESCAPE)
+            elif c in ("\r", "\n"):
+                emit(KeyEvent.ENTER)
+            elif c == "\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,
+}
+
+
+if __name__ == "__main__":
+
+    async def dev_main():
+        async for event in listen_for_keyboard():
+            print(event)
+
+    asyncio.run(dev_main())