steerdev 1.1.31__tar.gz → 1.1.44__tar.gz

{steerdev-1.1.31 → steerdev-1.1.44}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: steerdev
-Version: 1.1.31
+Version: 1.1.44
 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.31 → steerdev-1.1.44}/pyproject.toml

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

{steerdev-1.1.31 → steerdev-1.1.44}/src/steerdev_agent/cli.py

@@ -1365,7 +1365,11 @@ def git_pr(
         steerdev git pr --title "Add auth" --body "Implements JWT auth"
         steerdev git pr --title "Add auth" --task-id abc123...
     """
-    import subprocess
+    from steerdev_agent.git.pr import (
+        STEERDEV_SIGNATURE,
+        create_pr,
+        resolve_task_base_branch,
+    )
 
     # Build PR body
     pr_body = body or ""
@@ -1374,49 +1378,23 @@ def git_pr(
         pr_body += task_ref
 
     # Add steerdev signature
-    pr_body += "\n\n---\nCreated with [steerdev](https://steerdev.com)"
+    pr_body += STEERDEV_SIGNATURE
 
     # Prefer the persisted base branch so the PR targets the correct base.
-    from steerdev_agent.api.tasks import TasksClient
-
-    base_branch: str | None = None
-    if task_id:
-        try:
-            with TasksClient() as pr_client:
-                if pr_client.check_api_key():
-                    task = pr_client.get_task(task_id)
-                    if task:
-                        base_branch = task.get("base_branch")
-        except Exception:  # fall back to gh default base
-            base_branch = None
+    base_branch = resolve_task_base_branch(task_id)
 
-    try:
-        # Build the gh pr create command
-        cmd = ["gh", "pr", "create", "--title", title, "--body", pr_body]
-        if base_branch:
-            cmd += ["--base", base_branch]
-        if draft:
-            cmd.append("--draft")
-
-        result = subprocess.run(cmd, capture_output=True, text=True)
-
-        if result.returncode != 0:
-            console.print(f"[red]Error creating PR: {result.stderr}[/red]")
-            raise typer.Exit(1)
+    result = create_pr(title, pr_body, base_branch=base_branch, draft=draft)
+    if not result.created:
+        console.print(f"[red]Error creating PR: {result.error}[/red]")
+        raise typer.Exit(1)
 
-        # Extract PR URL from output
-        pr_url = result.stdout.strip()
-        console.print(
-            Panel(
-                f"[bold green]Pull request created[/bold green]\n\nTitle: {title}\nURL: {pr_url}",
-                title="Success",
-                border_style="green",
-            )
+    console.print(
+        Panel(
+            f"[bold green]Pull request created[/bold green]\n\nTitle: {title}\nURL: {result.url}",
+            title="Success",
+            border_style="green",
         )
-
-    except FileNotFoundError:
-        console.print("[red]Error: gh not found. Install GitHub CLI: https://cli.github.com[/red]")
-        raise typer.Exit(1) from None
+    )
 
 
 @git_app.command("status")
@@ -1806,6 +1784,16 @@ def run(
             ),
         ),
     ] = None,
+    base_branch: Annotated[
+        str | None,
+        typer.Option(
+            "--base-branch",
+            help=(
+                "Branch to cut a new wave/task branch from (overrides the "
+                "auto-chosen predecessor/default). Falls back to STEERDEV_BASE_BRANCH."
+            ),
+        ),
+    ] = None,
 ) -> None:
     """Run the agent for a project!
 
@@ -1841,6 +1829,9 @@ def run(
         console.print("[red]Error: --project-id required (or set via env/config)[/red]")
         raise typer.Exit(1)
 
+    # Resolve base branch override: CLI > env > None
+    resolved_base_branch = base_branch or os.environ.get("STEERDEV_BASE_BRANCH") or None
+
     # Resolve other options: CLI > config > hardcoded default
     resolved_model = model if model is not None else config.agent.model
     resolved_max_turns = max_turns if max_turns is not None else config.agent.max_turns
@@ -1937,6 +1928,7 @@ def run(
                 task_id=task_id,
                 agent_id=agent_id,
                 wave_id=wave_id,
+                base_branch_override=resolved_base_branch,
             )
         )
 

steerdev-1.1.44/src/steerdev_agent/git/pr.py

@@ -0,0 +1,192 @@
+"""Pull-request helpers shared by the CLI and the runner's wave PR safety net.
+
+The wave-tasks-merge skill instructs the agent to open a PR at wave end, but
+nothing guarantees the agent does. `ensure_wave_pr` is the deterministic
+fallback: at wave completion the runner checks whether a PR already exists for
+the wave branch and creates one if not.
+
+All functions are best-effort and never raise — a PR failure must never break
+the run. Synchronous, mirroring `git_ops` (these run once at wave end, outside
+the hot path).
+"""
+
+from __future__ import annotations
+
+import json
+import shutil
+import subprocess
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+
+from loguru import logger
+
+from steerdev_agent.git_ops import current_branch
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    from steerdev_agent.prompt.builder import WaveContext
+
+_GH_TIMEOUT = 60  # seconds; gh talks to the GitHub API
+
+STEERDEV_SIGNATURE = "\n\n---\nCreated with [steerdev](https://steerdev.com)"
+
+
+@dataclass
+class PrResult:
+    """Outcome of a `gh pr create` invocation."""
+
+    created: bool
+    url: str | None = None
+    error: str | None = None
+
+
+def _run_gh(cwd: str | Path | None, *args: str) -> tuple[int, str, str]:
+    """Run gh, returning (returncode, stdout, stderr). Raises only on missing gh/timeout."""
+    proc = subprocess.run(
+        ["gh", *args],
+        cwd=str(cwd) if cwd else None,
+        capture_output=True,
+        text=True,
+        timeout=_GH_TIMEOUT,
+    )
+    return proc.returncode, (proc.stdout or "").strip(), (proc.stderr or "").strip()
+
+
+def find_existing_pr(cwd: str | Path | None, branch: str) -> str:
+    """Check whether a PR (any state) already exists for *branch*.
+
+    Returns one of:
+        "exists", "none", "unknown" (gh missing or the lookup failed).
+    """
+    try:
+        if shutil.which("gh") is None:
+            logger.warning("find_existing_pr: gh not found")
+            return "unknown"
+        rc, out, err = _run_gh(
+            cwd, "pr", "list", "--head", branch, "--state", "all", "--json", "number,state"
+        )
+        if rc != 0:
+            logger.warning(f"find_existing_pr: gh pr list failed (non-fatal): {err}")
+            return "unknown"
+        return "exists" if json.loads(out or "[]") else "none"
+    except Exception as exc:  # broad catch intentional: durability must never break the run
+        logger.warning(f"find_existing_pr: unexpected error (non-fatal): {exc}")
+        return "unknown"
+
+
+def create_pr(
+    title: str,
+    body: str,
+    *,
+    cwd: str | Path | None = None,
+    base_branch: str | None = None,
+    draft: bool = False,
+) -> PrResult:
+    """Create a PR for the current branch via `gh pr create`. Never raises."""
+    try:
+        cmd = ["pr", "create", "--title", title, "--body", body]
+        if base_branch:
+            cmd += ["--base", base_branch]
+        if draft:
+            cmd.append("--draft")
+
+        rc, out, err = _run_gh(cwd, *cmd)
+        if rc != 0:
+            return PrResult(created=False, error=err or out)
+        return PrResult(created=True, url=out)
+    except FileNotFoundError:
+        return PrResult(
+            created=False, error="gh not found. Install GitHub CLI: https://cli.github.com"
+        )
+    except Exception as exc:  # broad catch intentional: durability must never break the run
+        return PrResult(created=False, error=str(exc))
+
+
+def resolve_task_base_branch(task_id: str | None, api_key: str | None = None) -> str | None:
+    """Resolve the persisted PR base from a task's `base_branch`, if available.
+
+    For a stacked wave this is the predecessor wave's branch. Falls back to
+    None (gh's default base) on any failure.
+    """
+    if not task_id:
+        return None
+    try:
+        from steerdev_agent.api.tasks import TasksClient
+
+        with TasksClient(api_key=api_key) as client:
+            if not client.check_api_key():
+                return None
+            task = client.get_task(task_id)
+            return task.get("base_branch") if task else None
+    except Exception:  # fall back to gh default base
+        logger.debug("resolve_task_base_branch: lookup failed", exc_info=True)
+        return None
+
+
+def build_wave_pr_title(wave_context: WaveContext) -> str:
+    """Build the fallback PR title for a completed wave."""
+    name = (wave_context.wave_name or "").strip()
+    if name and name != f"wave-{wave_context.wave_number}":
+        return f"Wave {wave_context.wave_number}: {name}"
+    return f"Wave {wave_context.wave_number}"
+
+
+def build_wave_pr_body(completed_tasks: list[dict[str, Any]]) -> str:
+    """Build the fallback PR body: one bullet per completed task, plus signature."""
+    lines = ["## Completed tasks", ""]
+    for task in completed_tasks:
+        task_id = task.get("id", "unknown")
+        short = task_id[:8] if len(task_id) > 8 else task_id
+        title = (task.get("title") or "").strip() or "(untitled)"
+        lines.append(f"- `{short}` {title}")
+    if not completed_tasks:
+        lines.append("- (no task summary available)")
+    return "\n".join(lines) + STEERDEV_SIGNATURE
+
+
+def ensure_wave_pr(
+    cwd: str | Path,
+    wave_context: WaveContext,
+    completed_tasks: list[dict[str, Any]],
+    api_key: str | None = None,
+) -> str:
+    """Create the wave PR if the agent didn't. Best-effort; never raises.
+
+    Returns one of:
+        "created", "already_exists", "skipped_detached", "failed".
+    """
+    try:
+        branch = current_branch(cwd)
+        if branch is None:
+            logger.info("ensure_wave_pr: detached HEAD, skipping")
+            return "skipped_detached"
+
+        existing = find_existing_pr(cwd, branch)
+        if existing == "exists":
+            logger.info(f"ensure_wave_pr: PR already exists for {branch}, skipping")
+            return "already_exists"
+        if existing == "unknown":
+            logger.warning("ensure_wave_pr: could not check for existing PR, skipping")
+            return "failed"
+
+        last_task = completed_tasks[-1] if completed_tasks else None
+        base_branch = resolve_task_base_branch(
+            last_task.get("id") if last_task else None, api_key=api_key
+        )
+
+        result = create_pr(
+            build_wave_pr_title(wave_context),
+            build_wave_pr_body(completed_tasks),
+            cwd=cwd,
+            base_branch=base_branch,
+        )
+        if not result.created:
+            logger.warning(f"ensure_wave_pr: PR creation failed (non-fatal): {result.error}")
+            return "failed"
+
+        logger.info(f"ensure_wave_pr: created PR for {branch}: {result.url}")
+        return "created"
+    except Exception as exc:  # broad catch intentional: durability must never break the run
+        logger.warning(f"ensure_wave_pr: unexpected error (non-fatal): {exc}")
+        return "failed"

{steerdev-1.1.31 → steerdev-1.1.44}/src/steerdev_agent/runner.py

@@ -30,6 +30,7 @@ from steerdev_agent.executor import ExecutorFactory
 from steerdev_agent.executor.base import AgentExecutor, EventType, StreamEvent
 from steerdev_agent.executor.claude import ClaudeExecutorError
 from steerdev_agent.git.commit import commit_task_boundary
+from steerdev_agent.git.pr import ensure_wave_pr
 from steerdev_agent.git_ops import checkpoint_push
 from steerdev_agent.prompt.builder import (
     ProjectContext,
@@ -248,6 +249,11 @@ def compute_worktree_name(task_id: str, wave_context: WaveContext | None = None)
     return f"task-{task_short}"
 
 
+def wave_identity(wave_context: WaveContext) -> str:
+    """Stable identity for a wave; matches the wave branch/worktree naming."""
+    return wave_context.wave_name or f"wave-{wave_context.wave_number}"
+
+
 def build_workflow_task_context(
     task: dict[str, Any],
     wave_context: WaveContext | None,
@@ -338,6 +344,7 @@ class Runner:
         agent_id: str | None = None,
         task_id: str | None = None,
         wave_id: str | None = None,
+        base_branch_override: str | None = None,
     ) -> None:
         """Initialize the runner.
 
@@ -363,6 +370,8 @@ class Runner:
             task_id: Run a single specific task (bypasses queue/wave scheduling).
             wave_id: Scope scheduling to a single wave; the loop processes every
                 task of that wave and stops when it is exhausted.
+            base_branch_override: Override the base branch used when preparing
+                each task's workspace.
         """
         self.project_id = project_id
         self.working_directory = Path(working_directory or Path.cwd())
@@ -390,6 +399,7 @@ class Runner:
         self._agent_id = agent_id
         self._target_task_id = task_id
         self._target_wave_id = wave_id
+        self._base_branch_override = base_branch_override
 
         # State
         self._state = RunState.STOPPED
@@ -405,6 +415,11 @@ class Runner:
         self._tasks_failed = 0
         self._events_sent = 0
 
+        # Wave PR safety-net state (see _maybe_create_wave_pr)
+        self._last_wave_ctx: WaveContext | None = None
+        self._wave_completed_tasks: list[dict[str, Any]] = []
+        self._wave_working_dir: str | None = None
+
         # Components
         self._sessions_client: SessionsClient | None = None
         self._events_client: EventsClient | None = None
@@ -836,6 +851,7 @@ class Runner:
                 working_directory=self.working_directory,
                 worktree_config=self._worktree_config,
                 branch_config=self._branch_config,
+                base_branch_override=self._base_branch_override,
             )
             prep_result = await preparation.prepare(task, wave_context)
             if not prep_result.success:
@@ -978,6 +994,7 @@ class Runner:
                 "exit_code": exit_code,
                 "agent_session_id": agent_session_id,
                 "events_sent": self._events_sent,
+                "working_dir": str(effective_working_dir),
             }
 
         except (KeyboardInterrupt, asyncio.CancelledError):
@@ -1053,6 +1070,7 @@ class Runner:
             working_directory=self.working_directory,
             worktree_config=self._worktree_config,
             branch_config=self._branch_config,
+            base_branch_override=self._base_branch_override,
         )
         prep_result = await preparation.prepare(task, wave_context)
         if not prep_result.success:
@@ -1134,6 +1152,7 @@ class Runner:
                 "phases_completed": phases_completed,
                 "phases_failed": phases_failed,
                 "total_phases": total_phases,
+                "working_dir": str(effective_working_dir),
             }
 
         except Exception as e:
@@ -1261,8 +1280,20 @@ class Runner:
                         console.print("[yellow]No tasks available[/yellow]")
                     else:
                         console.print("[yellow]No more tasks available[/yellow]")
+                    # No more wave tasks → the wave is done; make sure its PR exists.
+                    self._maybe_create_wave_pr()
                     break
 
+                # Moving on to a different wave means the previous one
+                # completed — flush its PR safety net before tracking the new
+                # wave.
+                if (
+                    wave_ctx is not None
+                    and self._last_wave_ctx is not None
+                    and wave_identity(wave_ctx) != wave_identity(self._last_wave_ctx)
+                ):
+                    self._maybe_create_wave_pr()
+
                 # Resolve workflow: force override > API suggestion > none
                 per_task_workflow_id = self.workflow_id or suggested_workflow_id
 
@@ -1290,6 +1321,14 @@ class Runner:
                 if result.get("success"):
                     self._tasks_succeeded += 1
                     console.print("[green]Task completed successfully[/green]")
+                    if wave_ctx is not None:
+                        # Track wave progress for the PR safety net.
+                        self._last_wave_ctx = wave_ctx
+                        self._wave_completed_tasks.append(
+                            {"id": task.get("id"), "title": task.get("title")}
+                        )
+                        if result.get("working_dir"):
+                            self._wave_working_dir = result["working_dir"]
                 else:
                     self._tasks_failed += 1
                     console.print(f"[red]Task failed: {result.get('error', 'Unknown')}[/red]")
@@ -1382,6 +1421,37 @@ class Runner:
             "error": str(run_error) if run_error else None,
         }
 
+    def _maybe_create_wave_pr(self) -> None:
+        """Wave PR safety net: create the wave PR if the agent didn't.
+
+        Fires when a wave finishes — either no more wave tasks come back, or
+        the run moves on to a different wave. The wave-tasks-merge skill
+        normally has the agent create a richer PR; this only acts when no PR
+        exists for the wave branch yet. Best-effort: never raises, never fails
+        the run. Always resets the tracked wave state.
+        """
+        wave_ctx = self._last_wave_ctx
+        try:
+            if wave_ctx is None or self.dry_run:
+                return
+            working_dir = self._wave_working_dir or str(self.working_directory)
+            status = ensure_wave_pr(
+                working_dir,
+                wave_ctx,
+                self._wave_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 run
+            logger.warning("Wave PR safety net failed (non-fatal)", exc_info=True)
+        finally:
+            self._last_wave_ctx = None
+            self._wave_completed_tasks = []
+            self._wave_working_dir = None
+
     async def resume(
         self,
         session_id: str,
@@ -1510,6 +1580,7 @@ async def run_agent(
     task_id: str | None = None,
     agent_id: str | None = None,
     wave_id: str | None = None,
+    base_branch_override: str | None = None,
 ) -> dict[str, Any]:
     """Run the steerdev agent.
 
@@ -1560,6 +1631,7 @@ async def run_agent(
         task_id=task_id,
         agent_id=agent_id,
         wave_id=wave_id,
+        base_branch_override=base_branch_override,
     )
 
     # Install signal handler that kills the subprocess immediately on Ctrl+C

{steerdev-1.1.31 → steerdev-1.1.44}/src/steerdev_agent/setup/templates/skills/steerdev-wave-tasks-merge-skill/SKILL.md

@@ -63,6 +63,23 @@ git merge-tree --write-tree origin/<default-branch> HEAD
 
 **Fallback** (if `git merge-tree` is unavailable): Skip the dry-run and rebase directly. If rebase fails, abort and re-queue as above.
 
+### Before pushing: reconcile concurrent work on the wave branch
+
+Another task of this wave may have pushed to the wave branch while you worked.
+Before any push to the wave branch:
+
+```bash
+git fetch origin "$(git branch --show-current)"
+git rebase "origin/$(git branch --show-current)"
+```
+
+- If the rebase is clean, continue.
+- If it conflicts, resolve the conflicts in the files in your working tree
+  (you have full context for the change you just made), then
+  `git rebase --continue`.
+- If you genuinely cannot resolve them, abort (`git rebase --abort`) and report
+  a blocker with `steerdev activity report`.
+
 4. Create one pull request for the wave:
 
 ```bash