Optimize glob_mac to use find instead of python version.

Author: beacoder

python_agent_harness/tools/glob_mac.py

@@ -1,10 +1,15 @@
-"""macOS Glob tool: ``git ls-files`` inside git repos, ``pathlib`` outside.
+"""macOS Glob tool: ``git ls-files`` inside git repos, ``find`` outside.
 
 Apple ships neither GNU ``tree`` nor a compatible equivalent, so the
 non-git fallback in :class:`GlobTool` (which shells out to ``tree``)
 fails on a stock macOS install.  ``GlobMac`` replaces that fallback
-with :meth:`pathlib.Path.rglob`, which is pure-Python, requires no
-external binary, and produces identical results.
+with a hybrid approach: ``find`` (C binary, pre-installed on macOS)
+handles directory traversal and pattern matching, while Python handles
+mtime sorting — which ``find`` does not support.
+
+This is significantly faster than the previous pure-Python
+:meth:`pathlib.Path.rglob` approach on large directory trees, while
+producing identical results.
 
 Only the non-git fallback differs; the git path, the tool name, and
 the result format are inherited unchanged so callers, the tool
@@ -13,59 +18,72 @@
 
 from __future__ import annotations
 
-import fnmatch
 import os
-from pathlib import Path
+import subprocess
 
 from .base import ToolContext
 from .filesystem import _natnump, _spool
 from .glob import GlobTool
 
 
 class GlobMac(GlobTool):
-    """Glob with a pure-Python non-git fallback for macOS."""
+    """Glob with a hybrid ``find`` + Python-sort non-git fallback for macOS."""
 
     def _tree_fallback(self, pattern: str, base: str, depth: object) -> str:
-        """Walk *base* with :func:`pathlib.Path.rglob` instead of ``tree``.
+        """Use ``find`` for traversal + matching, Python for mtime sort.
 
-        Results are absolute paths sorted by modification time (newest
-        first), matching the ``tree --sort=mtime`` order of the Linux
-        fallback.  Hidden directories (``.git``, etc.) are skipped.
+        ``find`` (C binary) walks the directory tree and applies pattern
+        matching natively, which is significantly faster than
+        :meth:`pathlib.Path.rglob` on large trees.  Results are then
+        sorted by modification time (newest first) in Python, matching
+        the ``tree --sort=mtime`` order of the Linux fallback.  Hidden
+        directories (``.git``, etc.) are skipped via ``-path */.* -prune``.
+        Symlinks are followed (``-L``), matching ``tree -l`` and the old
+        :meth:`pathlib.Path.rglob` behavior.
         """
-        root = Path(base)
-        matches: list[tuple[float, str]] = []
+        cmd = [
+            "find",
+            "-L",
+            base,
+            "-path",
+            "*/.*",
+            "-prune",
+            "-o",
+            "-type",
+            "f",
+            "-iname",
+            pattern,
+            "-print",
+        ]
         if _natnump(depth):
-            # Depth-limited: walk manually so we can count levels.
-            for dirpath, dirnames, filenames in os.walk(base):
-                # Skip hidden directories (mirrors tree's -I .git and
-                # the general expectation that dotfiles are excluded).
-                dirnames[:] = [d for d in dirnames if not d.startswith(".")]
-                rel = os.path.relpath(dirpath, base)
-                level = 0 if rel == "." else rel.count(os.sep) + 1
-                if level >= depth:
-                    dirnames.clear()
-                    continue
-                for name in filenames:
-                    if fnmatch.fnmatch(name.lower(), pattern.lower()):
-                        full = os.path.join(dirpath, name)
-                        try:
-                            mtime = os.path.getmtime(full)
-                        except OSError:
-                            mtime = 0.0
-                        matches.append((mtime, full))
-        else:
-            # Unlimited depth: rglob is simpler.
-            for p in root.rglob("*"):
-                if any(part.startswith(".") for part in p.relative_to(root).parts):
-                    continue
-                if p.is_file() and fnmatch.fnmatch(p.name.lower(), pattern.lower()):
-                    try:
-                        mtime = p.stat().st_mtime
-                    except OSError:
-                        mtime = 0.0
-                    matches.append((mtime, str(p)))
-
-        # Sort newest-first (like tree --sort=mtime).
+            cmd[3:3] = ["-maxdepth", str(depth)]
+        try:
+            proc = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                encoding="utf-8",
+                errors="replace",
+                timeout=60,
+            )
+        except (OSError, subprocess.TimeoutExpired) as e:
+            return f"Error: {e}"
+        lines = [line for line in proc.stdout.splitlines() if line]
+        if not lines:
+            if proc.returncode != 0:
+                out = f"Glob failed with exit code {proc.returncode}\n"
+                out += proc.stderr or ""
+                return _spool(out, "glob")
+            return ""
+
+        matches: list[tuple[float, str]] = []
+        for path in lines:
+            try:
+                mtime = os.path.getmtime(path)
+            except OSError:
+                mtime = 0.0
+            matches.append((mtime, path))
+
         matches.sort(key=lambda t: t[0], reverse=True)
         out = "\n".join(path for _, path in matches)
         if not out:
@@ -93,5 +111,5 @@ def run(self, args: dict, ctx: ToolContext) -> str:
             # The git path is identical to the parent — delegate.
             return super().run(args, ctx)
 
-        # Non-git: pure-Python fallback instead of `tree`.
+        # Non-git: hybrid find + Python sort fallback instead of `tree`.
         return self._tree_fallback(pattern, base, depth)