kimi-cli 0.35__tar.gz → 0.37__tar.gz

kimi_cli-0.37/PKG-INFO

@@ -0,0 +1,150 @@
+Metadata-Version: 2.3
+Name: kimi-cli
+Version: 0.37
+Summary: Kimi CLI is your next CLI agent.
+Requires-Dist: agent-client-protocol>=0.4.9
+Requires-Dist: aiofiles>=25.1.0
+Requires-Dist: aiohttp>=3.13.1
+Requires-Dist: click>=8.3.0
+Requires-Dist: kosong>=0.15.0
+Requires-Dist: loguru>=0.7.3
+Requires-Dist: patch-ng>=1.19.0
+Requires-Dist: prompt-toolkit>=3.0.52
+Requires-Dist: pyyaml>=6.0.3
+Requires-Dist: rich>=14.2.0
+Requires-Dist: ripgrepy>=2.2.0
+Requires-Dist: streamingjson>=0.0.5
+Requires-Dist: trafilatura>=2.0.0
+Requires-Dist: tenacity>=9.1.2
+Requires-Dist: fastmcp>=2.12.5
+Requires-Dist: pydantic>=2.12.3
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+
+# 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.
+
+> [!IMPORTANT]
+> Kimi CLI is currently in technical preview.
+
+## Key features
+
+- Shell-like UI and raw shell command execution
+- Zsh integration
+- [Agent Client Protocol] support
+- MCP support
+- And more to come...
+
+[Agent Client Protocol]: https://github.com/agentclientprotocol/agent-client-protocol
+
+## Installation
+
+Kimi CLI is published as a Python package on PyPI. We highly recommend installing it with [uv](https://docs.astral.sh/uv/). If you have not installed uv yet, please follow the instructions [here](https://docs.astral.sh/uv/getting-started/installation/) to install it first.
+
+Once uv is installed, you can install Kimi CLI with:
+
+```sh
+uv tool install --python 3.13 kimi-cli
+```
+
+Run `kimi --help` to check if Kimi CLI is installed successfully.
+
+> [!IMPORTANT]
+> Due to the security checks on macOS, the first time you run `kimi` command may take 10 seconds or more depending on your system environment.
+
+## Upgrading
+
+Upgrade Kimi CLI to the latest version with:
+
+```sh
+uv tool upgrade kimi-cli --no-cache
+```
+
+## Usage
+
+Run `kimi` command in the directory you want to work on, then send `/setup` to setup Kimi CLI:
+
+![](./docs/images/setup.png)
+
+After setup is complete, Kimi CLI will be ready to use. You can send `/help` to get more information.
+
+## Features
+
+### Shell mode
+
+Kimi CLI is not only a coding agent, but also a shell. You can switch the mode by pressing `Ctrl-K`. In shell mode, you can directly run shell commands without leaving Kimi CLI.
+
+> [!NOTE]
+> Built-in shell commands like `cd` are not supported yet.
+
+### Zsh integration
+
+You can use Kimi CLI together with Zsh, to empower your shell experience with AI agent capabilities.
+
+Install the [zsh-kimi-cli](https://github.com/MoonshotAI/zsh-kimi-cli) plugin via:
+
+```sh
+git clone https://github.com/MoonshotAI/zsh-kimi-cli.git \
+  ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/kimi-cli
+```
+
+> [!NOTE]
+> If you are using a plugin manager other than Oh My Zsh, you may need to refer to the plugin's README for installation instructions.
+
+Then add `kimi-cli` to your Zsh plugin list in `~/.zshrc`:
+
+```sh
+plugins=(... kimi-cli)
+```
+
+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.
+
+For example, to use Kimi CLI with [Zed](https://zed.dev/), add the following configuration to your `~/.config/zed/settings.json`:
+
+```json
+{
+  "agent_servers": {
+    "Kimi CLI": {
+      "command": "kimi",
+      "args": ["--acp"],
+      "env": {}
+    }
+  }
+}
+```
+
+Then you can create Kimi CLI threads in Zed's agent panel.
+
+### Using MCP tools
+
+Kimi CLI supports the well-established MCP config convention. For example:
+
+```json
+{
+  "mcpServers": {
+    "context7": {
+      "url": "https://mcp.context7.com/mcp",
+      "headers": {
+        "CONTEXT7_API_KEY": "YOUR_API_KEY"
+      }
+    },
+    "chrome-devtools": {
+      "command": "npx",
+      "args": ["-y", "chrome-devtools-mcp@latest"]
+    }
+  }
+}
+```
+
+Run `kimi` with `--mcp-config-file` option to connect to the specified MCP servers:
+
+```sh
+kimi --mcp-config-file /path/to/mcp.json
+```

kimi_cli-0.37/README.md

@@ -0,0 +1,127 @@
+# 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.
+
+> [!IMPORTANT]
+> Kimi CLI is currently in technical preview.
+
+## Key features
+
+- Shell-like UI and raw shell command execution
+- Zsh integration
+- [Agent Client Protocol] support
+- MCP support
+- And more to come...
+
+[Agent Client Protocol]: https://github.com/agentclientprotocol/agent-client-protocol
+
+## Installation
+
+Kimi CLI is published as a Python package on PyPI. We highly recommend installing it with [uv](https://docs.astral.sh/uv/). If you have not installed uv yet, please follow the instructions [here](https://docs.astral.sh/uv/getting-started/installation/) to install it first.
+
+Once uv is installed, you can install Kimi CLI with:
+
+```sh
+uv tool install --python 3.13 kimi-cli
+```
+
+Run `kimi --help` to check if Kimi CLI is installed successfully.
+
+> [!IMPORTANT]
+> Due to the security checks on macOS, the first time you run `kimi` command may take 10 seconds or more depending on your system environment.
+
+## Upgrading
+
+Upgrade Kimi CLI to the latest version with:
+
+```sh
+uv tool upgrade kimi-cli --no-cache
+```
+
+## Usage
+
+Run `kimi` command in the directory you want to work on, then send `/setup` to setup Kimi CLI:
+
+![](./docs/images/setup.png)
+
+After setup is complete, Kimi CLI will be ready to use. You can send `/help` to get more information.
+
+## Features
+
+### Shell mode
+
+Kimi CLI is not only a coding agent, but also a shell. You can switch the mode by pressing `Ctrl-K`. In shell mode, you can directly run shell commands without leaving Kimi CLI.
+
+> [!NOTE]
+> Built-in shell commands like `cd` are not supported yet.
+
+### Zsh integration
+
+You can use Kimi CLI together with Zsh, to empower your shell experience with AI agent capabilities.
+
+Install the [zsh-kimi-cli](https://github.com/MoonshotAI/zsh-kimi-cli) plugin via:
+
+```sh
+git clone https://github.com/MoonshotAI/zsh-kimi-cli.git \
+  ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/kimi-cli
+```
+
+> [!NOTE]
+> If you are using a plugin manager other than Oh My Zsh, you may need to refer to the plugin's README for installation instructions.
+
+Then add `kimi-cli` to your Zsh plugin list in `~/.zshrc`:
+
+```sh
+plugins=(... kimi-cli)
+```
+
+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.
+
+For example, to use Kimi CLI with [Zed](https://zed.dev/), add the following configuration to your `~/.config/zed/settings.json`:
+
+```json
+{
+  "agent_servers": {
+    "Kimi CLI": {
+      "command": "kimi",
+      "args": ["--acp"],
+      "env": {}
+    }
+  }
+}
+```
+
+Then you can create Kimi CLI threads in Zed's agent panel.
+
+### Using MCP tools
+
+Kimi CLI supports the well-established MCP config convention. For example:
+
+```json
+{
+  "mcpServers": {
+    "context7": {
+      "url": "https://mcp.context7.com/mcp",
+      "headers": {
+        "CONTEXT7_API_KEY": "YOUR_API_KEY"
+      }
+    },
+    "chrome-devtools": {
+      "command": "npx",
+      "args": ["-y", "chrome-devtools-mcp@latest"]
+    }
+  }
+}
+```
+
+Run `kimi` with `--mcp-config-file` option to connect to the specified MCP servers:
+
+```sh
+kimi --mcp-config-file /path/to/mcp.json
+```

{kimi_cli-0.35 → kimi_cli-0.37}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kimi-cli"
-version = "0.35"
+version = "0.37"
 description = "Kimi CLI is your next CLI agent."
 readme = "README.md"
 requires-python = ">=3.13"
@@ -9,7 +9,7 @@ dependencies = [
     "aiofiles>=25.1.0",
     "aiohttp>=3.13.1",
     "click>=8.3.0",
-    "kosong>=0.14.1",
+    "kosong>=0.15.0",
     "loguru>=0.7.3",
     "patch-ng>=1.19.0",
     "prompt-toolkit>=3.0.52",

{kimi_cli-0.35 → kimi_cli-0.37}/src/kimi_cli/CHANGELOG.md

@@ -9,6 +9,26 @@ Internal builds may append content to the Unreleased section.
 Only write entries that are worth mentioning to users.
 -->
 
+## [0.37] - 2025-10-24
+
+### Fixed
+
+- Fix update checking
+
+## [0.36] - 2025-10-24
+
+### Added
+
+- Add `/debug` meta command to debug the context
+- Add auto context compaction
+- Add approval request mechanism
+- Add `--yolo` option to automatically approve all actions
+- Render markdown content for better readability
+
+### Fixed
+
+- Fix "unknown error" message when interrupting a meta command
+
 ## [0.35] - 2025-10-22
 
 ### Changed

{kimi_cli-0.35 → kimi_cli-0.37}/src/kimi_cli/__init__.py

@@ -152,6 +152,16 @@ UIMode = Literal["shell", "print", "acp"]
         "Default: none."
     ),
 )
+@click.option(
+    "--yolo",
+    "--yes",
+    "-y",
+    "--auto-approve",
+    "yolo",
+    is_flag=True,
+    default=False,
+    help="Automatically approve all actions. Default: no.",
+)
 def kimi(
     verbose: bool,
     debug: bool,
@@ -165,6 +175,7 @@ def kimi(
     output_format: OutputFormat | None,
     mcp_config_file: list[Path],
     mcp_config: list[str],
+    yolo: bool,
 ):
     """Kimi, your next CLI agent."""
     echo = click.echo if verbose else lambda *args, **kwargs: None
@@ -232,6 +243,7 @@ def kimi(
                     input_format=input_format,
                     output_format=output_format,
                     mcp_configs=mcp_configs,
+                    yolo=yolo,
                 )
             )
             if not succeeded:
@@ -254,6 +266,7 @@ async def kimi_run(
     input_format: InputFormat | None = None,
     output_format: OutputFormat | None = None,
     mcp_configs: list[dict[str, Any]] | None = None,
+    yolo: bool = False,
 ) -> bool:
     """Run Kimi CLI."""
     echo = click.echo if verbose else lambda *args, **kwargs: None
@@ -286,7 +299,7 @@ async def kimi_run(
         echo(f"✓ Using LLM provider: {provider}")
         echo(f"✓ Using LLM model: {model}")
         stream = ui != "print"  # use non-streaming mode only for print UI
-        llm = create_llm(provider, model, stream=stream)
+        llm = create_llm(provider, model, stream=stream, session_id=session.id)
 
     # TODO: support Windows
     ls = subprocess.run(["ls", "-la"], capture_output=True, text=True)
@@ -305,7 +318,7 @@ async def kimi_run(
         ),
         denwa_renji=DenwaRenji(),
         session=session,
-        approval=Approval(),
+        approval=Approval(yolo=yolo),
     )
     try:
         agent = await load_agent_with_mcp(agent_file, agent_globals, mcp_configs or [])

{kimi_cli-0.35 → kimi_cli-0.37}/src/kimi_cli/soul/__init__.py

@@ -51,7 +51,7 @@ class Soul(Protocol):
             wire (Wire): The wire to send events and requests to the UI loop.
 
         Raises:
-            ChatProviderNotSet: When the chat provider is not set.
+            LLMNotSet: When the LLM is not set.
             ChatProviderError: When the LLM provider returns an error.
             MaxStepsReached: When the maximum number of steps is reached.
             asyncio.CancelledError: When the run is cancelled by user.

{kimi_cli-0.35 → kimi_cli-0.37}/src/kimi_cli/soul/approval.py

@@ -15,11 +15,12 @@ class Approval:
     def set_yolo(self, yolo: bool) -> None:
         self._yolo = yolo
 
-    async def request(self, action: str, description: str) -> bool:
+    async def request(self, sender: str, action: str, description: str) -> bool:
         """
         Request approval for the given action. Intended to be called by tools.
 
         Args:
+            sender (str): The name of the sender.
             action (str): The action to request approval for.
                 This is used to identify the action for auto-approval.
             description (str): The description of the action. This is used to display to the user.
@@ -47,7 +48,7 @@ class Approval:
         if action in self._auto_approve_actions:
             return True
 
-        request = ApprovalRequest(tool_call.id, action, description)
+        request = ApprovalRequest(tool_call.id, sender, action, description)
         self._request_queue.put_nowait(request)
         response = await request.wait()
         logger.debug("Received approval response: {response}", response=response)

kimi_cli-0.37/src/kimi_cli/soul/compaction.py

@@ -0,0 +1,105 @@
+from collections.abc import Sequence
+from string import Template
+from typing import Protocol, runtime_checkable
+
+from kosong.base import generate
+from kosong.base.message import ContentPart, Message, TextPart
+
+import kimi_cli.prompts as prompts
+from kimi_cli.llm import LLM
+from kimi_cli.soul.message import system
+from kimi_cli.utils.logging import logger
+
+MAX_PRESERVED_MESSAGES = 2
+
+
+@runtime_checkable
+class Compaction(Protocol):
+    async def compact(self, messages: Sequence[Message], llm: LLM) -> Sequence[Message]:
+        """
+        Compact a sequence of messages into a new sequence of messages.
+
+        Args:
+            messages (Sequence[Message]): The messages to compact.
+            llm (LLM): The LLM to use for compaction.
+
+        Returns:
+            Sequence[Message]: The compacted messages.
+
+        Raises:
+            ChatProviderError: When the chat provider returns an error.
+        """
+        ...
+
+
+class SimpleCompaction:
+    async def compact(self, messages: Sequence[Message], llm: LLM) -> Sequence[Message]:
+        history = list(messages)
+        if not history:
+            return history
+
+        preserve_start_index = len(history)
+        n_preserved = 0
+        for index in range(len(history) - 1, -1, -1):
+            if history[index].role in {"user", "assistant"}:
+                n_preserved += 1
+                if n_preserved == MAX_PRESERVED_MESSAGES:
+                    preserve_start_index = index
+                    break
+
+        if n_preserved < MAX_PRESERVED_MESSAGES:
+            return history
+
+        to_compact = history[:preserve_start_index]
+        to_preserve = history[preserve_start_index:]
+
+        if not to_compact:
+            # Let's hope this won't exceed the context size limit
+            return to_preserve
+
+        # 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(to_compact)
+        )
+
+        # 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
+        # TODO: set max completion tokens
+        logger.debug("Compacting context...")
+        compacted_msg, usage = await generate(
+            chat_provider=llm.chat_provider,
+            system_prompt="You are a helpful assistant that compacts conversation context.",
+            tools=[],
+            history=[compact_message],
+        )
+        if usage:
+            logger.debug(
+                "Compaction used {input} input tokens and {output} output tokens",
+                input=usage.input,
+                output=usage.output,
+            )
+
+        content: list[ContentPart] = [
+            system("Previous context has been compacted. Here is the compaction output:")
+        ]
+        content.extend(
+            [TextPart(text=compacted_msg.content)]
+            if isinstance(compacted_msg.content, str)
+            else compacted_msg.content
+        )
+        compacted_messages: list[Message] = [Message(role="assistant", content=content)]
+        compacted_messages.extend(to_preserve)
+        return compacted_messages
+
+
+def __static_type_check(
+    simple: SimpleCompaction,
+):
+    _: Compaction = simple