DEVX-104: feat: auto-rebase in auto-merge, new rebase tools, CLI registration

tests/unit/test_api_clients.py

@@ -233,6 +233,18 @@ class TestGiteaClient:
             json={"Do": "squash", "MergeTitleField": "fix: bug"},
         )
 
+    def test_update_pr_branch(self) -> None:
+        client = GiteaClient("https://git.example.com", "tok", "owner", "repo")
+        client._session.request = MagicMock(return_value=_mock_response())
+
+        client.update_pr_branch(7, style="rebase")
+        client._session.request.assert_called_once_with(
+            "POST",
+            "https://git.example.com/repos/owner/repo/pulls/7/update",
+            timeout=DEFAULT_TIMEOUT,
+            params={"style": "rebase"},
+        )
+
     def test_get_pr_labels(self) -> None:
         client = GiteaClient("https://git.example.com", "tok", "owner", "repo")
         client._session.request = MagicMock(return_value=_mock_response([{"name": "ready-to-merge"}]))

tests/unit/test_auto_merge.py

@@ -292,14 +292,13 @@ class TestMain:
     @patch.dict("os.environ", {"CI_GITEA_TOKEN": "tok", "VIKUNJA_TOKEN": "tok"}, clear=True)
     @patch("devx.ci.auto_merge.validate_pr_title_matches_vikunja")
     @patch("devx.ci.auto_merge.GiteaClient")
-    def test_merge_behind_master_raises_no_rebase(
+    def test_merge_behind_master_auto_rebases(
         self, mock_client_cls: MagicMock, _mock_validate: MagicMock, tmp_path, monkeypatch
     ) -> None:  # type: ignore[no-untyped-def]
-        """When branch is behind master, auto-merge should NOT rebase.
+        """When branch is behind master, auto-merge rebases via Gitea API.
 
-        Auto-rebasing creates a feedback loop: the force-push triggers a new
-        pull_request synchronize event, which starts a new CI run, which runs
-        auto-merge again, which rebases again, etc.
+        The rebase triggers a new CI run. The next auto-merge attempt will
+        find the branch up-to-date and merge successfully.
         """
         monkeypatch.chdir(tmp_path)
 
@@ -315,12 +314,40 @@ class TestMain:
             main,
             ["DEVX-19-fix-bug", "DEVX-19: Fix timeout", "owner/repo", "7"],
         )
-        assert result.exit_code != 0
+        assert result.exit_code == 0
         assert "behind master" in result.output.lower()
-        assert "rebase manually" in result.output.lower()
-        # Must NOT have called merge_pr twice (no retry after rebase)
+        assert "auto-rebasing" in result.output.lower()
+        # Should have called update_pr_branch to trigger server-side rebase
+        mock_client.update_pr_branch.assert_called_once_with(7, style="rebase")
+        # Must NOT have called merge_pr twice (no immediate retry)
         assert mock_client.merge_pr.call_count == 1
 
+    @patch.dict("os.environ", {"CI_GITEA_TOKEN": "tok", "VIKUNJA_TOKEN": "tok"}, clear=True)
+    @patch("devx.ci.auto_merge.validate_pr_title_matches_vikunja")
+    @patch("devx.ci.auto_merge.GiteaClient")
+    def test_merge_behind_master_rebase_failure_raises(
+        self, mock_client_cls: MagicMock, _mock_validate: MagicMock, tmp_path, monkeypatch
+    ) -> None:  # type: ignore[no-untyped-def]
+        """When auto-rebase fails, raise with manual rebase instructions."""
+        monkeypatch.chdir(tmp_path)
+
+        mock_client = MagicMock()
+        mock_client.get_pr_commits.return_value = [
+            {"commit": {"message": "fix: resolve timeout"}},
+        ]
+        mock_client.merge_pr.side_effect = APIError(405, "HEAD branch is behind master")
+        mock_client.update_pr_branch.side_effect = APIError(409, "Conflict during rebase")
+        mock_client_cls.return_value = mock_client
+
+        runner = CliRunner()
+        result = runner.invoke(
+            main,
+            ["DEVX-19-fix-bug", "DEVX-19: Fix timeout", "owner/repo", "7"],
+        )
+        assert result.exit_code != 0
+        assert "auto-rebase failed" in result.output.lower()
+        assert "rebase manually" in result.output.lower()
+
     @patch.dict("os.environ", {"CI_GITEA_TOKEN": "tok", "VIKUNJA_TOKEN": "tok"}, clear=True)
     @patch("devx.ci.auto_merge.validate_pr_title_matches_vikunja")
     @patch("devx.ci.auto_merge.GiteaClient")
@@ -386,10 +413,10 @@ class TestMain:
     @patch.dict("os.environ", {"CI_GITEA_TOKEN": "tok", "VIKUNJA_TOKEN": "tok"}, clear=True)
     @patch("devx.ci.auto_merge.validate_pr_title_matches_vikunja")
     @patch("devx.ci.auto_merge.GiteaClient")
-    def test_merge_behind_master_does_not_force_push(
+    def test_merge_behind_master_does_not_run_git_commands(
         self, mock_client_cls: MagicMock, _mock_validate: MagicMock, tmp_path, monkeypatch
     ) -> None:  # type: ignore[no-untyped-def]
-        """Verify no git commands are run when branch is behind master."""
+        """When behind master, auto-merge uses API rebase — no local git commands."""
         monkeypatch.chdir(tmp_path)
 
         mock_client = MagicMock()
@@ -405,8 +432,8 @@ class TestMain:
                 main,
                 ["DEVX-19-fix-bug", "DEVX-19: Fix timeout", "owner/repo", "7"],
             )
-            assert result.exit_code != 0
-            # No git commands should be run (no rebase, no push)
+            assert result.exit_code == 0
+            # No local git commands should be run (rebase is via API)
             mock_run.assert_not_called()
 
 

tests/unit/test_cli.py

@@ -201,6 +201,20 @@ class TestToolsCommands:
         assert result.exit_code == 0
         mock_run.assert_called_once_with("devx.tools.setup", [])
 
+    @patch("devx.cli._run_module")
+    def test_tools_rebase(self, mock_run: MagicMock) -> None:
+        runner = CliRunner()
+        result = runner.invoke(cli, ["tools", "rebase", "--", "--no-push"])
+        assert result.exit_code == 0
+        mock_run.assert_called_once_with("devx.tools.rebase", ["--no-push"])
+
+    @patch("devx.cli._run_module")
+    def test_tools_pr_rebase(self, mock_run: MagicMock) -> None:
+        runner = CliRunner()
+        result = runner.invoke(cli, ["tools", "pr-rebase", "--", "--pr", "42"])
+        assert result.exit_code == 0
+        mock_run.assert_called_once_with("devx.tools.pr_rebase", ["--pr", "42"])
+
 
 class TestMoleculeCommands:
     @patch("devx.cli._run_module")

tests/unit/test_rebase.py

@@ -0,0 +1,348 @@
+"""Tests for devx.tools.rebase, devx.tools.pr_rebase, and detect_pr_number."""
+
+from __future__ import annotations
+
+from unittest.mock import MagicMock, patch
+
+from click.testing import CliRunner
+
+from devx.tools.pr_rebase import main as pr_rebase_main
+from devx.tools.rebase import main as rebase_main
+
+_FULL_ENV = {
+    "CI_GITEA_TOKEN": "tok",
+    "DEVX_REPO_OWNER": "owner",
+    "DEVX_REPO_NAME": "repo",
+}
+
+
+class TestRunGitHelper:
+    """Tests for the _run_git helper function."""
+
+    @patch("devx.tools.rebase.subprocess.run")
+    def test_run_git_with_check(self, mock_run: MagicMock) -> None:
+        """_run_git passes check=True by default."""
+        from devx.tools.rebase import _run_git
+
+        mock_run.return_value = MagicMock(stdout="ok\n", returncode=0)
+        result = _run_git(["status"])
+        mock_run.assert_called_once_with(
+            ["git", "status"],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        assert result.stdout == "ok\n"
+
+    @patch("devx.tools.rebase.subprocess.run")
+    def test_run_git_without_check(self, mock_run: MagicMock) -> None:
+        """_run_git passes check=False when specified."""
+        from devx.tools.rebase import _run_git
+
+        mock_run.return_value = MagicMock(stdout="", stderr="err", returncode=1)
+        result = _run_git(["rebase", "origin/master"], check=False)
+        mock_run.assert_called_once_with(
+            ["git", "rebase", "origin/master"],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        assert result.returncode == 1
+
+
+class TestDetectPrNumber:
+    """Tests for the detect_pr_number helper in _shared."""
+
+    @patch("devx.tools._shared.subprocess.run")
+    @patch.dict("os.environ", _FULL_ENV, clear=True)
+    @patch("devx.api_clients.GiteaClient")
+    def test_detect_pr_found(self, mock_client_cls: MagicMock, mock_run: MagicMock) -> None:
+        """detect_pr_number returns PR number when branch has an open PR."""
+        from devx.tools._shared import detect_pr_number
+
+        mock_run.return_value = MagicMock(stdout="feature-branch\n", returncode=0)
+        mock_client = MagicMock()
+        mock_client.list_prs.return_value = [
+            {"number": 42, "head": {"ref": "feature-branch"}},
+            {"number": 99, "head": {"ref": "other-branch"}},
+        ]
+        mock_client_cls.return_value = mock_client
+
+        result = detect_pr_number()
+        assert result == 42
+
+    @patch("devx.tools._shared.subprocess.run")
+    @patch.dict("os.environ", _FULL_ENV, clear=True)
+    @patch("devx.api_clients.GiteaClient")
+    def test_detect_pr_not_found(self, mock_client_cls: MagicMock, mock_run: MagicMock) -> None:
+        """detect_pr_number returns None when no open PR matches branch."""
+        from devx.tools._shared import detect_pr_number
+
+        mock_run.return_value = MagicMock(stdout="no-pr-branch\n", returncode=0)
+        mock_client = MagicMock()
+        mock_client.list_prs.return_value = [
+            {"number": 42, "head": {"ref": "other-branch"}},
+        ]
+        mock_client_cls.return_value = mock_client
+
+        result = detect_pr_number()
+        assert result is None
+
+    @patch("devx.tools._shared.subprocess.run")
+    def test_detect_pr_detached_head(self, mock_run: MagicMock) -> None:
+        """detect_pr_number returns None on detached HEAD."""
+        from devx.tools._shared import detect_pr_number
+
+        mock_run.return_value = MagicMock(stdout="HEAD\n", returncode=0)
+        result = detect_pr_number()
+        assert result is None
+
+    @patch("devx.tools._shared.subprocess.run")
+    def test_detect_pr_git_failure(self, mock_run: MagicMock) -> None:
+        """detect_pr_number returns None when git command fails."""
+        from devx.tools._shared import detect_pr_number
+
+        mock_run.return_value = MagicMock(stdout="", stderr="error", returncode=1)
+        result = detect_pr_number()
+        assert result is None
+
+    @patch("devx.tools._shared.subprocess.run")
+    @patch.dict("os.environ", {}, clear=True)
+    def test_detect_pr_no_token(self, mock_run: MagicMock) -> None:
+        """detect_pr_number returns None when CI_GITEA_TOKEN is not set."""
+        from devx.tools._shared import detect_pr_number
+
+        mock_run.return_value = MagicMock(stdout="feature\n", returncode=0)
+        result = detect_pr_number()
+        assert result is None
+
+    @patch("devx.tools._shared.subprocess.run")
+    @patch.dict("os.environ", {"CI_GITEA_TOKEN": "tok", "GITHUB_REPOSITORY": "owner/repo"}, clear=True)
+    @patch("devx.api_clients.GiteaClient")
+    def test_detect_pr_github_repo_fallback(self, mock_client_cls: MagicMock, mock_run: MagicMock) -> None:
+        """detect_pr_number uses GITHUB_REPOSITORY as fallback for owner/repo."""
+        from devx.tools._shared import detect_pr_number
+
+        mock_run.return_value = MagicMock(stdout="feature\n", returncode=0)
+        mock_client = MagicMock()
+        mock_client.list_prs.return_value = [{"number": 7, "head": {"ref": "feature"}}]
+        mock_client_cls.return_value = mock_client
+
+        result = detect_pr_number()
+        assert result == 7
+
+    @patch("devx.tools._shared.subprocess.run")
+    @patch.dict("os.environ", {"CI_GITEA_TOKEN": "tok", "GITHUB_REPOSITORY": "invalid-no-slash"}, clear=True)
+    def test_detect_pr_github_repo_no_slash(self, mock_run: MagicMock) -> None:
+        """GITHUB_REPOSITORY without slash is ignored, returns None."""
+        from devx.tools._shared import detect_pr_number
+
+        mock_run.return_value = MagicMock(stdout="feature\n", returncode=0)
+        result = detect_pr_number()
+        assert result is None
+
+    @patch("devx.tools._shared.subprocess.run")
+    @patch.dict("os.environ", _FULL_ENV, clear=True)
+    @patch("devx.api_clients.GiteaClient")
+    def test_detect_pr_api_error_returns_none(self, mock_client_cls: MagicMock, mock_run: MagicMock) -> None:
+        """detect_pr_number returns None when API call fails (best-effort)."""
+        from devx.api_clients import APIError
+        from devx.tools._shared import detect_pr_number
+
+        mock_run.return_value = MagicMock(stdout="feature\n", returncode=0)
+        mock_client = MagicMock()
+        mock_client.list_prs.side_effect = APIError(401, "Unauthorized")
+        mock_client_cls.return_value = mock_client
+
+        result = detect_pr_number()
+        assert result is None
+
+
+class TestRebaseTool:
+    """Tests for the local rebase tool (devx.tools.rebase)."""
+
+    @patch("devx.tools.rebase._run_git")
+    def test_rebase_already_up_to_date(self, mock_run_git: MagicMock) -> None:
+        """When branch is up-to-date, no rebase or push happens."""
+        mock_run_git.side_effect = [
+            MagicMock(stdout="feature-branch\n", returncode=0),  # rev-parse
+            MagicMock(stdout="", returncode=0),  # fetch
+            MagicMock(stdout="0\n", returncode=0),  # rev-list --count
+        ]
+
+        runner = CliRunner()
+        result = runner.invoke(rebase_main, [])
+        assert result.exit_code == 0
+        assert "already up-to-date" in result.output.lower()
+
+    @patch("devx.tools.rebase._run_git")
+    def test_rebase_behind_master_success(self, mock_run_git: MagicMock) -> None:
+        """When behind master, rebase and force-push."""
+        mock_run_git.side_effect = [
+            MagicMock(stdout="feature-branch\n", returncode=0),  # rev-parse
+            MagicMock(stdout="", returncode=0),  # fetch
+            MagicMock(stdout="2\n", returncode=0),  # rev-list --count (behind by 2)
+            MagicMock(stdout="", stderr="", returncode=0),  # rebase
+            MagicMock(stdout="", stderr="", returncode=0),  # push
+        ]
+
+        runner = CliRunner()
+        result = runner.invoke(rebase_main, [])
+        assert result.exit_code == 0
+        assert "2 commit(s) behind" in result.output
+        assert "rebase successful" in result.output.lower()
+        assert "pushed" in result.output.lower()
+
+    @patch("devx.tools.rebase._run_git")
+    def test_rebase_no_push_flag(self, mock_run_git: MagicMock) -> None:
+        """With --no-push, rebase happens but no push."""
+        mock_run_git.side_effect = [
+            MagicMock(stdout="feature-branch\n", returncode=0),  # rev-parse
+            MagicMock(stdout="", returncode=0),  # fetch
+            MagicMock(stdout="1\n", returncode=0),  # rev-list --count
+            MagicMock(stdout="", stderr="", returncode=0),  # rebase
+        ]
+
+        runner = CliRunner()
+        result = runner.invoke(rebase_main, ["--no-push"])
+        assert result.exit_code == 0
+        assert "rebase successful" in result.output.lower()
+        # Only 4 git calls (no push)
+        assert mock_run_git.call_count == 4
+
+    @patch("devx.tools.rebase._run_git")
+    def test_rebase_detached_head_fails(self, mock_run_git: MagicMock) -> None:
+        """Detached HEAD should fail immediately."""
+        mock_run_git.return_value = MagicMock(stdout="HEAD\n", returncode=0)
+
+        runner = CliRunner()
+        result = runner.invoke(rebase_main, [])
+        assert result.exit_code != 0
+        assert "detached" in result.output.lower()
+
+    @patch("devx.tools.rebase._run_git")
+    def test_rebase_branch_detection_failure(self, mock_run_git: MagicMock) -> None:
+        """Git rev-parse failure should exit with error."""
+        mock_run_git.return_value = MagicMock(stdout="", stderr="fatal: not a repo", returncode=1)
+
+        runner = CliRunner()
+        result = runner.invoke(rebase_main, [])
+        assert result.exit_code != 0
+        assert "could not detect" in result.output.lower()
+
+    @patch("devx.tools.rebase._run_git")
+    def test_rebase_conflict_fails(self, mock_run_git: MagicMock) -> None:
+        """Rebase conflict should exit with error."""
+        mock_run_git.side_effect = [
+            MagicMock(stdout="feature-branch\n", returncode=0),  # rev-parse
+            MagicMock(stdout="", returncode=0),  # fetch
+            MagicMock(stdout="1\n", returncode=0),  # rev-list --count
+            MagicMock(stdout="", stderr="CONFLICT", returncode=1),  # rebase fails
+        ]
+
+        runner = CliRunner()
+        result = runner.invoke(rebase_main, [])
+        assert result.exit_code != 0
+        assert "rebase failed" in result.output.lower()
+
+    @patch("devx.tools.rebase._run_git")
+    def test_rebase_fetch_failure(self, mock_run_git: MagicMock) -> None:
+        """Fetch failure should exit with error."""
+        mock_run_git.side_effect = [
+            MagicMock(stdout="feature-branch\n", returncode=0),  # rev-parse
+            MagicMock(stdout="", stderr="network error", returncode=1),  # fetch fails
+        ]
+
+        runner = CliRunner()
+        result = runner.invoke(rebase_main, [])
+        assert result.exit_code != 0
+        assert "fetch failed" in result.output.lower()
+
+    @patch("devx.tools.rebase._run_git")
+    def test_rebase_push_failure(self, mock_run_git: MagicMock) -> None:
+        """Force-push rejection should exit with error."""
+        mock_run_git.side_effect = [
+            MagicMock(stdout="feature-branch\n", returncode=0),  # rev-parse
+            MagicMock(stdout="", returncode=0),  # fetch
+            MagicMock(stdout="1\n", returncode=0),  # rev-list --count
+            MagicMock(stdout="", stderr="", returncode=0),  # rebase
+            MagicMock(stdout="", stderr="rejected", returncode=1),  # push fails
+        ]
+
+        runner = CliRunner()
+        result = runner.invoke(rebase_main, [])
+        assert result.exit_code != 0
+        assert "force-push failed" in result.output.lower()
+
+
+class TestPrRebaseTool:
+    """Tests for the server-side PR rebase tool (devx.tools.pr_rebase)."""
+
+    @patch.dict("os.environ", _FULL_ENV, clear=True)
+    @patch("devx.tools.pr_rebase.GiteaClient")
+    def test_pr_rebase_success(self, mock_client_cls: MagicMock) -> None:
+        """Successful API rebase prints confirmation."""
+        mock_client = MagicMock()
+        mock_client_cls.return_value = mock_client
+
+        runner = CliRunner()
+        result = runner.invoke(pr_rebase_main, ["--pr", "42"])
+        assert result.exit_code == 0
+        assert "rebased successfully" in result.output.lower()
+        mock_client.update_pr_branch.assert_called_once_with(42, style="rebase")
+
+    @patch.dict("os.environ", _FULL_ENV, clear=True)
+    @patch("devx.tools.pr_rebase.GiteaClient")
+    def test_pr_rebase_api_error(self, mock_client_cls: MagicMock) -> None:
+        """API error during rebase exits with error."""
+        from devx.api_clients import APIError
+
+        mock_client = MagicMock()
+        mock_client.update_pr_branch.side_effect = APIError(409, "Conflict")
+        mock_client_cls.return_value = mock_client
+
+        runner = CliRunner()
+        result = runner.invoke(pr_rebase_main, ["--pr", "42"])
+        assert result.exit_code != 0
+        assert "rebase failed" in result.output.lower()
+
+    @patch("devx.tools.pr_rebase.load_dotenv")
+    @patch.dict("os.environ", {}, clear=True)
+    def test_pr_rebase_no_token(self, _mock_load: MagicMock) -> None:
+        """Missing CI_GITEA_TOKEN should fail."""
+        runner = CliRunner()
+        result = runner.invoke(pr_rebase_main, ["--pr", "42"])
+        assert result.exit_code != 0
+        assert "CI_GITEA_TOKEN" in result.output
+
+    @patch.dict("os.environ", _FULL_ENV, clear=True)
+    @patch("devx.tools.pr_rebase.detect_pr_number", return_value=None)
+    def test_pr_rebase_no_pr_detected(self, _mock_detect: MagicMock) -> None:
+        """When PR number can't be auto-detected, fail with instructions."""
+        runner = CliRunner()
+        result = runner.invoke(pr_rebase_main, [])
+        assert result.exit_code != 0
+        assert "could not detect" in result.output.lower()
+
+    @patch("devx.tools.pr_rebase.load_dotenv")
+    @patch.dict("os.environ", {"CI_GITEA_TOKEN": "tok"}, clear=True)
+    @patch("devx.tools.pr_rebase.GiteaClient")
+    def test_pr_rebase_no_repo_env(self, _mock_client: MagicMock, _mock_load: MagicMock) -> None:
+        """Missing repo env vars should fail."""
+        runner = CliRunner()
+        result = runner.invoke(pr_rebase_main, ["--pr", "42"])
+        assert result.exit_code != 0
+        assert "DEVX_REPO_OWNER" in result.output
+
+    @patch("devx.tools.pr_rebase.load_dotenv")
+    @patch.dict("os.environ", {"CI_GITEA_TOKEN": "tok", "GITHUB_REPOSITORY": "owner/repo"}, clear=True)
+    @patch("devx.tools.pr_rebase.GiteaClient")
+    def test_pr_rebase_github_repo_fallback(self, mock_client_cls: MagicMock, _mock_load: MagicMock) -> None:
+        """GITHUB_REPOSITORY env var is used as fallback for owner/repo."""
+        mock_client = MagicMock()
+        mock_client_cls.return_value = mock_client
+
+        runner = CliRunner()
+        result = runner.invoke(pr_rebase_main, ["--pr", "42"])
+        assert result.exit_code == 0
+        mock_client.update_pr_branch.assert_called_once_with(42, style="rebase")