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

kimi_cli/ui/wire/__init__.py

@@ -0,0 +1,267 @@
+from __future__ import annotations
+
+import asyncio
+import contextlib
+
+import acp  # type: ignore[reportMissingTypeStubs]
+import pydantic
+from kosong.chat_provider import ChatProviderError
+
+from kimi_cli.soul import LLMNotSet, LLMNotSupported, MaxStepsReached, RunCancelled, Soul, run_soul
+from kimi_cli.soul.kimisoul import KimiSoul
+from kimi_cli.utils.aioqueue import Queue, QueueShutDown
+from kimi_cli.utils.logging import logger
+from kimi_cli.wire import Wire
+from kimi_cli.wire.types import ApprovalRequest, Request
+
+from .jsonrpc import (
+    ErrorCodes,
+    JSONRPCApprovalRequestResult,
+    JSONRPCCancelMessage,
+    JSONRPCErrorObject,
+    JSONRPCErrorResponse,
+    JSONRPCEventMessage,
+    JSONRPCInMessage,
+    JSONRPCInMessageAdapter,
+    JSONRPCOutMessage,
+    JSONRPCPromptMessage,
+    JSONRPCRequestMessage,
+    JSONRPCSuccessResponse,
+    Statuses,
+)
+
+# Maximum buffer size for the asyncio StreamReader used for stdio.
+# Passed as the `limit` argument to `acp.stdio_streams`, this caps how much
+# data can be buffered when reading from stdin (e.g., large tool or model
+# outputs sent over JSON-RPC). A 100MB limit is large enough for typical
+# interactive use while still protecting the process from unbounded memory
+# growth or buffer-overrun errors when peers send unexpectedly large payloads.
+STDIO_BUFFER_LIMIT = 100 * 1024 * 1024
+
+
+class WireOverStdio:
+    def __init__(self, soul: Soul):
+        self._reader: asyncio.StreamReader | None = None
+        self._writer: asyncio.StreamWriter | None = None
+
+        # outward
+        self._write_task: asyncio.Task[None] | None = None
+        self._write_queue: Queue[JSONRPCOutMessage] = Queue()
+
+        # inward
+        self._dispatch_tasks: set[asyncio.Task[None]] = set()
+
+        # soul running stuffs
+        self._soul = soul
+        self._cancel_event: asyncio.Event | None = None
+        self._pending_requests: dict[str, Request] = {}
+        """Maps JSON RPC message IDs to pending `Request`s."""
+
+    async def serve(self) -> None:
+        logger.info("Starting Wire server on stdio")
+
+        self._reader, self._writer = await acp.stdio_streams(limit=STDIO_BUFFER_LIMIT)
+        self._write_task = asyncio.create_task(self._write_loop())
+        try:
+            await self._read_loop()
+        finally:
+            await self._shutdown()
+
+    async def _write_loop(self) -> None:
+        assert self._writer is not None
+
+        try:
+            while True:
+                try:
+                    msg = await self._write_queue.get()
+                except QueueShutDown:
+                    logger.debug("Send queue shut down, stopping Wire server write loop")
+                    break
+                self._writer.write(msg.model_dump_json().encode("utf-8") + b"\n")
+                await self._writer.drain()
+        except asyncio.CancelledError:
+            raise
+        except Exception:
+            logger.exception("Wire server write loop error:")
+            raise
+
+    async def _read_loop(self) -> None:
+        assert self._reader is not None
+
+        while True:
+            line = await self._reader.readline()
+            if not line:
+                logger.info("stdin closed, Wire server exiting")
+                break
+
+            try:
+                msg = JSONRPCInMessageAdapter.validate_json(line)
+            except ValueError:
+                logger.error("Invalid JSONRPC line: {line}", line=line)
+                continue
+
+            task = asyncio.create_task(self._dispatch_msg(msg))
+            task.add_done_callback(self._dispatch_tasks.discard)
+            self._dispatch_tasks.add(task)
+
+    async def _shutdown(self) -> None:
+        for request in self._pending_requests.values():
+            if not request.resolved:
+                request.resolve("reject")
+        self._pending_requests.clear()
+
+        if self._cancel_event is not None:
+            self._cancel_event.set()
+            self._cancel_event = None
+
+        self._write_queue.shutdown()
+        if self._write_task is not None:
+            with contextlib.suppress(asyncio.CancelledError):
+                await self._write_task
+
+        await asyncio.gather(*self._dispatch_tasks, return_exceptions=True)
+        self._dispatch_tasks.clear()
+
+        if self._writer is not None:
+            self._writer.close()
+            with contextlib.suppress(Exception):
+                await self._writer.wait_closed()
+            self._writer = None
+
+        self._reader = None
+
+    async def _dispatch_msg(self, msg: JSONRPCInMessage) -> None:
+        resp: JSONRPCSuccessResponse | JSONRPCErrorResponse | None = None
+        try:
+            match msg:
+                case JSONRPCPromptMessage():
+                    resp = await self._handle_prompt(msg)
+                case JSONRPCCancelMessage():
+                    resp = await self._handle_cancel(msg)
+                case JSONRPCSuccessResponse() | JSONRPCErrorResponse():
+                    await self._handle_response(msg)
+
+            if resp is not None:
+                await self._send_msg(resp)
+        except Exception:
+            logger.exception("Unexpected error dispatching JSONRPC message:")
+            raise
+
+    async def _send_msg(self, msg: JSONRPCOutMessage) -> None:
+        try:
+            await self._write_queue.put(msg)
+        except QueueShutDown:
+            logger.error("Send queue shut down; dropping message: {msg}", msg=msg)
+
+    @property
+    def _soul_is_running(self) -> bool:
+        return self._cancel_event is not None
+
+    async def _handle_prompt(
+        self, msg: JSONRPCPromptMessage
+    ) -> JSONRPCSuccessResponse | JSONRPCErrorResponse:
+        if self._soul_is_running:
+            # TODO: support queueing multiple inputs
+            return JSONRPCErrorResponse(
+                id=msg.id,
+                error=JSONRPCErrorObject(
+                    code=ErrorCodes.INVALID_STATE, message="An agent turn is already in progress"
+                ),
+            )
+
+        self._cancel_event = asyncio.Event()
+        try:
+            await run_soul(
+                self._soul,
+                msg.params.user_input,
+                self._stream_wire_messages,
+                self._cancel_event,
+                self._soul.wire_file if isinstance(self._soul, KimiSoul) else None,
+            )
+            return JSONRPCSuccessResponse(
+                id=msg.id,
+                result={"status": Statuses.FINISHED},
+            )
+        except LLMNotSet:
+            return JSONRPCErrorResponse(
+                id=msg.id,
+                error=JSONRPCErrorObject(code=ErrorCodes.LLM_NOT_SET, message="LLM is not set"),
+            )
+        except LLMNotSupported as e:
+            return JSONRPCErrorResponse(
+                id=msg.id,
+                error=JSONRPCErrorObject(code=ErrorCodes.LLM_NOT_SUPPORTED, message=str(e)),
+            )
+        except ChatProviderError as e:
+            return JSONRPCErrorResponse(
+                id=msg.id,
+                error=JSONRPCErrorObject(code=ErrorCodes.CHAT_PROVIDER_ERROR, message=str(e)),
+            )
+        except MaxStepsReached as e:
+            return JSONRPCSuccessResponse(
+                id=msg.id,
+                result={"status": Statuses.MAX_STEPS_REACHED, "steps": e.n_steps},
+            )
+        except RunCancelled:
+            return JSONRPCSuccessResponse(
+                id=msg.id,
+                result={"status": Statuses.CANCELLED},
+            )
+        finally:
+            self._cancel_event = None
+
+    async def _handle_cancel(
+        self, msg: JSONRPCCancelMessage
+    ) -> JSONRPCSuccessResponse | JSONRPCErrorResponse:
+        if not self._soul_is_running:
+            return JSONRPCErrorResponse(
+                id=msg.id,
+                error=JSONRPCErrorObject(
+                    code=ErrorCodes.INVALID_STATE, message="No agent turn is in progress"
+                ),
+            )
+
+        assert self._cancel_event is not None
+        self._cancel_event.set()
+        return JSONRPCSuccessResponse(
+            id=msg.id,
+            result={},
+        )
+
+    async def _handle_response(self, msg: JSONRPCSuccessResponse | JSONRPCErrorResponse) -> None:
+        request = self._pending_requests.pop(msg.id, None)
+        if request is None:
+            logger.error("No pending request for response id={id}", id=msg.id)
+            return
+
+        match request:
+            case ApprovalRequest():
+                if isinstance(msg, JSONRPCErrorResponse):
+                    request.resolve("reject")
+                else:
+                    try:
+                        result = JSONRPCApprovalRequestResult.model_validate(msg.result)
+                        request.resolve(result.response)
+                    except pydantic.ValidationError as e:
+                        logger.error(
+                            "Invalid response result for request id={id}: {error}",
+                            id=msg.id,
+                            error=e,
+                        )
+                        request.resolve("reject")
+
+    async def _stream_wire_messages(self, wire: Wire) -> None:
+        wire_ui = wire.ui_side(merge=False)
+        while True:
+            msg = await wire_ui.receive()
+            match msg:
+                case ApprovalRequest():
+                    await self._request_approval(msg)
+                case _:
+                    await self._send_msg(JSONRPCEventMessage(method="event", params=msg))
+
+    async def _request_approval(self, request: ApprovalRequest) -> None:
+        msg_id = request.id  # just use the approval request id as message id
+        self._pending_requests[msg_id] = request
+        await self._send_msg(JSONRPCRequestMessage(id=msg_id, params=request))
+        await request.wait()

kimi_cli/ui/wire/jsonrpc.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+
+from typing import Any, Literal
+
+from kosong.utils.typing import JsonType
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    TypeAdapter,
+    field_serializer,
+    field_validator,
+    model_serializer,
+)
+
+from kimi_cli.wire.serde import serialize_wire_message
+from kimi_cli.wire.types import (
+    ApprovalRequestResolved,
+    ContentPart,
+    Event,
+    Request,
+    is_event,
+    is_request,
+)
+
+
+class _MessageBase(BaseModel):
+    jsonrpc: Literal["2.0"] = "2.0"
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class JSONRPCEventMessage(_MessageBase):
+    method: Literal["event"] = "event"
+    params: Event
+
+    @field_serializer("params")
+    def _serialize_params(self, params: Event) -> dict[str, JsonType]:
+        return serialize_wire_message(params)
+
+    @field_validator("params", mode="before")
+    @classmethod
+    def _validate_params(cls, value: Any) -> Event:
+        if is_event(value):
+            return value
+        raise NotImplementedError("Event message deserialization is not implemented.")
+
+
+class JSONRPCRequestMessage(_MessageBase):
+    method: Literal["request"] = "request"
+    id: str
+    params: Request
+
+    @field_serializer("params")
+    def _serialize_params(self, params: Request) -> dict[str, JsonType]:
+        return serialize_wire_message(params)
+
+    @field_validator("params", mode="before")
+    @classmethod
+    def _validate_params(cls, value: Any) -> Request:
+        if is_request(value):
+            return value
+        raise NotImplementedError("Request message deserialization is not implemented.")
+
+
+class JSONRPCPromptMessage(_MessageBase):
+    class Params(BaseModel):
+        user_input: str | list[ContentPart]
+
+    method: Literal["prompt"] = "prompt"
+    id: str
+    params: Params
+
+    @model_serializer()
+    def _serialize(self) -> dict[str, Any]:
+        raise NotImplementedError("Prompt message serialization is not implemented.")
+
+
+class JSONRPCCancelMessage(_MessageBase):
+    method: Literal["cancel"] = "cancel"
+    id: str
+    params: JsonType | None = None
+
+    @model_serializer()
+    def _serialize(self) -> dict[str, Any]:
+        raise NotImplementedError("Cancel message serialization is not implemented.")
+
+
+class _ResponseBase(_MessageBase):
+    id: str
+
+
+class JSONRPCSuccessResponse(_ResponseBase):
+    result: JsonType
+
+
+class JSONRPCErrorObject(BaseModel):
+    code: int
+    message: str
+    data: JsonType | None = None
+
+
+class JSONRPCErrorResponse(_ResponseBase):
+    error: JSONRPCErrorObject
+
+
+class JSONRPCApprovalRequestResult(ApprovalRequestResolved):
+    """
+    The `JSONRPCSuccessResponse.result` field for approval request responses should be able to
+    be parsed into this type.
+    """
+
+    pass
+
+
+type JSONRPCInMessage = (
+    JSONRPCPromptMessage | JSONRPCCancelMessage | JSONRPCSuccessResponse | JSONRPCErrorResponse
+)
+JSONRPCInMessageAdapter = TypeAdapter[JSONRPCInMessage](JSONRPCInMessage)
+
+type JSONRPCOutMessage = (
+    JSONRPCEventMessage | JSONRPCRequestMessage | JSONRPCSuccessResponse | JSONRPCErrorResponse
+)
+
+
+class ErrorCodes:
+    INVALID_STATE = -32000
+    """The server is in an invalid state to process the request."""
+    LLM_NOT_SET = -32001
+    """The LLM is not set."""
+    LLM_NOT_SUPPORTED = -32002
+    """The specified LLM is not supported."""
+    CHAT_PROVIDER_ERROR = -32003
+    """There was an error from the chat provider."""
+
+
+class Statuses:
+    FINISHED = "finished"
+    """The agent run has finished successfully."""
+    CANCELLED = "cancelled"
+    """The agent run was cancelled by the user."""
+    MAX_STEPS_REACHED = "max_steps_reached"
+    """The agent run reached the maximum number of steps."""

kimi_cli/ui/wire/protocol.py

@@ -0,0 +1 @@
+WIRE_PROTOCOL_VERSION: str = "1"

kimi_cli/utils/aiohttp.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import ssl
 
 import aiohttp

kimi_cli/utils/aioqueue.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+import asyncio
+import sys
+
+if sys.version_info >= (3, 13):
+    QueueShutDown = asyncio.QueueShutDown  # type: ignore[assignment]
+
+    class Queue[T](asyncio.Queue[T]):
+        """Asyncio Queue with shutdown support."""
+
+else:
+
+    class QueueShutDown(Exception):
+        """Raised when operating on a shut down queue."""
+
+    class _Shutdown:
+        """Sentinel for queue shutdown."""
+
+    _SHUTDOWN = _Shutdown()
+
+    class Queue[T](asyncio.Queue[T | _Shutdown]):
+        """Asyncio Queue with shutdown support for Python < 3.13."""
+
+        def __init__(self) -> None:
+            super().__init__()
+            self._shutdown = False
+
+        def shutdown(self, immediate: bool = False) -> None:
+            if self._shutdown:
+                return
+            self._shutdown = True
+            if immediate:
+                self._queue.clear()
+
+            getters = list(getattr(self, "_getters", []))
+            count = max(1, len(getters))
+            self._enqueue_shutdown(count)
+
+        def _enqueue_shutdown(self, count: int) -> None:
+            for _ in range(count):
+                try:
+                    super().put_nowait(_SHUTDOWN)
+                except asyncio.QueueFull:
+                    self._queue.clear()
+                    super().put_nowait(_SHUTDOWN)
+
+        async def get(self) -> T:
+            if self._shutdown and self.empty():
+                raise QueueShutDown
+            item = await super().get()
+            if isinstance(item, _Shutdown):
+                raise QueueShutDown
+            return item
+
+        def get_nowait(self) -> T:
+            if self._shutdown and self.empty():
+                raise QueueShutDown
+            item = super().get_nowait()
+            if isinstance(item, _Shutdown):
+                raise QueueShutDown
+            return item
+
+        async def put(self, item: T) -> None:
+            if self._shutdown:
+                raise QueueShutDown
+            await super().put(item)
+
+        def put_nowait(self, item: T) -> None:
+            if self._shutdown:
+                raise QueueShutDown
+            super().put_nowait(item)

kimi_cli/utils/broadcast.py

@@ -0,0 +1,37 @@
+import asyncio
+
+from kimi_cli.utils.aioqueue import Queue
+
+
+class BroadcastQueue[T]:
+    """
+    A broadcast queue that allows multiple subscribers to receive published items.
+    """
+
+    def __init__(self) -> None:
+        self._queues: set[Queue[T]] = set()
+
+    def subscribe(self) -> Queue[T]:
+        """Create a new subscription queue."""
+        queue: Queue[T] = Queue()
+        self._queues.add(queue)
+        return queue
+
+    def unsubscribe(self, queue: Queue[T]) -> None:
+        """Remove a subscription queue."""
+        self._queues.discard(queue)
+
+    async def publish(self, item: T) -> None:
+        """Publish an item to all subscription queues."""
+        await asyncio.gather(*(queue.put(item) for queue in self._queues))
+
+    def publish_nowait(self, item: T) -> None:
+        """Publish an item to all subscription queues without waiting."""
+        for queue in self._queues:
+            queue.put_nowait(item)
+
+    def shutdown(self, immediate: bool = False) -> None:
+        """Close all subscription queues."""
+        for queue in self._queues:
+            queue.shutdown(immediate=immediate)
+        self._queues.clear()

kimi_cli/utils/changelog.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from pathlib import Path
 from typing import NamedTuple
 
@@ -41,13 +43,14 @@ def parse_changelog(md_text: str) -> dict[str, ReleaseEntry]:
 
     for raw in lines:
         line = raw.rstrip()
-        if line.startswith("## ["):
-            # New version section, flush previous
+        # Format: `## 0.75 (2026-01-09)` or `## Unreleased`
+        if line.startswith("## "):
             commit()
-            # Extract version token inside brackets
-            end = line.find("]")
-            ver = line[4:end] if end != -1 else line[3:].strip()
-            current_ver = ver.strip()
+            ver = line[3:].strip()
+            # Remove trailing date in parentheses if present
+            if "(" in ver:
+                ver = ver[: ver.find("(")].strip()
+            current_ver = ver
             desc_lines = []
             bullet_lines = []
             collecting_desc = True
@@ -85,7 +88,7 @@ def parse_changelog(md_text: str) -> dict[str, ReleaseEntry]:
     return result
 
 
-def format_release_notes(changelog: dict[str, ReleaseEntry]) -> str:
+def format_release_notes(changelog: dict[str, ReleaseEntry], include_lib_changes: bool) -> str:
     parts: list[str] = []
     for ver, entry in changelog.items():
         s = f"[bold]{ver}[/bold]"
@@ -93,6 +96,8 @@ def format_release_notes(changelog: dict[str, ReleaseEntry]) -> str:
             s += f": {entry.description}"
         if entry.entries:
             for it in entry.entries:
+                if it.lower().startswith("lib:") and not include_lib_changes:
+                    continue
                 s += "\n[markdown.item.bullet]• [/]" + it
         parts.append(s + "\n")
     return "\n".join(parts).strip()

kimi_cli/utils/clipboard.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+import pyperclip
+
+
+def is_clipboard_available() -> bool:
+    """Check if the Pyperclip clipboard is available."""
+    try:
+        pyperclip.paste()
+        return True
+    except Exception:
+        return False

kimi_cli/utils/datetime.py

@@ -0,0 +1,37 @@
+from datetime import datetime, timedelta
+
+
+def format_relative_time(timestamp: float) -> str:
+    """Format a timestamp as a relative time string."""
+    now = datetime.now()
+    dt = datetime.fromtimestamp(timestamp)
+    diff = now - dt
+    if diff < timedelta(minutes=5):
+        return "just now"
+    if diff < timedelta(hours=1):
+        minutes = int(diff.total_seconds() / 60)
+        return f"{minutes}m ago"
+    if diff < timedelta(days=1):
+        hours = int(diff.total_seconds() / 3600)
+        return f"{hours}h ago"
+    if diff < timedelta(days=7):
+        return f"{diff.days}d ago"
+    return dt.strftime("%m-%d")
+
+
+def format_duration(seconds: int) -> str:
+    """Format a duration in seconds using short units."""
+    delta = timedelta(seconds=seconds)
+    parts: list[str] = []
+    days = delta.days
+    if days:
+        parts.append(f"{days}d")
+    hours, remainder = divmod(delta.seconds, 3600)
+    minutes, secs = divmod(remainder, 60)
+    if hours:
+        parts.append(f"{hours}h")
+    if minutes:
+        parts.append(f"{minutes}m")
+    if secs and not parts:
+        parts.append(f"{secs}s")
+    return " ".join(parts) or "0s"

kimi_cli/utils/environment.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+import platform
+from dataclasses import dataclass
+from typing import Literal
+
+from kaos.path import KaosPath
+
+
+@dataclass(slots=True, frozen=True, kw_only=True)
+class Environment:
+    os_kind: Literal["Windows", "Linux", "macOS"] | str
+    os_arch: str
+    os_version: str
+    shell_name: Literal["bash", "sh", "Windows PowerShell"]
+    shell_path: KaosPath
+
+    @staticmethod
+    async def detect() -> Environment:
+        match platform.system():
+            case "Darwin":
+                os_kind = "macOS"
+            case "Windows":
+                os_kind = "Windows"
+            case "Linux":
+                os_kind = "Linux"
+            case system:
+                os_kind = system
+
+        os_arch = platform.machine()
+        os_version = platform.version()
+
+        if os_kind == "Windows":
+            shell_name = "Windows PowerShell"
+            shell_path = KaosPath("powershell.exe")
+        else:
+            possible_paths = [
+                KaosPath("/bin/bash"),
+                KaosPath("/usr/bin/bash"),
+                KaosPath("/usr/local/bin/bash"),
+            ]
+            fallback_path = KaosPath("/bin/sh")
+            for path in possible_paths:
+                if await path.is_file():
+                    shell_name = "bash"
+                    shell_path = path
+                    break
+            else:
+                shell_name = "sh"
+                shell_path = fallback_path
+
+        return Environment(
+            os_kind=os_kind,
+            os_arch=os_arch,
+            os_version=os_version,
+            shell_name=shell_name,
+            shell_path=shell_path,
+        )