kimi-cli 0.39__py3-none-any.whl → 0.41__py3-none-any.whl

kimi_cli/ui/acp/__init__.py

@@ -12,18 +12,17 @@ from kosong.base.message import (
 from kosong.chat_provider import ChatProviderError
 from kosong.tooling import ToolError, ToolOk, ToolResult
 
-from kimi_cli.soul import LLMNotSet, MaxStepsReached, Soul
-from kimi_cli.soul.wire import (
+from kimi_cli.soul import LLMNotSet, MaxStepsReached, RunCancelled, Soul, run_soul
+from kimi_cli.tools import extract_subtitle
+from kimi_cli.utils.logging import logger
+from kimi_cli.wire import WireUISide
+from kimi_cli.wire.message import (
     ApprovalRequest,
     ApprovalResponse,
     StatusUpdate,
     StepBegin,
     StepInterrupted,
-    Wire,
 )
-from kimi_cli.tools import extract_subtitle
-from kimi_cli.ui import RunCancelled, run_soul
-from kimi_cli.utils.logging import logger
 
 
 class _ToolCallState:
@@ -64,7 +63,7 @@ class _RunState:
         self.cancel_event = asyncio.Event()
 
 
-class ACPAgentImpl:
+class ACPAgent:
     """Implementation of the ACP Agent protocol."""
 
     def __init__(self, soul: Soul, connection: acp.AgentSideConnection):
@@ -172,7 +171,7 @@ class ACPAgentImpl:
             logger.info("Cancelling running prompt")
             self.run_state.cancel_event.set()
 
-    async def _stream_events(self, wire: Wire):
+    async def _stream_events(self, wire: WireUISide):
         try:
             # expect a StepBegin
             assert isinstance(await wire.receive(), StepBegin)
@@ -428,7 +427,7 @@ class ACPServer:
 
         # Create connection - the library handles all JSON-RPC details!
         _ = acp.AgentSideConnection(
-            lambda conn: ACPAgentImpl(self.soul, conn),
+            lambda conn: ACPAgent(self.soul, conn),
             writer,
             reader,
         )

kimi_cli/ui/print/__init__.py

@@ -3,18 +3,18 @@ import json
 import signal
 import sys
 from functools import partial
+from pathlib import Path
 from typing import Literal
 
 import aiofiles
 from kosong.base.message import Message
 from kosong.chat_provider import ChatProviderError
 
-from kimi_cli.soul import LLMNotSet, MaxStepsReached
-from kimi_cli.soul.kimisoul import KimiSoul
-from kimi_cli.soul.wire import StepInterrupted, Wire
-from kimi_cli.ui import RunCancelled, run_soul
+from kimi_cli.soul import LLMNotSet, MaxStepsReached, RunCancelled, Soul, run_soul
 from kimi_cli.utils.logging import logger
 from kimi_cli.utils.message import message_extract_text
+from kimi_cli.wire import WireUISide
+from kimi_cli.wire.message import StepInterrupted
 
 InputFormat = Literal["text", "stream-json"]
 OutputFormat = Literal["text", "stream-json"]
@@ -25,17 +25,23 @@ class PrintApp:
     An app implementation that prints the agent behavior to the console.
 
     Args:
-        soul (KimiSoul): The soul to run. Only `KimiSoul` is supported.
+        soul (Soul): The soul to run.
         input_format (InputFormat): The input format to use.
         output_format (OutputFormat): The output format to use.
+        context_file (Path): The file to store the context.
     """
 
-    def __init__(self, soul: KimiSoul, input_format: InputFormat, output_format: OutputFormat):
+    def __init__(
+        self,
+        soul: Soul,
+        input_format: InputFormat,
+        output_format: OutputFormat,
+        context_file: Path,
+    ):
         self.soul = soul
         self.input_format = input_format
         self.output_format = output_format
-        self.soul._approval.set_yolo(True)
-        # TODO(approval): proper approval request handling
+        self.context_file = context_file
 
     async def run(self, command: str | None = None) -> bool:
         cancel_event = asyncio.Event()
@@ -95,30 +101,6 @@ class PrintApp:
             loop.remove_signal_handler(signal.SIGINT)
         return False
 
-    # TODO: unify with `_soul_run` in `ShellApp` and `ACPAgentImpl`
-    async def _soul_run(self, user_input: str):
-        wire = Wire()
-        logger.debug("Starting visualization loop")
-
-        if self.output_format == "text":
-            vis_task = asyncio.create_task(self._visualize_text(wire))
-        else:
-            assert self.output_format == "stream-json"
-            if not self.soul._context._file_backend.exists():
-                self.soul._context._file_backend.touch()
-            start_position = self.soul._context._file_backend.stat().st_size
-            vis_task = asyncio.create_task(self._visualize_stream_json(wire, start_position))
-
-        try:
-            await self.soul.run(user_input, wire)
-        finally:
-            wire.shutdown()
-            # shutting down the event queue should break the visualization loop
-            try:
-                await asyncio.wait_for(vis_task, timeout=0.5)
-            except TimeoutError:
-                logger.warning("Visualization loop timed out")
-
     def _read_next_command(self) -> str | None:
         while True:
             json_line = sys.stdin.readline()
@@ -144,7 +126,7 @@ class PrintApp:
             except Exception:
                 logger.warning("Ignoring invalid user message: {json_line}", json_line=json_line)
 
-    async def _visualize_text(self, wire: Wire):
+    async def _visualize_text(self, wire: WireUISide):
         try:
             while True:
                 msg = await wire.receive()
@@ -154,10 +136,10 @@ class PrintApp:
         except asyncio.QueueShutDown:
             logger.debug("Visualization loop shutting down")
 
-    async def _visualize_stream_json(self, wire: Wire, start_position: int):
+    async def _visualize_stream_json(self, wire: WireUISide, start_position: int):
         # TODO: be aware of context compaction
         try:
-            async with aiofiles.open(self.soul._context._file_backend, encoding="utf-8") as f:
+            async with aiofiles.open(self.context_file, encoding="utf-8") as f:
                 await f.seek(start_position)
                 while True:
                     should_end = False

kimi_cli/ui/shell/__init__.py

@@ -1,7 +1,6 @@
 import asyncio
 import signal
 from collections.abc import Awaitable, Coroutine
-from functools import partial
 from typing import Any
 
 from kosong.chat_provider import APIStatusError, ChatProviderError
@@ -10,9 +9,8 @@ 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, MaxStepsReached, RunCancelled, Soul, run_soul
 from kimi_cli.soul.kimisoul import KimiSoul
-from kimi_cli.ui import RunCancelled, run_soul
 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, toast
@@ -21,12 +19,6 @@ from kimi_cli.ui.shell.visualize import visualize
 from kimi_cli.utils.logging import logger
 
 
-class Reload(Exception):
-    """Reload configuration."""
-
-    pass
-
-
 class ShellApp:
     def __init__(self, soul: Soul, welcome_info: dict[str, str] | None = None):
         self.soul = soul
@@ -107,6 +99,8 @@ class ShellApp:
             loop.remove_signal_handler(signal.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:]
@@ -160,10 +154,13 @@ class ShellApp:
         loop.add_signal_handler(signal.SIGINT, _handler)
 
         try:
+            # Use lambda to pass cancel_event via closure
             await run_soul(
                 self.soul,
                 command,
-                partial(visualize, initial_status=self.soul.status),
+                lambda wire: visualize(
+                    wire, initial_status=self.soul.status, cancel_event=cancel_event
+                ),
                 cancel_event,
             )
             return True
@@ -186,9 +183,6 @@ 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]")
@@ -263,9 +257,9 @@ def _print_welcome_info(name: str, model: str, info_items: dict[str, str]) -> No
         )
 
     if LATEST_VERSION_FILE.exists():
-        from kimi_cli import __version__ as current_version
+        from kimi_cli.constant import VERSION as current_version
 
-        latest_version = LATEST_VERSION_FILE.read_text().strip()
+        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(

kimi_cli/ui/shell/liveview.py

@@ -1,3 +1,4 @@
+import asyncio
 from collections import deque
 
 import streamingjson
@@ -14,10 +15,10 @@ 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
+from kimi_cli.wire.message import ApprovalRequest, ApprovalResponse
 
 
 class _ToolCallDisplay:
@@ -125,7 +126,7 @@ class _ApprovalRequestDisplay:
 
 
 class StepLiveView:
-    def __init__(self, status: StatusSnapshot):
+    def __init__(self, status: StatusSnapshot, cancel_event: asyncio.Event | None = None):
         # message content
         self._line_buffer = Text("")
 
@@ -144,6 +145,9 @@ class StepLiveView:
         )
         self._buffer_status: RenderableType | None = None
 
+        # cancel event for ESC key handling
+        self._cancel_event = cancel_event
+
     def __enter__(self):
         self._live = Live(
             self._compose(),
@@ -243,6 +247,11 @@ class StepLiveView:
         self._status_text.plain = self._format_status(status)
 
     def handle_keyboard_event(self, event: KeyEvent):
+        # Handle ESC key to cancel the run
+        if event == KeyEvent.ESCAPE and self._cancel_event is not None:
+            self._cancel_event.set()
+            return
+
         if not self._current_approval:
             # just ignore any keyboard event when there's no approval request
             return
@@ -298,8 +307,8 @@ class StepLiveView:
 class StepLiveViewWithMarkdown(StepLiveView):
     # TODO: figure out a streaming implementation for this
 
-    def __init__(self, status: StatusSnapshot):
-        super().__init__(status)
+    def __init__(self, status: StatusSnapshot, cancel_event: asyncio.Event | None = None):
+        super().__init__(status, cancel_event)
         self._pending_markdown_parts: list[str] = []
         self._buffer_status_active = False
         self._buffer_status_obj: Status | None = None

kimi_cli/ui/shell/metacmd.py

@@ -8,8 +8,8 @@ from kosong.base.message import Message
 from rich.panel import Panel
 
 import kimi_cli.prompts as prompts
-from kimi_cli.agent import load_agents_md
 from kimi_cli.soul.context import Context
+from kimi_cli.soul.globals import load_agents_md
 from kimi_cli.soul.kimisoul import KimiSoul
 from kimi_cli.soul.message import system
 from kimi_cli.ui.shell.console import console
@@ -173,9 +173,9 @@ def help(app: "ShellApp", args: list[str]):
 @meta_command
 def version(app: "ShellApp", args: list[str]):
     """Show version information"""
-    from kimi_cli import __version__
+    from kimi_cli.constant import VERSION
 
-    console.print(f"kimi, version {__version__}")
+    console.print(f"kimi, version {VERSION}")
 
 
 @meta_command(name="release-notes")

kimi_cli/ui/shell/setup.py

@@ -9,6 +9,7 @@ from pydantic import SecretStr
 from kimi_cli.config import LLMModel, LLMProvider, MoonshotSearchConfig, load_config, save_config
 from kimi_cli.ui.shell.console import console
 from kimi_cli.ui.shell.metacmd import meta_command
+from kimi_cli.utils.aiohttp import new_client_session
 
 if TYPE_CHECKING:
     from kimi_cli.ui.shell import ShellApp
@@ -25,19 +26,19 @@ class _Platform(NamedTuple):
 _PLATFORMS = [
     _Platform(
         id="kimi-for-coding",
-        name="Kimi For Coding",
+        name="Kimi For Coding (CN)",
         base_url="https://api.kimi.com/coding/v1",
         search_url="https://api.kimi.com/coding/v1/search",
     ),
     _Platform(
         id="moonshot-cn",
-        name="Moonshot AI 开放平台",
+        name="Moonshot AI 开放平台 (moonshot.cn)",
         base_url="https://api.moonshot.cn/v1",
         allowed_models=["kimi-k2-turbo-preview", "kimi-k2-0905-preview", "kimi-k2-0711-preview"],
     ),
     _Platform(
         id="moonshot-ai",
-        name="Moonshot AI Open Platform",
+        name="Moonshot AI Open Platform (moonshot.ai)",
         base_url="https://api.moonshot.ai/v1",
         allowed_models=["kimi-k2-turbo-preview", "kimi-k2-0905-preview", "kimi-k2-0711-preview"],
     ),
@@ -76,7 +77,7 @@ async def setup(app: "ShellApp", args: list[str]):
     await asyncio.sleep(1)
     console.clear()
 
-    from kimi_cli import Reload
+    from kimi_cli.cli import Reload
 
     raise Reload
 
@@ -109,7 +110,7 @@ async def _setup() -> _SetupResult | None:
     models_url = f"{platform.base_url}/models"
     try:
         async with (
-            aiohttp.ClientSession() as session,
+            new_client_session() as session,
             session.get(
                 models_url,
                 headers={
@@ -184,6 +185,6 @@ async def _prompt_text(prompt: str, *, is_password: bool = False) -> str | None:
 @meta_command
 def reload(app: "ShellApp", args: list[str]):
     """Reload configuration"""
-    from kimi_cli import Reload
+    from kimi_cli.cli import Reload
 
     raise Reload

kimi_cli/ui/shell/update.py

@@ -13,6 +13,7 @@ import aiohttp
 
 from kimi_cli.share import get_share_dir
 from kimi_cli.ui.shell.console import console
+from kimi_cli.utils.aiohttp import new_client_session
 from kimi_cli.utils.logging import logger
 
 BASE_URL = "https://cdn.kimi.com/binaries/kimi-cli"
@@ -84,7 +85,7 @@ LATEST_VERSION_FILE = get_share_dir() / "latest_version.txt"
 
 
 async def _do_update(*, print: bool, check_only: bool) -> UpdateResult:
-    from kimi_cli import __version__ as current_version
+    from kimi_cli.constant import VERSION as current_version
 
     def _print(message: str) -> None:
         if print:
@@ -95,7 +96,7 @@ async def _do_update(*, print: bool, check_only: bool) -> UpdateResult:
         _print("[red]Failed to detect target platform.[/red]")
         return UpdateResult.UNSUPPORTED
 
-    async with aiohttp.ClientSession() as session:
+    async with new_client_session() as session:
         logger.info("Checking for updates...")
         _print("Checking for updates...")
         latest_version = await _get_latest_version(session)
@@ -104,7 +105,7 @@ async def _do_update(*, print: bool, check_only: bool) -> UpdateResult:
             return UpdateResult.FAILED
 
         logger.debug("Latest version: {latest_version}", latest_version=latest_version)
-        LATEST_VERSION_FILE.write_text(latest_version)
+        LATEST_VERSION_FILE.write_text(latest_version, encoding="utf-8")
 
         cur_t = semver_tuple(current_version)
         lat_t = semver_tuple(latest_version)

kimi_cli/ui/shell/visualize.py

@@ -5,19 +5,19 @@ 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 (
+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
+from kimi_cli.wire import WireUISide
+from kimi_cli.wire.message 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
@@ -25,7 +25,6 @@ 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
@@ -39,10 +38,20 @@ async def _keyboard_listener(step: StepLiveView):
             await task
 
 
-async def visualize(wire: Wire, *, initial_status: StatusSnapshot):
+async def visualize(
+    wire: WireUISide,
+    *,
+    initial_status: StatusSnapshot,
+    cancel_event: asyncio.Event | None = None,
+):
     """
     A loop to consume agent events and visualize the agent behavior.
     This loop never raise any exception except asyncio.CancelledError.
+
+    Args:
+        wire: Communication channel with the agent
+        initial_status: Initial status snapshot
+        cancel_event: Event that can be set (e.g., by ESC key) to cancel the run
     """
     latest_status = initial_status
     try:
@@ -52,7 +61,7 @@ async def visualize(wire: Wire, *, initial_status: StatusSnapshot):
         while True:
             # TODO: Maybe we can always have a StepLiveView here.
             #       No need to recreate for each step.
-            with StepLiveViewWithMarkdown(latest_status) as step:
+            with StepLiveViewWithMarkdown(latest_status, cancel_event) as step:
                 async with _keyboard_listener(step):
                     # spin the moon at the beginning of each step
                     with console.status("", spinner="moon"):

kimi_cli/utils/aiohttp.py

@@ -0,0 +1,10 @@
+import ssl
+
+import aiohttp
+import certifi
+
+_ssl_context = ssl.create_default_context(cafile=certifi.where())
+
+
+def new_client_session() -> aiohttp.ClientSession:
+    return aiohttp.ClientSession(connector=aiohttp.TCPConnector(ssl=_ssl_context))

kimi_cli/utils/changelog.py

@@ -98,4 +98,6 @@ def format_release_notes(changelog: dict[str, ReleaseEntry]) -> str:
     return "\n".join(parts).strip()
 
 
-CHANGELOG = parse_changelog((Path(__file__).parent.parent / "CHANGELOG.md").read_text())
+CHANGELOG = parse_changelog(
+    (Path(__file__).parent.parent / "CHANGELOG.md").read_text(encoding="utf-8")
+)

kimi_cli/wire/__init__.py

@@ -0,0 +1,57 @@
+import asyncio
+
+from kosong.base.message import ContentPart, ToolCallPart
+
+from kimi_cli.utils.logging import logger
+from kimi_cli.wire.message import WireMessage
+
+
+class Wire:
+    """
+    A channel for communication between the soul and the UI during a soul run.
+    """
+
+    def __init__(self):
+        self._queue = asyncio.Queue[WireMessage]()
+        self._soul_side = WireSoulSide(self._queue)
+        self._ui_side = WireUISide(self._queue)
+
+    @property
+    def soul_side(self) -> "WireSoulSide":
+        return self._soul_side
+
+    @property
+    def ui_side(self) -> "WireUISide":
+        return self._ui_side
+
+    def shutdown(self) -> None:
+        self._queue.shutdown()
+
+
+class WireSoulSide:
+    """
+    The soul side of a wire.
+    """
+
+    def __init__(self, queue: asyncio.Queue[WireMessage]):
+        self._queue = queue
+
+    def send(self, msg: WireMessage) -> None:
+        if not isinstance(msg, ContentPart | ToolCallPart):
+            logger.debug("Sending wire message: {msg}", msg=msg)
+        self._queue.put_nowait(msg)
+
+
+class WireUISide:
+    """
+    The UI side of a wire.
+    """
+
+    def __init__(self, queue: asyncio.Queue[WireMessage]):
+        self._queue = queue
+
+    async def receive(self) -> WireMessage:
+        msg = await self._queue.get()
+        if not isinstance(msg, ContentPart | ToolCallPart):
+            logger.debug("Receiving wire message: {msg}", msg=msg)
+        return msg

kimi_cli/{soul/wire.py → wire/message.py}

@@ -1,14 +1,13 @@
 import asyncio
 import uuid
-from contextvars import ContextVar
 from enum import Enum
-from typing import NamedTuple
+from typing import TYPE_CHECKING, NamedTuple
 
 from kosong.base.message import ContentPart, ToolCall, ToolCallPart
 from kosong.tooling import ToolResult
 
-from kimi_cli.soul import StatusSnapshot
-from kimi_cli.utils.logging import logger
+if TYPE_CHECKING:
+    from kimi_cli.soul import StatusSnapshot
 
 
 class StepBegin(NamedTuple):
@@ -39,7 +38,7 @@ class CompactionEnd:
 
 
 class StatusUpdate(NamedTuple):
-    status: StatusSnapshot
+    status: "StatusSnapshot"
 
 
 type ControlFlowEvent = StepBegin | StepInterrupted | CompactionBegin | CompactionEnd | StatusUpdate
@@ -90,37 +89,3 @@ class ApprovalRequest:
 
 
 type WireMessage = Event | ApprovalRequest
-
-
-class Wire:
-    """
-    A channel for communication between the soul and the UI.
-    """
-
-    def __init__(self):
-        self._queue = asyncio.Queue[WireMessage]()
-
-    def send(self, msg: WireMessage) -> None:
-        if not isinstance(msg, ContentPart | ToolCallPart):
-            logger.debug("Sending wire message: {msg}", msg=msg)
-        self._queue.put_nowait(msg)
-
-    async def receive(self) -> WireMessage:
-        msg = await self._queue.get()
-        if not isinstance(msg, ContentPart | ToolCallPart):
-            logger.debug("Receiving wire message: {msg}", msg=msg)
-        return msg
-
-    def shutdown(self) -> None:
-        self._queue.shutdown()
-
-
-current_wire = ContextVar[Wire | None]("current_wire", default=None)
-
-
-def get_wire_or_none() -> Wire | None:
-    """
-    Get the current wire or None.
-    Expect to be not None when called from anywhere in the agent loop.
-    """
-    return current_wire.get()

{kimi_cli-0.39.dist-info → kimi_cli-0.41.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: kimi-cli
-Version: 0.39
+Version: 0.41
 Summary: Kimi CLI is your next CLI agent.
 Requires-Dist: agent-client-protocol>=0.4.9
 Requires-Dist: aiofiles>=25.1.0
@@ -24,6 +24,11 @@ Description-Content-Type: text/markdown
 
 # Kimi CLI
 
+[![Commit Activity](https://img.shields.io/github/commit-activity/w/MoonshotAI/kimi-cli)](https://github.com/MoonshotAI/kimi-cli/graphs/commit-activity)
+[![Checks](https://img.shields.io/github/check-runs/MoonshotAI/kimi-cli/main)](https://github.com/MoonshotAI/kimi-cli/actions)
+[![Version](https://img.shields.io/pypi/v/kimi-cli)](https://pypi.org/project/kimi-cli/)
+[![Downloads](https://img.shields.io/pypi/dw/kimi-cli)](https://pypistats.org/packages/kimi-cli)
+
 [中文](https://www.kimi.com/coding/docs/kimi-cli.html)
 
 Kimi CLI is a new CLI agent that can help you with your software development tasks and terminal operations.
@@ -108,7 +113,7 @@ After restarting Zsh, you can switch to agent mode by pressing `Ctrl-K`.
 
 ### ACP support
 
-Kimi CLI supports [Agent Client Protocol] out of the box. You can use it together with any ACP-compatible editors or IDEs.
+Kimi CLI supports [Agent Client Protocol] out of the box. You can use it together with any ACP-compatible editor or IDE.
 
 For example, to use Kimi CLI with [Zed](https://zed.dev/), add the following configuration to your `~/.config/zed/settings.json`:
 
@@ -152,3 +157,31 @@ Run `kimi` with `--mcp-config-file` option to connect to the specified MCP serve
 ```sh
 kimi --mcp-config-file /path/to/mcp.json
 ```
+
+## Development
+
+To develop Kimi CLI, run:
+
+```sh
+git clone https://github.com/MoonshotAI/kimi-cli.git
+cd kimi-cli
+
+make prepare  # prepare the development environment
+```
+
+Then you can start working on Kimi CLI.
+
+Refer to the following commands after you make changes:
+
+```sh
+uv run kimi  # run Kimi CLI
+
+make format  # format code
+make check  # run linting and type checking
+make test  # run tests
+make help  # show all make targets
+```
+
+## Contributing
+
+We welcome contributions to Kimi CLI! Please refer to [CONTRIBUTING.md](./CONTRIBUTING.md) for more information.