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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-agent-harness
-Version: 1.5.5.2
+Version: 1.5.5.3
 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.3}/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.3}/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.3"
 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.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.5.2"
+__version__ = "1.5.5.3"
 
 __all__ = [
     "Session",

{python_agent_harness-1.5.5.2 → python_agent_harness-1.5.5.3}/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
@@ -175,7 +175,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 +250,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.3}/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.3}/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.3}/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.3}/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.3/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.3/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.3}/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")

python_agent_harness-1.5.5.3/python_agent_harness/tools/glob_win.py

@@ -0,0 +1,90 @@
+"""Windows Glob tool: ``git ls-files`` inside git repos, ``pathlib`` outside.
+
+Windows ships neither ``tree`` nor ``find``, so the non-git fallback
+in :class:`GlobTool` (which shells out to ``tree``) and the macOS
+variant :class:`GlobMac` (which shells out to ``find``) both fail on
+a stock Windows install.  ``GlobWindows`` replaces that fallback with
+a pure-Python :meth:`pathlib.Path.rglob` approach: Python handles
+directory traversal, pattern matching, and mtime sorting.
+
+This is slower than the C-based ``tree``/``find`` on large directory
+trees, but produces identical results and has no external dependencies
+— critical on Windows where neither binary is guaranteed to exist.
+
+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
+from pathlib import Path
+
+from .base import ToolContext
+from .filesystem import _natnump, _spool
+from .glob import GlobTool
+
+
+class GlobWindows(GlobTool):
+    """Glob with a pure-Python ``pathlib.rglob`` non-git fallback for Windows."""
+
+    def _rglob_fallback(self, pattern: str, base: str, depth: object) -> str:
+        """Use ``pathlib.Path.rglob`` for traversal + matching, Python for mtime sort.
+
+        Walks the directory tree with :meth:`pathlib.Path.rglob`, filters
+        hidden directories (``.git``, etc.), and sorts results by
+        modification time (newest first), matching the ``tree --sort=mtime``
+        order of the Linux fallback.  Symlinks are followed by default
+        via ``Path.rglob``.
+        """
+        root = Path(base)
+        max_depth = depth if _natnump(depth) else None
+
+        matches: list[tuple[float, str]] = []
+        try:
+            for p in root.rglob(pattern):
+                if not p.is_file():
+                    continue
+                # skip hidden directories (.git, etc.)
+                if any(part.startswith(".") for part in p.relative_to(root).parts[:-1]):
+                    continue
+                if max_depth is not None:
+                    rel_depth = len(p.relative_to(root).parts)
+                    if rel_depth > max_depth:
+                        continue
+                try:
+                    mtime = p.stat().st_mtime
+                except OSError:
+                    mtime = 0.0
+                matches.append((mtime, str(p)))
+        except OSError as e:
+            return f"Error: {e}"
+
+        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:
+            return super().run(args, ctx)
+
+        return self._rglob_fallback(pattern, base, depth)