steerdev 1.0.60__tar.gz → 1.1.2__tar.gz

{steerdev-1.0.60 → steerdev-1.1.2}/PKG-INFO

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

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

{steerdev-1.0.60 → steerdev-1.1.2}/src/steerdev_agent/workspace/preparation.py

@@ -35,6 +35,8 @@ class PreparationResult:
     is_worktree: bool
     error: str | None = None
     warnings: list[str] = field(default_factory=list)
+    repo_directories: list[Path] = field(default_factory=list)
+    """For multi-repo workspaces, the list of prepared git repositories."""
 
 
 async def _run_git(
@@ -145,13 +147,23 @@ class WorkspacePreparation:
         default_branch: str,
         wave_context: WaveContext | None,
     ) -> PreparationResult:
-        """Prepare workspace in the main repository directory."""
+        """Prepare workspace in the main repository directory.
+
+        If the working directory is not itself a git repository, discovers
+        git repos in immediate subdirectories (multi-repo layout) and
+        prepares each one.
+        """
         cwd = self.working_directory
-        warnings: list[str] = []
 
-        # 1. Validate git repo
+        # 1. Check if working directory is a git repo
         rc, _, _ = await _run_git("rev-parse", "--is-inside-work-tree", cwd=cwd, check=False)
-        if rc != 0:
+        if rc == 0:
+            # Single-repo layout: prepare in place
+            return await self._prepare_single_repo(cwd, target_branch, default_branch, wave_context)
+
+        # Not a git repo — check for multi-repo layout (subdirectories that are git repos)
+        repos = await self._discover_git_repos(cwd)
+        if not repos:
             return PreparationResult(
                 success=False,
                 branch_name=target_branch,
@@ -161,10 +173,120 @@ class WorkspacePreparation:
                 error=f"Not a git repository: {cwd}",
             )
 
-        # 2. Check current branch
+        # Multi-repo layout: prepare each discovered repo
+        return await self._prepare_multi_repo(repos, target_branch, default_branch, wave_context)
+
+    async def _discover_git_repos(self, directory: Path) -> list[Path]:
+        """Discover git repositories in immediate subdirectories.
+
+        Args:
+            directory: Parent directory to scan.
+
+        Returns:
+            Sorted list of paths that are git repositories.
+        """
+        repos: list[Path] = []
+        try:
+            for entry in sorted(directory.iterdir()):
+                if entry.is_dir() and not entry.name.startswith("."):
+                    rc, _, _ = await _run_git(
+                        "rev-parse", "--is-inside-work-tree", cwd=entry, check=False
+                    )
+                    if rc == 0:
+                        repos.append(entry)
+        except OSError as exc:
+            logger.warning(f"Failed to scan directory {directory}: {exc}")
+        return repos
+
+    async def _prepare_multi_repo(
+        self,
+        repos: list[Path],
+        target_branch: str,
+        default_branch: str,
+        wave_context: WaveContext | None,
+    ) -> PreparationResult:
+        """Prepare multiple git repositories in a workspace directory.
+
+        Applies the same branch preparation to each discovered repo.
+        Returns success only if all repos are prepared successfully.
+
+        Args:
+            repos: List of git repository paths to prepare.
+            target_branch: Target branch name for the task.
+            default_branch: Default branch to sync from.
+            wave_context: Optional wave context.
+
+        Returns:
+            PreparationResult with the parent directory as working_directory.
+        """
+        parent_dir = self.working_directory
+        all_warnings: list[str] = []
+        prepared_repos: list[Path] = []
+
+        logger.info(
+            f"Multi-repo workspace detected at {parent_dir}: preparing {len(repos)} repositories"
+        )
+
+        for repo_path in repos:
+            repo_name = repo_path.name
+            logger.info(f"Preparing repository: {repo_name}")
+
+            result = await self._prepare_single_repo(
+                repo_path, target_branch, default_branch, wave_context
+            )
+
+            if not result.success:
+                return PreparationResult(
+                    success=False,
+                    branch_name=target_branch,
+                    working_directory=parent_dir,
+                    default_branch=default_branch,
+                    is_worktree=False,
+                    error=f"Failed to prepare repo {repo_name}: {result.error}",
+                    repo_directories=prepared_repos,
+                )
+
+            prepared_repos.append(repo_path)
+            # Prefix per-repo warnings with the repo name for clarity
+            for warning in result.warnings:
+                all_warnings.append(f"[{repo_name}] {warning}")
+
+        logger.info(f"Multi-repo workspace ready: {len(prepared_repos)} repositories prepared")
+
+        return PreparationResult(
+            success=True,
+            branch_name=target_branch,
+            working_directory=parent_dir,
+            default_branch=default_branch,
+            is_worktree=False,
+            warnings=all_warnings,
+            repo_directories=prepared_repos,
+        )
+
+    async def _prepare_single_repo(
+        self,
+        cwd: Path,
+        target_branch: str,
+        default_branch: str,
+        wave_context: WaveContext | None,
+    ) -> PreparationResult:
+        """Prepare a single git repository directory.
+
+        Args:
+            cwd: Path to the git repository.
+            target_branch: Target branch name for the task.
+            default_branch: Default branch to sync from.
+            wave_context: Optional wave context.
+
+        Returns:
+            PreparationResult for this repository.
+        """
+        warnings: list[str] = []
+
+        # 1. Check current branch
         _, current_branch, _ = await _run_git("branch", "--show-current", cwd=cwd, check=False)
 
-        # 3. If continuing a wave on the same branch, just fetch
+        # 2. If continuing a wave on the same branch, just fetch
         if wave_context and current_branch == target_branch:
             logger.info(f"Continuing wave on branch {target_branch}, fetching only")
             await _run_git("fetch", "origin", cwd=cwd, check=False)
@@ -176,17 +298,17 @@ class WorkspacePreparation:
                 is_worktree=False,
             )
 
-        # 4. Stash if dirty
+        # 3. Stash if dirty
         rc, status_output, _ = await _run_git("status", "--porcelain", cwd=cwd, check=False)
         if status_output:
             logger.info("Working directory dirty, stashing changes")
             await _run_git("stash", "push", "-m", "steerdev-preflight", cwd=cwd, check=False)
             warnings.append("Stashed uncommitted changes (steerdev-preflight)")
 
-        # 5. Fetch from origin
+        # 4. Fetch from origin
         await _run_git("fetch", "origin", cwd=cwd, check=False)
 
-        # 6. Sync to default branch
+        # 5. Sync to default branch
         rc, _, _ = await _run_git("checkout", default_branch, cwd=cwd, check=False)
         if rc != 0:
             return PreparationResult(
@@ -210,7 +332,7 @@ class WorkspacePreparation:
                 f"Fast-forward failed, reset {default_branch} to origin/{default_branch}"
             )
 
-        # 7. Create or checkout target branch
+        # 6. Create or checkout target branch
         rc, _, _ = await _run_git("rev-parse", "--verify", target_branch, cwd=cwd, check=False)
         branch_exists = rc == 0
 
@@ -221,7 +343,7 @@ class WorkspacePreparation:
             await _run_git("checkout", "-b", target_branch, cwd=cwd)
             logger.info(f"Created new branch: {target_branch}")
 
-        # 8. Validate current branch
+        # 7. Validate current branch
         _, actual_branch, _ = await _run_git("branch", "--show-current", cwd=cwd, check=False)
         if actual_branch != target_branch:
             return PreparationResult(

{steerdev-1.0.60 → steerdev-1.1.2}/tests/test_preparation.py

@@ -290,10 +290,12 @@ class TestWorkspacePreparationInPlace:
         assert len(stash_cmds) > 0
 
     @pytest.mark.asyncio
-    async def test_not_git_repo_fails(self, worktree_disabled, default_config, sample_task):
-        """Non-git directory returns failure."""
+    async def test_not_git_repo_no_subrepos_fails(
+        self, worktree_disabled, default_config, sample_task, tmp_path
+    ):
+        """Non-git directory with no sub-repos returns failure."""
         prep = WorkspacePreparation(
-            working_directory=Path("/tmp/not-a-repo"),
+            working_directory=tmp_path,
             worktree_config=worktree_disabled,
             branch_config=default_config,
         )
@@ -356,3 +358,307 @@ class TestWorkspacePreparationInPlace:
         reset_cmds = [c for c in calls if "reset" in " ".join(c)]
         assert len(reset_cmds) > 0
         assert any("fast-forward" in w.lower() or "reset" in w.lower() for w in result.warnings)
+
+
+class TestWorkspacePreparationMultiRepo:
+    """Tests for multi-repo workspace preparation."""
+
+    @pytest.fixture
+    def worktree_disabled(self):
+        return WorktreeConfig(enabled=False)
+
+    @pytest.fixture
+    def default_config(self):
+        return BranchConfig(default_branch="main")
+
+    @pytest.fixture
+    def sample_task(self):
+        return {
+            "id": "abc12345-6789-0000-0000-000000000000",
+            "title": "Add user authentication",
+            "prompt": "Implement user auth",
+            "status": "started",
+        }
+
+    @pytest.mark.asyncio
+    async def test_multi_repo_discovers_and_prepares_all(
+        self, worktree_disabled, default_config, sample_task, tmp_path
+    ):
+        """Multi-repo layout: discovers sub-repos and prepares each one."""
+        # Create subdirectories to simulate multi-repo layout
+        (tmp_path / "repo_a").mkdir()
+        (tmp_path / "repo_b").mkdir()
+        (tmp_path / ".hidden").mkdir()  # should be skipped
+
+        prep = WorkspacePreparation(
+            working_directory=tmp_path,
+            worktree_config=worktree_disabled,
+            branch_config=default_config,
+        )
+
+        calls: list[tuple[tuple[str, ...], Path]] = []
+
+        async def mock_run_git(*args, cwd, check=True):
+            calls.append((args, Path(cwd)))
+            cmd = " ".join(args)
+            cwd_path = Path(cwd)
+
+            if "rev-parse --is-inside-work-tree" in cmd:
+                # Parent dir is NOT a repo; subdirs ARE repos
+                if cwd_path == tmp_path:
+                    return (128, "", "fatal: not a git repository")
+                if cwd_path.name in ("repo_a", "repo_b"):
+                    return (0, "true", "")
+                return (128, "", "fatal: not a git repository")
+            if "branch --show-current" in cmd:
+                # Track per-repo calls to return correct branch after checkout
+                show_current_calls = [
+                    c
+                    for c in calls
+                    if "branch --show-current" in " ".join(c[0]) and c[1] == cwd_path
+                ]
+                if len(show_current_calls) <= 1:
+                    return (0, "main", "")
+                return (0, "task/abc12345-add-user-authentication", "")
+            if "status --porcelain" in cmd:
+                return (0, "", "")
+            if "fetch origin" in cmd:
+                return (0, "", "")
+            if "checkout main" in cmd:
+                return (0, "", "")
+            if "merge --ff-only" in cmd:
+                return (0, "", "")
+            if "rev-parse --verify" in cmd:
+                return (1, "", "")  # branch doesn't exist
+            if "checkout -b" in cmd:
+                return (0, "", "")
+            if "checkout" in cmd:
+                return (0, "", "")
+            return (0, "", "")
+
+        with patch("steerdev_agent.workspace.preparation._run_git", side_effect=mock_run_git):
+            result = await prep.prepare(sample_task)
+
+        assert result.success is True
+        assert result.working_directory == tmp_path  # parent dir preserved
+        assert len(result.repo_directories) == 2
+        assert tmp_path / "repo_a" in result.repo_directories
+        assert tmp_path / "repo_b" in result.repo_directories
+        # Verify git operations ran against both repos
+        repo_a_checkouts = [
+            c for c in calls if c[1] == tmp_path / "repo_a" and "checkout -b" in " ".join(c[0])
+        ]
+        repo_b_checkouts = [
+            c for c in calls if c[1] == tmp_path / "repo_b" and "checkout -b" in " ".join(c[0])
+        ]
+        assert len(repo_a_checkouts) == 1
+        assert len(repo_b_checkouts) == 1
+
+    @pytest.mark.asyncio
+    async def test_multi_repo_fails_if_one_repo_fails(
+        self, worktree_disabled, default_config, sample_task, tmp_path
+    ):
+        """Multi-repo: failure in one repo fails the whole preparation."""
+        (tmp_path / "repo_a").mkdir()
+        (tmp_path / "repo_b").mkdir()
+
+        prep = WorkspacePreparation(
+            working_directory=tmp_path,
+            worktree_config=worktree_disabled,
+            branch_config=default_config,
+        )
+
+        # Track per-repo branch --show-current calls
+        branch_calls_per_repo: dict[str, int] = {}
+
+        async def mock_run_git(*args, cwd, check=True):
+            cmd = " ".join(args)
+            cwd_path = Path(cwd)
+            repo_name = cwd_path.name
+
+            if "rev-parse --is-inside-work-tree" in cmd:
+                if cwd_path == tmp_path:
+                    return (128, "", "fatal: not a git repository")
+                if repo_name in ("repo_a", "repo_b"):
+                    return (0, "true", "")
+                return (128, "", "")
+            if "branch --show-current" in cmd:
+                branch_calls_per_repo[repo_name] = branch_calls_per_repo.get(repo_name, 0) + 1
+                if branch_calls_per_repo[repo_name] <= 1:
+                    return (0, "main", "")
+                return (0, "task/abc12345-add-user-authentication", "")
+            if "status --porcelain" in cmd:
+                return (0, "", "")
+            if "fetch origin" in cmd:
+                return (0, "", "")
+            if "checkout main" in cmd:
+                # repo_b fails to checkout default branch
+                if repo_name == "repo_b":
+                    return (1, "", "error: pathspec 'main' did not match")
+                return (0, "", "")
+            if "merge --ff-only" in cmd:
+                return (0, "", "")
+            if "rev-parse --verify" in cmd:
+                return (1, "", "")
+            if "checkout -b" in cmd:
+                return (0, "", "")
+            return (0, "", "")
+
+        with patch("steerdev_agent.workspace.preparation._run_git", side_effect=mock_run_git):
+            result = await prep.prepare(sample_task)
+
+        assert result.success is False
+        assert "repo_b" in (result.error or "")
+        # repo_a was prepared before repo_b failed
+        assert len(result.repo_directories) == 1
+        assert tmp_path / "repo_a" in result.repo_directories
+
+    @pytest.mark.asyncio
+    async def test_multi_repo_collects_warnings_with_prefix(
+        self, worktree_disabled, default_config, sample_task, tmp_path
+    ):
+        """Multi-repo: warnings are prefixed with repo name."""
+        (tmp_path / "repo_a").mkdir()
+
+        prep = WorkspacePreparation(
+            working_directory=tmp_path,
+            worktree_config=worktree_disabled,
+            branch_config=default_config,
+        )
+
+        branch_call_count = [0]
+
+        async def mock_run_git(*args, cwd, check=True):
+            cmd = " ".join(args)
+            cwd_path = Path(cwd)
+
+            if "rev-parse --is-inside-work-tree" in cmd:
+                if cwd_path == tmp_path:
+                    return (128, "", "fatal: not a git repository")
+                return (0, "true", "")
+            if "branch --show-current" in cmd:
+                # Return target branch on validation check
+                branch_call_count[0] += 1
+                if branch_call_count[0] > 1:
+                    return (0, "task/abc12345-add-user-authentication", "")
+                return (0, "main", "")
+            if "status --porcelain" in cmd:
+                return (0, "M  dirty.py", "")  # dirty repo
+            if "stash push" in cmd:
+                return (0, "", "")
+            if "fetch origin" in cmd:
+                return (0, "", "")
+            if "checkout main" in cmd:
+                return (0, "", "")
+            if "merge --ff-only" in cmd:
+                return (0, "", "")
+            if "rev-parse --verify" in cmd:
+                return (1, "", "")
+            if "checkout -b" in cmd:
+                return (0, "", "")
+            return (0, "", "")
+
+        with patch("steerdev_agent.workspace.preparation._run_git", side_effect=mock_run_git):
+            result = await prep.prepare(sample_task)
+
+        assert result.success is True
+        assert any("[repo_a]" in w for w in result.warnings)
+
+    @pytest.mark.asyncio
+    async def test_multi_repo_skips_hidden_and_non_repo_dirs(
+        self, worktree_disabled, default_config, sample_task, tmp_path
+    ):
+        """Multi-repo: hidden dirs and non-repo dirs are skipped."""
+        (tmp_path / ".hidden_repo").mkdir()
+        (tmp_path / "not_a_repo").mkdir()
+        (tmp_path / "actual_repo").mkdir()
+
+        prep = WorkspacePreparation(
+            working_directory=tmp_path,
+            worktree_config=worktree_disabled,
+            branch_config=default_config,
+        )
+
+        calls_by_cwd: dict[str, list[str]] = {}
+
+        async def mock_run_git(*args, cwd, check=True):
+            cmd = " ".join(args)
+            cwd_path = Path(cwd)
+            calls_by_cwd.setdefault(cwd_path.name, []).append(cmd)
+
+            if "rev-parse --is-inside-work-tree" in cmd:
+                if cwd_path == tmp_path:
+                    return (128, "", "fatal: not a git repository")
+                if cwd_path.name == "actual_repo":
+                    return (0, "true", "")
+                return (128, "", "fatal: not a git repository")
+            if "branch --show-current" in cmd:
+                branch_calls = [
+                    c for c in calls_by_cwd.get(cwd_path.name, []) if "branch --show-current" in c
+                ]
+                if len(branch_calls) <= 1:
+                    return (0, "main", "")
+                return (0, "task/abc12345-add-user-authentication", "")
+            if "status --porcelain" in cmd:
+                return (0, "", "")
+            if "fetch origin" in cmd:
+                return (0, "", "")
+            if "checkout main" in cmd:
+                return (0, "", "")
+            if "merge --ff-only" in cmd:
+                return (0, "", "")
+            if "rev-parse --verify" in cmd:
+                return (1, "", "")
+            if "checkout -b" in cmd:
+                return (0, "", "")
+            return (0, "", "")
+
+        with patch("steerdev_agent.workspace.preparation._run_git", side_effect=mock_run_git):
+            result = await prep.prepare(sample_task)
+
+        assert result.success is True
+        assert len(result.repo_directories) == 1
+        assert tmp_path / "actual_repo" in result.repo_directories
+        # Hidden dir should never have been checked
+        assert ".hidden_repo" not in calls_by_cwd
+
+    @pytest.mark.asyncio
+    async def test_single_repo_still_works(self, worktree_disabled, default_config, sample_task):
+        """Single-repo layout still works as before (no regressions)."""
+        prep = WorkspacePreparation(
+            working_directory=Path("/tmp/repo"),
+            worktree_config=worktree_disabled,
+            branch_config=default_config,
+        )
+
+        calls = []
+
+        async def mock_run_git(*args, cwd, check=True):
+            calls.append(args)
+            cmd = " ".join(args)
+            if "rev-parse --is-inside-work-tree" in cmd:
+                return (0, "true", "")
+            if "branch --show-current" in cmd:
+                if len([c for c in calls if "branch --show-current" in " ".join(c)]) <= 1:
+                    return (0, "main", "")
+                return (0, "task/abc12345-add-user-authentication", "")
+            if "status --porcelain" in cmd:
+                return (0, "", "")
+            if "fetch origin" in cmd:
+                return (0, "", "")
+            if "checkout main" in cmd:
+                return (0, "", "")
+            if "merge --ff-only" in cmd:
+                return (0, "", "")
+            if "rev-parse --verify" in cmd:
+                return (1, "", "")
+            if "checkout -b" in cmd:
+                return (0, "", "")
+            return (0, "", "")
+
+        with patch("steerdev_agent.workspace.preparation._run_git", side_effect=mock_run_git):
+            result = await prep.prepare(sample_task)
+
+        assert result.success is True
+        assert result.repo_directories == []  # single-repo: no repo_directories
+        assert result.working_directory == Path("/tmp/repo")