steerdev 1.1.45__tar.gz → 1.1.48__tar.gz

{steerdev-1.1.45 → steerdev-1.1.48}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: steerdev
-Version: 1.1.45
+Version: 1.1.48
 Summary: Backend task runner for steerdev.com - orchestrates CLI coding agents with activity reporting
 Project-URL: Homepage, https://github.com/pentoai/steerdev-agent
 Project-URL: Repository, https://github.com/pentoai/steerdev-agent

{steerdev-1.1.45 → steerdev-1.1.48}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "steerdev"
-version = "1.1.45"
+version = "1.1.48"
 description = "Backend task runner for steerdev.com - orchestrates CLI coding agents with activity reporting"
 readme = "README.md"
 authors = [

{steerdev-1.1.45 → steerdev-1.1.48}/src/steerdev_agent/agent_loop.py

@@ -18,8 +18,9 @@ import asyncio
 import contextlib
 import signal
 import socket
+from dataclasses import dataclass, field
 from pathlib import Path
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 import httpx
 from loguru import logger
@@ -28,6 +29,7 @@ from rich.panel import Panel
 
 if TYPE_CHECKING:
     from steerdev_agent.api.agents import AgentsClient, ProjectAssignment
+    from steerdev_agent.prompt.builder import WaveContext
     from steerdev_agent.workspace.project_manager import ProjectManager
 
 from steerdev_agent.api.commands import CommandResponse, CommandsClient
@@ -54,6 +56,15 @@ class AgentLoopError(Exception):
     """Error during agent loop execution."""
 
 
+@dataclass
+class _WavePrTracking:
+    """Per-project wave PR safety-net state (mirrors Runner.run's tracking)."""
+
+    wave_ctx: WaveContext
+    completed_tasks: list[dict[str, Any]] = field(default_factory=list)
+    working_dir: str | None = None
+
+
 # ---------------------------------------------------------------------------
 # Shared execution logic
 # ---------------------------------------------------------------------------
@@ -92,6 +103,7 @@ class CommandExecutor:
     _commands_succeeded: int
     _commands_failed: int
     _is_busy: bool
+    _wave_pr_state: dict[str, _WavePrTracking]
 
     async def _execute_command(
         self,
@@ -273,6 +285,90 @@ class CommandExecutor:
             finally:
                 await runs_client.close()
 
+        # Wave PR safety net (mirrors Runner.run): once the wave has no more
+        # pending tasks, make sure its PR exists.
+        await self._maybe_ensure_wave_pr(
+            project_id,
+            task,
+            wave_ctx,
+            result,
+            fallback_working_dir=str(command.working_directory or working_directory),
+        )
+
+    async def _maybe_ensure_wave_pr(
+        self,
+        project_id: str,
+        task: dict[str, Any],
+        wave_ctx: WaveContext | None,
+        result: dict[str, Any],
+        fallback_working_dir: str,
+    ) -> None:
+        """Track completed wave tasks across commands and create the wave PR.
+
+        Command-driven counterpart of Runner.run's wave PR safety net: each
+        command executes a single task, so wave completion is detected by
+        peeking at the wave queue after every successful wave task — no task
+        left (or scheduling moved to a different wave) means the wave is done
+        and its PR must exist. Best-effort: never raises.
+        """
+        if wave_ctx is None or not result.get("success"):
+            return
+
+        from steerdev_agent.runner import extract_task_and_wave_context, wave_identity
+
+        try:
+            state = self._wave_pr_state.get(project_id)
+            if state is not None and wave_identity(state.wave_ctx) != wave_identity(wave_ctx):
+                # Scheduling moved on to a new wave: the tracked one completed.
+                self._flush_wave_pr(project_id, fallback_working_dir)
+                state = None
+            if state is None:
+                state = _WavePrTracking(wave_ctx=wave_ctx)
+                self._wave_pr_state[project_id] = state
+            state.completed_tasks.append({"id": task.get("id"), "title": task.get("title")})
+            if result.get("working_dir"):
+                state.working_dir = result["working_dir"]
+
+            try:
+                with TasksClient(api_key=self._api_key) as tasks_client:
+                    wave_response = tasks_client.get_next_wave(
+                        project_id=project_id, agent_id=self._agent_id
+                    )
+                next_task, next_wave_ctx, _ = extract_task_and_wave_context(wave_response)
+            except Exception:
+                logger.debug("Wave PR safety net: wave peek failed, skipping", exc_info=True)
+                return
+
+            if (
+                next_task is None
+                or next_wave_ctx is None
+                or wave_identity(next_wave_ctx) != wave_identity(wave_ctx)
+            ):
+                self._flush_wave_pr(project_id, fallback_working_dir)
+        except Exception:  # broad catch intentional: safety net must never break the loop
+            logger.warning("Wave PR safety net failed (non-fatal)", exc_info=True)
+
+    def _flush_wave_pr(self, project_id: str, fallback_working_dir: str) -> None:
+        """Create the tracked wave's PR if the agent didn't. Never raises."""
+        state = self._wave_pr_state.pop(project_id, None)
+        if state is None:
+            return
+        try:
+            from steerdev_agent.git.pr import ensure_wave_pr
+
+            status = ensure_wave_pr(
+                state.working_dir or fallback_working_dir,
+                state.wave_ctx,
+                state.completed_tasks,
+                api_key=self._api_key,
+            )
+            if status == "created":
+                console.print("[green]Wave PR created (safety net)[/green]")
+            else:
+                logger.info(f"Wave PR safety net: {status}")
+        except Exception:  # broad catch intentional: safety net must never break the loop
+            logger.warning("Wave PR safety net failed (non-fatal)", exc_info=True)
+
     async def _execute_prompt_command(
         self,
         command: CommandResponse,
@@ -530,6 +626,7 @@ class AgentLoop(CommandExecutor):
         self._commands_executed = 0
         self._commands_succeeded = 0
         self._commands_failed = 0
+        self._wave_pr_state: dict[str, _WavePrTracking] = {}
 
         # Components
         self._commands_client: CommandsClient | None = None
@@ -921,6 +1018,7 @@ class WorkspaceAgentLoop(CommandExecutor):
         self._commands_executed = 0
         self._commands_succeeded = 0
         self._commands_failed = 0
+        self._wave_pr_state: dict[str, _WavePrTracking] = {}
 
         # Components
         self._commands_client: CommandsClient | None = None

steerdev-1.1.48/tests/test_agent_loop_wave_pr.py

@@ -0,0 +1,180 @@
+"""Tests for the agent loop's wave PR safety net (command-driven counterpart
+of the runner's Runner.run safety net)."""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from steerdev_agent.agent_loop import AgentLoop, _WavePrTracking
+from tests.test_runner_merge_modes import _make_wave_context
+
+
+def _make_loop() -> AgentLoop:
+    return AgentLoop(project_id="p", agent_name="a", api_key="k")
+
+
+def _make_wave_response(wave_name: str = "wave-a1b2c3", next_task: dict | None = None) -> dict:
+    return {
+        "wave": {"wave_number": 3, "total_waves": 5, "name": wave_name},
+        "context": {"next_task": next_task},
+    }
+
+
+def _patch_wave_peek(wave_response):
+    """Patch TasksClient so get_next_wave returns the given response."""
+    client = MagicMock()
+    client.__enter__.return_value = client
+    client.get_next_wave.return_value = wave_response
+    return patch("steerdev_agent.agent_loop.TasksClient", return_value=client)
+
+
+class TestMaybeEnsureWavePr:
+    @pytest.mark.asyncio
+    async def test_noop_without_wave_context(self):
+        loop = _make_loop()
+        with patch("steerdev_agent.git.pr.ensure_wave_pr") as ensure:
+            await loop._maybe_ensure_wave_pr("p", {"id": "t1"}, None, {"success": True}, "/repo")
+        ensure.assert_not_called()
+        assert loop._wave_pr_state == {}
+
+    @pytest.mark.asyncio
+    async def test_noop_on_failed_task(self):
+        loop = _make_loop()
+        with patch("steerdev_agent.git.pr.ensure_wave_pr") as ensure:
+            await loop._maybe_ensure_wave_pr(
+                "p", {"id": "t1"}, _make_wave_context(), {"success": False}, "/repo"
+            )
+        ensure.assert_not_called()
+        assert loop._wave_pr_state == {}
+
+    @pytest.mark.asyncio
+    async def test_accumulates_while_wave_has_pending_tasks(self):
+        loop = _make_loop()
+        ctx = _make_wave_context()
+        # Peek returns another task in the same wave → wave not done yet.
+        peek = _make_wave_response(next_task={"id": "t2", "title": "next"})
+        with (
+            _patch_wave_peek(peek),
+            patch("steerdev_agent.git.pr.ensure_wave_pr") as ensure,
+        ):
+            await loop._maybe_ensure_wave_pr(
+                "p", {"id": "t1", "title": "do work"}, ctx, {"success": True}, "/repo"
+            )
+        ensure.assert_not_called()
+        assert loop._wave_pr_state["p"].completed_tasks == [{"id": "t1", "title": "do work"}]
+
+    @pytest.mark.asyncio
+    async def test_creates_pr_when_wave_exhausted(self):
+        loop = _make_loop()
+        ctx = _make_wave_context()
+        with (
+            _patch_wave_peek(None),
+            patch("steerdev_agent.git.pr.ensure_wave_pr", return_value="created") as ensure,
+        ):
+            await loop._maybe_ensure_wave_pr(
+                "p",
+                {"id": "t1", "title": "do work"},
+                ctx,
+                {"success": True, "working_dir": "/repo/.worktrees/wave-a1b2c3"},
+                "/repo",
+            )
+        ensure.assert_called_once_with(
+            "/repo/.worktrees/wave-a1b2c3",
+            ctx,
+            [{"id": "t1", "title": "do work"}],
+            api_key="k",
+        )
+        # State is reset so the next wave starts clean.
+        assert loop._wave_pr_state == {}
+
+    @pytest.mark.asyncio
+    async def test_creates_pr_when_scheduling_moves_to_next_wave(self):
+        loop = _make_loop()
+        ctx = _make_wave_context()
+        peek = _make_wave_response(wave_name="wave-next", next_task={"id": "t9"})
+        with (
+            _patch_wave_peek(peek),
+            patch("steerdev_agent.git.pr.ensure_wave_pr", return_value="created") as ensure,
+        ):
+            await loop._maybe_ensure_wave_pr(
+                "p", {"id": "t1", "title": "do work"}, ctx, {"success": True}, "/repo"
+            )
+        ensure.assert_called_once()
+        assert loop._wave_pr_state == {}
+
+    @pytest.mark.asyncio
+    async def test_flushes_previous_wave_when_new_wave_task_completes(self):
+        loop = _make_loop()
+        old_ctx = _make_wave_context()
+        new_ctx = _make_wave_context()
+        new_ctx.wave_name = "wave-next"
+        loop._wave_pr_state["p"] = _WavePrTracking(
+            wave_ctx=old_ctx, completed_tasks=[{"id": "t0", "title": "old"}]
+        )
+        # Peek says the new wave still has tasks → only the old wave flushes.
+        peek = _make_wave_response(wave_name="wave-next", next_task={"id": "t9"})
+        with (
+            _patch_wave_peek(peek),
+            patch("steerdev_agent.git.pr.ensure_wave_pr", return_value="created") as ensure,
+        ):
+            await loop._maybe_ensure_wave_pr(
+                "p", {"id": "t1", "title": "new work"}, new_ctx, {"success": True}, "/repo"
+            )
+        ensure.assert_called_once_with(
+            "/repo", old_ctx, [{"id": "t0", "title": "old"}], api_key="k"
+        )
+        assert loop._wave_pr_state["p"].wave_ctx is new_ctx
+        assert loop._wave_pr_state["p"].completed_tasks == [{"id": "t1", "title": "new work"}]
+
+    @pytest.mark.asyncio
+    async def test_peek_failure_keeps_state_and_skips(self):
+        loop = _make_loop()
+        ctx = _make_wave_context()
+        with (
+            patch("steerdev_agent.agent_loop.TasksClient", side_effect=RuntimeError("api down")),
+            patch("steerdev_agent.git.pr.ensure_wave_pr") as ensure,
+        ):
+            await loop._maybe_ensure_wave_pr(
+                "p", {"id": "t1", "title": "do work"}, ctx, {"success": True}, "/repo"
+            )
+        ensure.assert_not_called()
+        # Task is still tracked, so a later flush includes it.
+        assert loop._wave_pr_state["p"].completed_tasks == [{"id": "t1", "title": "do work"}]
+
+    @pytest.mark.asyncio
+    async def test_never_raises(self):
+        loop = _make_loop()
+        ctx = _make_wave_context()
+        with (
+            _patch_wave_peek(None),
+            patch("steerdev_agent.git.pr.ensure_wave_pr", side_effect=RuntimeError("boom")),
+        ):
+            await loop._maybe_ensure_wave_pr(
+                "p", {"id": "t1", "title": "do work"}, ctx, {"success": True}, "/repo"
+            )  # must not raise
+        assert loop._wave_pr_state == {}
+
+
+class TestFlushWavePr:
+    def test_noop_without_tracked_state(self):
+        loop = _make_loop()
+        with patch("steerdev_agent.git.pr.ensure_wave_pr") as ensure:
+            loop._flush_wave_pr("p", "/repo")
+        ensure.assert_not_called()
+
+    def test_falls_back_to_command_working_dir(self):
+        loop = _make_loop()
+        loop._wave_pr_state["p"] = _WavePrTracking(wave_ctx=_make_wave_context())
+        with patch("steerdev_agent.git.pr.ensure_wave_pr", return_value="created") as ensure:
+            loop._flush_wave_pr("p", "/repo")
+        assert ensure.call_args.args[0] == "/repo"
+        assert loop._wave_pr_state == {}
+
+    def test_state_is_per_project(self):
+        loop = _make_loop()
+        loop._wave_pr_state["p1"] = _WavePrTracking(wave_ctx=_make_wave_context())
+        loop._wave_pr_state["p2"] = _WavePrTracking(wave_ctx=_make_wave_context())
+        with patch("steerdev_agent.git.pr.ensure_wave_pr", return_value="created"):
+            loop._flush_wave_pr("p1", "/repo")
+        assert "p1" not in loop._wave_pr_state
+        assert "p2" in loop._wave_pr_state