✨Moved the gitignore-aware ** traversal into the kaos package and switched the glob tool to call it, so the matching logic lives in packages/kaos rather than being inlined in Kimi CLI. This removes the local matching implementation while keeping the same behavior. Updated packages/kaos/src/kaos/__init__.py and src/kimi_cli/tools/file/glob.py.

Author: Eric-Guo

packages/kaos/src/kaos/__init__.py

@@ -1,9 +1,10 @@
 from __future__ import annotations
 
 import contextvars
-from collections.abc import AsyncGenerator, AsyncIterator, Iterable
+import fnmatch
+from collections.abc import AsyncGenerator, AsyncIterator, Callable, Iterable
 from dataclasses import dataclass
-from pathlib import PurePath
+from pathlib import PurePath, PurePosixPath
 from typing import TYPE_CHECKING, Literal, Protocol, runtime_checkable
 
 if TYPE_CHECKING:
@@ -294,6 +295,70 @@ def glob(
     return get_current_kaos().glob(path, pattern, case_sensitive=case_sensitive)
 
 
+async def glob_pruned(
+    base_dir: KaosPath,
+    pattern: str,
+    *,
+    should_ignore: Callable[[KaosPath, bool], bool] | None = None,
+) -> list[KaosPath]:
+    """Glob with a pruning callback to skip entries during traversal."""
+    normalized_pattern = pattern.replace("\\", "/")
+    parts = list(PurePosixPath(normalized_pattern).parts)
+    if parts and parts[0] == "/":
+        parts = parts[1:]
+
+    matches: list[KaosPath] = []
+
+    def _should_ignore(path: KaosPath, is_dir: bool) -> bool:
+        if should_ignore is None:
+            return False
+        return should_ignore(path, is_dir)
+
+    async def recurse(current: KaosPath, idx: int) -> None:
+        if idx == len(parts):
+            matches.append(current)
+            return
+
+        part = parts[idx]
+        if part == "**":
+            await recurse(current, idx + 1)
+
+            if not await current.is_dir():
+                return
+
+            async for child in current.iterdir():
+                try:
+                    is_dir = await child.is_dir()
+                except OSError:
+                    continue
+
+                if _should_ignore(child, is_dir):
+                    continue
+
+                if is_dir:
+                    await recurse(child, idx)
+                elif idx == len(parts) - 1:
+                    matches.append(child)
+            return
+
+        if not await current.is_dir():
+            return
+
+        async for child in current.iterdir():
+            try:
+                is_dir = await child.is_dir()
+            except OSError:
+                continue
+
+            if _should_ignore(child, is_dir):
+                continue
+
+            if fnmatch.fnmatchcase(child.name, part):
+                await recurse(child, idx + 1)
+
+    await recurse(base_dir, 0)
+    return matches
+
 async def readbytes(path: StrOrKaosPath, n: int | None = None) -> bytes:
     return await get_current_kaos().readbytes(path, n=n)
 

src/kimi_cli/tools/file/glob.py

@@ -1,14 +1,15 @@
 """Glob tool implementation."""
 
-import fnmatch
-from pathlib import Path, PurePosixPath
+from pathlib import Path
 from typing import override
 
+from kaos import glob_pruned
 from kaos.path import KaosPath
 from kosong.tooling import CallableTool2, ToolError, ToolOk, ToolReturnValue
 from pathspec import PathSpec
 from pydantic import BaseModel, Field
 
+from kaos import glob_pruned
 from kimi_cli.soul.agent import BuiltinSystemPromptArgs
 from kimi_cli.tools.utils import load_desc
 from kimi_cli.utils.path import is_within_directory, list_directory
@@ -67,62 +68,6 @@ def _is_gitignored(self, path: KaosPath, gitignore_spec: PathSpec, is_dir: bool)
             relative_str += "/"
         return gitignore_spec.match_file(relative_str)
 
-    async def _gitignore_aware_glob(
-        self, base_dir: KaosPath, pattern: str, gitignore_spec: PathSpec
-    ) -> list[KaosPath]:
-        """Glob that prunes gitignored directories instead of filtering after traversal."""
-        normalized_pattern = pattern.replace("\\", "/")
-        parts = list(PurePosixPath(normalized_pattern).parts)
-        if parts and parts[0] == "/":
-            parts = parts[1:]
-
-        matches: list[KaosPath] = []
-
-        async def recurse(current: KaosPath, idx: int) -> None:
-            if idx == len(parts):
-                matches.append(current)
-                return
-
-            part = parts[idx]
-            if part == "**":
-                await recurse(current, idx + 1)
-
-                if not await current.is_dir():
-                    return
-
-                async for child in current.iterdir():
-                    try:
-                        is_dir = await child.is_dir()
-                    except OSError:
-                        continue
-
-                    if self._is_gitignored(child, gitignore_spec, is_dir):
-                        continue
-
-                    if is_dir:
-                        await recurse(child, idx)
-                    elif idx == len(parts) - 1:
-                        matches.append(child)
-                return
-
-            if not await current.is_dir():
-                return
-
-            async for child in current.iterdir():
-                try:
-                    is_dir = await child.is_dir()
-                except OSError:
-                    continue
-
-                if self._is_gitignored(child, gitignore_spec, is_dir):
-                    continue
-
-                if fnmatch.fnmatchcase(child.name, part):
-                    await recurse(child, idx + 1)
-
-        await recurse(base_dir, 0)
-        return matches
-
     async def _filter_gitignored(
         self, paths: list[KaosPath], gitignore_spec: PathSpec
     ) -> list[KaosPath]:
@@ -217,8 +162,12 @@ async def __call__(self, params: Params) -> ToolReturnValue:
             # Perform the glob search - users can use ** directly in pattern
             normalized_pattern = params.pattern.replace("\\", "/")
             if gitignore_spec and normalized_pattern.startswith("**"):
-                matches = await self._gitignore_aware_glob(
-                    dir_path, normalized_pattern, gitignore_spec
+                matches = await glob_pruned(
+                    dir_path,
+                    normalized_pattern,
+                    should_ignore=lambda path, is_dir: self._is_gitignored(
+                        path, gitignore_spec, is_dir
+                    ),
                 )
             else:
                 matches = [match async for match in dir_path.glob(params.pattern)]