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

kimi_cli/ui/shell/liveview.py

@@ -1,15 +1,23 @@
+from collections import deque
+
 import streamingjson
 from kosong.base.message import ToolCall, ToolCallPart
 from kosong.tooling import ToolError, ToolOk, ToolResult, ToolReturnType
-from rich.console import Group, RenderableType
+from rich import box
+from rich.console import Console, ConsoleOptions, Group, RenderableType, RenderResult
 from rich.live import Live
+from rich.markdown import Heading, Markdown
 from rich.markup import escape
+from rich.panel import Panel
 from rich.spinner import Spinner
+from rich.status import Status
 from rich.text import Text
 
 from kimi_cli.soul import StatusSnapshot
+from kimi_cli.soul.wire import ApprovalRequest, ApprovalResponse
 from kimi_cli.tools import extract_subtitle
 from kimi_cli.ui.shell.console import console
+from kimi_cli.ui.shell.keyboard import KeyEvent
 
 
 class _ToolCallDisplay:
@@ -67,20 +75,80 @@ class _ToolCallDisplay:
         self.renderable = Group(*lines)
 
 
+class _ApprovalRequestDisplay:
+    def __init__(self, request: ApprovalRequest):
+        self.request = request
+        self.options = [
+            ("Approve", ApprovalResponse.APPROVE),
+            ("Approve for this session", ApprovalResponse.APPROVE_FOR_SESSION),
+            ("Reject, tell Kimi CLI what to do instead", ApprovalResponse.REJECT),
+        ]
+        self.selected_index = 0
+
+    def render(self) -> RenderableType:
+        """Render the approval menu as a panel."""
+        lines = []
+
+        # Add request details
+        lines.append(
+            Text(f'{self.request.sender} is requesting approval to "{self.request.description}".')
+        )
+
+        lines.append(Text(""))  # Empty line
+
+        # Add menu options
+        for i, (option_text, _) in enumerate(self.options):
+            if i == self.selected_index:
+                lines.append(Text(f"→ {option_text}", style="cyan"))
+            else:
+                lines.append(Text(f"  {option_text}", style="grey50"))
+
+        content = Group(*lines)
+        return Panel.fit(
+            content,
+            title="[yellow]⚠ Approval Requested[/yellow]",
+            border_style="yellow",
+            padding=(1, 2),
+        )
+
+    def move_up(self):
+        """Move selection up."""
+        self.selected_index = (self.selected_index - 1) % len(self.options)
+
+    def move_down(self):
+        """Move selection down."""
+        self.selected_index = (self.selected_index + 1) % len(self.options)
+
+    def get_selected_response(self) -> ApprovalResponse:
+        """Get the approval response based on selected option."""
+        return self.options[self.selected_index][1]
+
+
 class StepLiveView:
     def __init__(self, status: StatusSnapshot):
+        # message content
         self._line_buffer = Text("")
+
+        # tool call
         self._tool_calls: dict[str, _ToolCallDisplay] = {}
         self._last_tool_call: _ToolCallDisplay | None = None
+
+        # approval request
+        self._approval_queue = deque[ApprovalRequest]()
+        self._current_approval: _ApprovalRequestDisplay | None = None
+        self._reject_all_following = False
+
+        # status
         self._status_text: Text | None = Text(
             self._format_status(status), style="grey50", justify="right"
         )
+        self._buffer_status: RenderableType | None = None
 
     def __enter__(self):
         self._live = Live(
             self._compose(),
             console=console,
-            refresh_per_second=4,
+            refresh_per_second=10,
             transient=False,  # leave the last frame on the screen
             vertical_overflow="visible",
         )
@@ -94,18 +162,26 @@ class StepLiveView:
         sections = []
         if self._line_buffer:
             sections.append(self._line_buffer)
+        if self._buffer_status:
+            sections.append(self._buffer_status)
         for view in self._tool_calls.values():
             sections.append(view.renderable)
+        if self._current_approval:
+            sections.append(self._current_approval.render())
+        if not sections:
+            # if there's nothing to display, do not show status bar
+            return Group()
+        # TODO: pin status bar at the bottom
         if self._status_text:
             sections.append(self._status_text)
         return Group(*sections)
 
-    def _push_out(self, text: Text | str):
+    def _push_out(self, renderable: RenderableType):
         """
-        Push the text out of the live view to the console.
-        After this, the printed line will not be changed further.
+        Push the renderable out of the live view to the console.
+        After this, the renderable will not be changed further.
         """
-        console.print(text)
+        console.print(renderable)
 
     def append_text(self, text: str):
         lines = text.split("\n")
@@ -134,12 +210,72 @@ class StepLiveView:
             view.finish(tool_result.result)
             self._live.update(self._compose())
 
+    def request_approval(self, approval_request: ApprovalRequest) -> None:
+        # If we're rejecting all following requests, reject immediately
+        if self._reject_all_following:
+            approval_request.resolve(ApprovalResponse.REJECT)
+            return
+
+        # Add to queue
+        self._approval_queue.append(approval_request)
+
+        # If no approval is currently being displayed, show the next one
+        if self._current_approval is None:
+            self._show_next_approval_request()
+            self._live.update(self._compose())
+
+    def _show_next_approval_request(self) -> None:
+        """Show the next approval request from the queue."""
+        if not self._approval_queue:
+            return
+
+        while self._approval_queue:
+            request = self._approval_queue.popleft()
+            if request.resolved:
+                # skip resolved requests
+                continue
+            self._current_approval = _ApprovalRequestDisplay(request)
+            break
+
     def update_status(self, status: StatusSnapshot):
         if self._status_text is None:
             return
         self._status_text.plain = self._format_status(status)
 
+    def handle_keyboard_event(self, event: KeyEvent):
+        if not self._current_approval:
+            # just ignore any keyboard event when there's no approval request
+            return
+
+        match event:
+            case KeyEvent.UP:
+                self._current_approval.move_up()
+                self._live.update(self._compose())
+            case KeyEvent.DOWN:
+                self._current_approval.move_down()
+                self._live.update(self._compose())
+            case KeyEvent.ENTER:
+                resp = self._current_approval.get_selected_response()
+                self._current_approval.request.resolve(resp)
+                if resp == ApprovalResponse.APPROVE_FOR_SESSION:
+                    for request in self._approval_queue:
+                        # approve all queued requests with the same action
+                        if request.action == self._current_approval.request.action:
+                            request.resolve(ApprovalResponse.APPROVE_FOR_SESSION)
+                elif resp == ApprovalResponse.REJECT:
+                    # one rejection should stop the step immediately
+                    while self._approval_queue:
+                        self._approval_queue.popleft().resolve(ApprovalResponse.REJECT)
+                    self._reject_all_following = True
+                self._current_approval = None
+                self._show_next_approval_request()
+                self._live.update(self._compose())
+            case _:
+                # just ignore any other keyboard event
+                return
+
     def finish(self):
+        self._current_approval = None
         for view in self._tool_calls.values():
             if not view.finished:
                 # this should not happen, but just in case
@@ -147,6 +283,7 @@ class StepLiveView:
         self._live.update(self._compose())
 
     def interrupt(self):
+        self._current_approval = None
         for view in self._tool_calls.values():
             if not view.finished:
                 view.finish(ToolError(message="", brief="Interrupted"))
@@ -156,3 +293,85 @@ class StepLiveView:
     def _format_status(status: StatusSnapshot) -> str:
         bounded = max(0.0, min(status.context_usage, 1.0))
         return f"context: {bounded:.1%}"
+
+
+class StepLiveViewWithMarkdown(StepLiveView):
+    # TODO: figure out a streaming implementation for this
+
+    def __init__(self, status: StatusSnapshot):
+        super().__init__(status)
+        self._pending_markdown_parts: list[str] = []
+        self._buffer_status_active = False
+        self._buffer_status_obj: Status | None = None
+
+    def append_text(self, text: str):
+        if not self._pending_markdown_parts:
+            self._show_thinking_status()
+        self._pending_markdown_parts.append(text)
+
+    def append_tool_call(self, tool_call: ToolCall):
+        self._flush_markdown()
+        super().append_tool_call(tool_call)
+
+    def finish(self):
+        self._flush_markdown()
+        super().finish()
+
+    def interrupt(self):
+        self._flush_markdown()
+        super().interrupt()
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self._flush_markdown()
+        return super().__exit__(exc_type, exc_value, traceback)
+
+    def _flush_markdown(self):
+        self._hide_thinking_status()
+        if not self._pending_markdown_parts:
+            return
+        markdown_text = "".join(self._pending_markdown_parts)
+        self._pending_markdown_parts.clear()
+        if markdown_text.strip():
+            self._push_out(_LeftAlignedMarkdown(markdown_text, justify="left"))
+
+    def _show_thinking_status(self):
+        if self._buffer_status_active:
+            return
+        self._buffer_status_active = True
+        self._line_buffer.plain = ""
+        self._buffer_status_obj = Status("Thinking...", console=console, spinner="dots")
+        self._buffer_status = self._buffer_status_obj.renderable
+        self._live.update(self._compose())
+
+    def _hide_thinking_status(self):
+        if not self._buffer_status_active:
+            return
+        self._buffer_status_active = False
+        if self._buffer_status_obj is not None:
+            self._buffer_status_obj.stop()
+        self._buffer_status = None
+        self._buffer_status_obj = None
+        self._live.update(self._compose())
+
+
+class _LeftAlignedHeading(Heading):
+    """Heading element with left-aligned content."""
+
+    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
+        text = self.text
+        text.justify = "left"
+        if self.tag == "h2":
+            text.stylize("bold")
+        if self.tag == "h1":
+            yield Panel(text, box=box.HEAVY, style="markdown.h1.border")
+        else:
+            if self.tag == "h2":
+                yield Text("")
+            yield text
+
+
+class _LeftAlignedMarkdown(Markdown):
+    """Markdown renderer that left-aligns headings."""
+
+    elements = dict(Markdown.elements)
+    elements["heading_open"] = _LeftAlignedHeading

kimi_cli/ui/shell/metacmd.py

@@ -2,16 +2,13 @@ import tempfile
 import webbrowser
 from collections.abc import Awaitable, Callable, Sequence
 from pathlib import Path
-from string import Template
 from typing import TYPE_CHECKING, NamedTuple, overload
 
-from kosong.base import generate
-from kosong.base.message import ContentPart, Message, TextPart
+from kosong.base.message import Message
 from rich.panel import Panel
 
-import kimi_cli.prompts.metacmds as prompts
+import kimi_cli.prompts as prompts
 from kimi_cli.agent import load_agents_md
-from kimi_cli.soul import LLMNotSet
 from kimi_cli.soul.context import Context
 from kimi_cli.soul.kimisoul import KimiSoul
 from kimi_cli.soul.message import system
@@ -23,6 +20,17 @@ if TYPE_CHECKING:
     from kimi_cli.ui.shell import ShellApp
 
 type MetaCmdFunc = Callable[["ShellApp", list[str]], None | Awaitable[None]]
+"""
+A function that runs as a meta command.
+
+Raises:
+    LLMNotSet: When the LLM is not set.
+    ChatProviderError: When the LLM provider returns an error.
+    Reload: When the configuration should be reloaded.
+    asyncio.CancelledError: When the command is interrupted by user.
+
+This is quite similar to the `Soul.run` method.
+"""
 
 
 class MetaCommand(NamedTuple):
@@ -188,14 +196,12 @@ def feedback(app: "ShellApp", args: list[str]):
     console.print(f"Please submit feedback at [underline]{ISSUE_URL}[/underline].")
 
 
-@meta_command
+@meta_command(kimi_soul_only=True)
 async def init(app: "ShellApp", args: list[str]):
     """Analyze the codebase and generate an `AGENTS.md` file"""
-    soul_bak = app.soul
-    if not isinstance(soul_bak, KimiSoul):
-        console.print("[red]Failed to analyze the codebase.[/red]")
-        return
+    assert isinstance(app.soul, KimiSoul)
 
+    soul_bak = app.soul
     with tempfile.TemporaryDirectory() as temp_dir:
         logger.info("Running `/init`")
         console.print("Analyzing the codebase...")
@@ -206,7 +212,7 @@ async def init(app: "ShellApp", args: list[str]):
             context=tmp_context,
             loop_control=soul_bak._loop_control,
         )
-        ok = await app._run(prompts.INIT)
+        ok = await app._run_soul_command(prompts.INIT)
 
         if ok:
             console.print(
@@ -239,71 +245,23 @@ async def clear(app: "ShellApp", args: list[str]):
     console.print("[green]✓[/green] Context has been cleared.")
 
 
-@meta_command
+@meta_command(kimi_soul_only=True)
 async def compact(app: "ShellApp", args: list[str]):
     """Compact the context"""
     assert isinstance(app.soul, KimiSoul)
 
-    logger.info("Running `/compact`")
-
-    if app.soul._agent_globals.llm is None:
-        raise LLMNotSet()
-
-    # Get current context history
-    current_history = list(app.soul._context.history)
-    if len(current_history) <= 1:
-        console.print("[yellow]Context is too short to compact.[/yellow]")
+    if app.soul._context.n_checkpoints == 0:
+        console.print("[yellow]Context is empty.[/yellow]")
         return
 
-    # Convert history to string for the compact prompt
-    history_text = "\n\n".join(
-        f"## Message {i + 1}\nRole: {msg.role}\nContent: {msg.content}"
-        for i, msg in enumerate(current_history)
-    )
-
-    # Build the compact prompt using string template
-    compact_template = Template(prompts.COMPACT)
-    compact_prompt = compact_template.substitute(CONTEXT=history_text)
-
-    # Create input message for compaction
-    compact_message = Message(role="user", content=compact_prompt)
-
-    # Call generate to get the compacted context
-    try:
-        with console.status("[cyan]Compacting...[/cyan]"):
-            compacted_msg, usage = await generate(
-                chat_provider=app.soul._agent_globals.llm.chat_provider,
-                system_prompt="You are a helpful assistant that compacts conversation context.",
-                tools=[],
-                history=[compact_message],
-            )
-
-        # Clear the context and add the compacted message as the first message
-        await app.soul._context.revert_to(0)
-        content: list[ContentPart] = (
-            [TextPart(text=compacted_msg.content)]
-            if isinstance(compacted_msg.content, str)
-            else compacted_msg.content
-        )
-        content.insert(
-            0, system("Previous context has been compacted. Here is the compaction output:")
-        )
-        await app.soul._context.append_message(Message(role="assistant", content=content))
-
-        console.print("[green]✓[/green] Context has been compacted.")
-        if usage:
-            logger.info(
-                "Compaction used {input} input tokens and {output} output tokens",
-                input=usage.input,
-                output=usage.output,
-            )
-    except Exception as e:
-        logger.error("Failed to compact context: {error}", error=e)
-        console.print(f"[red]Failed to compact the context: {e}[/red]")
-        return
+    logger.info("Running `/compact`")
+    with console.status("[cyan]Compacting...[/cyan]"):
+        await app.soul.compact_context()
+    console.print("[green]✓[/green] Context has been compacted.")
 
 
 from . import (  # noqa: E402
+    debug,  # noqa: F401
     setup,  # noqa: F401
     update,  # noqa: F401
 )

kimi_cli/ui/shell/setup.py

@@ -7,7 +7,6 @@ from prompt_toolkit.shortcuts.choice_input import ChoiceInput
 from pydantic import SecretStr
 
 from kimi_cli.config import LLMModel, LLMProvider, MoonshotSearchConfig, load_config, save_config
-from kimi_cli.soul.kimisoul import KimiSoul
 from kimi_cli.ui.shell.console import console
 from kimi_cli.ui.shell.metacmd import meta_command
 
@@ -25,8 +24,8 @@ class _Platform(NamedTuple):
 
 _PLATFORMS = [
     _Platform(
-        id="kimi-coding",
-        name="Kimi Coding Plan",
+        id="kimi-for-coding",
+        name="Kimi For Coding",
         base_url="https://api.kimi.com/coding/v1",
         search_url="https://api.kimi.com/coding/v1/search",
     ),
@@ -45,11 +44,9 @@ _PLATFORMS = [
 ]
 
 
-@meta_command(kimi_soul_only=True)
+@meta_command
 async def setup(app: "ShellApp", args: list[str]):
     """Setup Kimi CLI"""
-    assert isinstance(app.soul, KimiSoul)
-
     result = await _setup()
     if not result:
         # error message already printed

kimi_cli/ui/shell/visualize.py

@@ -0,0 +1,105 @@
+import asyncio
+from contextlib import asynccontextmanager, suppress
+
+from kosong.base.message import ContentPart, TextPart, ToolCall, ToolCallPart
+from kosong.tooling import ToolResult
+
+from kimi_cli.soul import StatusSnapshot
+from kimi_cli.soul.wire import (
+    ApprovalRequest,
+    CompactionBegin,
+    CompactionEnd,
+    StatusUpdate,
+    StepBegin,
+    StepInterrupted,
+    Wire,
+)
+from kimi_cli.ui.shell.console import console
+from kimi_cli.ui.shell.keyboard import listen_for_keyboard
+from kimi_cli.ui.shell.liveview import StepLiveView, StepLiveViewWithMarkdown
+from kimi_cli.utils.logging import logger
+
+
+@asynccontextmanager
+async def _keyboard_listener(step: StepLiveView):
+    async def _keyboard():
+        try:
+            async for event in listen_for_keyboard():
+                # TODO: ESCAPE to interrupt
+                step.handle_keyboard_event(event)
+        except asyncio.CancelledError:
+            return
+
+    task = asyncio.create_task(_keyboard())
+    try:
+        yield
+    finally:
+        task.cancel()
+        with suppress(asyncio.CancelledError):
+            await task
+
+
+async def visualize(wire: Wire, *, initial_status: StatusSnapshot):
+    """
+    A loop to consume agent events and visualize the agent behavior.
+    This loop never raise any exception except asyncio.CancelledError.
+    """
+    latest_status = initial_status
+    try:
+        # expect a StepBegin
+        assert isinstance(await wire.receive(), StepBegin)
+
+        while True:
+            # TODO: Maybe we can always have a StepLiveView here.
+            #       No need to recreate for each step.
+            with StepLiveViewWithMarkdown(latest_status) as step:
+                async with _keyboard_listener(step):
+                    # spin the moon at the beginning of each step
+                    with console.status("", spinner="moon"):
+                        msg = await wire.receive()
+
+                    if isinstance(msg, CompactionBegin):
+                        with console.status("[cyan]Compacting...[/cyan]"):
+                            msg = await wire.receive()
+                        if isinstance(msg, StepInterrupted):
+                            break
+                        assert isinstance(msg, CompactionEnd)
+                        continue
+
+                    # 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():
+                                step.request_approval(msg)
+                            case StatusUpdate(status=status):
+                                latest_status = status
+                                step.update_status(latest_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")

kimi_cli/utils/provider.py

@@ -29,7 +29,13 @@ def augment_provider_with_env_vars(provider: LLMProvider, model: LLMModel):
             pass
 
 
-def create_llm(provider: LLMProvider, model: LLMModel, stream: bool = True) -> LLM:
+def create_llm(
+    provider: LLMProvider,
+    model: LLMModel,
+    *,
+    stream: bool = True,
+    session_id: str | None = None,
+) -> LLM:
     match provider.type:
         case "kimi":
             chat_provider = Kimi(
@@ -41,6 +47,8 @@ def create_llm(provider: LLMProvider, model: LLMModel, stream: bool = True) -> L
                     "User-Agent": kimi_cli.USER_AGENT,
                 },
             )
+            if session_id:
+                chat_provider = chat_provider.with_generation_kwargs(prompt_cache_key=session_id)
         case "openai_legacy":
             chat_provider = OpenAILegacy(
                 model=model.model,