python-agent-harness 1.5.4.2__tar.gz → 1.5.4.3__tar.gz

{python_agent_harness-1.5.4.2/python_agent_harness.egg-info → python_agent_harness-1.5.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-agent-harness
-Version: 1.5.4.2
+Version: 1.5.4.3
 Summary: A lightweight, hackable mini-OpenCode written in Python.
 Author: huming
 License-Expression: MIT
@@ -248,7 +248,7 @@ python_agent_harness/
 
 ## Development
 
-Requires Python ≥ 3.11. CI runs against Python 3.11, 3.12, and 3.13.
+Requires Python ≥ 3.11. CI runs against Python 3.11, 3.12, and 3.13 on Linux and macOS.
 
 ```sh
 make test                           # unit tests

{python_agent_harness-1.5.4.2 → python_agent_harness-1.5.4.3}/README.md

@@ -225,7 +225,7 @@ python_agent_harness/
 
 ## Development
 
-Requires Python ≥ 3.11. CI runs against Python 3.11, 3.12, and 3.13.
+Requires Python ≥ 3.11. CI runs against Python 3.11, 3.12, and 3.13 on Linux and macOS.
 
 ```sh
 make test                           # unit tests

{python_agent_harness-1.5.4.2 → python_agent_harness-1.5.4.3}/pyproject.toml

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

{python_agent_harness-1.5.4.2 → python_agent_harness-1.5.4.3}/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.2"
+__version__ = "1.5.4.3"
 
 __all__ = [
     "Session",

{python_agent_harness-1.5.4.2 → python_agent_harness-1.5.4.3}/python_agent_harness/mcp/manager.py

@@ -23,6 +23,7 @@ SDK/connection errors that the tool adapter turns into error strings.
 from __future__ import annotations
 
 import asyncio
+import concurrent.futures
 import contextlib
 import threading
 import time
@@ -102,7 +103,10 @@ class _LoopThread:
         while True:
             try:
                 exc = future.exception(timeout=0.1)
-            except TimeoutError:
+            # concurrent.futures.TimeoutError is the builtin TimeoutError on
+            # 3.11+ but a distinct class on 3.10 — catch the futures one so
+            # the poll-timeout branch works on every supported Python.
+            except concurrent.futures.TimeoutError:
                 # future still running: enforce deadline / cancellation
                 if deadline is not None and time.monotonic() >= deadline:
                     future.cancel()

{python_agent_harness-1.5.4.2 → python_agent_harness-1.5.4.3}/python_agent_harness/planmode.py

@@ -64,8 +64,11 @@ class PlanMode:
         os.makedirs(os.path.dirname(path), exist_ok=True)
         if not os.path.exists(path):
             Path(path).write_text("", encoding="utf-8")
-        self.plan_file = path
-        return path
+        # Store the canonical path so the plan-mode write guard (which
+        # compares against realpath'd tool targets) matches — on macOS
+        # TMPDIR (/var) is a symlink to /private/var.
+        self.plan_file = os.path.realpath(path)
+        return self.plan_file
 
     def cleanup_plan_file(self) -> None:
         if not self.plan_file:

{python_agent_harness-1.5.4.2 → python_agent_harness-1.5.4.3}/python_agent_harness/tools/__init__.py

@@ -2,10 +2,14 @@
 
 from __future__ import annotations
 
+import sys
+
 from .agent_tool import AgentTool
 from .base import PendingToolResult, Registry, Tool, ToolContext
 from .bash import Bash
-from .filesystem import Edit, GlobTool, Grep, Insert, Mkdir, Read, Write
+from .edit import Edit
+from .edit_mac import EditMac
+from .filesystem import GlobTool, Grep, Insert, Mkdir, Read, Write
 from .mcp import MCPTool, mcp_tools_from_manager, normalize_mcp_result
 from .planexit import PlanExit
 from .question import Question
@@ -20,6 +24,7 @@ __all__ = [
     "AgentTool",
     "Bash",
     "Edit",
+    "EditMac",
     "GlobTool",
     "Grep",
     "Insert",
@@ -38,6 +43,10 @@ __all__ = [
 
 def default_registry() -> Registry:
     reg = Registry()
+    # macOS's BSD patch rejects well-formed hunks that GNU patch accepts,
+    # so macOS uses EditMac (pure-Python diff applier); Linux keeps the
+    # patch-binary Edit.  Both register under the name "Edit".
+    edit_tool = EditMac() if sys.platform == "darwin" else Edit()
     for tool in (
         AgentTool(),
         TodoWrite(),
@@ -45,7 +54,7 @@ def default_registry() -> Registry:
         Grep(),
         Read(),
         Insert(),
-        Edit(),
+        edit_tool,
         Write(),
         Mkdir(),
         Bash(),

python_agent_harness-1.5.4.3/python_agent_harness/tools/diffapply.py

@@ -0,0 +1,246 @@
+"""Pure-Python unified diff applier (macOS Edit backend).
+
+macOS ships Apple's old BSD ``/usr/bin/patch`` (patch 2.0-12u11-Apple),
+which rejects well-formed hunks that GNU patch accepts: asymmetric
+context (leading but no trailing context, or vice versa), hunks whose
+last body line is a ``---``-rendered content line, etc.  Rather than
+rewriting every diff into a shape that specific patch binary likes, the
+macOS Edit tool applies diffs here, in Python:
+
+- the diff is parsed STRUCTURALLY, so hunk-header counts are advisory
+  (they are recounted from the body, like ``_fix_patch_headers``) and
+  ``---``/``+++`` content lines are only file headers when followed by
+  their ``+++``/``---`` partner;
+- hunks are matched against the file by content with fuzz (context
+  lines may mismatch up to ``FUZZ`` times, removed lines must match
+  exactly), preferring the position the header claims;
+- hunks are applied bottom-up so earlier positions stay valid;
+- files are written only when every hunk of the section matched.
+
+The applier is platform-independent, so its behavior is covered by
+tests on every OS.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+
+_HUNK_HEADER_RE = re.compile(r"^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@")
+_FILE_OLD_RE = re.compile(r"^---[ \t]")
+_FILE_NEW_RE = re.compile(r"^\+\+\+[ \t]")
+_HUNK_BOUNDARY_RE = re.compile(r"^@@ ")
+
+# Maximum number of context lines that may mismatch when anchoring a
+# hunk (removed lines must always match exactly).
+FUZZ = 3
+
+
+class _Hunk:
+    __slots__ = ("old_start", "body")
+
+    def __init__(self, old_start: int, body: list[tuple[str, str, bool]]) -> None:
+        # body entries: (kind, content, no_newline); kind in ' ', '-', '+'.
+        self.old_start = old_start
+        self.body = body
+
+    def old_seq(self) -> list[tuple[str, str]]:
+        """(kind, content-without-newline) for the lines that must exist
+        in the old file (' ' context and '-' removed lines)."""
+        return [
+            (kind, content.rstrip("\n")) for kind, content, _ in self.body if kind in (" ", "-")
+        ]
+
+
+class _Section:
+    __slots__ = ("new_path", "hunks")
+
+    def __init__(self, new_path: str, hunks: list[_Hunk]) -> None:
+        self.new_path = new_path
+        self.hunks = hunks
+
+
+def _section_header_at(lines: list[str], idx: int) -> bool:
+    """Whether lines[idx] begins a file section: a ``--- path`` line
+    immediately followed by a ``+++ path`` line.  Removed/added content
+    lines rendered ``---``/``+++`` inside a hunk body are only mistaken
+    for headers when the pair shape matches, so the trailing ``+++``
+    partner is required (mirrors ``_starts_file_section``)."""
+    if idx + 1 >= len(lines):
+        return False
+    return bool(_FILE_OLD_RE.match(lines[idx]) and _FILE_NEW_RE.match(lines[idx + 1]))
+
+
+def _parse(diff_text: str) -> list[_Section]:
+    """Parse a unified diff into file sections (paths + hunks)."""
+    lines = diff_text.splitlines(keepends=True)
+    sections: list[_Section] = []
+    i = 0
+    n = len(lines)
+    while i < n:
+        if not _section_header_at(lines, i):
+            i += 1
+            continue
+        new_path = lines[i + 1][len("+++") :].strip()
+        i += 2
+        hunks: list[_Hunk] = []
+        while i < n:
+            m = _HUNK_HEADER_RE.match(lines[i])
+            if m:
+                old_start = int(m.group(1))
+                body: list[tuple[str, str, bool]] = []
+                i += 1
+                while (
+                    i < n
+                    and not _HUNK_BOUNDARY_RE.match(lines[i])
+                    and not _section_header_at(lines, i)
+                ):
+                    line = lines[i]
+                    if line.startswith("\\"):  # ""
+                        if body and body[-1][0] in (" ", "-", "+"):
+                            kind, content, _ = body[-1]
+                            body[-1] = (kind, content, True)
+                    elif line[:1] in (" ", "-", "+"):
+                        body.append((line[0], line[1:], False))
+                    i += 1
+                hunks.append(_Hunk(old_start, body))
+                continue
+            if _section_header_at(lines, i):
+                break
+            i += 1  # stray line (e.g. "diff --git", "index ...") — skip
+        sections.append(_Section(new_path, hunks))
+    return sections
+
+
+def _candidate_positions(start: int, limit: int) -> list[int]:
+    """Match offsets around *start* (0-based), closest first, within
+    ``FUZZ`` lines and bounded by [0, *limit*]."""
+    out: list[int] = []
+    seen: set[int] = set()
+    for d in range(FUZZ + 1):
+        for p in (start - d, start + d):
+            if 0 <= p <= limit and p not in seen:
+                seen.add(p)
+                out.append(p)
+    return out
+
+
+def _match_hunk(hunk: _Hunk, file_lines: list[str]) -> int | None:
+    """Find the 0-based position where the hunk's old lines match.
+
+    Removed lines must match exactly; up to ``FUZZ`` context lines may
+    mismatch (patch-style fuzz).  Pure-insertion hunks (no old lines)
+    anchor at ``old_start - 1``.
+    """
+    old_seq = hunk.old_seq()
+    if not old_seq:
+        p = hunk.old_start - 1
+        return max(0, min(p, len(file_lines)))
+    start = hunk.old_start - 1
+    limit = len(file_lines) - len(old_seq)
+    for p in _candidate_positions(start, limit):
+        mismatches = 0
+        ok = True
+        for i, (kind, content) in enumerate(old_seq):
+            file_content = file_lines[p + i].rstrip("\n")
+            if kind == "-":
+                if file_content != content:
+                    ok = False
+                    break
+            elif file_content != content:
+                mismatches += 1
+                if mismatches > FUZZ:
+                    ok = False
+                    break
+        if ok:
+            return p
+    return None
+
+
+def _apply_hunk(hunk: _Hunk, pos: int, file_lines: list[str]) -> None:
+    """Replace the matched region with the hunk's new lines in place."""
+    old_count = sum(1 for kind, _, _ in hunk.body if kind in (" ", "-"))
+    new_block: list[str] = []
+    p = pos
+    for kind, content, no_newline in hunk.body:
+        if kind == " ":
+            new_block.append(file_lines[p])
+            p += 1
+        elif kind == "-":
+            p += 1
+        else:  # "+"
+            if no_newline:
+                new_block.append(content.rstrip("\n"))
+            elif content.endswith("\n"):
+                new_block.append(content)
+            else:
+                new_block.append(content + "\n")
+    file_lines[pos : pos + old_count] = new_block
+
+
+def _resolve_target(new_path: str, cwd: str, fallback_path: str | None) -> str:
+    """Resolve a diff's ``+++ path`` against *cwd*, with the single-file
+    *fallback_path* as backup when the name does not match an existing
+    file (e.g. the model wrote a bare basename for a deep path)."""
+    name = new_path
+    for prefix in ("a/", "b/"):
+        if name.startswith(prefix):
+            name = name[len(prefix) :]
+            break
+    if os.path.isabs(name):
+        return name
+    target = os.path.join(cwd, name)
+    if not os.path.isfile(target) and fallback_path and os.path.isfile(fallback_path):
+        return fallback_path
+    return target
+
+
+def _apply_section(section: _Section, cwd: str, fallback_path: str | None) -> tuple[bool, str]:
+    target = _resolve_target(section.new_path, cwd, fallback_path)
+    if not os.path.isfile(target):
+        return False, f"target file does not exist: {target}"
+    try:
+        with open(target, encoding="utf-8", errors="replace") as f:
+            file_lines = f.readlines()
+    except OSError as e:
+        return False, f"cannot read {target}: {e}"
+    # Match every hunk against the ORIGINAL content first; only write
+    # when all matched (a failed hunk leaves the file untouched).
+    plan: list[tuple[_Hunk, int]] = []
+    for hunk in section.hunks:
+        pos = _match_hunk(hunk, file_lines)
+        if pos is None:
+            return (
+                False,
+                f"hunk at line {hunk.old_start} failed to match the file content",
+            )
+        plan.append((hunk, pos))
+    new_lines = list(file_lines)
+    for hunk, pos in reversed(plan):  # bottom-up: earlier positions stay valid
+        _apply_hunk(hunk, pos, new_lines)
+    try:
+        with open(target, "w", encoding="utf-8") as f:
+            f.writelines(new_lines)
+    except OSError as e:
+        return False, f"cannot write {target}: {e}"
+    return True, f"patched {target}"
+
+
+def apply_unified_diff(
+    diff_text: str, cwd: str, fallback_path: str | None = None
+) -> tuple[bool, str]:
+    """Apply a unified diff to files under *cwd*.
+
+    Returns ``(ok, message)``; on failure no file is written.  Multi-file
+    diffs are applied section by section.  *fallback_path* is used when a
+    section's target cannot be resolved to an existing file (single-file
+    mode).
+    """
+    sections = _parse(diff_text)
+    if not sections:
+        return False, "no file sections found in diff"
+    for section in sections:
+        ok, msg = _apply_section(section, cwd, fallback_path)
+        if not ok:
+            return False, msg
+    return True, f"applied {len(sections)} file section(s)"

python_agent_harness-1.5.4.3/python_agent_harness/tools/edit_mac.py

@@ -0,0 +1,56 @@
+"""macOS Edit tool: string replacement like ``Edit``, but diff/patch
+mode applies diffs with the built-in Python applier instead of
+``/usr/bin/patch``.
+
+Apple's BSD ``patch`` (patch 2.0-12u11-Apple) rejects well-formed hunks
+that GNU patch accepts — asymmetric context, ``---``/``+++``-rendered
+content lines at hunk edges, and so on — so model-generated diffs that
+apply cleanly on Linux fail on macOS.  The Python applier
+(``diffapply.py``) parses the diff structurally and matches hunks with
+fuzz, so the same diffs apply on both platforms.
+
+Only the diff-application strategy differs; the tool name stays
+``Edit`` so callers, the tool registry and the plan-mode write guard
+are platform-independent.
+"""
+
+from __future__ import annotations
+
+import os
+
+from ..diffrender import unified_diff
+from .base import ToolContext
+from .diffapply import apply_unified_diff
+from .edit import Edit, _strip_diff_fence
+
+
+class EditMac(Edit):
+    """Edit with a pure-Python diff/patch backend for macOS."""
+
+    def _apply_patch(self, path: str, cwd: str, diff: str, ctx: ToolContext) -> str:
+        text = diff if diff.endswith("\n") else diff + "\n"
+        text = _strip_diff_fence(text)
+        is_file = os.path.isfile(path)
+        old_content = None
+        if is_file:
+            try:
+                with open(path, encoding="utf-8", errors="replace") as f:
+                    old_content = f.read()
+            except OSError:
+                old_content = None
+        ok, msg = apply_unified_diff(text, cwd, path if is_file else None)
+        if not ok:
+            return f"Error: Failed to apply diff to {path}.\n{msg}"
+        if old_content is not None and os.path.isfile(path):
+            try:
+                with open(path, encoding="utf-8", errors="replace") as f:
+                    new_content = f.read()
+                diff_text = unified_diff(old_content, new_content, path)
+                if diff_text:
+                    ctx.record_diff(diff_text)
+            except OSError:
+                pass
+        return (
+            f"Diff successfully applied to {path}.\n"
+            f"Applied with the built-in Python diff applier.\n{msg}"
+        )

{python_agent_harness-1.5.4.2 → python_agent_harness-1.5.4.3}/python_agent_harness/tools/glob.py

@@ -70,7 +70,10 @@ class GlobTool(Tool):
                 return f"Error: path {path} is not readable"
         else:
             path = ctx.cwd
-        base = os.path.abspath(path)  # directory-file-name + expand-file-name
+        # realpath (not abspath): _git_root resolves symlinks (macOS /var ->
+        # /private/var), so the base must be canonical or relpath produces a
+        # pathspec git rejects as "outside repository".
+        base = os.path.realpath(path)
         depth = args.get("depth")
 
         git_root = _git_root(base)

{python_agent_harness-1.5.4.2 → python_agent_harness-1.5.4.3}/python_agent_harness/tools/grep.py

@@ -41,7 +41,7 @@ class Grep(Tool):
 
     def run(self, args: dict, ctx: ToolContext) -> str:
         regex = args["regex"]
-        path = os.path.abspath(args["path"])
+        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")

{python_agent_harness-1.5.4.2 → python_agent_harness-1.5.4.3/python_agent_harness.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-agent-harness
-Version: 1.5.4.2
+Version: 1.5.4.3
 Summary: A lightweight, hackable mini-OpenCode written in Python.
 Author: huming
 License-Expression: MIT
@@ -248,7 +248,7 @@ python_agent_harness/
 
 ## Development
 
-Requires Python ≥ 3.11. CI runs against Python 3.11, 3.12, and 3.13.
+Requires Python ≥ 3.11. CI runs against Python 3.11, 3.12, and 3.13 on Linux and macOS.
 
 ```sh
 make test                           # unit tests

{python_agent_harness-1.5.4.2 → python_agent_harness-1.5.4.3}/python_agent_harness.egg-info/SOURCES.txt

@@ -44,7 +44,9 @@ python_agent_harness/tools/__init__.py
 python_agent_harness/tools/agent_tool.py
 python_agent_harness/tools/base.py
 python_agent_harness/tools/bash.py
+python_agent_harness/tools/diffapply.py
 python_agent_harness/tools/edit.py
+python_agent_harness/tools/edit_mac.py
 python_agent_harness/tools/filesystem.py
 python_agent_harness/tools/glob.py
 python_agent_harness/tools/grep.py

{python_agent_harness-1.5.4.2 → python_agent_harness-1.5.4.3}/tests/test_agents_md.py

@@ -46,7 +46,7 @@ class TestFindAgentsMdFiles(unittest.TestCase):
         with tempfile.TemporaryDirectory() as d:
             (Path(d) / "AGENTS.md").write_text("# Rules\n", encoding="utf-8")
             result = find_agents_md_files(d)
-            self.assertEqual([Path(p) for p in result], [Path(d) / "AGENTS.md"])
+            self.assertEqual([Path(p) for p in result], [(Path(d) / "AGENTS.md").resolve()])
 
     @unittest.skipUnless(shutil.which("git"), "git not available")
     def test_finds_agents_md_in_ancestor(self):
@@ -57,7 +57,7 @@ class TestFindAgentsMdFiles(unittest.TestCase):
             sub.mkdir(parents=True)
             (Path(d) / "AGENTS.md").write_text("# Root rules\n", encoding="utf-8")
             result = find_agents_md_files(str(sub))
-            self.assertEqual([Path(p) for p in result], [Path(d) / "AGENTS.md"])
+            self.assertEqual([Path(p) for p in result], [(Path(d) / "AGENTS.md").resolve()])
 
     @unittest.skipUnless(shutil.which("git"), "git not available")
     def test_stacks_every_ancestor_nearest_first(self):
@@ -76,7 +76,7 @@ class TestFindAgentsMdFiles(unittest.TestCase):
             result = find_agents_md_files(str(sub))
             self.assertEqual(
                 [Path(p) for p in result],
-                [pkg / "AGENTS.md", Path(d) / "AGENTS.md"],
+                [(pkg / "AGENTS.md").resolve(), (Path(d) / "AGENTS.md").resolve()],
             )
 
     @unittest.skipUnless(shutil.which("git"), "git not available")
@@ -92,7 +92,7 @@ class TestFindAgentsMdFiles(unittest.TestCase):
             # above the git root: must NOT be picked up
             (Path(outer) / "AGENTS.md").write_text("# Outer rules\n", encoding="utf-8")
             result = find_agents_md_files(str(sub))
-            self.assertEqual([Path(p) for p in result], [repo / "AGENTS.md"])
+            self.assertEqual([Path(p) for p in result], [(repo / "AGENTS.md").resolve()])
 
     def test_non_git_dir_is_its_own_bound(self):
         """Outside a repo the search is bounded by the project dir."""
@@ -147,7 +147,7 @@ class TestAgentsMdAsContextFiles(unittest.TestCase):
             result = load_context_files(None, extra_files=find_agents_md_files(d))
             self.assertEqual(
                 result,
-                f"Request context:\n\nIn file `{agents}`:\n\n# Project Rules\nUse 4 spaces.",
+                f"Request context:\n\nIn file `{agents.resolve()}`:\n\n# Project Rules\nUse 4 spaces.",
             )
 
     def test_empty_file_yields_no_context(self):

{python_agent_harness-1.5.4.2 → python_agent_harness-1.5.4.3}/tests/test_filesystem.py

@@ -6,11 +6,13 @@ import os
 import re
 import shutil
 import subprocess
+import sys
 import tempfile
 import unittest
 from unittest import mock
 
 from python_agent_harness.tools.base import ToolContext
+from python_agent_harness.tools.edit_mac import EditMac
 from python_agent_harness.tools.filesystem import (
     Edit,
     GlobTool,
@@ -24,6 +26,13 @@ from python_agent_harness.tools.filesystem import (
 )
 
 
+def edit_tool() -> Edit:
+    """The Edit tool active on this platform: Linux uses the patch
+    binary, macOS the built-in Python diff applier (Apple's BSD patch
+    rejects well-formed hunks that GNU patch accepts)."""
+    return EditMac() if sys.platform == "darwin" else Edit()
+
+
 def _big_output(lines: int = 6000, width: int = 80) -> str:
     return "".join(f"line{i:04d}-{'x' * width}\n" for i in range(lines))
 
@@ -512,11 +521,11 @@ class TestGlobGrepTools(unittest.TestCase):
         self._mkdir("proj", "sub")
         open(os.path.join(d, "sub", "b.py"), "w").close()
         out = GlobTool().run({"pattern": "*.py", "path": d}, self.ctx)
-        self.assertIn(os.path.join(d, "a.py"), out)
-        self.assertIn(os.path.join(d, "sub", "b.py"), out)
+        self.assertIn(os.path.realpath(os.path.join(d, "a.py")), out)
+        self.assertIn(os.path.realpath(os.path.join(d, "sub", "b.py")), out)
         out1 = GlobTool().run({"pattern": "*.py", "path": d, "depth": 1}, self.ctx)
-        self.assertIn(os.path.join(d, "a.py"), out1)
-        self.assertNotIn(os.path.join(d, "sub", "b.py"), out1)
+        self.assertIn(os.path.realpath(os.path.join(d, "a.py")), out1)
+        self.assertNotIn(os.path.realpath(os.path.join(d, "sub", "b.py")), out1)
 
     @unittest.skipUnless(shutil.which("git"), "git not available")
     def test_glob_and_grep_use_git_backend_in_repo(self):
@@ -527,8 +536,8 @@ class TestGlobGrepTools(unittest.TestCase):
                 f.write(content)
         subprocess.run(["git", "add", "."], cwd=repo, check=True)
         out = GlobTool().run({"pattern": "*", "path": repo}, self.ctx)
-        self.assertIn(os.path.join(repo, "a.py"), out)
-        self.assertIn(os.path.join(repo, "b.txt"), out)
+        self.assertIn(os.path.realpath(os.path.join(repo, "a.py")), out)
+        self.assertIn(os.path.realpath(os.path.join(repo, "b.txt")), out)
         out = Grep().run({"regex": "hello", "path": repo}, self.ctx)
         self.assertIn("a.py", out)
         self.assertIn("hello", out)
@@ -537,6 +546,27 @@ class TestGlobGrepTools(unittest.TestCase):
         self.assertIn("a.py", out)
         self.assertIn("hello", out)
 
+    @unittest.skipUnless(shutil.which("git"), "git not available")
+    def test_glob_and_grep_work_through_symlinked_path(self):
+        """Regression: a search path that goes through a symlink (macOS
+        /var -> /private/var) must be resolved before the git backend
+        computes relpaths, or git rejects the pathspec as outside the
+        repository."""
+        real = self._mkdir("real")
+        link = os.path.join(self.tmp.name, "link")
+        os.symlink(real, link)
+        subprocess.run(["git", "init", "-q", real], check=True)
+        with open(os.path.join(real, "a.py"), "w") as f:
+            f.write("hello world\n")
+        subprocess.run(["git", "add", "."], cwd=real, check=True)
+        out = GlobTool().run({"pattern": "*", "path": link}, self.ctx)
+        self.assertNotIn("outside repository", out)
+        self.assertNotIn("Glob failed", out)
+        self.assertIn(os.path.realpath(os.path.join(real, "a.py")), out)
+        out = Grep().run({"regex": "hello", "path": link}, self.ctx)
+        self.assertIn("a.py", out)
+        self.assertIn("hello", out)
+
     def test_glob_nonexistent_path_errors(self):
         out = GlobTool().run(
             {"pattern": "*", "path": os.path.join(self.tmp.name, "nope")}, self.ctx
@@ -604,7 +634,7 @@ class TestEditTool(unittest.TestCase):
                 f.write("line1\nline2\nline3\n")
             ctx, sess = make_ctx()
             diff = "--- a/f.txt\n+++ b/f.txt\n@@ -1,3 +1,3 @@\n line1\n-line2\n+lineTWO\n line3\n"
-            result = Edit().run({"path": path, "new_str": diff, "diff": True}, ctx)
+            result = edit_tool().run({"path": path, "new_str": diff, "diff": True}, ctx)
             self.assertIn("Diff successfully applied", result)
             with open(path) as f:
                 self.assertEqual(f.read(), "line1\nlineTWO\nline3\n")
@@ -618,7 +648,7 @@ class TestEditTool(unittest.TestCase):
                 f.write(original)
             ctx, sess = make_ctx()
             bad_diff = "--- a/f.txt\n+++ b/f.txt\n@@ -1,2 +1,2 @@\n line1\n-NOPE\n+lineTWO\n"
-            result = Edit().run({"path": path, "new_str": bad_diff, "diff": True}, ctx)
+            result = edit_tool().run({"path": path, "new_str": bad_diff, "diff": True}, ctx)
             self.assertTrue(result.startswith("Error:"))
             with open(path) as f:
                 self.assertEqual(f.read(), original)  # unchanged on failure
@@ -1134,7 +1164,7 @@ class TestEditDiffModePatch(unittest.TestCase):
                 f.write("a\nb\nc\n")
             ctx, _ = make_ctx()
             diff = "```diff\n--- a/f.txt\n+++ b/f.txt\n@@ -1,3 +1,3 @@\n a\n-b\n+B\n c\n```\n"
-            result = Edit().run({"path": path, "new_str": diff, "diff": True}, ctx)
+            result = edit_tool().run({"path": path, "new_str": diff, "diff": True}, ctx)
             self.assertIn("Diff successfully applied", result)
             with open(path) as f:
                 self.assertEqual(f.read(), "a\nB\nc\n")
@@ -1148,7 +1178,7 @@ class TestEditDiffModePatch(unittest.TestCase):
                 f.write("a\nb\nc\n")
             ctx, _ = make_ctx()
             diff = "--- a/f.txt\n+++ b/f.txt\n@@ -1,9 +1,9 @@\n a\n-b\n+B\n c\n"
-            result = Edit().run({"path": path, "new_str": diff, "diff": True}, ctx)
+            result = edit_tool().run({"path": path, "new_str": diff, "diff": True}, ctx)
             self.assertIn("Diff successfully applied", result)
             with open(path) as f:
                 self.assertEqual(f.read(), "a\nB\nc\n")
@@ -1163,7 +1193,7 @@ class TestEditDiffModePatch(unittest.TestCase):
                 f.write("a\n--removed\nzzz\nc\n")
             ctx, _ = make_ctx()
             diff = "--- a/f.txt\n+++ b/f.txt\n@@ -1,9 +1,9 @@\n a\n---removed\n+++added\n c\n"
-            result = Edit().run({"path": path, "new_str": diff, "diff": True}, ctx)
+            result = edit_tool().run({"path": path, "new_str": diff, "diff": True}, ctx)
             self.assertIn("Diff successfully applied", result)
             with open(path) as f:
                 self.assertEqual(f.read(), "a\n++added\nzzz\nc\n")
@@ -1182,7 +1212,7 @@ class TestEditDiffModePatch(unittest.TestCase):
                 "@@ -2,3 +2,2 @@\n   id INT\n );\n--- old comment\n"
                 "@@ -6,1 +6,1 @@\n--- tail\n+-- new tail\n"
             )
-            result = Edit().run({"path": path, "new_str": diff, "diff": True}, ctx)
+            result = edit_tool().run({"path": path, "new_str": diff, "diff": True}, ctx)
             self.assertIn("Diff successfully applied", result)
             with open(path) as f:
                 self.assertEqual(
@@ -1204,7 +1234,7 @@ class TestEditDiffModePatch(unittest.TestCase):
                 "--- a/f2.txt\n+++ b/f2.txt\n@@ -1 +1 @@\n-two\n+TWO\n"
             )
             # Trailing slash -> patch runs inside the directory.
-            result = Edit().run({"path": d + os.sep, "new_str": diff, "diff": True}, ctx)
+            result = edit_tool().run({"path": d + os.sep, "new_str": diff, "diff": True}, ctx)
             self.assertIn("Diff successfully applied", result)
             with open(os.path.join(d, "f1.txt")) as f:
                 self.assertEqual(f.read(), "ONE\n")
@@ -1212,5 +1242,141 @@ class TestEditDiffModePatch(unittest.TestCase):
                 self.assertEqual(f.read(), "TWO\n")
 
 
+class TestEditMac(unittest.TestCase):
+    """The macOS Edit backend (pure-Python diff applier) must accept the
+    same model diffs that GNU patch accepts on Linux.  Run on every
+    platform so the macOS path is covered by Linux CI too."""
+
+    def _file(self, d: str, name: str, content: str) -> str:
+        path = os.path.join(d, name)
+        with open(path, "w") as f:
+            f.write(content)
+        return path
+
+    def test_dashed_content_line_ending_a_hunk_applies(self):
+        """The macOS CI failure: a removed line starting with -- as the
+        LAST body line of a hunk, followed by a second hunk.  Apple's
+        BSD patch rejects it; the Python applier must apply it."""
+        with tempfile.TemporaryDirectory() as d:
+            path = self._file(
+                d,
+                "schema.sql",
+                "CREATE TABLE t (\n  id INT\n);\n-- old comment\nSELECT 1;\n-- tail\n",
+            )
+            ctx, sess = make_ctx()
+            diff = (
+                "--- a/schema.sql\n+++ b/schema.sql\n"
+                "@@ -2,3 +2,2 @@\n   id INT\n );\n--- old comment\n"
+                "@@ -6,1 +6,1 @@\n--- tail\n+-- new tail\n"
+            )
+            result = EditMac().run({"path": path, "new_str": diff, "diff": True}, ctx)
+            self.assertIn("Diff successfully applied", result)
+            with open(path) as f:
+                self.assertEqual(
+                    f.read(), "CREATE TABLE t (\n  id INT\n);\nSELECT 1;\n-- new tail\n"
+                )
+            self.assertEqual(len(sess.recorded_diffs), 1)
+
+    def test_simple_replace_applies(self):
+        with tempfile.TemporaryDirectory() as d:
+            path = self._file(d, "f.txt", "line1\nline2\nline3\n")
+            ctx, sess = make_ctx()
+            diff = "--- a/f.txt\n+++ b/f.txt\n@@ -1,3 +1,3 @@\n line1\n-line2\n+lineTWO\n line3\n"
+            result = EditMac().run({"path": path, "new_str": diff, "diff": True}, ctx)
+            self.assertIn("Diff successfully applied", result)
+            with open(path) as f:
+                self.assertEqual(f.read(), "line1\nlineTWO\nline3\n")
+            self.assertEqual(len(sess.recorded_diffs), 1)
+
+    def test_wrong_hunk_counts_recounted(self):
+        with tempfile.TemporaryDirectory() as d:
+            path = self._file(d, "f.txt", "a\nb\nc\n")
+            ctx, _ = make_ctx()
+            diff = "--- a/f.txt\n+++ b/f.txt\n@@ -1,9 +1,9 @@\n a\n-b\n+B\n c\n"
+            result = EditMac().run({"path": path, "new_str": diff, "diff": True}, ctx)
+            self.assertIn("Diff successfully applied", result)
+            with open(path) as f:
+                self.assertEqual(f.read(), "a\nB\nc\n")
+
+    def test_fenced_diff_applies(self):
+        with tempfile.TemporaryDirectory() as d:
+            path = self._file(d, "f.txt", "a\nb\nc\n")
+            ctx, _ = make_ctx()
+            diff = "```diff\n--- a/f.txt\n+++ b/f.txt\n@@ -1,3 +1,3 @@\n a\n-b\n+B\n c\n```\n"
+            result = EditMac().run({"path": path, "new_str": diff, "diff": True}, ctx)
+            self.assertIn("Diff successfully applied", result)
+            with open(path) as f:
+                self.assertEqual(f.read(), "a\nB\nc\n")
+
+    def test_dashed_content_lines_apply(self):
+        with tempfile.TemporaryDirectory() as d:
+            path = self._file(d, "f.txt", "a\n--removed\nzzz\nc\n")
+            ctx, _ = make_ctx()
+            diff = "--- a/f.txt\n+++ b/f.txt\n@@ -1,9 +1,9 @@\n a\n---removed\n+++added\n c\n"
+            result = EditMac().run({"path": path, "new_str": diff, "diff": True}, ctx)
+            self.assertIn("Diff successfully applied", result)
+            with open(path) as f:
+                self.assertEqual(f.read(), "a\n++added\nzzz\nc\n")
+
+    def test_mismatch_errors_and_leaves_file_untouched(self):
+        with tempfile.TemporaryDirectory() as d:
+            path = self._file(d, "f.txt", "line1\nline2\nline3\n")
+            ctx, sess = make_ctx()
+            bad_diff = "--- a/f.txt\n+++ b/f.txt\n@@ -1,2 +1,2 @@\n line1\n-NOPE\n+lineTWO\n"
+            result = EditMac().run({"path": path, "new_str": bad_diff, "diff": True}, ctx)
+            self.assertTrue(result.startswith("Error:"))
+            with open(path) as f:
+                self.assertEqual(f.read(), "line1\nline2\nline3\n")
+            self.assertEqual(sess.recorded_diffs, [])
+
+    def test_directory_multifile_diff_applies(self):
+        with tempfile.TemporaryDirectory() as d:
+            self._file(d, "f1.txt", "one\n")
+            self._file(d, "f2.txt", "two\n")
+            ctx, _ = make_ctx()
+            diff = (
+                "--- a/f1.txt\n+++ b/f1.txt\n@@ -1 +1 @@\n-one\n+ONE\n"
+                "--- a/f2.txt\n+++ b/f2.txt\n@@ -1 +1 @@\n-two\n+TWO\n"
+            )
+            result = EditMac().run({"path": d + os.sep, "new_str": diff, "diff": True}, ctx)
+            self.assertIn("Diff successfully applied", result)
+            with open(os.path.join(d, "f1.txt")) as f:
+                self.assertEqual(f.read(), "ONE\n")
+            with open(os.path.join(d, "f2.txt")) as f:
+                self.assertEqual(f.read(), "TWO\n")
+
+    def test_insert_only_hunk(self):
+        with tempfile.TemporaryDirectory() as d:
+            path = self._file(d, "f.txt", "a\nc\n")
+            ctx, _ = make_ctx()
+            diff = "--- a/f.txt\n+++ b/f.txt\n@@ -1,1 +1,2 @@\n a\n+b\n c\n"
+            result = EditMac().run({"path": path, "new_str": diff, "diff": True}, ctx)
+            self.assertIn("Diff successfully applied", result)
+            with open(path) as f:
+                self.assertEqual(f.read(), "a\nb\nc\n")
+
+    def test_fuzz_matches_context_one_line_off(self):
+        """A context line that does not match (model drift) still
+        applies when the removed lines match, up to the fuzz limit."""
+        with tempfile.TemporaryDirectory() as d:
+            path = self._file(d, "f.txt", "x\na\nzzz\nc\n")
+            ctx, _ = make_ctx()
+            diff = "--- a/f.txt\n+++ b/f.txt\n@@ -1,3 +1,3 @@\n a\n-zzz\n+c\n"
+            result = EditMac().run({"path": path, "new_str": diff, "diff": True}, ctx)
+            self.assertIn("Diff successfully applied", result)
+            with open(path) as f:
+                self.assertEqual(f.read(), "x\na\nc\nc\n")
+
+    def test_no_newline_at_eof_handled(self):
+        with tempfile.TemporaryDirectory() as d:
+            path = self._file(d, "f.txt", "a\nb")
+            ctx, _ = make_ctx()
+            diff = "--- a/f.txt\n+++ b/f.txt\n@@ -1,2 +1,2 @@\n a\n-b\n+b\n\\n"
+            result = EditMac().run({"path": path, "new_str": diff, "diff": True}, ctx)
+            self.assertIn("Diff successfully applied", result)
+            with open(path) as f:
+                self.assertEqual(f.read(), "a\nb")
+
+
 if __name__ == "__main__":
     unittest.main()

{python_agent_harness-1.5.4.2 → python_agent_harness-1.5.4.3}/tests/test_invariants.py

@@ -780,6 +780,32 @@ class TestPlanModeWriteGuard(unittest.TestCase):
             with open(plan_file) as f:
                 self.assertEqual(f.read(), "via link")
 
+    def test_plan_file_writable_when_temp_dir_is_symlinked(self):
+        """Regression: when the plan dir goes through a symlink (macOS
+        TMPDIR /var -> /private/var), the plan file must still be
+        recognized as the plan file and stay writable in plan mode."""
+        with tempfile.TemporaryDirectory(prefix="pah-prop-plan-") as tmpdir:
+            real = os.path.join(tmpdir, "real")
+            os.makedirs(real)
+            link = os.path.join(tmpdir, "link")
+            os.symlink(real, link)
+            with mock.patch(
+                "python_agent_harness.planmode._plan_temp_dir",
+                return_value=link,
+            ):
+                session = self.make_plan_session(tmpdir)
+            plan_file = session.plan_mode.plan_file
+            self.assertTrue(os.path.isfile(plan_file))
+            dirname, basename = os.path.split(plan_file)
+            r = session.execute_tool(
+                "Write",
+                {"path": dirname, "filename": basename, "content": "# plan\n"},
+                call_id="w1",
+            )
+            self.assertNotIn("blocked by plan mode", r)
+            with open(plan_file) as f:
+                self.assertEqual(f.read(), "# plan\n")
+
     def test_read_only_tools_pass_through_plan_mode(self):
         with tempfile.TemporaryDirectory(prefix="pah-prop-plan-") as tmpdir:
             session = self.make_plan_session(tmpdir)

{python_agent_harness-1.5.4.2 → python_agent_harness-1.5.4.3}/tests/test_prompts.py

@@ -200,7 +200,7 @@ class TestIndexSkills(unittest.TestCase):
                 encoding="utf-8",
             )
             index = index_skills(d)
-            self.assertEqual(index, {"天气预报助手": (str(skill), "does things")})
+            self.assertEqual(index, {"天气预报助手": (os.path.realpath(skill), "does things")})
 
     def test_no_frontmatter_name_skipped(self):
         with tempfile.TemporaryDirectory() as d:
@@ -219,7 +219,7 @@ class TestIndexSkills(unittest.TestCase):
             skill = sub / "SKILL.md"
             skill.write_text("---\nname: linked-skill\n---\nbody", encoding="utf-8")
             os.symlink(sub, Path(d) / "linked")
-            self.assertEqual(index_skills(d)["linked-skill"][0], str(skill))
+            self.assertEqual(index_skills(d)["linked-skill"][0], os.path.realpath(skill))
 
 
 class TestLoadContextFiles(unittest.TestCase):

{python_agent_harness-1.5.4.2 → python_agent_harness-1.5.4.3}/tests/test_session.py

@@ -152,7 +152,10 @@ class TestFindSkill(unittest.TestCase):
             with open(os.path.join(sub, "SKILL.md"), "w") as f:
                 f.write("---\nname: my-rules\ndescription: rules\n---\n# Rules")
             session._skill_dir = d
-            self.assertEqual(session.find_skill("my-rules"), os.path.join(sub, "SKILL.md"))
+            self.assertEqual(
+                session.find_skill("my-rules"),
+                os.path.realpath(os.path.join(sub, "SKILL.md")),
+            )
 
     def test_frontmatter_name_differs_from_directory_name(self):
         """Regression test: the advertised name (frontmatter) must
@@ -165,7 +168,10 @@ class TestFindSkill(unittest.TestCase):
             with open(os.path.join(sub, "SKILL.md"), "w") as f:
                 f.write("---\nname: 天气预报助手\n---\n# body")
             session._skill_dir = d
-            self.assertEqual(session.find_skill("天气预报助手"), os.path.join(sub, "SKILL.md"))
+            self.assertEqual(
+                session.find_skill("天气预报助手"),
+                os.path.realpath(os.path.join(sub, "SKILL.md")),
+            )
 
     def test_nested_skill_dir_discovered(self):
         session = RecordingSession()
@@ -175,7 +181,10 @@ class TestFindSkill(unittest.TestCase):
             with open(os.path.join(nested, "SKILL.md"), "w") as f:
                 f.write("---\nname: deep-skill\n---\nbody")
             session._skill_dir = d
-            self.assertEqual(session.find_skill("deep-skill"), os.path.join(nested, "SKILL.md"))
+            self.assertEqual(
+                session.find_skill("deep-skill"),
+                os.path.realpath(os.path.join(nested, "SKILL.md")),
+            )
 
     def test_flat_file_without_frontmatter_returns_none(self):
         """Flat files (skills/style.md) are no longer resolvable: only
@@ -210,7 +219,10 @@ class TestFindSkill(unittest.TestCase):
                 f.write("---\nname: linked-skill\n---\n# Linked")
             os.symlink(sub, os.path.join(d, "linked"))
             session._skill_dir = d
-            self.assertEqual(session.find_skill("linked-skill"), os.path.join(sub, "SKILL.md"))
+            self.assertEqual(
+                session.find_skill("linked-skill"),
+                os.path.realpath(os.path.join(sub, "SKILL.md")),
+            )
 
     def test_traversal_skill_returns_none(self):
         """Path-traversal inputs are inert: lookup only matches names in