kimi-cli 0.35__py3-none-any.whl

kimi_cli/tools/file/grep.py

@@ -0,0 +1,285 @@
+import asyncio
+import os
+import platform
+import shutil
+import stat
+import tarfile
+import tempfile
+from pathlib import Path
+from typing import override
+
+import aiohttp
+import ripgrepy
+from kosong.tooling import CallableTool2, ToolError, ToolOk, ToolReturnType
+from pydantic import BaseModel, Field
+
+import kimi_cli
+from kimi_cli.share import get_share_dir
+from kimi_cli.utils.logging import logger
+
+
+class Params(BaseModel):
+    pattern: str = Field(
+        description="The regular expression pattern to search for in file contents"
+    )
+    path: str = Field(
+        description=(
+            "File or directory to search in. Defaults to current working directory. "
+            "If specified, it must be an absolute path."
+        ),
+        default=".",
+    )
+    glob: str | None = Field(
+        description=(
+            "Glob pattern to filter files (e.g. `*.js`, `*.{ts,tsx}`). No filter by default."
+        ),
+        default=None,
+    )
+    output_mode: str = Field(
+        description=(
+            "`content`: Show matching lines (supports `-B`, `-A`, `-C`, `-n`, `head_limit`); "
+            "`files_with_matches`: Show file paths (supports `head_limit`); "
+            "`count_matches`: Show total number of matches. "
+            "Defaults to `files_with_matches`."
+        ),
+        default="files_with_matches",
+    )
+    before_context: int | None = Field(
+        alias="-B",
+        description=(
+            "Number of lines to show before each match (the `-B` option). "
+            "Requires `output_mode` to be `content`."
+        ),
+        default=None,
+    )
+    after_context: int | None = Field(
+        alias="-A",
+        description=(
+            "Number of lines to show after each match (the `-A` option). "
+            "Requires `output_mode` to be `content`."
+        ),
+        default=None,
+    )
+    context: int | None = Field(
+        alias="-C",
+        description=(
+            "Number of lines to show before and after each match (the `-C` option). "
+            "Requires `output_mode` to be `content`."
+        ),
+        default=None,
+    )
+    line_number: bool = Field(
+        alias="-n",
+        description=(
+            "Show line numbers in output (the `-n` option). Requires `output_mode` to be `content`."
+        ),
+        default=False,
+    )
+    ignore_case: bool = Field(
+        alias="-i",
+        description="Case insensitive search (the `-i` option).",
+        default=False,
+    )
+    type: str | None = Field(
+        description=(
+            "File type to search. Examples: py, rust, js, ts, go, java, etc. "
+            "More efficient than `glob` for standard file types."
+        ),
+        default=None,
+    )
+    head_limit: int | None = Field(
+        description=(
+            "Limit output to first N lines, equivalent to `| head -N`. "
+            "Works across all output modes: content (limits output lines), "
+            "files_with_matches (limits file paths), count_matches (limits count entries). "
+            "By default, no limit is applied."
+        ),
+        default=None,
+    )
+    multiline: bool = Field(
+        description=(
+            "Enable multiline mode where `.` matches newlines and patterns can span "
+            "lines (the `-U` and `--multiline-dotall` options). "
+            "By default, multiline mode is disabled."
+        ),
+        default=False,
+    )
+
+
+RG_VERSION = "15.0.0"
+RG_BASE_URL = "http://cdn.kimi.com/binaries/kimi-cli/rg"
+_RG_DOWNLOAD_LOCK = asyncio.Lock()
+
+
+def _rg_binary_name() -> str:
+    return "rg.exe" if os.name == "nt" else "rg"
+
+
+def _find_existing_rg(bin_name: str) -> Path | None:
+    share_bin = get_share_dir() / "bin" / bin_name
+    if share_bin.is_file():
+        return share_bin
+
+    local_dep = Path(kimi_cli.__file__).parent / "deps" / "bin" / bin_name
+    if local_dep.is_file():
+        return local_dep
+
+    system_rg = shutil.which("rg")
+    if system_rg:
+        return Path(system_rg)
+
+    return None
+
+
+def _detect_target() -> str | None:
+    sys_name = platform.system()
+    mach = platform.machine().lower()
+
+    if mach in ("x86_64", "amd64"):
+        arch = "x86_64"
+    elif mach in ("arm64", "aarch64"):
+        arch = "aarch64"
+    else:
+        logger.error("Unsupported architecture for ripgrep: {mach}", mach=mach)
+        return None
+
+    if sys_name == "Darwin":
+        os_name = "apple-darwin"
+    elif sys_name == "Linux":
+        os_name = "unknown-linux-musl" if arch == "x86_64" else "unknown-linux-gnu"
+    else:
+        logger.error("Unsupported operating system for ripgrep: {sys_name}", sys_name=sys_name)
+        return None
+
+    return f"{arch}-{os_name}"
+
+
+async def _download_and_install_rg(bin_name: str) -> Path:
+    target = _detect_target()
+    if not target:
+        raise RuntimeError("Unsupported platform for ripgrep download")
+
+    filename = f"ripgrep-{RG_VERSION}-{target}.tar.gz"
+    url = f"{RG_BASE_URL}/{filename}"
+    logger.info("Downloading ripgrep from {url}", url=url)
+
+    share_bin_dir = get_share_dir() / "bin"
+    share_bin_dir.mkdir(parents=True, exist_ok=True)
+    destination = share_bin_dir / bin_name
+
+    async with aiohttp.ClientSession() as session:
+        with tempfile.TemporaryDirectory(prefix="kimi-rg-") as tmpdir:
+            tar_path = Path(tmpdir) / filename
+
+            try:
+                async with session.get(url) as resp:
+                    resp.raise_for_status()
+                    with open(tar_path, "wb") as fh:
+                        async for chunk in resp.content.iter_chunked(1024 * 64):
+                            if chunk:
+                                fh.write(chunk)
+            except (aiohttp.ClientError, TimeoutError) as exc:
+                raise RuntimeError("Failed to download ripgrep binary") from exc
+
+            try:
+                with tarfile.open(tar_path, "r:gz") as tar:
+                    member = next(
+                        (m for m in tar.getmembers() if Path(m.name).name == bin_name),
+                        None,
+                    )
+                    if not member:
+                        raise RuntimeError("Ripgrep binary not found in archive")
+                    extracted = tar.extractfile(member)
+                    if not extracted:
+                        raise RuntimeError("Failed to extract ripgrep binary")
+                    with open(destination, "wb") as dest_fh:
+                        shutil.copyfileobj(extracted, dest_fh)
+            except (tarfile.TarError, OSError) as exc:
+                raise RuntimeError("Failed to extract ripgrep archive") from exc
+
+    destination.chmod(destination.stat().st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
+    logger.info("Installed ripgrep to {destination}", destination=destination)
+    return destination
+
+
+async def _ensure_rg_path() -> str:
+    bin_name = _rg_binary_name()
+    existing = _find_existing_rg(bin_name)
+    if existing:
+        return str(existing)
+
+    async with _RG_DOWNLOAD_LOCK:
+        existing = _find_existing_rg(bin_name)
+        if existing:
+            return str(existing)
+
+        downloaded = await _download_and_install_rg(bin_name)
+        return str(downloaded)
+
+
+class Grep(CallableTool2[Params]):
+    name: str = "Grep"
+    description: str = (Path(__file__).parent / "grep.md").read_text()
+    params: type[Params] = Params
+
+    @override
+    async def __call__(self, params: Params) -> ToolReturnType:
+        try:
+            # Initialize ripgrep with pattern and path
+            rg_path = await _ensure_rg_path()
+            logger.debug("Using ripgrep binary: {rg_bin}", rg_bin=rg_path)
+            rg = ripgrepy.Ripgrepy(params.pattern, params.path, rg_path=rg_path)
+
+            # Apply search options
+            if params.ignore_case:
+                rg = rg.ignore_case()
+            if params.multiline:
+                rg = rg.multiline().multiline_dotall()
+
+            # Content display options (only for content mode)
+            if params.output_mode == "content":
+                if params.before_context is not None:
+                    rg = rg.before_context(params.before_context)
+                if params.after_context is not None:
+                    rg = rg.after_context(params.after_context)
+                if params.context is not None:
+                    rg = rg.context(params.context)
+                if params.line_number:
+                    rg = rg.line_number()
+
+            # File filtering options
+            if params.glob:
+                rg = rg.glob(params.glob)
+            if params.type:
+                rg = rg.type_(params.type)
+
+            # Set output mode
+            if params.output_mode == "files_with_matches":
+                rg = rg.files_with_matches()
+            elif params.output_mode == "count_matches":
+                rg = rg.count_matches()
+
+            # Execute search
+            result = rg.run()
+
+            # Get results
+            output = result.as_string
+
+            # Apply head limit if specified
+            if params.head_limit is not None:
+                lines = output.split("\n")
+                if len(lines) > params.head_limit:
+                    lines = lines[: params.head_limit]
+                    output = "\n".join(lines)
+                    if params.output_mode in ["content", "files_with_matches", "count_matches"]:
+                        output += f"\n... (results truncated to {params.head_limit} lines)"
+
+            if not output:
+                return ToolOk(output="", message="No matches found")
+            return ToolOk(output=output)
+
+        except Exception as e:
+            return ToolError(
+                message=f"Failed to grep. Error: {str(e)}",
+                brief="Failed to grep",
+            )

kimi_cli/tools/file/patch.md

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,131 @@
+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.agent import BuiltinSystemPromptArgs
+
+
+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()
+    params: type[Params] = Params
+
+    def __init__(self, builtin_args: BuiltinSystemPromptArgs, **kwargs):
+        super().__init__(**kwargs)
+        self._work_dir = builtin_args.KIMI_WORK_DIR
+
+    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",
+                )
+
+            # 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/file/read.md

@@ -0,0 +1,14 @@
+Read content from a file.
+
+**Tips:**
+- Make sure you follow the description of each tool parameter.
+- A `<system>` tag will be given before the read file content.
+- Content will be returned with a line number before each line like `cat -n` format.
+- Use `line_offset` and `n_lines` parameters when you only need to read a part of the file.
+- The maximum number of lines that can be read at once is ${MAX_LINES}.
+- Any lines longer than ${MAX_LINE_LENGTH} characters will be truncated, ending with "...".
+- The system will notify you when there is any limitation hit when reading the file.
+- This tool is a tool that you typically want to use in parallel. Always read multiple files in one response when possible.
+- This tool can only read text files. To list directories, you must use the Glob tool or `ls` command via the Bash tool. To read other file types, use appropriate commands via the Bash tool.
+- If the file doesn't exist or path is invalid, an error will be returned.
+- If you want to search for a certain content/pattern, prefer Grep tool over ReadFile.

kimi_cli/tools/file/read.py

@@ -0,0 +1,139 @@
+from pathlib import Path
+from typing import override
+
+import aiofiles
+from kosong.tooling import CallableTool2, ToolError, ToolOk, ToolReturnType
+from pydantic import BaseModel, Field
+
+from kimi_cli.agent import BuiltinSystemPromptArgs
+from kimi_cli.tools.utils import load_desc, truncate_line
+
+MAX_LINES = 1000
+MAX_LINE_LENGTH = 2000
+MAX_BYTES = 100 << 10  # 100KB
+
+
+class Params(BaseModel):
+    path: str = Field(description="The absolute path to the file to read")
+    line_offset: int = Field(
+        description=(
+            "The line number to start reading from. "
+            "By default read from the beginning of the file. "
+            "Set this when the file is too large to read at once."
+        ),
+        default=1,
+        ge=1,
+    )
+    n_lines: int = Field(
+        description=(
+            "The number of lines to read. "
+            f"By default read up to {MAX_LINES} lines, which is the max allowed value. "
+            "Set this value when the file is too large to read at once."
+        ),
+        default=MAX_LINES,
+        ge=1,
+    )
+
+
+class ReadFile(CallableTool2[Params]):
+    name: str = "ReadFile"
+    description: str = load_desc(
+        Path(__file__).parent / "read.md",
+        {
+            "MAX_LINES": str(MAX_LINES),
+            "MAX_LINE_LENGTH": str(MAX_LINE_LENGTH),
+            "MAX_BYTES": str(MAX_BYTES),
+        },
+    )
+    params: type[Params] = Params
+
+    def __init__(self, builtin_args: BuiltinSystemPromptArgs, **kwargs):
+        super().__init__(**kwargs)
+        self._work_dir = builtin_args.KIMI_WORK_DIR
+
+    @override
+    async def __call__(self, params: Params) -> ToolReturnType:
+        # TODO: checks:
+        # - check if the path may contain secrets
+        # - check if the file format is readable
+        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 read a file."
+                    ),
+                    brief="Invalid path",
+                )
+
+            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",
+                )
+
+            assert params.line_offset >= 1
+            assert params.n_lines >= 1
+
+            lines: list[str] = []
+            n_bytes = 0
+            truncated_line_numbers = []
+            max_lines_reached = False
+            max_bytes_reached = False
+            async with aiofiles.open(p, encoding="utf-8", errors="replace") as f:
+                current_line_no = 0
+                async for line in f:
+                    current_line_no += 1
+                    if current_line_no < params.line_offset:
+                        continue
+                    truncated = truncate_line(line, MAX_LINE_LENGTH)
+                    if truncated != line:
+                        truncated_line_numbers.append(current_line_no)
+                    lines.append(truncated)
+                    n_bytes += len(truncated.encode("utf-8"))
+                    if len(lines) >= params.n_lines:
+                        break
+                    if len(lines) >= MAX_LINES:
+                        max_lines_reached = True
+                        break
+                    if n_bytes >= MAX_BYTES:
+                        max_bytes_reached = True
+                        break
+
+            # Format output with line numbers like `cat -n`
+            lines_with_no = []
+            for line_num, line in zip(
+                range(params.line_offset, params.line_offset + len(lines)), lines, strict=True
+            ):
+                # Use 6-digit line number width, right-aligned, with tab separator
+                lines_with_no.append(f"{line_num:6d}\t{line}")
+
+            message = (
+                f"{len(lines)} lines read from file starting from line {params.line_offset}."
+                if len(lines) > 0
+                else "No lines read from file."
+            )
+            if max_lines_reached:
+                message += f" Max {MAX_LINES} lines reached."
+            elif max_bytes_reached:
+                message += f" Max {MAX_BYTES} bytes reached."
+            elif len(lines) < params.n_lines:
+                message += " End of file reached."
+            if truncated_line_numbers:
+                message += f" Lines {truncated_line_numbers} were truncated."
+            return ToolOk(
+                output="".join(lines_with_no),  # lines already contain \n, just join them
+                message=message,
+            )
+        except Exception as e:
+            return ToolError(
+                message=f"Failed to read {params.path}. Error: {e}",
+                brief="Failed to read file",
+            )

kimi_cli/tools/file/replace.md

@@ -0,0 +1,7 @@
+Replace specific strings within a specified file.
+
+**Tips:**
+- Only use this tool on text files.
+- Multi-line strings are supported.
+- Can specify a single edit or a list of edits in one call.
+- You should prefer this tool over WriteFile tool and Bash `sed` command.