agentic-dev-loop 1.0.0a26__tar.gz → 1.0.0a27__tar.gz

{agentic_dev_loop-1.0.0a26/src/agentic_dev_loop.egg-info → agentic_dev_loop-1.0.0a27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-dev-loop
-Version: 1.0.0a26
+Version: 1.0.0a27
 Summary: Turn an LLM into a gated, sandboxed, resumable construction loop over your codebase.
 Author: Luke Wilson
 License-Expression: Apache-2.0
@@ -84,6 +84,20 @@ timeout (agent runs are long), and fail fast on a broken sandbox - daemon-side
 exec failures are classified and stop the run without an agent retry loop,
 while a startup reaper reclaims containers leaked by a crashed run.
 
+## Supported platforms
+
+The engine is plain Linux under the hood and runs wherever a compliant
+Docker engine does:
+
+| Platform | Support |
+| --- | --- |
+| **Linux** | Native. Docker Engine, OrbStack, Colima, or podman with docker compat. |
+| **macOS** | Native. Docker Desktop, OrbStack, or Colima. |
+| **Windows** | Via **WSL2** (Ubuntu distro). Enable Docker Desktop's WSL integration (or run Docker Engine inside the distro) and keep the repo on the WSL filesystem (`~/dev/...`), not `/mnt/c` - bind-mounting a 9p path into containers breaks permissions and is slow. |
+
+Native Windows (outside WSL2) is not supported: every Windows-specific code
+path and test was removed, and CI runs on Ubuntu only.
+
 ## Installation
 
 **Prerequisites**
@@ -91,7 +105,7 @@ while a startup reaper reclaims containers leaked by a crashed run.
 | Requirement | Detail |
 | --- | --- |
 | Python | ≥ 3.12 |
-| Docker engine | Engine API ≥ 1.43 (Engine 24). Any compliant engine works - Docker Desktop, OrbStack, Colima, Rancher Desktop, podman docker-compat. On Windows, Linux-containers mode is required. |
+| Docker engine | Engine API ≥ 1.43 (Engine 24). Any compliant engine works - Docker Desktop, OrbStack, Colima, Rancher Desktop, podman docker-compat. On Windows, run under WSL2: the repo must live on the WSL filesystem, not /mnt/c. |
 | LLM API key | The env var named by your pipeline's `api_key_env` (e.g. `OPENAI_API_KEY`) must be set - a missing key fails fast, naming it. |
 
 ```bash
@@ -579,7 +593,7 @@ agentic-dev-loop agentic-dev-loop/pipeline.yaml --dry-run   # run the shipped pi
 - The shipped pipeline (`agentic-dev-loop/pipeline.yaml`) **dogfoods the tool on
   its own repo** - dev → test → review → qa → commit, with the engine's own
   three agent definitions in `sdk_agents/`.
-- CI: `ci.yml` (unit + integration suite, ubuntu + windows),
+- CI: `ci.yml` (unit + integration suite, ubuntu),
   `publish-image.yml` (multi-arch dev image, amd64 + arm64), `release.yml`
   (PyPI publishing).
 

{agentic_dev_loop-1.0.0a26 → agentic_dev_loop-1.0.0a27}/README.md

@@ -42,6 +42,20 @@ timeout (agent runs are long), and fail fast on a broken sandbox - daemon-side
 exec failures are classified and stop the run without an agent retry loop,
 while a startup reaper reclaims containers leaked by a crashed run.
 
+## Supported platforms
+
+The engine is plain Linux under the hood and runs wherever a compliant
+Docker engine does:
+
+| Platform | Support |
+| --- | --- |
+| **Linux** | Native. Docker Engine, OrbStack, Colima, or podman with docker compat. |
+| **macOS** | Native. Docker Desktop, OrbStack, or Colima. |
+| **Windows** | Via **WSL2** (Ubuntu distro). Enable Docker Desktop's WSL integration (or run Docker Engine inside the distro) and keep the repo on the WSL filesystem (`~/dev/...`), not `/mnt/c` - bind-mounting a 9p path into containers breaks permissions and is slow. |
+
+Native Windows (outside WSL2) is not supported: every Windows-specific code
+path and test was removed, and CI runs on Ubuntu only.
+
 ## Installation
 
 **Prerequisites**
@@ -49,7 +63,7 @@ while a startup reaper reclaims containers leaked by a crashed run.
 | Requirement | Detail |
 | --- | --- |
 | Python | ≥ 3.12 |
-| Docker engine | Engine API ≥ 1.43 (Engine 24). Any compliant engine works - Docker Desktop, OrbStack, Colima, Rancher Desktop, podman docker-compat. On Windows, Linux-containers mode is required. |
+| Docker engine | Engine API ≥ 1.43 (Engine 24). Any compliant engine works - Docker Desktop, OrbStack, Colima, Rancher Desktop, podman docker-compat. On Windows, run under WSL2: the repo must live on the WSL filesystem, not /mnt/c. |
 | LLM API key | The env var named by your pipeline's `api_key_env` (e.g. `OPENAI_API_KEY`) must be set - a missing key fails fast, naming it. |
 
 ```bash
@@ -537,7 +551,7 @@ agentic-dev-loop agentic-dev-loop/pipeline.yaml --dry-run   # run the shipped pi
 - The shipped pipeline (`agentic-dev-loop/pipeline.yaml`) **dogfoods the tool on
   its own repo** - dev → test → review → qa → commit, with the engine's own
   three agent definitions in `sdk_agents/`.
-- CI: `ci.yml` (unit + integration suite, ubuntu + windows),
+- CI: `ci.yml` (unit + integration suite, ubuntu),
   `publish-image.yml` (multi-arch dev image, amd64 + arm64), `release.yml`
   (PyPI publishing).
 

{agentic_dev_loop-1.0.0a26 → agentic_dev_loop-1.0.0a27}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "agentic-dev-loop"
-version = "1.0.0a26"
+version = "1.0.0a27"
 description = "Turn an LLM into a gated, sandboxed, resumable construction loop over your codebase."
 readme = "README.md"
 requires-python = ">=3.12"

{agentic_dev_loop-1.0.0a26 → agentic_dev_loop-1.0.0a27}/src/agentic_dev_loop/engine/proc.py

@@ -9,9 +9,7 @@ from __future__ import annotations
 
 import os
 import shlex
-import shutil
 import signal
-import subprocess
 from collections.abc import Mapping
 
 _SHELL_METACHARS = frozenset("&|;><$`~*?[]")
@@ -33,47 +31,21 @@ def split_command(command: str) -> list[str]:
     return shlex.split(command)
 
 
-def host_shell_execution(
-        command: str, *, nt: bool = os.name == "nt",
-        which=shutil.which) -> tuple[str | list[str], bool]:
-    """How the HOST (non-sandbox) path executes a shell-needing command.
-
-    POSIX: the raw string with ``shell=True`` (unchanged unit-2 behaviour).
-    Windows: ``shell=True`` is cmd.exe, which mangles ``$VAR`` expansion and
-    ``|`` pipelines (the CI-red hybrid failures) - prefer the discovered
-    POSIX ``sh`` (git-bash) via argv instead; fall back to ``shell=True``
-    only when no ``sh`` exists anywhere on PATH.
-    """
-    if not nt:
-        return command, True
-    sh = which("sh")
-    if sh:
-        return [sh, "-c", command], False
+def host_shell_execution(command: str) -> tuple[str, bool]:
+    """How the HOST (non-sandbox) path executes a shell-needing command:
+    the raw string with ``shell=True``. The engine targets Linux and WSL2
+    (which is plain Linux), so ``sh`` is always present."""
     return command, True
 
 
-def kill_process_tree(proc, *, nt: bool | None = None,
-                      run=subprocess.run) -> None:
+def kill_process_tree(proc) -> None:
     """Terminate `proc` and its descendants after a timeout.
 
-    POSIX: ``start_new_session`` made ``proc.pid`` the process-group id -
+    ``start_new_session`` made ``proc.pid`` the process-group id, so
     ``killpg`` reaps the whole group (a shell wrapper's children survive a
     plain ``kill``).
-
-    Windows: ``proc.kill()`` terminates only the direct child - a git-bash
-    ``sh -c`` wrapper's python child survives and keeps the pipes open, so
-    the follow-up ``communicate()`` blocks out the child's full lifetime.
-    ``taskkill /T`` walks the process tree while the parent is still alive,
-    then ``kill`` sweeps up anything left (CI-red: 9.5s timeout test).
     """
-    if nt is None:
-        nt = os.name == "nt"
-    if nt:
-        run(["taskkill", "/F", "/T", "/PID", str(proc.pid)],
-            capture_output=True, check=False)
-        proc.kill()
-    else:
-        os.killpg(proc.pid, signal.SIGKILL)
+    os.killpg(proc.pid, signal.SIGKILL)
 
 
 def is_pid_token(token: str) -> bool:

{agentic_dev_loop-1.0.0a26 → agentic_dev_loop-1.0.0a27/src/agentic_dev_loop.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-dev-loop
-Version: 1.0.0a26
+Version: 1.0.0a27
 Summary: Turn an LLM into a gated, sandboxed, resumable construction loop over your codebase.
 Author: Luke Wilson
 License-Expression: Apache-2.0
@@ -84,6 +84,20 @@ timeout (agent runs are long), and fail fast on a broken sandbox - daemon-side
 exec failures are classified and stop the run without an agent retry loop,
 while a startup reaper reclaims containers leaked by a crashed run.
 
+## Supported platforms
+
+The engine is plain Linux under the hood and runs wherever a compliant
+Docker engine does:
+
+| Platform | Support |
+| --- | --- |
+| **Linux** | Native. Docker Engine, OrbStack, Colima, or podman with docker compat. |
+| **macOS** | Native. Docker Desktop, OrbStack, or Colima. |
+| **Windows** | Via **WSL2** (Ubuntu distro). Enable Docker Desktop's WSL integration (or run Docker Engine inside the distro) and keep the repo on the WSL filesystem (`~/dev/...`), not `/mnt/c` - bind-mounting a 9p path into containers breaks permissions and is slow. |
+
+Native Windows (outside WSL2) is not supported: every Windows-specific code
+path and test was removed, and CI runs on Ubuntu only.
+
 ## Installation
 
 **Prerequisites**
@@ -91,7 +105,7 @@ while a startup reaper reclaims containers leaked by a crashed run.
 | Requirement | Detail |
 | --- | --- |
 | Python | ≥ 3.12 |
-| Docker engine | Engine API ≥ 1.43 (Engine 24). Any compliant engine works - Docker Desktop, OrbStack, Colima, Rancher Desktop, podman docker-compat. On Windows, Linux-containers mode is required. |
+| Docker engine | Engine API ≥ 1.43 (Engine 24). Any compliant engine works - Docker Desktop, OrbStack, Colima, Rancher Desktop, podman docker-compat. On Windows, run under WSL2: the repo must live on the WSL filesystem, not /mnt/c. |
 | LLM API key | The env var named by your pipeline's `api_key_env` (e.g. `OPENAI_API_KEY`) must be set - a missing key fails fast, naming it. |
 
 ```bash
@@ -579,7 +593,7 @@ agentic-dev-loop agentic-dev-loop/pipeline.yaml --dry-run   # run the shipped pi
 - The shipped pipeline (`agentic-dev-loop/pipeline.yaml`) **dogfoods the tool on
   its own repo** - dev → test → review → qa → commit, with the engine's own
   three agent definitions in `sdk_agents/`.
-- CI: `ci.yml` (unit + integration suite, ubuntu + windows),
+- CI: `ci.yml` (unit + integration suite, ubuntu),
   `publish-image.yml` (multi-arch dev image, amd64 + arm64), `release.yml`
   (PyPI publishing).
 

{agentic_dev_loop-1.0.0a26 → agentic_dev_loop-1.0.0a27}/tests/test_actions.py

@@ -375,9 +375,8 @@ class TestCommitNode:
 
     def test_add_excludes_live_checkpoint_db(self, tmp_path, monkeypatch):
         """The live checkpointer DB under state_dir stays open for the whole
-        run; on Windows an open SQLite file blocks other readers and
-        `git add -A` fails to hash it (CI-red gate failure). The add must
-        exclude sqlite files under the state dir on every OS."""
+        run, so `git add -A` cannot hash it. The add must exclude sqlite
+        files under the state dir."""
         repo = tmp_path / "repo"
         init_git_repo(repo)
         (repo / "feature.cs").write_text("// constructed by the pipeline")

{agentic_dev_loop-1.0.0a26 → agentic_dev_loop-1.0.0a27}/tests/test_proc.py

@@ -5,11 +5,8 @@ stateless pure functions shared by the command-step and action-step
 surfaces; property tests exercise the invariants that keep the subprocess
 boundary fail-safe (BR-4, BR-5)."""
 
-import os
-import pytest
 import signal
 import string
-import subprocess
 
 from hypothesis import given, settings
 from hypothesis import strategies as st
@@ -45,23 +42,10 @@ class TestNeedsShell:
 
 
 class TestHostShellExecution:
-    """How the HOST (non-sandbox) path executes a shell-needing command.
-    Windows cannot rely on shell=True - cmd.exe mangles $VAR and pipelines
-    (the CI-red hybrid failures) - so it prefers the discovered POSIX sh."""
+    """How the HOST (non-sandbox) path executes a shell-needing command."""
 
-    def test_posix_uses_shell_true(self):
-        argv, shell = host_shell_execution("a && b", nt=False)
-        assert (argv, shell) == ("a && b", True)
-
-    def test_windows_prefers_discovered_sh(self):
-        which = lambda name: "C:/Program Files/Git/bin/sh.exe"  # noqa: E731
-        argv, shell = host_shell_execution("a && b", nt=True, which=which)
-        assert argv == ["C:/Program Files/Git/bin/sh.exe", "-c", "a && b"]
-        assert shell is False
-
-    def test_windows_without_sh_falls_back_to_shell_true(self):
-        argv, shell = host_shell_execution("a && b", nt=True,
-                                           which=lambda name: None)
+    def test_uses_shell_true(self):
+        argv, shell = host_shell_execution("a && b")
         assert (argv, shell) == ("a && b", True)
 
 
@@ -144,10 +128,8 @@ class TestChildEnv:
 
 
 class TestKillProcessTree:
-    """The timeout reap path. CI-red on Windows: `proc.kill()` terminates
-    only the direct child - a git-bash `sh -c` wrapper's python child
-    survives, keeps the pipes open, and the follow-up communicate() blocks
-    out the full sleep. The tree must be reaped root-to-leaves."""
+    """The timeout reap path: ``start_new_session`` made ``proc.pid`` the
+    process-group id, so ``killpg`` reaps the whole tree."""
 
     class _Proc:
         def __init__(self, log):
@@ -157,30 +139,14 @@ class TestKillProcessTree:
         def kill(self):
             self.log.append("kill")
 
-    @pytest.mark.skipif(not hasattr(os, "killpg"), reason="POSIX-only: os.killpg does not exist on Windows")
-    def test_posix_reaps_the_whole_process_group(self, monkeypatch):
+    def test_reaps_the_whole_process_group(self, monkeypatch):
         killed = []
         monkeypatch.setattr(
             "agentic_dev_loop.engine.proc.os.killpg",
             lambda pid, sig: killed.append((pid, sig)))
         proc = self._Proc([])
 
-        kill_process_tree(proc, nt=False)
+        kill_process_tree(proc)
 
         assert killed == [(99, signal.SIGKILL)]
         assert proc.log == []  # the wrapper needs no separate kill
-
-    def test_windows_taskkills_the_tree_then_kills_the_wrapper(self):
-        log = []
-        proc = self._Proc(log)
-
-        def fake_run(argv, **kwargs):
-            log.append("taskkill")
-            assert argv == ["taskkill", "/F", "/T", "/PID", "99"]
-            return subprocess.CompletedProcess(argv, 0, "", "")
-
-        kill_process_tree(proc, nt=True, run=fake_run)
-
-        # taskkill /T needs the parent alive to walk the tree - then the
-        # wrapper itself is swept up.
-        assert log == ["taskkill", "kill"]

{agentic_dev_loop-1.0.0a26 → agentic_dev_loop-1.0.0a27}/tests/test_stages.py

@@ -393,8 +393,8 @@ class TestCommandNode:
         """The host-path timeout must cut the WHOLE tree short, not just the
         direct child - a shell wrapper's grandchild that survives keeps the
         pipes open and the follow-up communicate() blocks out the full sleep
-        (CI-red 9.5s). kill_process_tree's per-OS branches are unit-pinned
-        in tests/test_proc.py::TestKillProcessTree."""
+        (CI-red 9.5s). kill_process_tree is unit-pinned in
+        tests/test_proc.py::TestKillProcessTree."""
         code, out, timed_out = _run_command(
             f'"{sys.executable}" -c "import time; time.sleep(30)"',
             tmp_path, 0.2)

{agentic_dev_loop-1.0.0a26 → agentic_dev_loop-1.0.0a27}/tests/test_sync_back.py

@@ -338,9 +338,9 @@ class TestMergeOnConflictPartition:
         exp = _export(tmp_path, ws)
         (ws / "src" / "audit.md").write_text("base\n")
         (exp / "src" / "audit.md").write_text("base\nexport\n")
-        # Baseline comes from the real workspace bytes: write_text translates
-        # \n to os.linesep on Windows, so a fabricated sha256(b"base\n") would
-        # never match and would misclassify the copy as a merge conflict.
+        # Baseline comes from the real workspace bytes, so a fabricated
+        # sha256(b"base\n") would never match and would misclassify the
+        # copy as a merge conflict.
         baseline = {"src/audit.md": _digest(ws / "src" / "audit.md")}
         report = sync_back(exp, ws, ["src"], baseline=baseline,
                            merge_on_conflict=["src/audit.md"])

{agentic_dev_loop-1.0.0a26 → agentic_dev_loop-1.0.0a27}/tests/test_trigger_script.py

@@ -6,11 +6,7 @@ a stale install rejects newer pipeline configs at load time (e.g.
 is upgraded on every run. Tests drive the real script with stub
 executables on PATH - no network, no mocks of the script's logic.
 
-The script is bash, so it is executed through `bash` on every platform:
-Windows cannot CreateProcess a `.sh` file (shebangs are a POSIX concept)
-and its MSYS bash (git-bash, preinstalled on windows-latest runners)
-understands only POSIX-style paths (`/c/...`), so PATH entries and
-redirect targets inside stub bodies are converted accordingly.
+The script is bash, so it is executed through `bash`.
 """
 
 import os
@@ -24,19 +20,6 @@ REPO_ROOT = Path(__file__).resolve().parents[1]
 SCRIPT = REPO_ROOT / "trigger-agentic-dev-loop.sh"
 
 
-def _msys(path: Path) -> str:
-    """POSIX-style form of a Windows path (`C:\\x` -> `/c/x`).
-
-    MSYS bash splits PATH on `:` and treats backslashes as escapes, so a
-    native `C:\\...` entry would fragment into `C` + `\\...`. Pass the
-    mount-style form instead. On POSIX the path is returned unchanged.
-    """
-    if os.name != "nt":
-        return str(path)
-    drive, rest = os.path.splitdrive(str(path))
-    return "/" + drive[0].lower() + rest.replace("\\", "/")
-
-
 def _bash() -> str:
     bash = shutil.which("bash")
     if bash is None:
@@ -46,7 +29,7 @@ def _bash() -> str:
 
 def _run_script(*args: str, env: dict) -> subprocess.CompletedProcess:
     return subprocess.run(
-        [_bash(), _msys(SCRIPT), *args],
+        [_bash(), str(SCRIPT), *args],
         capture_output=True,
         text=True,
         env=env,
@@ -64,7 +47,7 @@ def _make_stub(bin_dir: Path, name: str, body: str) -> None:
 def _env_with(bin_dir: Path | None = None) -> dict:
     entries = ["/usr/bin", "/bin"]
     if bin_dir is not None:
-        entries.insert(0, _msys(bin_dir))
+        entries.insert(0, str(bin_dir))
     return {**os.environ, "PATH": ":".join(entries)}
 
 
@@ -80,7 +63,7 @@ def test_trigger_upgrades_existing_install(tmp_path):
     _make_stub(
         bin_dir,
         "pipx",
-        f'echo "$*" >> "{_msys(pipx_log)}"',
+        f'echo "$*" >> "{str(pipx_log)}"',
     )
 
     result = _run_script("--plan", "plan.md", env=_env_with(bin_dir))