kimi-cli 0.44__py3-none-any.whl → 0.78__py3-none-any.whl

kimi_cli/ui/print/visualize.py

@@ -0,0 +1,179 @@
+from dataclasses import dataclass
+from typing import Protocol
+
+import rich
+from kosong.message import Message
+
+from kimi_cli.cli import OutputFormat
+from kimi_cli.soul.message import tool_result_to_message
+from kimi_cli.utils.aioqueue import QueueShutDown
+from kimi_cli.wire import Wire
+from kimi_cli.wire.types import (
+    ContentPart,
+    StepBegin,
+    StepInterrupted,
+    ToolCall,
+    ToolCallPart,
+    ToolResult,
+    WireMessage,
+)
+
+
+class Printer(Protocol):
+    def feed(self, msg: WireMessage) -> None: ...
+    def flush(self) -> None: ...
+
+
+def _merge_content(buffer: list[ContentPart], part: ContentPart) -> None:
+    if not buffer or not buffer[-1].merge_in_place(part):
+        buffer.append(part)
+
+
+class TextPrinter(Printer):
+    def feed(self, msg: WireMessage) -> None:
+        rich.print(msg)
+
+    def flush(self) -> None:
+        pass
+
+
+class JsonPrinter(Printer):
+    @dataclass(slots=True)
+    class _ToolCallState:
+        tool_call: ToolCall
+        tool_result: ToolResult | None
+
+    def __init__(self) -> None:
+        self._content_buffer: list[ContentPart] = []
+        """The buffer to merge content parts."""
+        self._tool_call_buffer: dict[str, JsonPrinter._ToolCallState] = {}
+        """The buffer to store tool calls and their results."""
+        self._last_tool_call: ToolCall | None = None
+
+    def feed(self, msg: WireMessage) -> None:
+        match msg:
+            case StepBegin() | StepInterrupted():
+                self.flush()
+            case ContentPart() as part:
+                # merge with previous parts as much as possible
+                _merge_content(self._content_buffer, part)
+            case ToolCall() as call:
+                self._tool_call_buffer[call.id] = JsonPrinter._ToolCallState(
+                    tool_call=call, tool_result=None
+                )
+                self._last_tool_call = call
+            case ToolCallPart() as part:
+                if self._last_tool_call is None:
+                    return
+                assert self._last_tool_call.merge_in_place(part)
+            case ToolResult() as result:
+                state = self._tool_call_buffer.get(result.tool_call_id)
+                if state is None:
+                    return
+                state.tool_result = result
+            case _:
+                # ignore other messages
+                pass
+
+    def flush(self) -> None:
+        if not self._content_buffer and not self._tool_call_buffer:
+            return
+
+        tool_calls: list[ToolCall] = []
+        tool_results: list[ToolResult] = []
+        for state in self._tool_call_buffer.values():
+            if state.tool_result is None:
+                # this should only happen when interrupted
+                continue
+            tool_calls.append(state.tool_call)
+            tool_results.append(state.tool_result)
+
+        message = Message(
+            role="assistant",
+            content=self._content_buffer,
+            tool_calls=tool_calls or None,
+        )
+        print(message.model_dump_json(exclude_none=True), flush=True)
+
+        for result in tool_results:
+            # FIXME: this assumes the way how the soul convert `ToolResult` to `Message`
+            message = tool_result_to_message(result)
+            print(message.model_dump_json(exclude_none=True), flush=True)
+
+        self._content_buffer.clear()
+        self._tool_call_buffer.clear()
+
+
+class FinalOnlyTextPrinter(Printer):
+    def __init__(self) -> None:
+        self._content_buffer: list[ContentPart] = []
+
+    def feed(self, msg: WireMessage) -> None:
+        match msg:
+            case StepBegin() | StepInterrupted():
+                self._content_buffer.clear()
+            case ContentPart() as part:
+                _merge_content(self._content_buffer, part)
+            case _:
+                pass
+
+    def flush(self) -> None:
+        if not self._content_buffer:
+            return
+        message = Message(role="assistant", content=self._content_buffer)
+        text = message.extract_text()
+        if text:
+            print(text, flush=True)
+        self._content_buffer.clear()
+
+
+class FinalOnlyJsonPrinter(Printer):
+    def __init__(self) -> None:
+        self._content_buffer: list[ContentPart] = []
+
+    def feed(self, msg: WireMessage) -> None:
+        match msg:
+            case StepBegin() | StepInterrupted():
+                self._content_buffer.clear()
+            case ContentPart() as part:
+                _merge_content(self._content_buffer, part)
+            case _:
+                pass
+
+    def flush(self) -> None:
+        if not self._content_buffer:
+            return
+        message = Message(role="assistant", content=self._content_buffer)
+        text = message.extract_text()
+        if text:
+            final_message = Message(role="assistant", content=text)
+            print(final_message.model_dump_json(exclude_none=True), flush=True)
+        self._content_buffer.clear()
+
+
+async def visualize(output_format: OutputFormat, final_only: bool, wire: Wire) -> None:
+    if final_only:
+        match output_format:
+            case "text":
+                handler = FinalOnlyTextPrinter()
+            case "stream-json":
+                handler = FinalOnlyJsonPrinter()
+    else:
+        match output_format:
+            case "text":
+                handler = TextPrinter()
+            case "stream-json":
+                handler = JsonPrinter()
+
+    wire_ui = wire.ui_side(merge=True)
+    while True:
+        try:
+            msg = await wire_ui.receive()
+        except QueueShutDown:
+            handler.flush()
+            break
+
+        handler.feed(msg)
+
+        if isinstance(msg, StepInterrupted):
+            break

kimi_cli/ui/shell/__init__.py

@@ -1,11 +1,14 @@
+from __future__ import annotations
+
 import asyncio
+import shlex
 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 loguru import logger
 from rich.console import Group, RenderableType
 from rich.panel import Panel
 from rich.table import Table
@@ -14,20 +17,34 @@ from rich.text import Text
 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, ensure_new_line, toast
+from kimi_cli.ui.shell.prompt import CustomPromptSession, PromptMode, toast
 from kimi_cli.ui.shell.replay import replay_recent_history
+from kimi_cli.ui.shell.slash import registry as shell_slash_registry
+from kimi_cli.ui.shell.slash import shell_mode_registry
 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.envvar import get_env_bool
 from kimi_cli.utils.signals import install_sigint_handler
+from kimi_cli.utils.slashcmd import SlashCommand, SlashCommandCall, parse_slash_command_call
+from kimi_cli.utils.term import ensure_new_line, ensure_tty_sane
+from kimi_cli.wire.types import ContentPart, StatusUpdate
 
 
-class ShellApp:
-    def __init__(self, soul: Soul, welcome_info: list["WelcomeInfoItem"] | None = None):
+class Shell:
+    def __init__(self, soul: Soul, welcome_info: list[WelcomeInfoItem] | None = None):
         self.soul = soul
         self._welcome_info = list(welcome_info or [])
         self._background_tasks: set[asyncio.Task[Any]] = set()
+        self._available_slash_commands: dict[str, SlashCommand[Any]] = {
+            **{cmd.name: cmd for cmd in soul.available_slash_commands},
+            **{cmd.name: cmd for cmd in shell_slash_registry.list_commands()},
+        }
+        """Shell-level slash commands + soul-level slash commands. Name to command mapping."""
+
+    @property
+    def available_slash_commands(self) -> dict[str, SlashCommand[Any]]:
+        """Get all available slash commands, including shell-level and soul-level commands."""
+        return self._available_slash_commands
 
     async def run(self, command: str | None = None) -> bool:
         if command is not None:
@@ -35,48 +52,64 @@ class ShellApp:
             logger.info("Running agent with command: {command}", command=command)
             return await self._run_soul_command(command)
 
-        self._start_background_task(self._auto_update())
+        # Start auto-update background task if not disabled
+        if get_env_bool("KIMI_CLI_NO_AUTO_UPDATE"):
+            logger.info("Auto-update disabled by KIMI_CLI_NO_AUTO_UPDATE environment variable")
+        else:
+            self._start_background_task(self._auto_update())
 
         _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)
+            await replay_recent_history(
+                self.soul.context.history,
+                wire_file=self.soul.wire_file,
+            )
 
-        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")
-                    console.print("[grey50]Tip: press Ctrl-D or send 'exit' to quit[/grey50]")
-                    continue
-                except EOFError:
-                    logger.debug("Exiting by EOF")
-                    console.print("Bye!")
-                    break
-
-                if not user_input:
-                    logger.debug("Got empty input, skipping")
-                    continue
-                logger.debug("Got user input: {user_input}", user_input=user_input)
-
-                if user_input.command in ["exit", "quit", "/exit", "/quit"]:
-                    logger.debug("Exiting by meta command")
-                    console.print("Bye!")
-                    break
-
-                if user_input.mode == PromptMode.SHELL:
-                    await self._run_shell_command(user_input.command)
-                    continue
-
-                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=user_input.content)
-                await self._run_soul_command(user_input.content)
+        with CustomPromptSession(
+            status_provider=lambda: self.soul.status,
+            model_capabilities=self.soul.model_capabilities or set(),
+            model_name=self.soul.model_name,
+            thinking=self.soul.thinking or False,
+            agent_mode_slash_commands=list(self._available_slash_commands.values()),
+            shell_mode_slash_commands=shell_mode_registry.list_commands(),
+        ) as prompt_session:
+            try:
+                while True:
+                    ensure_tty_sane()
+                    try:
+                        ensure_new_line()
+                        user_input = await prompt_session.prompt()
+                    except KeyboardInterrupt:
+                        logger.debug("Exiting by KeyboardInterrupt")
+                        console.print("[grey50]Tip: press Ctrl-D or send 'exit' to quit[/grey50]")
+                        continue
+                    except EOFError:
+                        logger.debug("Exiting by EOF")
+                        console.print("Bye!")
+                        break
+
+                    if not user_input:
+                        logger.debug("Got empty input, skipping")
+                        continue
+                    logger.debug("Got user input: {user_input}", user_input=user_input)
+
+                    if user_input.command in ["exit", "quit", "/exit", "/quit"]:
+                        logger.debug("Exiting by slash command")
+                        console.print("Bye!")
+                        break
+
+                    if user_input.mode == PromptMode.SHELL:
+                        await self._run_shell_command(user_input.command)
+                        continue
+
+                    if slash_cmd_call := parse_slash_command_call(user_input.command):
+                        await self._run_slash_command(slash_cmd_call)
+                        continue
+
+                    await self._run_soul_command(user_input.content)
+            finally:
+                ensure_tty_sane()
 
         return True
 
@@ -85,6 +118,28 @@ class ShellApp:
         if not command.strip():
             return
 
+        # Check if it's an allowed slash command in shell mode
+        if slash_cmd_call := parse_slash_command_call(command):
+            if shell_mode_registry.find_command(slash_cmd_call.name):
+                await self._run_slash_command(slash_cmd_call)
+                return
+            else:
+                console.print(
+                    f'[yellow]"/{slash_cmd_call.name}" is not available in shell mode. '
+                    "Press Ctrl-X to switch to agent mode.[/yellow]"
+                )
+                return
+
+        # Check if user is trying to use 'cd' command
+        stripped_cmd = command.strip()
+        split_cmd = shlex.split(stripped_cmd)
+        if len(split_cmd) == 2 and split_cmd[0] == "cd":
+            console.print(
+                "[yellow]Warning: Directory changes are not preserved across command executions."
+                "[/yellow]"
+            )
+            return
+
         logger.info("Running shell command: {cmd}", cmd=command)
 
         proc: asyncio.subprocess.Process | None = None
@@ -107,41 +162,37 @@ class ShellApp:
         finally:
             remove_sigint()
 
-    async def _run_meta_command(self, command_str: str):
+    async def _run_slash_command(self, command_call: SlashCommandCall) -> None:
         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")
+        if command_call.name not in self._available_slash_commands:
+            logger.info("Unknown slash command /{command}", command=command_call.name)
+            console.print(
+                f'[red]Unknown slash command "/{command_call.name}", '
+                'type "/" for all available commands[/red]'
+            )
             return
-        if command.kimi_soul_only and not isinstance(self.soul, KimiSoul):
-            console.print(f"Meta command /{command_name} not supported")
+
+        command = shell_slash_registry.find_command(command_call.name)
+        if command is None:
+            # the input is a soul-level slash command call
+            await self._run_soul_command(command_call.raw_input)
             return
+
         logger.debug(
-            "Running meta command: {command_name} with args: {command_args}",
-            command_name=command_name,
-            command_args=command_args,
+            "Running shell-level slash command: /{command} with args: {args}",
+            command=command_call.name,
+            args=command_call.args,
         )
+
         try:
-            ret = command.func(self, command_args)
+            ret = command.func(self, command_call.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:
+        except Exception as e:
             logger.exception("Unknown error:")
             console.print(f"[red]Unknown error: {e}[/red]")
             raise  # re-raise unknown error
@@ -153,6 +204,8 @@ class ShellApp:
         Returns:
             bool: Whether the run is successful.
         """
+        logger.info("Running soul with user input: {user_input}", user_input=user_input)
+
         cancel_event = asyncio.Event()
 
         def _handler():
@@ -163,25 +216,24 @@ class ShellApp:
         remove_sigint = install_sigint_handler(loop, _handler)
 
         try:
-            # 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
+                    wire.ui_side(merge=False),  # shell UI maintain its own merge buffer
+                    initial_status=StatusUpdate(context_usage=self.soul.status.context_usage),
+                    cancel_event=cancel_event,
                 ),
                 cancel_event,
+                self.soul.wire_file if isinstance(self.soul, KimiSoul) else None,
             )
             return True
         except LLMNotSet:
-            logger.error("LLM not set")
-            console.print("[red]LLM not set, send /setup to configure[/red]")
+            logger.exception("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),
-            )
+            # actually unsupported input/mode should already be blocked by prompt session
+            logger.exception("LLM not supported:")
             console.print(f"[red]{e}[/red]")
         except ChatProviderError as e:
             logger.exception("LLM provider error:")
@@ -195,27 +247,31 @@ class ShellApp:
                 console.print(f"[red]LLM provider error: {e}[/red]")
         except MaxStepsReached as e:
             logger.warning("Max steps reached: {n_steps}", n_steps=e.n_steps)
-            console.print(f"[yellow]Max steps reached: {e.n_steps}[/yellow]")
+            console.print(f"[yellow]{e}[/yellow]")
         except RunCancelled:
             logger.info("Cancelled by user")
             console.print("[red]Interrupted by user[/red]")
-        except BaseException as e:
-            logger.exception("Unknown error:")
-            console.print(f"[red]Unknown error: {e}[/red]")
+        except Exception as e:
+            logger.exception("Unexpected error:")
+            console.print(f"[red]Unexpected error: {e}[/red]")
             raise  # re-raise unknown error
         finally:
             remove_sigint()
         return False
 
     async def _auto_update(self) -> None:
-        toast("checking for updates...", duration=2.0)
+        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 kimi-cli` 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 _start_background_task(self, coro: Coroutine[Any, Any, Any]) -> asyncio.Task[Any]:
         task = asyncio.create_task(coro)
@@ -256,7 +312,7 @@ class WelcomeInfoItem:
 
 
 def _print_welcome_info(name: str, info_items: list[WelcomeInfoItem]) -> None:
-    head = Text.from_markup(f"[bold]Welcome to {name}![/bold]")
+    head = Text.from_markup("Welcome to 2026, happy new year!")
     help_text = Text.from_markup("[grey50]Send /help for help information.[/grey50]")
 
     # Use Table for precise width control
@@ -268,7 +324,8 @@ def _print_welcome_info(name: str, info_items: list[WelcomeInfoItem]) -> None:
 
     rows: list[RenderableType] = [table]
 
-    rows.append(Text(""))  # Empty line
+    if info_items:
+        rows.append(Text(""))  # empty line
     for item in info_items:
         rows.append(Text(f"{item.name}: {item.value}", style=item.level.value))
 

kimi_cli/ui/shell/console.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from rich.console import Console
 from rich.theme import Theme
 

kimi_cli/ui/shell/debug.py

@@ -1,16 +1,10 @@
+from __future__ import annotations
+
 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 kosong.message import Message
+from rich.console import Group, RenderableType
 from rich.panel import Panel
 from rich.rule import Rule
 from rich.syntax import Syntax
@@ -18,10 +12,19 @@ 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
+from kimi_cli.ui.shell.slash import registry
+from kimi_cli.wire.types import (
+    AudioURLPart,
+    ContentPart,
+    ImageURLPart,
+    TextPart,
+    ThinkPart,
+    ToolCall,
+    VideoURLPart,
+)
 
 if TYPE_CHECKING:
-    from kimi_cli.ui.shell import ShellApp
+    from kimi_cli.ui.shell import Shell
 
 
 def _format_content_part(part: ContentPart) -> Text | Panel | Group:
@@ -56,6 +59,11 @@ def _format_content_part(part: ContentPart) -> Text | Panel | Group:
             id_text = f" (id: {audio.id})" if audio.id else ""
             return Text(f"[Audio{id_text}] {url_display}", style="blue")
 
+        case VideoURLPart(video_url=video):
+            url_display = video.url[:80] + "..." if len(video.url) > 80 else video.url
+            id_text = f" (id: {video.id})" if video.id else ""
+            return Text(f"[Video{id_text}] {url_display}", style="blue")
+
         case _:
             return Text(f"[Unknown content type: {type(part).__name__}]", style="red")
 
@@ -106,14 +114,11 @@ def _format_message(msg: Message, index: int) -> Panel:
         role_text += f" [dim]→ {msg.tool_call_id}[/dim]"
 
     # Format content
-    content_items: list = []
+    content_items: list[RenderableType] = []
 
-    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)
+    for part in msg.content:
+        formatted = _format_content_part(part)
+        content_items.append(formatted)
 
     # Add tool calls if present
     if msg.tool_calls:
@@ -141,12 +146,12 @@ def _format_message(msg: Message, index: int) -> Panel:
     )
 
 
-@meta_command(kimi_soul_only=True)
-def debug(app: "ShellApp", args: list[str]):
+@registry.command
+def debug(app: Shell, args: str):
     """Debug the context"""
     assert isinstance(app.soul, KimiSoul)
 
-    context = app.soul._context
+    context = app.soul.context
     history = context.history
 
     if not history:
@@ -166,7 +171,7 @@ def debug(app: "ShellApp", args: list[str]):
                 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"),
+                Text(f"Trajectory: {context.file_backend}", style="dim"),
             ),
             title="[bold]Context Info[/bold]",
             border_style="cyan",

kimi_cli/ui/shell/keyboard.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import asyncio
 import sys
 import threading
@@ -5,6 +7,8 @@ import time
 from collections.abc import AsyncGenerator, Callable
 from enum import Enum, auto
 
+from kimi_cli.utils.aioqueue import Queue
+
 
 class KeyEvent(Enum):
     UP = auto()
@@ -18,7 +22,7 @@ class KeyEvent(Enum):
 
 async def listen_for_keyboard() -> AsyncGenerator[KeyEvent]:
     loop = asyncio.get_running_loop()
-    queue = asyncio.Queue[KeyEvent]()
+    queue = Queue[KeyEvent]()
     cancel_event = threading.Event()
 
     def emit(event: KeyEvent) -> None: