steerdev 1.1.28__tar.gz → 1.1.29__tar.gz

{steerdev-1.1.28 → steerdev-1.1.29}/PKG-INFO

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

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

steerdev-1.1.29/src/steerdev_agent/git/__init__.py

@@ -0,0 +1 @@
+"""Git helpers for the steerdev runtime."""

steerdev-1.1.29/src/steerdev_agent/git/commit.py

@@ -0,0 +1,96 @@
+"""Deterministic per-task boundary commit for wave runs.
+
+After each successful task in wave mode, the runner commits everything
+outstanding with a task-scoped message, so the wave branch ends up with one
+clean commit per task regardless of how the agent chose to commit (or didn't).
+
+All functions are best-effort and never raise — a commit failure must never
+break the run. Async, mirroring `workspace.preparation._run_git`.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from typing import TYPE_CHECKING, Any
+
+from loguru import logger
+
+from steerdev_agent.git_ops import PROTECTED_BRANCHES
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+def build_task_commit_message(task: dict[str, Any]) -> str:
+    """Build a task-scoped commit message.
+
+    Prefix precedence mirrors `worktree.compute_branch_name`:
+    - external ticket ID (`linear_identifier`, then `external_id`) → `[PROJ-123]`
+    - otherwise the first 8 chars of the internal id → `[task:abc12345]`
+
+    The task title is appended when present.
+    """
+    external_id = task.get("linear_identifier") or task.get("external_id")
+    if external_id:
+        prefix = f"[{external_id}]"
+    else:
+        task_id = task.get("id", "unknown")
+        short = task_id[:8] if len(task_id) > 8 else task_id
+        prefix = f"[task:{short}]"
+
+    title = (task.get("title") or "").strip()
+    return f"{prefix} {title}" if title else prefix
+
+
+async def _run_git(cwd: str | Path, *args: str) -> tuple[int, str]:
+    """Run git, returning (returncode, stdout+stderr). Never raises for git errors."""
+    proc = await asyncio.create_subprocess_exec(
+        "git",
+        *args,
+        cwd=str(cwd),
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+    )
+    stdout_bytes, stderr_bytes = await proc.communicate()
+    out = (stdout_bytes.decode("utf-8", errors="replace") or "").strip()
+    err = (stderr_bytes.decode("utf-8", errors="replace") or "").strip()
+    return proc.returncode or 0, out or err
+
+
+async def commit_task_boundary(cwd: str | Path, task: dict[str, Any]) -> str:
+    """Stage and commit everything outstanding as one task-scoped commit.
+
+    Best-effort; never raises. Returns one of:
+        "committed", "nothing_to_commit", "skipped_protected", "failed".
+    """
+    try:
+        # Resolve current branch; skip protected branches and detached/non-repo.
+        rc, branch = await _run_git(cwd, "rev-parse", "--abbrev-ref", "HEAD")
+        if rc != 0 or not branch or branch == "HEAD":
+            logger.info("commit_task_boundary: not on a branch, skipping")
+            return "failed"
+        if branch in PROTECTED_BRANCHES:
+            logger.info(f"commit_task_boundary: protected branch {branch}, skipping")
+            return "skipped_protected"
+
+        rc, _ = await _run_git(cwd, "add", "-A")
+        if rc != 0:
+            logger.warning("commit_task_boundary: git add failed (non-fatal)")
+            return "failed"
+
+        # Anything staged? `diff --cached --quiet` exits 1 when there are changes.
+        rc, _ = await _run_git(cwd, "diff", "--cached", "--quiet")
+        if rc == 0:
+            return "nothing_to_commit"
+
+        message = build_task_commit_message(task)
+        rc, out = await _run_git(cwd, "commit", "-m", message)
+        if rc != 0:
+            logger.warning(f"commit_task_boundary: commit failed (non-fatal): {out}")
+            return "failed"
+
+        logger.info(f"commit_task_boundary: committed on {branch}: {message}")
+        return "committed"
+    except Exception as exc:  # broad catch intentional: durability must never break the run
+        logger.warning(f"commit_task_boundary: unexpected error (non-fatal): {exc}")
+        return "failed"

{steerdev-1.1.28 → steerdev-1.1.29}/src/steerdev_agent/runner.py

@@ -29,6 +29,8 @@ from steerdev_agent.config.models import (
 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_ops import checkpoint_push
 from steerdev_agent.prompt.builder import (
     ProjectContext,
     PromptBuilder,
@@ -200,6 +202,27 @@ async def _get_modified_files(working_dir: str | Path) -> list[str]:
         return []
 
 
+async def maybe_commit_task_boundary(
+    working_dir: str | Path,
+    task: dict[str, Any],
+    wave_context: WaveContext | None,
+    dry_run: bool,
+) -> None:
+    """Commit a wave task's work at its completion boundary, then checkpoint-push.
+
+    Only fires in wave mode (single-task mode keeps the agent-driven,
+    one-PR-per-task flow). Best-effort: `commit_task_boundary` and
+    `checkpoint_push` never raise. Pushes only when a commit was actually made,
+    so the wave branch lands on origin for the next wave to stack on.
+    """
+    if dry_run or wave_context is None:
+        return
+
+    result = await commit_task_boundary(working_dir, task)
+    if result == "committed":
+        checkpoint_push(working_dir)
+
+
 def compute_worktree_name(task_id: str, wave_context: WaveContext | None = None) -> str:
     """Compute the git worktree name for a task execution.
 
@@ -924,6 +947,14 @@ class Runner:
                     except Exception:
                         logger.debug("Failed to report modified files", exc_info=True)
 
+            # Deterministic per-task commit boundary (wave mode only): commit
+            # everything outstanding as one task-scoped commit and checkpoint-push,
+            # so the wave branch has one clean commit per task and lands on origin
+            # for the next wave to stack on. No-op in single-task/dry-run mode.
+            await maybe_commit_task_boundary(
+                effective_working_dir, task, wave_context, self.dry_run
+            )
+
             if self._evidence_config.enabled and not self.dry_run:
                 await self._submit_evidence_report(
                     task=task,
@@ -1072,6 +1103,13 @@ class Runner:
                         else:
                             logger.warning(f"Failed to mark task {task_id} as completed")
 
+            # Deterministic per-task commit boundary (wave mode only; successful
+            # tasks only). See execute_task for rationale.
+            if success:
+                await maybe_commit_task_boundary(
+                    effective_working_dir, task, wave_context, self.dry_run
+                )
+
             if self._evidence_config.enabled and not self.dry_run:
                 await self._submit_evidence_report(
                     task=task,

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

@@ -31,15 +31,7 @@ git checkout -b wave/<wave-number>
 2. For each task in the wave:
 - Mark the task `started`
 - Implement the requested change
-- Commit with a task-prefixed conventional commit. **Use the external ticket ID when available** (e.g. Linear ID), falling back to the internal short ID:
-
-```bash
-# With external ticket ID (preferred):
-git commit -m "[PROJ-123] feat: add user endpoint"
-
-# Fallback (no external ID):
-git commit -m "[task:abc12345] feat: add user endpoint"
-```
+- **Do not commit.** The steerdev runtime automatically commits each task's work at the task boundary with a task-prefixed message (`[PROJ-123] <title>`, or `[task:abc12345] <title>` when there is no external ID) and pushes the wave branch. You just implement; the runtime owns the per-task commit.
 
 3. After the wave work is ready for review, rebase onto the latest default branch:
 
@@ -80,22 +72,25 @@ steerdev git pr --title "Wave <N>: <description>" --body "..."
 5. Update all related tasks with the shared PR URL
 6. Log progress and completion in the root `docs/` progress files
 
-## Commit Prefix Convention
+## Commit Convention (handled by the runtime)
 
-Use external ticket IDs in commits so GitHub integrations can link commits to issues:
+You do **not** commit task work yourself. The steerdev runtime commits each task
+automatically at its completion boundary, using an external-ticket-ID-prefixed
+message so GitHub integrations can link commits to issues:
 
 | Has External ID? | Commit Prefix | Example |
 |---|---|---|
-| Yes | `[<TICKET-ID>]` | `[PROJ-123] feat: add user endpoint` |
-| No  | `[task:<short-uuid>]` | `[task:abc12345] feat: add user endpoint` |
+| Yes | `[<TICKET-ID>]` | `[PROJ-123] <task title>` |
+| No  | `[task:<short-uuid>]` | `[task:abc12345] <task title>` |
 
-Run `steerdev tasks get TASK_ID` to find the task's `linear_identifier` before committing.
+It also pushes the wave branch after each commit. Your job is to implement and,
+once the wave is done, rebase and open the PR (steps 3–5).
 
 ## Conventions
 
 - Use one branch per wave: `wave/<wave-number>`
+- Do not commit task work — the runtime commits and pushes each task automatically
 - Do not create per-task PRs inside the wave
-- Keep commits traceable by including the external ticket ID (or internal ID fallback) in each commit
 - Include the shared PR URL in every related task result
 - Replace `<default-branch>` in commands above with the actual branch name from the Git Branch Configuration section
 
@@ -105,18 +100,15 @@ Run `steerdev tasks get TASK_ID` to find the task's `linear_identifier` before c
 git checkout -b wave/3
 
 steerdev tasks update task-aaa... --status started
-# Check: steerdev tasks get task-aaa... → Linear ID: PROJ-123
-# ... implement task 1 ...
-git add .
-git commit -m "[PROJ-123] feat: add user endpoint"
+# ... implement task 1 ... (runtime commits "[PROJ-123] <title>" at the boundary)
 
 steerdev tasks update task-bbb... --status started
-# Check: steerdev tasks get task-bbb... → Linear ID: PROJ-124
-# ... implement task 2 ...
-git add .
-git commit -m "[PROJ-124] fix: validate email format"
+# ... implement task 2 ... (runtime commits "[PROJ-124] <title>" at the boundary)
 
-git push -u origin HEAD
+# Wave done: rebase onto the default branch (see step 3), then open one PR.
+git fetch origin <default-branch>
+git rebase origin/<default-branch>
+git push --force-with-lease origin HEAD
 steerdev git pr --title "Wave 3: User management improvements" --body "..."
 steerdev tasks update task-aaa... --result "PR: https://github.com/org/repo/pull/42"
 steerdev tasks update task-bbb... --result "PR: https://github.com/org/repo/pull/42"

steerdev-1.1.29/tests/test_git_commit.py

@@ -0,0 +1,127 @@
+"""Tests for the git/commit module (per-task boundary commit)."""
+
+import asyncio
+import subprocess
+from pathlib import Path
+
+from steerdev_agent.git.commit import build_task_commit_message, commit_task_boundary
+
+# ── build_task_commit_message ───────────────────────────────────────────────
+
+
+def test_message_uses_linear_identifier():
+    task = {"id": "abc12345xyz", "linear_identifier": "PROJ-123", "title": "Add auth"}
+    assert build_task_commit_message(task) == "[PROJ-123] Add auth"
+
+
+def test_message_falls_back_to_external_id():
+    task = {"id": "abc12345xyz", "external_id": "JIRA-9", "title": "Add auth"}
+    assert build_task_commit_message(task) == "[JIRA-9] Add auth"
+
+
+def test_message_prefers_linear_over_external():
+    task = {
+        "id": "abc12345xyz",
+        "linear_identifier": "PROJ-123",
+        "external_id": "JIRA-9",
+        "title": "Add auth",
+    }
+    assert build_task_commit_message(task) == "[PROJ-123] Add auth"
+
+
+def test_message_falls_back_to_short_id():
+    task = {"id": "abc12345xyz9999", "title": "Add auth"}
+    assert build_task_commit_message(task) == "[task:abc12345] Add auth"
+
+
+def test_message_handles_missing_title():
+    task = {"id": "abc12345xyz", "linear_identifier": "PROJ-123"}
+    assert build_task_commit_message(task) == "[PROJ-123]"
+
+
+# ── commit_task_boundary ─────────────────────────────────────────────────────
+
+
+def _git(cwd: Path, *args: str) -> None:
+    subprocess.run(["git", *args], cwd=cwd, check=True, capture_output=True)
+
+
+def _make_repo(tmp_path: Path) -> Path:
+    work = tmp_path / "work"
+    work.mkdir()
+    _git(work, "init")
+    _git(work, "config", "user.email", "t@t.dev")
+    _git(work, "config", "user.name", "t")
+    (work / "f.txt").write_text("a")
+    _git(work, "add", "-A")
+    _git(work, "commit", "-m", "init")
+    return work
+
+
+def _head_message(work: Path) -> str:
+    out = subprocess.run(
+        ["git", "log", "-1", "--pretty=%s"],
+        cwd=work,
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+    return out.stdout.strip()
+
+
+def _commit_count(work: Path) -> int:
+    out = subprocess.run(
+        ["git", "rev-list", "--count", "HEAD"],
+        cwd=work,
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+    return int(out.stdout.strip())
+
+
+def test_commits_outstanding_changes(tmp_path):
+    work = _make_repo(tmp_path)
+    _git(work, "checkout", "-b", "wave-1")
+    (work / "f.txt").write_text("changed")
+    (work / "new.txt").write_text("new file")
+
+    task = {"id": "abc12345xyz", "linear_identifier": "PROJ-7", "title": "do work"}
+    result = asyncio.run(commit_task_boundary(work, task))
+
+    assert result == "committed"
+    assert _head_message(work) == "[PROJ-7] do work"
+    # Both the modified and the untracked file are committed (git add -A).
+    assert _commit_count(work) == 2
+
+
+def test_nothing_to_commit_when_clean(tmp_path):
+    work = _make_repo(tmp_path)
+    _git(work, "checkout", "-b", "wave-1")
+
+    task = {"id": "abc12345xyz", "title": "nothing"}
+    result = asyncio.run(commit_task_boundary(work, task))
+
+    assert result == "nothing_to_commit"
+    assert _commit_count(work) == 1
+
+
+def test_skips_protected_branch(tmp_path):
+    work = _make_repo(tmp_path)  # stays on default branch (main/master)
+    (work / "f.txt").write_text("changed on protected")
+
+    task = {"id": "abc12345xyz", "title": "do work"}
+    result = asyncio.run(commit_task_boundary(work, task))
+
+    assert result == "skipped_protected"
+    assert _commit_count(work) == 1  # nothing committed
+
+
+def test_never_raises_on_non_repo(tmp_path):
+    not_a_repo = tmp_path / "plain"
+    not_a_repo.mkdir()
+
+    task = {"id": "abc12345xyz", "title": "do work"}
+    # Must not raise; returns a status marker.
+    result = asyncio.run(commit_task_boundary(not_a_repo, task))
+    assert result == "failed"

steerdev-1.1.29/tests/test_runner_boundary_commit.py

@@ -0,0 +1,74 @@
+"""Tests for the runner's per-task boundary-commit gate."""
+
+import asyncio
+from unittest.mock import patch
+
+from steerdev_agent.runner import maybe_commit_task_boundary
+from tests.test_runner_merge_modes import _make_wave_context
+
+
+def _run(coro):
+    return asyncio.run(coro)
+
+
+def test_commits_and_pushes_in_wave_mode(tmp_path):
+    task = {"id": "abc12345xyz", "title": "do work"}
+    with (
+        patch("steerdev_agent.runner.commit_task_boundary", return_value="committed") as commit,
+        patch("steerdev_agent.runner.checkpoint_push", return_value="pushed") as push,
+    ):
+        _run(
+            maybe_commit_task_boundary(
+                tmp_path, task, wave_context=_make_wave_context(), dry_run=False
+            )
+        )
+
+    commit.assert_awaited_once_with(tmp_path, task)
+    push.assert_called_once_with(tmp_path)
+
+
+def test_noop_without_wave_context(tmp_path):
+    task = {"id": "abc12345xyz", "title": "do work"}
+    with (
+        patch("steerdev_agent.runner.commit_task_boundary") as commit,
+        patch("steerdev_agent.runner.checkpoint_push") as push,
+    ):
+        _run(maybe_commit_task_boundary(tmp_path, task, wave_context=None, dry_run=False))
+
+    commit.assert_not_called()
+    push.assert_not_called()
+
+
+def test_noop_in_dry_run(tmp_path):
+    task = {"id": "abc12345xyz", "title": "do work"}
+    with (
+        patch("steerdev_agent.runner.commit_task_boundary") as commit,
+        patch("steerdev_agent.runner.checkpoint_push") as push,
+    ):
+        _run(
+            maybe_commit_task_boundary(
+                tmp_path, task, wave_context=_make_wave_context(), dry_run=True
+            )
+        )
+
+    commit.assert_not_called()
+    push.assert_not_called()
+
+
+def test_does_not_push_when_nothing_committed(tmp_path):
+    task = {"id": "abc12345xyz", "title": "do work"}
+    with (
+        patch(
+            "steerdev_agent.runner.commit_task_boundary", return_value="nothing_to_commit"
+        ) as commit,
+        patch("steerdev_agent.runner.checkpoint_push") as push,
+    ):
+        _run(
+            maybe_commit_task_boundary(
+                tmp_path, task, wave_context=_make_wave_context(), dry_run=False
+            )
+        )
+
+    commit.assert_awaited_once_with(tmp_path, task)
+    # No new commit → no point pushing.
+    push.assert_not_called()