python-agent-harness 1.5.4.7__tar.gz → 1.5.4.8__tar.gz

{python_agent_harness-1.5.4.7/python_agent_harness.egg-info → python_agent_harness-1.5.4.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-agent-harness
-Version: 1.5.4.7
+Version: 1.5.4.8
 Summary: A lightweight, hackable mini-OpenCode written in Python.
 Author: huming
 License-Expression: MIT

{python_agent_harness-1.5.4.7 → python_agent_harness-1.5.4.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-agent-harness"
-version = "1.5.4.7"
+version = "1.5.4.8"
 description = "A lightweight, hackable mini-OpenCode written in Python."
 readme = "README.md"
 requires-python = ">=3.11"

{python_agent_harness-1.5.4.7 → python_agent_harness-1.5.4.8}/python_agent_harness/__init__.py

@@ -5,7 +5,7 @@ from .mcp.manager import MCPManager
 from .models import AgentMode, Message, ToolCall, ToolSpec
 from .session import Session
 
-__version__ = "1.5.4.7"
+__version__ = "1.5.4.8"
 
 __all__ = [
     "Session",

{python_agent_harness-1.5.4.7 → python_agent_harness-1.5.4.8}/python_agent_harness/client.py

@@ -277,12 +277,16 @@ class Client:
 
         A blocked ``iter_lines()`` read must be interrupted so the agent
         loop can stop promptly.  Closing the pool alone is NOT enough:
-        on Linux, ``close()`` from another thread cannot wake a ``recv``
-        that is already blocked in the kernel.  So we first
-        ``shutdown(SHUT_RDWR)`` every in-flight connection socket (which
-        does wake the blocked read, turning it into a connection error
-        the loop treats as a cancel) and then close the pool.  A fresh
-        client is swapped in for the next request.
+        ``httpx.Client.close()`` from another thread cannot force-close a
+        socket whose fd is parked in a kernel ``recv``.  So we first
+        reach into every in-flight connection socket and both
+        ``shutdown(SHUT_RDWR)`` it (wakes the blocked read on Linux) and
+        ``close()`` the raw fd (the reliable wake on macOS/BSD, where
+        ``shutdown`` alone may not rouse a parked ``recv``); the woken
+        read surfaces as a connection error the loop treats as a cancel.
+        We then close the pool and swap in a fresh client for the next
+        request.  See ``_abort_inflight_sockets`` for the platform
+        details.
         """
         self._aborted = True
         old = self._http
@@ -819,15 +823,31 @@ def _default_api_key() -> str | None:
 
 
 def _abort_inflight_sockets(client: httpx.Client) -> None:
-    """Wake any blocked stream reads by shutting down live pool sockets.
+    """Wake any blocked stream reads on every live pool socket.
 
     Reaches through httpx/httpcore internals (transport -> pool ->
-    connection -> network stream -> raw socket) and calls
-    ``shutdown(SHUT_RDWR)`` on each live connection.  On Linux this is
-    the only reliable way to interrupt a ``recv`` already blocked in the
-    kernel from another thread — ``close()`` cannot do it.  Shutting
-    down an idle socket is harmless (the pool is closed right after
-    anyway); any failure is ignored (best effort).
+    connection -> network stream -> raw socket) and, for each live
+    connection, both ``shutdown(SHUT_RDWR)`` AND ``close()`` the raw
+    socket.
+
+    Both steps are needed for cross-platform reliability when another
+    thread is already blocked in ``recv``:
+
+    - On Linux, ``shutdown(SHUT_RDWR)`` reliably wakes the blocked
+      ``recv`` (turning it into a clean EOF / connection error), while
+      httpx's own ``close()`` cannot — it can't force-close a socket
+      whose fd is parked in a kernel read.
+    - On macOS/BSD (notably CI's macos-latest on py3.11), ``shutdown``
+      from another thread is NOT guaranteed to wake a ``recv`` already
+      parked in the kernel; the read stays blocked until the fd itself
+      is closed.  ``socket.close()`` closes the fd directly and does
+      wake it, so we always follow the shutdown with an explicit
+      close.
+
+    Closing the fd out from under httpcore is safe here: ``abort()``
+    swaps in a fresh pool immediately and closes the old one under
+    ``contextlib.suppress`` right after this call, so a double-close is
+    harmless.  Every step is best-effort; any failure is ignored.
     """
     pool = getattr(getattr(client, "_transport", None), "_pool", None)
     for conn in getattr(pool, "_connections", None) or ():
@@ -837,8 +857,13 @@ def _abort_inflight_sockets(client: httpx.Client) -> None:
         except Exception:  # noqa: BLE001 - best effort
             sock = None
         if sock is not None:
+            # shutdown first (wakes the recv on Linux without touching
+            # the fd), then close the fd (the reliable wake on
+            # macOS/BSD, where shutdown alone may not).
             with contextlib.suppress(OSError):
                 sock.shutdown(_socket.SHUT_RDWR)
+            with contextlib.suppress(OSError):
+                sock.close()
 
 
 def _iter_sse(lines: Iterator[str]) -> Iterator[str]:

{python_agent_harness-1.5.4.7 → python_agent_harness-1.5.4.8}/python_agent_harness/planmode.py

@@ -112,4 +112,6 @@ class PlanMode:
         return self.mode == AgentMode.PLAN
 
     def plan_reminder(self) -> str:
-        return config.PLAN_MODE_SUBAGENT_REMINDER % (self.plan_file or self.plan_file_path())
+        return config.PLAN_MODE_SUBAGENT_REMINDER.replace(
+            "%s", self.plan_file or self.plan_file_path()
+        )

{python_agent_harness-1.5.4.7 → python_agent_harness-1.5.4.8}/python_agent_harness/session.py

@@ -444,7 +444,7 @@ class Session:
         )
         if approved:
             self.switch_to_build()
-            msg = config.PLAN_EXIT_APPROVED_MESSAGE % (self.plan_mode.plan_file or "")
+            msg = config.PLAN_EXIT_APPROVED_MESSAGE.replace("%s", self.plan_mode.plan_file or "")
             self.pending_user_prompts.append(msg)
             return (
                 "User approved switching to build agent.  You are now in "

{python_agent_harness-1.5.4.7 → python_agent_harness-1.5.4.8}/python_agent_harness/tools/edit.py

@@ -90,7 +90,7 @@ class Edit(Tool):
         if old is None:
             return "Error: old_str is required for non-diff edits"
         try:
-            with open(path, encoding="utf-8") as f:
+            with open(path, encoding="utf-8", errors="replace") as f:
                 content = f.read()
         except OSError as e:
             return f"Error: cannot read {path}: {e}"

{python_agent_harness-1.5.4.7 → python_agent_harness-1.5.4.8}/python_agent_harness/tools/glob.py

@@ -107,7 +107,7 @@ class GlobTool(Tool):
                 return f"Error: {e}"
             if proc.returncode != 0:
                 # Failure banner is prepended to whatever git emitted.
-                banner = f"Glob failed with exit code {proc.returncode}\n.STDOUT:\n\n"
+                banner = f"Glob failed with exit code {proc.returncode}\nSTDOUT:\n\n"
                 return _spool(banner + (proc.stdout or "") + (proc.stderr or ""), "glob")
             return _git_glob_results(proc.stdout, git_root, base, depth)
 
@@ -141,7 +141,7 @@ class GlobTool(Tool):
             return f"Error: {e}"
         out = proc.stdout
         if proc.returncode != 0:
-            out = f"Glob failed with exit code {proc.returncode}\n.STDOUT:\n\n" + out
+            out = f"Glob failed with exit code {proc.returncode}\nSTDOUT:\n\n" + out
         return _spool(out, "glob")
 
 

python_agent_harness-1.5.4.8/python_agent_harness/tools/glob_mac.py

@@ -0,0 +1,115 @@
+"""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 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
+registry, and the plan-mode write guard are platform-independent.
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+
+from .base import ToolContext
+from .filesystem import _natnump, _spool
+from .glob import GlobTool
+
+
+class GlobMac(GlobTool):
+    """Glob with a hybrid ``find`` + Python-sort non-git fallback for macOS."""
+
+    def _find_fallback(self, pattern: str, base: str, depth: object) -> str:
+        """Use ``find`` for traversal + matching, Python for mtime sort.
+
+        ``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.
+        """
+        cmd = [
+            "find",
+            "-L",
+            base,
+            "-path",
+            "*/.*",
+            "-prune",
+            "-o",
+            "-type",
+            "f",
+            "-iname",
+            pattern,
+            "-print",
+        ]
+        if _natnump(depth):
+            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:
+            return ""
+        return _spool(out + "\n", "glob")
+
+    def run(self, args: dict, ctx: ToolContext) -> str:
+        pattern = args.get("pattern") or ""
+        if not pattern:
+            return "Error: pattern must not be empty"
+        path = args.get("path")
+        if path:
+            if not (os.path.isdir(path) and os.access(path, os.R_OK)):
+                return f"Error: path {path} is not readable"
+        else:
+            path = ctx.cwd
+        base = os.path.realpath(path)
+        depth = args.get("depth")
+
+        from .filesystem import _git_root
+
+        git_root = _git_root(base)
+
+        if git_root:
+            # The git path is identical to the parent — delegate.
+            return super().run(args, ctx)
+
+        # Non-git: hybrid find + Python sort fallback instead of `tree`.
+        return self._find_fallback(pattern, base, depth)

{python_agent_harness-1.5.4.7 → python_agent_harness-1.5.4.8}/python_agent_harness/tools/grep.py

@@ -49,7 +49,7 @@ class Grep(Tool):
         if context is not None:
             context = max(0, min(15, int(context)))
 
-        git_root = _git_root(path) if os.path.isdir(path) else None
+        git_root = _git_root(path)
         if git_root:
             rel = os.path.relpath(path, git_root)
             pathspec = rel
@@ -84,6 +84,18 @@ class Grep(Tool):
                 proc = None
             if proc is not None and proc.returncode in (0, 1):
                 return _grep_out(proc, "git")
+        return self._fallback_rg_grep(regex, path, glob, context)
+
+    def _fallback_rg_grep(
+        self, regex: str, path: str, glob: str | None, context: int | None
+    ) -> str:
+        """rg → grep fallback chain (no git grep).
+
+        Shared by :class:`Grep` (after git grep -P fails) and
+        :class:`GrepMac` (after git grep -E fails).  Extracted here so
+        the Mac variant can skip the parent's ``git grep -P`` attempt
+        without duplicating the rg/grep logic.
+        """
         if shutil.which("rg"):
             cmd = [
                 "rg",

python_agent_harness-1.5.4.8/python_agent_harness/tools/grep_mac.py

@@ -0,0 +1,209 @@
+"""macOS Grep tool: ``git grep -E`` instead of ``git grep -P``.
+
+Apple's default Git (installed via Xcode Command Line Tools) is built
+without PCRE support, so ``git grep -P`` (Perl-compatible regex) fails
+with::
+
+    fatal: cannot use Perl-compatible regexes when not compiled with USE_LIBPCRE
+
+The Linux :class:`Grep` tool uses ``-P`` as the first-choice backend;
+when that fails on macOS the fallback chain (``rg`` → ``grep``) still
+works, but:
+
+- ``rg`` (ripgrep) is not installed by default on macOS.
+- BSD ``grep`` supports only POSIX ERE, losing Perl features
+  (``\\d``, ``\\w``, lookaheads).
+- Two unnecessary failed attempts add latency before reaching a
+  working backend.
+
+``GrepMac`` replaces ``-P`` with ``-E`` (POSIX extended regex) in the
+``git grep`` command, so the git path — the fastest and most common
+backend — works on stock macOS.  PCRE character class shorthands
+(``\\d``, ``\\w``, ``\\s`` and their negations) are translated to
+POSIX bracket expressions so the LLM's regexes produce the same
+matches they would under ``-P``.  The translation is context-aware:
+it skips shorthands inside existing character classes (``[\\d.]``)
+and shorthands preceded by a literal backslash (``\\\\d``), so the
+regex structure is never corrupted.  ``\\b`` (word boundary) is
+translated to ``[[:<:]]`` / ``[[:>:]]`` on macOS git, which supports
+these GNU-compatible extensions.
+
+Features with no POSIX equivalent (lookaheads, backreferences) are
+left as-is — they will cause a syntax error, which is better than
+silently matching wrong content.
+
+The fallback chain skips the parent's ``git grep -P`` attempt (guaranteed
+to fail on macOS) and goes directly to ``rg`` / ``grep`` via the shared
+:meth:`Grep._fallback_rg_grep` method.
+
+Only the ``git grep`` regex flag differs; the tool name and result
+format are inherited so callers, the tool registry, and the plan-mode
+write guard are platform-independent.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import subprocess
+
+from .base import ToolContext
+from .filesystem import _git_root
+from .grep import Grep, _grep_out
+
+_PCRE_CLASS_MAP: dict[str, str] = {
+    r"\d": "[0-9]",
+    r"\D": "[^0-9]",
+    r"\w": "[A-Za-z0-9_]",
+    r"\W": "[^A-Za-z0-9_]",
+    r"\s": "[ \t\n\r\f\v]",
+    r"\S": "[^ \t\n\r\f\v]",
+}
+
+# Match \d, \D, \w, \W, \s, \S, or \b that is NOT preceded by an
+# odd number of backslashes (i.e. not escaped).  The lookbehind
+# (?<!\\) ensures we don't match a shorthand that is itself escaped.
+# The ``prefix`` group captures any preceding pairs of literal
+# backslashes so they can be preserved in the replacement — without
+# this, re.sub would discard them along with the full match.
+_PCRE_SHORTHAND_RE = re.compile(r"(?<!\\)(?P<prefix>(?:\\\\)*)(?P<shorthand>\\[dDwWsSb])")
+
+
+def _is_escaped(s: str, pos: int) -> bool:
+    """True if the character at *pos* is preceded by an odd number of backslashes."""
+    count = 0
+    j = pos - 1
+    while j >= 0 and s[j] == "\\":
+        count += 1
+        j -= 1
+    return count % 2 == 1
+
+
+def _find_char_class_end(s: str, start: int) -> int | None:
+    """Find the closing ``]`` of a character class starting at *start*.
+
+    Handles ``[]]`` (``]`` as first char) and ``[^]]``.  Returns the
+    index of the closing ``]`` or ``None`` if unterminated.
+    """
+    i = start + 1
+    if i < len(s) and s[i] == "^":
+        i += 1
+    if i < len(s) and s[i] == "]":
+        i += 1
+    while i < len(s):
+        if s[i] == "\\" and i + 1 < len(s):
+            i += 2
+            continue
+        if s[i] == "]":
+            return i
+        i += 1
+    return None
+
+
+def _pcre_to_ere(regex: str) -> str:
+    """Translate PCRE character class shorthands to POSIX ERE.
+
+    Translates ``\\d``, ``\\w``, ``\\s``, their negations, and ``\\b``
+    (word boundary) to POSIX-compatible equivalents.  The translation is
+    context-aware:
+
+    - Shorthands **inside** an existing character class (``[\\d.]``) are
+      left untouched — replacing them would create nested ``[]`` which
+      is invalid in POSIX ERE.  ``git grep -E`` on macOS handles
+      ``\\d`` inside ``[]`` natively, so this is safe.
+    - Shorthands preceded by a literal backslash (``\\\\d``) are left
+      untouched — they represent a literal backslash + letter, not a
+      character class.
+
+    Features with no POSIX equivalent (lookaheads, backreferences) are
+    left as-is so they produce a clear syntax error instead of silently
+    matching wrong content.
+    """
+    # Find all character class spans so we can skip shorthands inside them.
+    char_class_spans: list[tuple[int, int]] = []
+    i = 0
+    while i < len(regex):
+        if regex[i] == "[" and not _is_escaped(regex, i):
+            end = _find_char_class_end(regex, i)
+            if end is not None:
+                char_class_spans.append((i, end))
+                i = end + 1
+                continue
+        i += 1
+
+    def _in_char_class(pos: int) -> bool:
+        return any(start < pos < end for start, end in char_class_spans)
+
+    def _replace(m: re.Match) -> str:
+        if _in_char_class(m.start()):
+            return m.group(0)
+        prefix = m.group("prefix")
+        shorthand = m.group("shorthand")
+        if shorthand == r"\b":
+            pos = m.start("shorthand")
+            after = regex[pos + 2] if pos + 2 < len(regex) else ""
+            before = regex[pos - 1] if pos > 0 else ""
+            if before and (before.isalnum() or before == "_"):
+                return prefix + "[[:>:]]"
+            if after and (after.isalnum() or after == "_"):
+                return prefix + "[[:<:]]"
+            return prefix + "[[:<:]]"
+        return prefix + _PCRE_CLASS_MAP.get(shorthand, shorthand)
+
+    return _PCRE_SHORTHAND_RE.sub(_replace, regex)
+
+
+class GrepMac(Grep):
+    """Grep with ``git grep -E`` for macOS (no PCRE dependency)."""
+
+    def run(self, args: dict, ctx: ToolContext) -> str:
+        regex = args["regex"]
+        path = os.path.realpath(args["path"])
+        if not os.path.isdir(path) and not os.path.isfile(path):
+            return f"Error: path {args['path']} is not readable"
+        glob = args.get("glob")
+        context = args.get("context_lines")
+        if context is not None:
+            context = max(0, min(15, int(context)))
+
+        git_root = _git_root(path)
+        if git_root:
+            rel = os.path.relpath(path, git_root)
+            pathspec = rel
+            if glob and os.path.isdir(path):
+                pathspec = os.path.join(rel, glob).replace(os.sep, "/")
+            ere_regex = _pcre_to_ere(regex)
+            cmd = [
+                "git",
+                "grep",
+                "--line-number",
+                "--no-color",
+                "--max-count=1000",
+                "--untracked",
+                "-E",
+                "-e",
+                ere_regex,
+                "--",
+                pathspec,
+            ]
+            if context:
+                cmd = cmd[:3] + [f"-C{context}"] + cmd[3:]
+            try:
+                proc = subprocess.run(
+                    cmd,
+                    cwd=git_root,
+                    capture_output=True,
+                    text=True,
+                    encoding="utf-8",
+                    errors="replace",
+                    timeout=60,
+                )
+            except (OSError, subprocess.TimeoutExpired):
+                proc = None
+            if proc is not None and proc.returncode in (0, 1):
+                return _grep_out(proc, "git")
+
+        # Non-git or git grep -E failed: skip the parent's git grep -P
+        # attempt (guaranteed to fail on macOS) and go directly to the
+        # shared rg/grep fallback chain.
+        return self._fallback_rg_grep(regex, path, glob, context)

{python_agent_harness-1.5.4.7 → python_agent_harness-1.5.4.8}/python_agent_harness/tools/insert.py

@@ -43,6 +43,8 @@ class Insert(Tool):
         new_str = args["new_str"]
         if not new_str.endswith("\n"):
             new_str += "\n"
+        if ln < -1:
+            return f"Error: line_number {ln} is invalid (use 0 for beginning, -1 for end)"
         if ln == -1 or ln >= len(lines):
             lines.append(new_str)
         elif ln == 0:

{python_agent_harness-1.5.4.7 → python_agent_harness-1.5.4.8}/python_agent_harness/tools/write.py

@@ -26,7 +26,9 @@ class Write(Tool):
     def run(self, args: dict, ctx: ToolContext) -> str:
         dir_path = args.get("path") or "."
         filename = args.get("filename") or ""
-        content = args.get("content") or ""
+        content = args.get("content")
+        if content is None:
+            return "Error: Required argument `content' missing"
         # LLM may put the full file path in "filename" or in "path"
         if filename:
             path = os.path.realpath(os.path.abspath(os.path.join(dir_path, filename)))

{python_agent_harness-1.5.4.7 → python_agent_harness-1.5.4.8/python_agent_harness.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-agent-harness
-Version: 1.5.4.7
+Version: 1.5.4.8
 Summary: A lightweight, hackable mini-OpenCode written in Python.
 Author: huming
 License-Expression: MIT

{python_agent_harness-1.5.4.7 → python_agent_harness-1.5.4.8}/tests/test_client.py

@@ -812,7 +812,7 @@ class TestClientAbort(unittest.TestCase):
 
 class TestAbortInflightSockets(unittest.TestCase):
     """_abort_inflight_sockets wakes live pool sockets via
-    shutdown(SHUT_RDWR) and tolerates broken internals."""
+    shutdown(SHUT_RDWR) + close() and tolerates broken internals."""
 
     def _fake_client_with_stream(self, stream):
         conn = mock.Mock()
@@ -821,7 +821,7 @@ class TestAbortInflightSockets(unittest.TestCase):
         client._transport._pool._connections = [conn]
         return client
 
-    def test_shuts_down_live_socket(self):
+    def test_shuts_down_and_closes_live_socket(self):
         import socket as _socket
 
         from python_agent_harness.client import _abort_inflight_sockets
@@ -830,7 +830,22 @@ class TestAbortInflightSockets(unittest.TestCase):
         stream = mock.Mock()
         stream.get_extra_info.return_value = sock
         _abort_inflight_sockets(self._fake_client_with_stream(stream))
+        # shutdown wakes the recv on Linux; close() is the reliable wake
+        # on macOS/BSD where shutdown alone may leave a parked recv stuck
         sock.shutdown.assert_called_once_with(_socket.SHUT_RDWR)
+        sock.close.assert_called_once_with()
+
+    def test_close_still_runs_when_shutdown_raises(self):
+        """A shutdown OSError must not skip the fd close: on macOS the
+        close is the step that actually wakes the blocked read."""
+        from python_agent_harness.client import _abort_inflight_sockets
+
+        sock = mock.Mock()
+        sock.shutdown.side_effect = OSError("not connected")
+        stream = mock.Mock()
+        stream.get_extra_info.return_value = sock
+        _abort_inflight_sockets(self._fake_client_with_stream(stream))  # no raise
+        sock.close.assert_called_once_with()
 
     def test_empty_pool_is_noop(self):
         from python_agent_harness.client import _abort_inflight_sockets

{python_agent_harness-1.5.4.7 → python_agent_harness-1.5.4.8}/tests/test_filesystem.py

@@ -1606,7 +1606,7 @@ class TestGrepMac(unittest.TestCase):
         with (
             mock.patch("shutil.which", return_value="/usr/bin/rg"),
             mock.patch(
-                "python_agent_harness.tools.grep_mac.subprocess.run",
+                "python_agent_harness.tools.grep.subprocess.run",
                 return_value=proc,
             ),
         ):

python_agent_harness-1.5.4.7/python_agent_harness/tools/glob_mac.py

@@ -1,97 +0,0 @@
-"""macOS Glob tool: ``git ls-files`` inside git repos, ``pathlib`` 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.
-
-Only the non-git fallback differs; the git path, the tool name, and
-the result format are inherited unchanged so callers, the tool
-registry, and the plan-mode write guard are platform-independent.
-"""
-
-from __future__ import annotations
-
-import fnmatch
-import os
-from pathlib import Path
-
-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."""
-
-    def _tree_fallback(self, pattern: str, base: str, depth: object) -> str:
-        """Walk *base* with :func:`pathlib.Path.rglob` instead of ``tree``.
-
-        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.
-        """
-        root = Path(base)
-        matches: list[tuple[float, str]] = []
-        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).
-        matches.sort(key=lambda t: t[0], reverse=True)
-        out = "\n".join(path for _, path in matches)
-        if not out:
-            return ""
-        return _spool(out + "\n", "glob")
-
-    def run(self, args: dict, ctx: ToolContext) -> str:
-        pattern = args.get("pattern") or ""
-        if not pattern:
-            return "Error: pattern must not be empty"
-        path = args.get("path")
-        if path:
-            if not (os.path.isdir(path) and os.access(path, os.R_OK)):
-                return f"Error: path {path} is not readable"
-        else:
-            path = ctx.cwd
-        base = os.path.realpath(path)
-        depth = args.get("depth")
-
-        from .filesystem import _git_root
-
-        git_root = _git_root(base)
-
-        if git_root:
-            # The git path is identical to the parent — delegate.
-            return super().run(args, ctx)
-
-        # Non-git: pure-Python fallback instead of `tree`.
-        return self._tree_fallback(pattern, base, depth)

python_agent_harness-1.5.4.7/python_agent_harness/tools/grep_mac.py

@@ -1,92 +0,0 @@
-"""macOS Grep tool: ``git grep -E`` instead of ``git grep -P``.
-
-Apple's default Git (installed via Xcode Command Line Tools) is built
-without PCRE support, so ``git grep -P`` (Perl-compatible regex) fails
-with::
-
-    fatal: cannot use Perl-compatible regexes when not compiled with USE_LIBPCRE
-
-The Linux :class:`Grep` tool uses ``-P`` as the first-choice backend;
-when that fails on macOS the fallback chain (``rg`` → ``grep``) still
-works, but:
-
-- ``rg`` (ripgrep) is not installed by default on macOS.
-- BSD ``grep`` supports only POSIX ERE, losing Perl features
-  (``\\d``, ``\\w``, lookaheads).
-- Two unnecessary failed attempts add latency before reaching a
-  working backend.
-
-``GrepMac`` replaces ``-P`` with ``-E`` (POSIX extended regex) in the
-``git grep`` command, so the git path — the fastest and most common
-backend — works on stock macOS.  The rest of the fallback chain (rg,
-grep) is inherited unchanged.
-
-Only the ``git grep`` regex flag differs; the tool name and result
-format are inherited so callers, the tool registry, and the plan-mode
-write guard are platform-independent.
-"""
-
-from __future__ import annotations
-
-import os
-import subprocess
-
-from .base import ToolContext
-from .filesystem import _git_root
-from .grep import Grep, _grep_out
-
-
-class GrepMac(Grep):
-    """Grep with ``git grep -E`` for macOS (no PCRE dependency)."""
-
-    def run(self, args: dict, ctx: ToolContext) -> str:
-        regex = args["regex"]
-        path = os.path.realpath(args["path"])
-        if not os.path.isdir(path) and not os.path.isfile(path):
-            return f"Error: path {args['path']} is not readable"
-        glob = args.get("glob")
-        context = args.get("context_lines")
-        if context is not None:
-            context = max(0, min(15, int(context)))
-
-        git_root = _git_root(path) if os.path.isdir(path) else None
-        if git_root:
-            rel = os.path.relpath(path, git_root)
-            pathspec = rel
-            if glob and os.path.isdir(path):
-                pathspec = os.path.join(rel, glob).replace(os.sep, "/")
-            # -E (extended regex) instead of -P (Perl regex): Apple's
-            # Git is built without PCRE, so -P fails on stock macOS.
-            cmd = [
-                "git",
-                "grep",
-                "--line-number",
-                "--no-color",
-                "--max-count=1000",
-                "--untracked",
-                "-E",
-                "-e",
-                regex,
-                "--",
-                pathspec,
-            ]
-            if context:
-                cmd = cmd[:3] + [f"-C{context}"] + cmd[3:]
-            try:
-                proc = subprocess.run(
-                    cmd,
-                    cwd=git_root,
-                    capture_output=True,
-                    text=True,
-                    encoding="utf-8",
-                    errors="replace",
-                    timeout=60,
-                )
-            except (OSError, subprocess.TimeoutExpired):
-                proc = None
-            if proc is not None and proc.returncode in (0, 1):
-                return _grep_out(proc, "git")
-
-        # Non-git or git grep failed: delegate to the parent's rg/grep
-        # fallback chain (identical on both platforms).
-        return super().run(args, ctx)