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

kimi_cli/cli.py

@@ -1,250 +0,0 @@
-import asyncio
-import json
-import sys
-from collections.abc import Callable
-from pathlib import Path
-from typing import Any, Literal, get_args
-
-import click
-
-from kimi_cli.constant import VERSION
-
-
-class Reload(Exception):
-    """Reload configuration."""
-
-    pass
-
-
-UIMode = Literal["shell", "print", "acp"]
-InputFormat = Literal["text", "stream-json"]
-OutputFormat = Literal["text", "stream-json"]
-
-
-@click.command(context_settings=dict(help_option_names=["-h", "--help"]))
-@click.version_option(VERSION)
-@click.option(
-    "--verbose",
-    is_flag=True,
-    default=False,
-    help="Print verbose information. Default: no.",
-)
-@click.option(
-    "--debug",
-    is_flag=True,
-    default=False,
-    help="Log debug information. Default: no.",
-)
-@click.option(
-    "--agent-file",
-    type=click.Path(exists=True, file_okay=True, dir_okay=False, path_type=Path),
-    default=None,
-    help="Custom agent specification file. Default: builtin default agent.",
-)
-@click.option(
-    "--model",
-    "-m",
-    "model_name",
-    type=str,
-    default=None,
-    help="LLM model to use. Default: default model set in config file.",
-)
-@click.option(
-    "--work-dir",
-    "-w",
-    type=click.Path(exists=True, file_okay=False, dir_okay=True, path_type=Path),
-    default=Path.cwd(),
-    help="Working directory for the agent. Default: current directory.",
-)
-@click.option(
-    "--continue",
-    "-C",
-    "continue_",
-    is_flag=True,
-    default=False,
-    help="Continue the previous session for the working directory. Default: no.",
-)
-@click.option(
-    "--command",
-    "-c",
-    "--query",
-    "-q",
-    "command",
-    type=str,
-    default=None,
-    help="User query to the agent. Default: prompt interactively.",
-)
-@click.option(
-    "--ui",
-    "ui",
-    type=click.Choice(get_args(UIMode)),
-    default="shell",
-    help="UI mode to use. Default: shell.",
-)
-@click.option(
-    "--print",
-    "ui",
-    flag_value="print",
-    help="Run in print mode. Shortcut for `--ui print`. Note: print mode implicitly adds `--yolo`.",
-)
-@click.option(
-    "--acp",
-    "ui",
-    flag_value="acp",
-    help="Start ACP server. Shortcut for `--ui acp`.",
-)
-@click.option(
-    "--input-format",
-    type=click.Choice(get_args(InputFormat)),
-    default=None,
-    help=(
-        "Input format to use. Must be used with `--print` "
-        "and the input must be piped in via stdin. "
-        "Default: text."
-    ),
-)
-@click.option(
-    "--output-format",
-    type=click.Choice(get_args(OutputFormat)),
-    default=None,
-    help="Output format to use. Must be used with `--print`. Default: text.",
-)
-@click.option(
-    "--mcp-config-file",
-    type=click.Path(exists=True, file_okay=True, dir_okay=False, path_type=Path),
-    multiple=True,
-    help=(
-        "MCP config file to load. Add this option multiple times to specify multiple MCP configs. "
-        "Default: none."
-    ),
-)
-@click.option(
-    "--mcp-config",
-    type=str,
-    multiple=True,
-    help=(
-        "MCP config JSON to load. Add this option multiple times to specify multiple MCP configs. "
-        "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,
-    agent_file: Path | None,
-    model_name: str | None,
-    work_dir: Path,
-    continue_: bool,
-    command: str | None,
-    ui: UIMode,
-    input_format: InputFormat | None,
-    output_format: OutputFormat | None,
-    mcp_config_file: list[Path],
-    mcp_config: list[str],
-    yolo: bool,
-):
-    """Kimi, your next CLI agent."""
-    from kimi_cli.app import KimiCLI
-    from kimi_cli.session import Session
-    from kimi_cli.share import get_share_dir
-    from kimi_cli.utils.logging import logger
-
-    def _noop_echo(*args: Any, **kwargs: Any):
-        pass
-
-    echo: Callable[..., None] = click.echo if verbose else _noop_echo
-
-    logger.add(
-        get_share_dir() / "logs" / "kimi.log",
-        level="DEBUG" if debug else "INFO",
-        rotation="06:00",
-        retention="10 days",
-    )
-
-    work_dir = work_dir.absolute()
-    if continue_:
-        session = Session.continue_(work_dir)
-        if session is None:
-            raise click.BadOptionUsage(
-                "--continue", "No previous session found for the working directory"
-            )
-        echo(f"✓ Continuing previous session: {session.id}")
-    else:
-        session = Session.create(work_dir)
-        echo(f"✓ Created new session: {session.id}")
-    echo(f"✓ Session history file: {session.history_file}")
-
-    if command is not None:
-        command = command.strip()
-        if not command:
-            raise click.BadOptionUsage("--command", "Command cannot be empty")
-
-    if input_format is not None and ui != "print":
-        raise click.BadOptionUsage(
-            "--input-format",
-            "Input format is only supported for print UI",
-        )
-    if output_format is not None and ui != "print":
-        raise click.BadOptionUsage(
-            "--output-format",
-            "Output format is only supported for print UI",
-        )
-
-    try:
-        mcp_configs = [json.loads(conf.read_text(encoding="utf-8")) for conf in mcp_config_file]
-    except json.JSONDecodeError as e:
-        raise click.BadOptionUsage("--mcp-config-file", f"Invalid JSON: {e}") from e
-
-    try:
-        mcp_configs += [json.loads(conf) for conf in mcp_config]
-    except json.JSONDecodeError as e:
-        raise click.BadOptionUsage("--mcp-config", f"Invalid JSON: {e}") from e
-
-    async def _run() -> bool:
-        instance = await KimiCLI.create(
-            session,
-            yolo=yolo or (ui == "print"),  # print mode implies yolo
-            stream=ui != "print",  # use non-streaming mode only for print UI
-            mcp_configs=mcp_configs,
-            model_name=model_name,
-            agent_file=agent_file,
-        )
-        match ui:
-            case "shell":
-                return await instance.run_shell_mode(command)
-            case "print":
-                return await instance.run_print_mode(
-                    input_format or "text",
-                    output_format or "text",
-                    command,
-                )
-            case "acp":
-                if command is not None:
-                    logger.warning("ACP server ignores command argument")
-                return await instance.run_acp_server()
-
-    while True:
-        try:
-            succeeded = asyncio.run(_run())
-            if not succeeded:
-                sys.exit(1)
-            break
-        except Reload:
-            continue
-
-
-def main():
-    kimi()
-
-
-if __name__ == "__main__":
-    main()

kimi_cli/soul/runtime.py

@@ -1,96 +0,0 @@
-import asyncio
-import subprocess
-import sys
-from datetime import datetime
-from pathlib import Path
-from typing import NamedTuple
-
-from kimi_cli.config import Config
-from kimi_cli.llm import LLM
-from kimi_cli.session import Session
-from kimi_cli.soul.approval import Approval
-from kimi_cli.soul.denwarenji import DenwaRenji
-from kimi_cli.utils.logging import logger
-
-
-class BuiltinSystemPromptArgs(NamedTuple):
-    """Builtin system prompt arguments."""
-
-    KIMI_NOW: str
-    """The current datetime."""
-    KIMI_WORK_DIR: Path
-    """The current working directory."""
-    KIMI_WORK_DIR_LS: str
-    """The directory listing of current working directory."""
-    KIMI_AGENTS_MD: str  # TODO: move to first message from system prompt
-    """The content of AGENTS.md."""
-
-
-def load_agents_md(work_dir: Path) -> str | None:
-    paths = [
-        work_dir / "AGENTS.md",
-        work_dir / "agents.md",
-    ]
-    for path in paths:
-        if path.is_file():
-            logger.info("Loaded agents.md: {path}", path=path)
-            return path.read_text(encoding="utf-8").strip()
-    logger.info("No AGENTS.md found in {work_dir}", work_dir=work_dir)
-    return None
-
-
-def _list_work_dir(work_dir: Path) -> str:
-    if sys.platform == "win32":
-        ls = subprocess.run(
-            ["cmd", "/c", "dir", work_dir],
-            capture_output=True,
-            text=True,
-            encoding="utf-8",
-            errors="replace",
-        )
-    else:
-        ls = subprocess.run(
-            ["ls", "-la", work_dir],
-            capture_output=True,
-            text=True,
-            encoding="utf-8",
-            errors="replace",
-        )
-    return ls.stdout.strip()
-
-
-class Runtime(NamedTuple):
-    """Agent runtime."""
-
-    config: Config
-    llm: LLM | None
-    session: Session
-    builtin_args: BuiltinSystemPromptArgs
-    denwa_renji: DenwaRenji
-    approval: Approval
-
-    @staticmethod
-    async def create(
-        config: Config,
-        llm: LLM | None,
-        session: Session,
-        yolo: bool,
-    ) -> "Runtime":
-        ls_output, agents_md = await asyncio.gather(
-            asyncio.to_thread(_list_work_dir, session.work_dir),
-            asyncio.to_thread(load_agents_md, session.work_dir),
-        )
-
-        return Runtime(
-            config=config,
-            llm=llm,
-            session=session,
-            builtin_args=BuiltinSystemPromptArgs(
-                KIMI_NOW=datetime.now().astimezone().isoformat(),
-                KIMI_WORK_DIR=session.work_dir,
-                KIMI_WORK_DIR_LS=ls_output,
-                KIMI_AGENTS_MD=agents_md or "",
-            ),
-            denwa_renji=DenwaRenji(),
-            approval=Approval(yolo=yolo),
-        )

kimi_cli/tools/bash/__init__.py

@@ -1,99 +0,0 @@
-import asyncio
-from pathlib import Path
-from typing import override
-
-from kosong.tooling import CallableTool2, ToolReturnType
-from pydantic import BaseModel, Field
-
-from kimi_cli.soul.approval import Approval
-from kimi_cli.tools.utils import ToolRejectedError, ToolResultBuilder, load_desc
-
-MAX_TIMEOUT = 5 * 60
-
-
-class Params(BaseModel):
-    command: str = Field(description="The bash command to execute.")
-    timeout: int = Field(
-        description=(
-            "The timeout in seconds for the command to execute. "
-            "If the command takes longer than this, it will be killed."
-        ),
-        default=60,
-        ge=1,
-        le=MAX_TIMEOUT,
-    )
-
-
-class Bash(CallableTool2[Params]):
-    name: str = "Bash"
-    description: str = load_desc(Path(__file__).parent / "bash.md", {})
-    params: type[Params] = Params
-
-    def __init__(self, approval: Approval, **kwargs):
-        super().__init__(**kwargs)
-        self._approval = approval
-
-    @override
-    async def __call__(self, params: Params) -> ToolReturnType:
-        builder = ToolResultBuilder()
-
-        if not await self._approval.request(
-            self.name,
-            "run shell command",
-            f"Run command `{params.command}`",
-        ):
-            return ToolRejectedError()
-
-        def stdout_cb(line: bytes):
-            line_str = line.decode(errors="replace")
-            builder.write(line_str)
-
-        def stderr_cb(line: bytes):
-            line_str = line.decode(errors="replace")
-            builder.write(line_str)
-
-        try:
-            exitcode = await _stream_subprocess(
-                params.command, stdout_cb, stderr_cb, params.timeout
-            )
-
-            if exitcode == 0:
-                return builder.ok("Command executed successfully.")
-            else:
-                return builder.error(
-                    f"Command failed with exit code: {exitcode}.",
-                    brief=f"Failed with exit code: {exitcode}",
-                )
-        except TimeoutError:
-            return builder.error(
-                f"Command killed by timeout ({params.timeout}s)",
-                brief=f"Killed by timeout ({params.timeout}s)",
-            )
-
-
-async def _stream_subprocess(command: str, stdout_cb, stderr_cb, timeout: int) -> int:
-    async def _read_stream(stream, cb):
-        while True:
-            line = await stream.readline()
-            if line:
-                cb(line)
-            else:
-                break
-
-    # FIXME: if the event loop is cancelled, an exception may be raised when the process finishes
-    process = await asyncio.create_subprocess_shell(
-        command, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
-    )
-
-    try:
-        await asyncio.wait_for(
-            asyncio.gather(
-                _read_stream(process.stdout, stdout_cb),
-                _read_stream(process.stderr, stderr_cb),
-            ),
-            timeout,
-        )
-        return await process.wait()
-    except TimeoutError:
-        process.kill()
-        raise

kimi_cli/tools/file/patch.md

@@ -1,8 +0,0 @@
-Apply a unified diff patch to a file.
-
-**Tips:**
-- The patch must be in unified diff format, the format used by `diff -u` and `git diff`.
-- Only use this tool on text files.
-- The tool will fail with error returned if the patch doesn't apply cleanly.
-- The file must exist before applying the patch.
-- You should prefer this tool over WriteFile tool and Bash `sed` command when editing an existing file.

kimi_cli/tools/file/patch.py

@@ -1,143 +0,0 @@
-from pathlib import Path
-from typing import override
-
-import aiofiles
-import patch_ng
-from kosong.tooling import CallableTool2, ToolError, ToolOk, ToolReturnType
-from pydantic import BaseModel, Field
-
-from kimi_cli.soul.approval import Approval
-from kimi_cli.soul.runtime import BuiltinSystemPromptArgs
-from kimi_cli.tools.file import FileActions
-from kimi_cli.tools.utils import ToolRejectedError
-
-
-class Params(BaseModel):
-    path: str = Field(description="The absolute path to the file to apply the patch to.")
-    diff: str = Field(description="The diff content in unified format to apply.")
-
-
-class PatchFile(CallableTool2[Params]):
-    name: str = "PatchFile"
-    description: str = (Path(__file__).parent / "patch.md").read_text(encoding="utf-8")
-    params: type[Params] = Params
-
-    def __init__(self, builtin_args: BuiltinSystemPromptArgs, approval: Approval, **kwargs):
-        super().__init__(**kwargs)
-        self._work_dir = builtin_args.KIMI_WORK_DIR
-        self._approval = approval
-
-    def _validate_path(self, path: Path) -> ToolError | None:
-        """Validate that the path is safe to patch."""
-        # Check for path traversal attempts
-        resolved_path = path.resolve()
-        resolved_work_dir = Path(self._work_dir).resolve()
-
-        # Ensure the path is within work directory
-        if not str(resolved_path).startswith(str(resolved_work_dir)):
-            return ToolError(
-                message=(
-                    f"`{path}` is outside the working directory. "
-                    "You can only patch files within the working directory."
-                ),
-                brief="Path outside working directory",
-            )
-        return None
-
-    @override
-    async def __call__(self, params: Params) -> ToolReturnType:
-        try:
-            p = Path(params.path)
-
-            if not p.is_absolute():
-                return ToolError(
-                    message=(
-                        f"`{params.path}` is not an absolute path. "
-                        "You must provide an absolute path to patch a file."
-                    ),
-                    brief="Invalid path",
-                )
-
-            # Validate path safety
-            path_error = self._validate_path(p)
-            if path_error:
-                return path_error
-
-            if not p.exists():
-                return ToolError(
-                    message=f"`{params.path}` does not exist.",
-                    brief="File not found",
-                )
-            if not p.is_file():
-                return ToolError(
-                    message=f"`{params.path}` is not a file.",
-                    brief="Invalid path",
-                )
-
-            # Request approval
-            if not await self._approval.request(
-                self.name,
-                FileActions.EDIT,
-                f"Patch file `{params.path}`",
-            ):
-                return ToolRejectedError()
-
-            # Read the file content
-            async with aiofiles.open(p, encoding="utf-8", errors="replace") as f:
-                original_content = await f.read()
-
-            # Create patch object directly from string (no temporary file needed!)
-            patch_set = patch_ng.fromstring(params.diff.encode("utf-8"))
-
-            # Handle case where patch_ng.fromstring returns False on parse errors
-            if not patch_set or patch_set is True:
-                return ToolError(
-                    message=(
-                        "Failed to parse diff content: invalid patch format or no valid hunks found"
-                    ),
-                    brief="Invalid diff format",
-                )
-
-            # Count total hunks across all items
-            total_hunks = sum(len(item.hunks) for item in patch_set.items)
-
-            if total_hunks == 0:
-                return ToolError(
-                    message="No valid hunks found in the diff content",
-                    brief="No hunks found",
-                )
-
-            # Apply the patch
-            success = patch_set.apply(root=str(p.parent))
-
-            if not success:
-                return ToolError(
-                    message=(
-                        "Failed to apply patch - patch may not be compatible with the file content"
-                    ),
-                    brief="Patch application failed",
-                )
-
-            # Read the modified content to check if changes were made
-            async with aiofiles.open(p, encoding="utf-8", errors="replace") as f:
-                modified_content = await f.read()
-
-            # Check if any changes were made
-            if modified_content == original_content:
-                return ToolError(
-                    message="No changes were made. The patch does not apply to the file.",
-                    brief="No changes made",
-                )
-
-            return ToolOk(
-                output="",
-                message=(
-                    f"File successfully patched. Applied {total_hunks} hunk(s) to {params.path}."
-                ),
-            )
-
-        except Exception as e:
-            return ToolError(
-                message=f"Failed to patch file. Error: {e}",
-                brief="Failed to patch file",
-            )

kimi_cli/tools/mcp.py

@@ -1,85 +0,0 @@
-import fastmcp
-import mcp
-from fastmcp.client.client import CallToolResult
-from kosong.base.message import AudioURLPart, ContentPart, ImageURLPart, TextPart
-from kosong.tooling import CallableTool, ToolOk, ToolReturnType
-
-
-class MCPTool(CallableTool):
-    def __init__(self, mcp_tool: mcp.Tool, client: fastmcp.Client, **kwargs):
-        super().__init__(
-            name=mcp_tool.name,
-            description=mcp_tool.description or "",
-            parameters=mcp_tool.inputSchema,
-            **kwargs,
-        )
-        self._mcp_tool = mcp_tool
-        self._client = client
-
-    async def __call__(self, *args, **kwargs) -> ToolReturnType:
-        async with self._client as client:
-            result = await client.call_tool(self._mcp_tool.name, kwargs, timeout=20)
-            return convert_tool_result(result)
-
-
-def convert_tool_result(result: CallToolResult) -> ToolReturnType:
-    content: list[ContentPart] = []
-    for part in result.content:
-        match part:
-            case mcp.types.TextContent(text=text):
-                content.append(TextPart(text=text))
-            case mcp.types.ImageContent(data=data, mimeType=mimeType):
-                content.append(
-                    ImageURLPart(
-                        image_url=ImageURLPart.ImageURL(url=f"data:{mimeType};base64,{data}")
-                    )
-                )
-            case mcp.types.AudioContent(data=data, mimeType=mimeType):
-                content.append(
-                    AudioURLPart(
-                        audio_url=AudioURLPart.AudioURL(url=f"data:{mimeType};base64,{data}")
-                    )
-                )
-            case mcp.types.EmbeddedResource(
-                resource=mcp.types.BlobResourceContents(uri=_uri, mimeType=mimeType, blob=blob)
-            ):
-                mimeType = mimeType or "application/octet-stream"
-                if mimeType.startswith("image/"):
-                    content.append(
-                        ImageURLPart(
-                            type="image_url",
-                            image_url=ImageURLPart.ImageURL(
-                                url=f"data:{mimeType};base64,{blob}",
-                            ),
-                        )
-                    )
-                elif mimeType.startswith("audio/"):
-                    content.append(
-                        AudioURLPart(
-                            type="audio_url",
-                            audio_url=AudioURLPart.AudioURL(url=f"data:{mimeType};base64,{blob}"),
-                        )
-                    )
-                else:
-                    raise ValueError(f"Unsupported mime type: {mimeType}")
-            case mcp.types.ResourceLink(uri=uri, mimeType=mimeType, description=_description):
-                mimeType = mimeType or "application/octet-stream"
-                if mimeType.startswith("image/"):
-                    content.append(
-                        ImageURLPart(
-                            type="image_url",
-                            image_url=ImageURLPart.ImageURL(url=str(uri)),
-                        )
-                    )
-                elif mimeType.startswith("audio/"):
-                    content.append(
-                        AudioURLPart(
-                            type="audio_url",
-                            audio_url=AudioURLPart.AudioURL(url=str(uri)),
-                        )
-                    )
-                else:
-                    raise ValueError(f"Unsupported mime type: {mimeType}")
-            case _:
-                raise ValueError(f"Unsupported MCP tool result part: {part}")
-    return ToolOk(output=content)