python-agent-harness 1.5.5.2__tar.gz → 1.5.5.4__tar.gz

{python_agent_harness-1.5.5.2/python_agent_harness.egg-info → python_agent_harness-1.5.5.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-agent-harness
-Version: 1.5.5.2
+Version: 1.5.5.4
 Summary: A lightweight, hackable mini-OpenCode written in Python.
 Author-email: Huming Chen <chenhuming@gmail.com>
 License-Expression: MIT
@@ -9,6 +9,7 @@ Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
 Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: POSIX :: Linux
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
@@ -276,7 +277,7 @@ python_agent_harness/
 
 ## Development
 
-Requires Python ≥ 3.11. CI runs against Python 3.11, 3.12, and 3.13 on Linux and macOS.
+Requires Python ≥ 3.11. CI runs against Python 3.11, 3.12, and 3.13 on Linux, MacOS and Windows.
 
 ```sh
 make test                           # unit tests

{python_agent_harness-1.5.5.2 → python_agent_harness-1.5.5.4}/README.md

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

{python_agent_harness-1.5.5.2 → python_agent_harness-1.5.5.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-agent-harness"
-version = "1.5.5.2"
+version = "1.5.5.4"
 description = "A lightweight, hackable mini-OpenCode written in Python."
 authors = [
     {name = "Huming Chen", email = "chenhuming@gmail.com"}
@@ -17,6 +17,7 @@ classifiers = [
     "Environment :: Console",
     "Intended Audience :: Developers",
     "Operating System :: MacOS",
+    "Operating System :: Microsoft :: Windows",
     "Operating System :: POSIX :: Linux",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",

{python_agent_harness-1.5.5.2 → python_agent_harness-1.5.5.4}/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.5.2"
+__version__ = "1.5.5.4"
 
 __all__ = [
     "Session",

{python_agent_harness-1.5.5.2 → python_agent_harness-1.5.5.4}/python_agent_harness/cli.py

@@ -9,7 +9,7 @@ sessions, restore and summary/explain — are TUI slash commands only;
 they are NOT registered as CLI subcommands.
 
 Configuration (LLM etc.) is read from a JSON file, by default
-~/.config/python-agent-harness/config.json; see `config --init`.
+from the OS config directory; see `config --init`.
 """
 
 from __future__ import annotations
@@ -125,7 +125,11 @@ def make_session(
     )
     if default_agent and default_agent != RESERVED_AGENT_NAME:
         ok, msg = session.switch_agent(default_agent)
-        if not ok:
+        if ok:
+            # record the applied agent so saved sessions restore it;
+            # switch_agent("default") clears it again
+            session.store.agent = default_agent
+        else:
             # A typo'd/missing default_agent must not silently start the
             # session with the built-in prompt — record the config error
             # so the TUI can surface it (see Tui.run).
@@ -175,7 +179,7 @@ def cmd_config(args: argparse.Namespace) -> int:
         if path.exists() and not args.force:
             print(f"config already exists: {path} (use --force to overwrite)")
             return 1
-        template = config.CONFIG_TEMPLATE.format(path=path)
+        template = config.CONFIG_TEMPLATE.format(path=str(path).replace("\\", "\\\\"))
         path.write_text(template, encoding="utf-8")
         print(f"wrote config template: {path}")
         return 0
@@ -250,7 +254,7 @@ def _add_config_arg(parser: argparse.ArgumentParser, suppress: bool = False) ->
         "--config",
         metavar="PATH",
         default=argparse.SUPPRESS if suppress else None,
-        help="path to config.json (default: ~/.config/python-agent-harness/config.json)",
+        help="path to config.json (default: OS config dir / python-agent-harness / config.json)",
     )
 
 

{python_agent_harness-1.5.5.2 → python_agent_harness-1.5.5.4}/python_agent_harness/client.py

@@ -13,6 +13,7 @@ import os
 import random
 import socket as _socket
 import sys
+import tempfile
 import threading
 import time
 import uuid
@@ -128,7 +129,7 @@ def _llm_log_path() -> Path:
         d = Path(log_dir)
         d.mkdir(parents=True, exist_ok=True)
         return d / f"python-agent-harness-{date_str}-{session_id}.json"
-    return Path(f"/tmp/python-agent-harness-{date_str}-{session_id}.json")
+    return Path(tempfile.gettempdir()) / f"python-agent-harness-{date_str}-{session_id}.json"
 
 
 def _log_llm_interaction(
@@ -196,8 +197,12 @@ def _resolve_ca_bundle() -> str | bool:
         "/etc/pki/tls/certs/ca-bundle.crt",
         "/etc/ssl/certs/ca-certificates.crt",
         "/etc/ssl/ca-bundle.pem",
+        # Windows (Git for Windows, conda, etc.)
+        os.path.join(os.environ.get("PROGRAMFILES", ""), "Git", "mingw64", "ssl", "cert.pem"),
+        os.path.join(os.environ.get("PROGRAMFILES(X86)", ""), "Git", "mingw64", "ssl", "cert.pem"),
+        os.path.join(os.environ.get("CONDA_PREFIX", ""), "ssl", "cert.pem"),
     ):
-        if os.path.isfile(cand):
+        if cand and os.path.isfile(cand):
             return cand
     return True
 
@@ -877,9 +882,16 @@ def _shutdown_and_close(sock: _socket.socket) -> None:
     after, so a new socket could reuse the fd number before the
     reader observed the EOF.  The grace sleep delays the fd release
     so the woken thread can observe the EOF on the old fd first.
+
+    On Windows, ``shutdown(SHUT_RDWR)`` on the client socket causes
+    ``WinError 10058`` on the server side when it tries to read,
+    producing noisy BrokenPipeError tracebacks.  Skipping shutdown
+    and just closing the fd is sufficient — Windows ``close()``
+    triggers a TCP RST that reliably wakes the blocked read.
     """
-    with contextlib.suppress(OSError):
-        sock.shutdown(_socket.SHUT_RDWR)
+    if sys.platform != "win32":
+        with contextlib.suppress(OSError):
+            sock.shutdown(_socket.SHUT_RDWR)
     if sys.platform == "darwin":
         # macOS only; on Linux shutdown() alone reliably wakes the
         # blocked recv (measured: <200ms unblock, no sleeps needed).

{python_agent_harness-1.5.5.2 → python_agent_harness-1.5.5.4}/python_agent_harness/config.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import json
 import os
+import sys
 from pathlib import Path
 
 from .mcp.config import MCPConfig
@@ -50,7 +51,10 @@ CALIBRATION_MIN = 0.5
 CALIBRATION_MAX = 3.0
 
 # ---- sessions ---------------------------------------------------------------
-SESSION_DIR = Path(os.environ.get("XDG_DATA_HOME", Path.home() / ".local" / "share"))
+if sys.platform == "win32":
+    SESSION_DIR = Path(os.environ.get("LOCALAPPDATA", Path.home() / "AppData" / "Local"))
+else:
+    SESSION_DIR = Path(os.environ.get("XDG_DATA_HOME", Path.home() / ".local" / "share"))
 SESSION_SUBDIR = "python-agent-harness/sessions"
 AUTO_SAVE_SESSION = True
 
@@ -164,9 +168,15 @@ DEFAULT_AGENT_PROMPT_FILE = PROMPTS_DIR / "agent.md"
 DEFAULT_SUBAGENT_PROMPT_FILE = PROMPTS_DIR / "subagent.md"
 
 # ---- configuration file ---------------------------------------------------------
-CONFIG_DIR = (
-    Path(os.environ.get("XDG_CONFIG_HOME", Path.home() / ".config")) / "python-agent-harness"
-)
+if sys.platform == "win32":
+    CONFIG_DIR = (
+        Path(os.environ.get("APPDATA", Path.home() / "AppData" / "Roaming"))
+        / "python-agent-harness"
+    )
+else:
+    CONFIG_DIR = (
+        Path(os.environ.get("XDG_CONFIG_HOME", Path.home() / ".config")) / "python-agent-harness"
+    )
 CONFIG_FILE = CONFIG_DIR / "config.json"
 
 DEFAULT_LLM: dict = {

{python_agent_harness-1.5.5.2 → python_agent_harness-1.5.5.4}/python_agent_harness/persistence.py

@@ -112,9 +112,11 @@ class SessionPersistence:
         max_tokens: int | None = None,
         tool_names: list[str] | None = None,
         round_times: list[float] | None = None,
+        agent: str | None = None,
     ) -> None:
         self.project_dir = project_dir
         self.model = model
+        self.agent = agent
         self.system_prompt = system_prompt
         self.temperature = temperature
         self.max_tokens = max_tokens
@@ -171,6 +173,7 @@ class SessionPersistence:
         pairs = [
             ("python-agent-harness--project-dir", self.project_dir),
             ("python-agent-harness--model", self.model),
+            ("python-agent-harness--agent", self.agent),
         ]
         for name, value in pairs:
             if value is None:

{python_agent_harness-1.5.5.2 → python_agent_harness-1.5.5.4}/python_agent_harness/session.py

@@ -162,6 +162,12 @@ class Session:
         # cache build simultaneously — double-checked locking prevents
         # redundant filesystem scans and the data race on the cache tuple
         self._skill_index_lock = threading.Lock()
+        # NOTE: the store does NOT record ``default_agent`` here: the
+        # store's agent must reflect the agent actually applied, and
+        # only a successful switch_agent() can guarantee that (a typo'd
+        # default_agent is reported as a startup warning and the session
+        # keeps the built-in prompt).  cli.make_session applies the
+        # default_agent right after construction, which sets it.
         self.store = SessionPersistence(
             project_dir=project_dir,
             model=model,
@@ -731,6 +737,7 @@ class Session:
         if name == RESERVED_AGENT_NAME:
             self.system_prompt = self._default_system_prompt
             self.store.system_prompt = self._default_system_prompt
+            self.store.agent = None
             return True, "switched to default agent"
 
         agents = discover_agents()
@@ -749,6 +756,7 @@ class Session:
             context_path=self._configured_context_path,
         )
         self.store.system_prompt = self.system_prompt
+        self.store.agent = name
         return True, f"switched to {name}"
 
     # ------------------------------------------------------------------

{python_agent_harness-1.5.5.2 → python_agent_harness-1.5.5.4}/python_agent_harness/tools/__init__.py

@@ -7,11 +7,15 @@ import sys
 from .agent_tool import AgentTool
 from .base import PendingToolResult, Registry, Tool, ToolContext
 from .bash import Bash
+from .bash_win import BashWindows
 from .edit import Edit
 from .edit_mac import EditMac
+from .edit_win import EditWindows
 from .filesystem import GlobTool, Grep, Insert, Mkdir, Read, Write
 from .glob_mac import GlobMac
+from .glob_win import GlobWindows
 from .grep_mac import GrepMac
+from .grep_win import GrepWindows
 from .mcp import MCPTool, mcp_tools_from_manager, normalize_mcp_result
 from .planexit import PlanExit
 from .question import Question
@@ -25,12 +29,16 @@ __all__ = [
     "ToolContext",
     "AgentTool",
     "Bash",
+    "BashWindows",
     "Edit",
     "EditMac",
+    "EditWindows",
     "GlobMac",
     "GlobTool",
+    "GlobWindows",
     "Grep",
     "GrepMac",
+    "GrepWindows",
     "Insert",
     "MCPTool",
     "Mkdir",
@@ -50,10 +58,15 @@ def default_registry() -> Registry:
     # macOS lacks GNU `patch`, `tree`, and PCRE-enabled git — use
     # pure-Python / POSIX-compatible Mac variants that register under
     # the same tool names so callers are platform-independent.
+    # Windows lacks process groups, select on pipes, SIGKILL, `patch`,
+    # `tree`, `find`, and `grep` — Windows variants use pure-Python
+    # fallbacks and CREATE_NEW_PROCESS_GROUP + taskkill instead.
     _mac = sys.platform == "darwin"
-    edit_tool = EditMac() if _mac else Edit()
-    glob_tool = GlobMac() if _mac else GlobTool()
-    grep_tool = GrepMac() if _mac else Grep()
+    _win = sys.platform == "win32"
+    edit_tool = EditWindows() if _win else EditMac() if _mac else Edit()
+    glob_tool = GlobWindows() if _win else GlobMac() if _mac else GlobTool()
+    grep_tool = GrepWindows() if _win else GrepMac() if _mac else Grep()
+    bash_tool = BashWindows() if _win else Bash()
     for tool in (
         AgentTool(),
         TodoWrite(),
@@ -64,7 +77,7 @@ def default_registry() -> Registry:
         edit_tool,
         Write(),
         Mkdir(),
-        Bash(),
+        bash_tool,
         Skill(),
         Question(),
     ):

{python_agent_harness-1.5.5.2 → python_agent_harness-1.5.5.4}/python_agent_harness/tools/bash.py

@@ -30,6 +30,7 @@ import os
 import select
 import signal
 import subprocess
+import sys
 import threading
 import time
 from collections import deque
@@ -56,7 +57,7 @@ def _kill_pgid(pgid: int) -> None:
     stdout pipe open is still running in the group.
     """
     with contextlib.suppress(ProcessLookupError, PermissionError, OSError):
-        os.killpg(pgid, signal.SIGKILL)
+        os.killpg(pgid, signal.SIGKILL)  # pyright: ignore[reportAttributeAccessIssue]
 
 
 def _kill_graceful(pgid: int, proc: subprocess.Popen) -> None:
@@ -66,7 +67,7 @@ def _kill_graceful(pgid: int, proc: subprocess.Popen) -> None:
     children before the hard kill.
     """
     with contextlib.suppress(ProcessLookupError, PermissionError, OSError):
-        os.killpg(pgid, signal.SIGTERM)
+        os.killpg(pgid, signal.SIGTERM)  # pyright: ignore[reportAttributeAccessIssue]
     try:
         proc.wait(timeout=2)
     except subprocess.TimeoutExpired:
@@ -144,7 +145,8 @@ def _collect_output(proc: subprocess.Popen, cancel: threading.Event | None) -> t
     if stdout is None:  # unreachable (stdout=PIPE), kept for the type checker
         return "", "ok"
     fd = stdout.fileno()
-    os.set_blocking(fd, False)
+    if sys.platform != "win32":
+        os.set_blocking(fd, False)  # pyright: ignore[reportAttributeAccessIssue]
     decoder = codecs.getincrementaldecoder("utf-8")(errors="replace")
     head: list[str] = []
     head_len = 0

python_agent_harness-1.5.5.4/python_agent_harness/tools/bash_win.py

@@ -0,0 +1,232 @@
+"""Windows Bash tool: process management for win32.
+
+Windows lacks ``os.killpg``, ``os.set_blocking``, ``select.select``
+on pipe fds, and ``start_new_session``.  This subclass overrides
+``_execute`` to use Windows-native process creation and termination
+while inheriting the shared output-truncation, timeout, and exit-code
+helpers from :class:`Bash`.
+
+Process creation uses ``CREATE_NEW_PROCESS_GROUP`` so the child is
+isolated from console Ctrl-C signals (the TUI handles cancel itself).
+Process termination uses ``taskkill /F /T /PID`` to kill the process
+and all its children (the Windows equivalent of killing a process
+group).  Output is collected via a reader thread + queue, since
+``select.select`` cannot poll Windows pipes.
+
+Only the process-creation and output-collection strategy differs;
+the tool name, description, parameters, timeout semantics, and
+exit-code reporting are inherited so callers, the tool registry,
+and the plan-mode write guard are platform-independent.
+"""
+
+from __future__ import annotations
+
+import codecs
+import contextlib
+import os
+import queue
+import subprocess
+import threading
+import time
+from collections import deque
+
+from ..config import BASH_TIMEOUT_MAX, BASH_TIMEOUT_SILENCE
+from ..config import MAX_OUTPUT_CHARS as _MAX_OUTPUT
+from .base import PendingToolResult, ToolContext
+from .bash import (
+    _DRAIN_GRACE,
+    _POLL_INTERVAL,
+    _READ_CHUNK,
+    _TAIL_LINES,
+    Bash,
+    _append_exit_code,
+    _assemble_truncated,
+    _timeout_message,
+)
+
+
+def _kill_process_tree(pid: int) -> None:
+    """Kill the process PID and all its children (Windows equivalent of
+    ``os.killpg`` with ``SIGKILL``).
+
+    Uses ``taskkill /F /T /PID`` which recursively terminates the
+    process tree.  Errors are suppressed (already gone, etc.).
+    """
+    with contextlib.suppress(Exception):
+        subprocess.run(
+            ["taskkill", "/F", "/T", "/PID", str(pid)],
+            stdin=subprocess.DEVNULL,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            timeout=10,
+        )
+
+
+def _kill_process_tree_graceful(pid: int, proc: subprocess.Popen) -> None:
+    """Graceful kill: terminate, then taskkill /F /T if still alive.
+
+    Windows has no SIGTERM equivalent for process trees;
+    ``proc.terminate()`` calls ``TerminateProcess`` on the immediate
+    child.  If it doesn't die within 2s, ``taskkill /F /T`` force-kills
+    the whole tree (children included).
+    """
+    with contextlib.suppress(ProcessLookupError, OSError):
+        proc.terminate()
+    try:
+        proc.wait(timeout=2)
+    except subprocess.TimeoutExpired:
+        _kill_process_tree(pid)
+
+
+def _collect_output_win(proc: subprocess.Popen, cancel: threading.Event | None) -> tuple[str, str]:
+    """Read PROC's merged output on Windows; return (text, status).
+
+    Windows lacks ``select.select`` on pipe fds and ``os.set_blocking``,
+    so a reader thread does blocking ``os.read`` calls and feeds chunks
+    into a ``queue.Queue``.  The collector polls the queue with
+    ``_POLL_INTERVAL``, checking cancel/timeout conditions between
+    reads — mirroring the Unix ``_collect_output`` logic exactly.
+
+    Status is one of ``"ok"``, ``"cancelled"``, ``"timeout_silence"``,
+    ``"timeout_max"``.  Keeps the head (first ``_MAX_OUTPUT`` chars)
+    and the tail (last ``_TAIL_LINES`` lines) and discards the middle,
+    so memory stays bounded no matter how much the process writes.
+    """
+    stdout = proc.stdout
+    if stdout is None:
+        return "", "ok"
+
+    chunk_queue: queue.Queue[bytes | None] = queue.Queue()
+
+    def _reader() -> None:
+        """Blocking reader thread: reads raw bytes and feeds the queue."""
+        try:
+            fd = stdout.fileno()
+            while True:
+                raw = os.read(fd, _READ_CHUNK)
+                if not raw:
+                    break
+                chunk_queue.put(raw)
+        except OSError:
+            pass
+        finally:
+            chunk_queue.put(None)
+
+    threading.Thread(target=_reader, daemon=True).start()
+
+    decoder = codecs.getincrementaldecoder("utf-8")(errors="replace")
+    head: list[str] = []
+    head_len = 0
+    tail: deque[str] = deque(maxlen=_TAIL_LINES)
+    pending_line = ""
+    total = 0
+    exited = False
+    drain_until: float | None = None
+    start = time.monotonic()
+    last_output = start
+
+    def finish() -> str:
+        nonlocal pending_line
+        if pending_line:
+            if len(pending_line) > _MAX_OUTPUT:
+                pending_line = pending_line[:_MAX_OUTPUT]
+            tail.append(pending_line)
+        head_text = "".join(head)
+        if total > _MAX_OUTPUT:
+            return _assemble_truncated(head_text, tail)
+        return head_text
+
+    while True:
+        if cancel is not None and cancel.is_set():
+            return "", "cancelled"
+        now = time.monotonic()
+        if not exited:
+            if BASH_TIMEOUT_SILENCE is not None and now - last_output >= BASH_TIMEOUT_SILENCE:
+                return finish(), "timeout_silence"
+            if BASH_TIMEOUT_MAX is not None and now - start >= BASH_TIMEOUT_MAX:
+                return finish(), "timeout_max"
+        if exited and drain_until is not None and now >= drain_until:
+            break
+        try:
+            raw = chunk_queue.get(timeout=_POLL_INTERVAL)
+        except queue.Empty:
+            if not exited and proc.poll() is not None:
+                exited = True
+                drain_until = time.monotonic() + _DRAIN_GRACE
+            continue
+        if raw is None:
+            break
+        chunk = decoder.decode(raw).replace("\r\n", "\n")
+        total += len(chunk)
+        last_output = time.monotonic()
+        if head_len < _MAX_OUTPUT:
+            take = chunk[: _MAX_OUTPUT - head_len]
+            head.append(take)
+            head_len += len(take)
+        parts = chunk.split("\n")
+        parts[0] = pending_line + parts[0]
+        pending_line = parts.pop()
+        for line in parts:
+            if len(line) > _MAX_OUTPUT:
+                line = line[:_MAX_OUTPUT]
+            tail.append(line)
+    return finish(), "ok"
+
+
+class BashWindows(Bash):
+    """Bash for Windows: ``CREATE_NEW_PROCESS_GROUP`` + ``taskkill``.
+
+    Overrides :meth:`_execute` to use Windows-native process creation
+    (``CREATE_NEW_PROCESS_GROUP``) and termination (``taskkill /F /T``).
+    All shared logic — timeout messages, output truncation, exit-code
+    reporting, the ``PendingToolResult`` async contract — is inherited
+    unchanged from :class:`Bash`.
+    """
+
+    def _execute(self, command: str, ctx: ToolContext) -> str | PendingToolResult:
+        cancel = ctx.cancel_event
+        if cancel is not None and cancel.is_set():
+            return "Error: Bash command cancelled."
+        try:
+            proc = subprocess.Popen(
+                command,
+                shell=True,
+                stdin=subprocess.DEVNULL,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                bufsize=0,
+                cwd=ctx.cwd,
+                creationflags=getattr(subprocess, "CREATE_NEW_PROCESS_GROUP", 0),
+            )
+        except OSError as e:
+            return f"Error: {e}"
+
+        pid = proc.pid
+        pending = PendingToolResult()
+
+        def deliverer() -> None:
+            try:
+                out, status = _collect_output_win(proc, cancel)
+            except Exception as e:  # noqa: BLE001 - delivered as an error string
+                out = f"Error: Bash failed — {e}"
+            else:
+                if status == "cancelled":
+                    _kill_process_tree(pid)
+                    out = "Error: Bash command cancelled."
+                elif status == "timeout_silence":
+                    _kill_process_tree_graceful(pid, proc)
+                    out = _timeout_message(out, silence=True)
+                elif status == "timeout_max":
+                    _kill_process_tree_graceful(pid, proc)
+                    out = _timeout_message(out, silence=False)
+                elif status == "ok":
+                    out = _append_exit_code(out, proc)
+            pending.deliver(out)
+            with contextlib.suppress(Exception):
+                if proc.stdout is not None:
+                    proc.stdout.close()
+            with contextlib.suppress(Exception):
+                proc.wait(timeout=2)
+
+        threading.Thread(target=deliverer, daemon=True).start()
+        return pending

{python_agent_harness-1.5.5.2 → python_agent_harness-1.5.5.4}/python_agent_harness/tools/diffapply.py

@@ -48,7 +48,7 @@ class _Hunk:
         """(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 (" ", "-")
+            (kind, content.rstrip("\r\n")) for kind, content, _ in self.body if kind in (" ", "-")
         ]
 
 
@@ -142,7 +142,7 @@ def _match_hunk(hunk: _Hunk, file_lines: list[str]) -> int | None:
         mismatches = 0
         ok = True
         for i, (kind, content) in enumerate(old_seq):
-            file_content = file_lines[p + i].rstrip("\n")
+            file_content = file_lines[p + i].rstrip("\r\n")
             if kind == "-":
                 if file_content != content:
                     ok = False

python_agent_harness-1.5.5.4/python_agent_harness/tools/edit_win.py

@@ -0,0 +1,56 @@
+"""Windows Edit tool: pure-Python diff applier (no ``patch`` binary).
+
+Windows does not ship ``patch.exe``, so the diff/patch mode of
+:class:`Edit` (which shells out to ``patch --forward``) fails on a
+stock Windows install.  The pure-Python applier (``diffapply.py``)
+parses the diff structurally and matches hunks with fuzz, so the same
+diffs apply on Windows, macOS, and Linux.
+
+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.
+
+The implementation is identical to :class:`EditMac` — both platforms
+lack a reliable ``patch`` binary and use the same Python applier.
+"""
+
+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 EditWindows(Edit):
+    """Edit with a pure-Python diff/patch backend for Windows."""
+
+    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.5.2 → python_agent_harness-1.5.5.4}/python_agent_harness/tools/glob.py

@@ -156,10 +156,10 @@ def _git_glob_results(raw: str, git_root: str, base: str, depth: object) -> str:
     """
     lines = [line for line in raw.split("\0") if line]
     if _natnump(depth):
-        rel_base = os.path.relpath(base, git_root)
+        rel_base = os.path.relpath(base, git_root).replace(os.sep, "/")
         base_depth = 0 if rel_base == "." else 1 + rel_base.count("/")
         lines = [line for line in lines if line.count("/") < base_depth + depth]
-    out = "\n".join(os.path.join(git_root, line) for line in lines)
+    out = "\n".join(os.path.join(git_root, line).replace(os.sep, "/") for line in lines)
     if not out:
         return ""
     return _spool(out + "\n", "glob")