steerdev 1.1.43__tar.gz → 1.1.45__tar.gz

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

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

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

{steerdev-1.1.43 → steerdev-1.1.45}/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
-
-    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)
+    base_branch = resolve_task_base_branch(task_id)
 
-        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")
@@ -1676,6 +1654,18 @@ def run(
             envvar="STEERDEV_AGENT_ID",
         ),
     ] = None,
+    provider: Annotated[
+        str | None,
+        typer.Option(
+            "--provider",
+            help=(
+                "AI provider / executor type to run tasks with (e.g. claude)."
+                " Overrides steerdev.yaml executor.type."
+                " Reads from STEERDEV_PROVIDER env var."
+            ),
+            envvar="STEERDEV_PROVIDER",
+        ),
+    ] = None,
     model: Annotated[
         str | None,
         typer.Option(
@@ -1837,7 +1827,11 @@ def run(
         steerdev run --project-id abc123 --workflow-id wf-abc123
         steerdev run --config custom.yaml --project-id abc123
     """
-    from steerdev_agent.runner import resolve_max_tasks, run_agent
+    from steerdev_agent.runner import (
+        resolve_executor_config,
+        resolve_max_tasks,
+        run_agent,
+    )
 
     # Get config from context (loaded in app callback)
     config: SteerDevConfig = ctx.obj or SteerDevConfig()
@@ -1866,6 +1860,12 @@ def run(
     resolved_evidence_config = config.evidence.model_copy()
     if evidence is not None:
         resolved_evidence_config.enabled = evidence
+    # Resolve executor config: --provider/STEERDEV_PROVIDER overrides executor.type
+    try:
+        resolved_executor_config = resolve_executor_config(config.executor, provider)
+    except ValueError as e:
+        console.print(f"[red]Error: {e}[/red]")
+        raise typer.Exit(1) from e
 
     # API key: CLI > env (via envvar) > config env var
     resolved_api_key = api_key
@@ -1897,6 +1897,7 @@ def run(
             f"Project ID: {resolved_project_id}\n"
             f"Agent Name: {agent_name_display}\n"
             f"Working Directory: {working_dir or 'current'}\n"
+            f"Provider: {resolved_executor_config.type}\n"
             f"Model: {resolved_model or 'default'}\n"
             f"Max Tasks: {max_tasks_display}\n"
             f"Timeout: {resolved_timeout}s\n"
@@ -1943,6 +1944,7 @@ def run(
                 enable_canals=canals,
                 worktree_config=resolved_worktree_config,
                 evidence_config=resolved_evidence_config,
+                executor_config=resolved_executor_config,
                 force_workflow_id=resolved_workflow_id,
                 dry_run=dry_run,
                 retry_config=retry_config,

{steerdev-1.1.43 → steerdev-1.1.45}/src/steerdev_agent/executor/__init__.py

@@ -12,6 +12,7 @@ if TYPE_CHECKING:
     from steerdev_agent.config.models import ExecutorConfig
 
 __all__ = [
+    "SUPPORTED_EXECUTOR_TYPES",
     "AgentExecutor",
     "ClaudeExecutor",
     "ExecutorFactory",
@@ -19,6 +20,10 @@ __all__ = [
     "StreamParser",
 ]
 
+# Executor types ExecutorFactory can build. `steerdev run --provider` and
+# steerdev.yaml's executor.type are validated against this.
+SUPPORTED_EXECUTOR_TYPES: tuple[str, ...] = ("claude",)
+
 
 class ExecutorFactory:
     """Factory for creating agent executors based on configuration."""
@@ -62,4 +67,7 @@ class ExecutorFactory:
                 extra_args=config.args or None,
             )
 
-        raise ValueError(f"Unsupported executor type: {config.type}")
+        raise ValueError(
+            f"Unsupported executor type: {config.type} "
+            f"(supported: {', '.join(SUPPORTED_EXECUTOR_TYPES)})"
+        )

steerdev-1.1.45/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.43 → steerdev-1.1.45}/src/steerdev_agent/runner.py

@@ -26,10 +26,11 @@ from steerdev_agent.config.models import (
     RetryConfig,
     WorktreeConfig,
 )
-from steerdev_agent.executor import ExecutorFactory
+from steerdev_agent.executor import SUPPORTED_EXECUTOR_TYPES, 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,
@@ -164,6 +165,29 @@ def resolve_max_tasks(max_tasks: int | None, wave_id: str | None) -> int:
     return 0 if wave_id else 1
 
 
+def resolve_executor_config(
+    base: ExecutorConfig,
+    provider: str | None,
+) -> ExecutorConfig:
+    """Resolve the effective executor config for a run.
+
+    - `provider` (from --provider / STEERDEV_PROVIDER) overrides the config
+      file's executor.type; None keeps it.
+    - The resolved type is validated against SUPPORTED_EXECUTOR_TYPES so an
+      unsupported provider fails fast (before task claiming), not deep inside
+      ExecutorFactory mid-run.
+    """
+    resolved = base.model_copy()
+    if provider is not None:
+        resolved.type = provider
+    if resolved.type not in SUPPORTED_EXECUTOR_TYPES:
+        raise ValueError(
+            f"Unsupported provider: {resolved.type} "
+            f"(supported: {', '.join(SUPPORTED_EXECUTOR_TYPES)})"
+        )
+    return resolved
+
+
 def resolve_merge_flow(
     waves_enabled: bool,
     canals_enabled: bool,
@@ -248,6 +272,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,
@@ -409,6 +438,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
@@ -983,6 +1017,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):
@@ -1140,6 +1175,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:
@@ -1267,8 +1303,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
 
@@ -1296,6 +1344,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]")
@@ -1388,6 +1444,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,