Merge branch 'main' into fix/cp-sat-feasible-warning

Author: vitali87

README.md

@@ -115,7 +115,7 @@ Shows a table with each sub-PR's ID, title, branch, PR number, live state (OPEN/
 pr-split merge
 ```
 
-Walks the dependency DAG and merges each PR in topological order. Skips already-merged, closed, draft, review-required, or changes-requested PRs. Stops if a merge fails or a dependency wasn't merged to prevent out-of-order merges.
+Walks the dependency DAG and merges each PR in topological order. Skips already-merged, closed, draft, review-required, or changes-requested PRs, and every PR whose dependency was not merged in this run (independent subtrees still proceed). Stops if a merge fails. Exits 1 whenever a merge failed or any PR was left blocked, so re-run once the blocking PRs are ready.
 
 Use `--auto` to queue merges behind CI checks (uses `gh pr merge --auto`):
 

pr_split/cli.py

@@ -66,7 +66,7 @@
     push_branch,
     remove_worktree,
 )
-from .git_ops.branches import run_git
+from .git_ops.branches import commit_exists, run_git
 from .git_ops.prs import close_pr, create_pr, get_pr_state, link_stack, merge_pr
 from .graph import PlanDAG
 from .plan_store import load_plan, plan_exists, save_plan
@@ -948,9 +948,13 @@ def split(
     typer.confirm("Proceed with creating branches and PRs?", abort=True)
 
     namespace = derive_split_namespace(dev_branch_arg)
-    branch_records = _create_branches_and_commits(
-        groups, parsed_diff, base, merge_base_ref, namespace, author=author, stacked=stack
-    )
+    try:
+        branch_records = _create_branches_and_commits(
+            groups, parsed_diff, base, merge_base_ref, namespace, author=author, stacked=stack
+        )
+    except PRSplitError as exc:
+        console.print(f"[red]{exc}[/red]")
+        raise typer.Exit(1) from exc
     try:
         pr_records = _push_and_create_prs(groups, branch_records, draft=draft)
     except PRCreationError as exc:
@@ -1125,6 +1129,13 @@ def execute(
             " Re-run 'pr-split split --dry-run' to regenerate.[/red]"
         )
         raise typer.Exit(1)
+    if not commit_exists(plan.merge_base_sha):
+        console.print(
+            f"[red]Plan's merge base {plan.merge_base_sha} is not in this repository "
+            "(plan copied from another checkout, or history rewritten). "
+            "Fetch it or re-run 'pr-split split --dry-run' to regenerate.[/red]"
+        )
+        raise typer.Exit(1)
 
     if not branch_exists(plan.base_branch):
         console.print(f"[red]{ErrorMsg.BRANCH_NOT_FOUND(branch=plan.base_branch)}[/red]")
@@ -1157,15 +1168,19 @@ def execute(
     typer.confirm("Proceed with creating branches and PRs?", abort=True)
 
     namespace = derive_split_namespace(plan.dev_branch_arg or plan.dev_branch)
-    branch_records = _create_branches_and_commits(
-        plan.groups,
-        parsed_diff,
-        plan.base_branch,
-        plan.merge_base_sha,
-        namespace,
-        author=plan.author,
-        stacked=plan.stacked,
-    )
+    try:
+        branch_records = _create_branches_and_commits(
+            plan.groups,
+            parsed_diff,
+            plan.base_branch,
+            plan.merge_base_sha,
+            namespace,
+            author=plan.author,
+            stacked=plan.stacked,
+        )
+    except PRSplitError as exc:
+        console.print(f"[red]{exc}[/red]")
+        raise typer.Exit(1) from exc
     try:
         pr_records = _push_and_create_prs(plan.groups, branch_records, draft=plan.draft)
     except PRCreationError as exc:
@@ -1277,6 +1292,7 @@ def merge_all(
     merged: list[str] = []
     skipped: list[str] = []
     skipped_ids: set[str] = set()
+    blocked: list[str] = []
     failed: list[str] = []
 
     stopped = False
@@ -1305,6 +1321,18 @@ def merge_all(
                 merged.append(group_id)
                 continue
 
+            # Checked after the live state so a PR that already merged on GitHub
+            # (e.g. into a still-open parent branch) counts as merged rather
+            # than being reported as blocked.
+            unmerged_parents = [dep for dep in dag.parents(group_id) if dep not in merged]
+            if unmerged_parents:
+                deps = ", ".join(unmerged_parents)
+                logger.warning(f"{group_id} depends on unmerged {deps}, skipping")
+                skipped_ids.add(group_id)
+                blocked.append(group_id)
+                skipped.append(f"{group_id} (dependency {deps} not merged)")
+                continue
+
             if state != "OPEN":
                 logger.warning(f"PR #{pr_record.pr_number} ({group_id}) is {state}, skipping")
                 skipped_ids.add(group_id)
@@ -1366,9 +1394,20 @@ def merge_all(
         console.print(f"[yellow]Skipped ({len(skipped)}): {', '.join(skipped)}[/yellow]")
     if failed:
         console.print(f"[red]Failed ({len(failed)}): {', '.join(failed)}[/red]")
+    if blocked:
+        console.print(
+            f"[yellow]Blocked by unmerged dependencies ({len(blocked)}): "
+            f"{', '.join(blocked)}. Re-run once those PRs are merged.[/yellow]"
+        )
     if notify:
         exit_reason = (
-            "merge_error" if stopped else "incomplete_batch" if exited_early else "success"
+            "merge_error"
+            if stopped
+            else "incomplete_batch"
+            if exited_early
+            else "unmerged_dependency"
+            if blocked
+            else "success"
         )
         skipped_structured = [{"id": s.split(" (")[0], "reason": s} for s in skipped]
         _send_webhook(
@@ -1378,11 +1417,11 @@ def merge_all(
                 "merged": merged,
                 "skipped": skipped_structured,
                 "failed": failed,
-                "success": not (failed or stopped or exited_early),
+                "success": not (failed or stopped or exited_early or blocked),
                 "exit_reason": exit_reason,
             },
         )
 
-    if failed or stopped or exited_early:
+    if failed or stopped or exited_early or blocked:
         raise typer.Exit(1)
     logger.success(f"Merge complete: {len(merged)} PRs merged")

pr_split/exceptions.py

@@ -26,6 +26,10 @@ class ErrorMsg(StrEnum):
     MERGE_CONFLICT = "Groups '{a}' and '{b}' modify overlapping regions in '{file}'"
     NO_PLAN = "No split plan found; run 'pr-split split' first"
     LLM_PARSE_ERROR = "Failed to parse LLM response: {detail}"
+    LLM_OUTPUT_TRUNCATED = (
+        "LLM response was cut off before the plan was complete ({detail});"
+        " the partial plan cannot be trusted"
+    )
     BRANCH_CREATE_FAILED = "Failed to create branch '{branch}': {detail}"
     PR_CREATE_FAILED = "Failed to create PR for group '{group}': {detail}"
     MERGE_FAILED = "Merge of '{source}' into '{target}' failed: {detail}"

pr_split/git_ops/branches.py

@@ -32,6 +32,15 @@ def run_git_in_dir(cwd: str, *args: str) -> str:
     return result.stdout.strip()
 
 
+def commit_exists(ref: str) -> bool:
+    """True if ``ref`` resolves to a commit object in this repository."""
+    try:
+        run_git("cat-file", "-e", f"{ref}^{{commit}}")
+    except GitOperationError:
+        return False
+    return True
+
+
 def branch_exists(branch: str) -> bool:
     try:
         run_git("rev-parse", "--verify", branch)

pr_split/logs.py

@@ -44,6 +44,7 @@
 LLM_OUTPUT_TRUNCATED = (
     "LLM output truncated (stop_reason: {stop_reason}), keys in partial output: {keys}"
 )
+LLM_OUTPUT_INCOMPLETE = "LLM output incomplete (status: {status}, reason: {reason})"
 CHUNK_RETRY = "Chunk {index}/{total} failed (attempt {attempt}), retrying: {error}"
 INVALID_HUNK_INDEX = (
     "Group '{group}': invalid hunk index {index} for {file} (max: {max}), skipping"

pr_split/planner/client.py

@@ -131,13 +131,20 @@ def _call_anthropic(system: str, user: str, *, settings: Settings) -> RawToolOut
     except anthropic.APIError as exc:
         raise LLMError(ErrorMsg.LLM_PARSE_ERROR(detail=str(exc))) from exc
     if response.stop_reason != "tool_use":
+        # A max_tokens stop means the tool input was cut off mid-plan.
+        # Accepting it would silently drop groups and let
+        # assign_uncovered_hunks paper over the gap, so fail and let the
+        # chunk retry loop / caller handle it. Other stop reasons without a
+        # tool block are reported below as "no tool_use block".
         stop_reason = getattr(response, "stop_reason", "unknown")
         keys: list[str] = []
         for block in getattr(response, "content", []):
             if isinstance(block, BetaToolUseBlock) and isinstance(block.input, dict):
                 keys = list(block.input.keys())
                 break
         logger.warning(logs.LLM_OUTPUT_TRUNCATED.format(stop_reason=stop_reason, keys=keys))
+        if stop_reason == "max_tokens":
+            raise LLMError(ErrorMsg.LLM_OUTPUT_TRUNCATED(detail=f"stop_reason={stop_reason}"))
     for block in response.content:
         if isinstance(block, BetaToolUseBlock) and block.name == SPLIT_TOOL_NAME:
             return RawToolOutput(groups=_extract_raw_output(block.input))
@@ -156,6 +163,12 @@ def _call_openai(system: str, user: str, *, settings: Settings) -> RawToolOutput
         )
     except openai.APIError as exc:
         raise LLMError(ErrorMsg.LLM_PARSE_ERROR(detail=str(exc))) from exc
+    status = getattr(response, "status", None)
+    if status == "incomplete":
+        details = getattr(response, "incomplete_details", None)
+        reason = getattr(details, "reason", None) or "unknown"
+        logger.warning(logs.LLM_OUTPUT_INCOMPLETE.format(status=status, reason=reason))
+        raise LLMError(ErrorMsg.LLM_OUTPUT_TRUNCATED(detail=f"status={status}, reason={reason}"))
     for item in response.output:
         if item.type == "function_call" and item.name == SPLIT_TOOL_NAME:
             try:

tests/test_cli_coverage.py

@@ -651,6 +651,67 @@ def test_execute_missing_raw_diff(self, mock_pe: MagicMock, mock_load: MagicMock
         result = runner.invoke(app, ["execute"])
         assert result.exit_code != 0
 
+    @patch("pr_split.cli.commit_exists", return_value=False)
+    @patch("pr_split.cli.load_plan")
+    @patch("pr_split.cli.plan_exists", return_value=True)
+    def test_execute_unknown_merge_base_sha_is_a_clean_error(
+        self, mock_pe: MagicMock, mock_load: MagicMock, mock_commit: MagicMock
+    ) -> None:
+        mock_plan_file = MagicMock()
+        mock_plan_file.git_state.branches = []
+        mock_plan_file.git_state.prs = []
+        mock_plan_file.plan.raw_diff = "some diff"
+        mock_plan_file.plan.merge_base_sha = "0123456789abcdef"
+        mock_load.return_value = mock_plan_file
+        result = runner.invoke(app, ["execute"])
+        assert result.exit_code == 1
+        assert result.exception is None or isinstance(result.exception, SystemExit)
+        assert "merge base 0123456789abcdef is not in this repository" in result.output
+        mock_commit.assert_called_once_with("0123456789abcdef")
+
+    @patch(
+        "pr_split.cli._create_branches_and_commits",
+        side_effect=PRSplitError("3 branch(es) failed"),
+    )
+    @patch("pr_split.cli.typer.confirm", return_value=True)
+    @patch("pr_split.cli.validate_coverage")
+    @patch("pr_split.cli.parse_diff")
+    @patch("pr_split.cli.commit_exists", return_value=True)
+    @patch("pr_split.cli.check_gh_auth", return_value=True)
+    @patch("pr_split.cli.is_worktree_clean", return_value=True)
+    @patch("pr_split.cli.branch_exists", return_value=True)
+    @patch("pr_split.cli.load_plan")
+    @patch("pr_split.cli.plan_exists", return_value=True)
+    def test_execute_branch_creation_failure_is_a_clean_error(
+        self,
+        mock_pe: MagicMock,
+        mock_load: MagicMock,
+        mock_be: MagicMock,
+        mock_clean: MagicMock,
+        mock_auth: MagicMock,
+        mock_commit: MagicMock,
+        mock_parse: MagicMock,
+        mock_validate: MagicMock,
+        mock_confirm: MagicMock,
+        mock_create: MagicMock,
+    ) -> None:
+        mock_plan_file = MagicMock()
+        mock_plan_file.git_state.branches = []
+        mock_plan_file.git_state.prs = []
+        mock_plan_file.plan.raw_diff = "some diff"
+        mock_plan_file.plan.merge_base_sha = "abc123"
+        mock_plan_file.plan.stacked = False
+        mock_plan_file.plan.dev_branch_arg = "feature"
+        mock_plan_file.plan.dev_branch = "feature"
+        mock_plan_file.plan.base_branch = "main"
+        mock_plan_file.plan.groups = [_group("pr-1", "t", files=["a.py"])]
+        mock_load.return_value = mock_plan_file
+        result = runner.invoke(app, ["execute"])
+        assert result.exit_code == 1
+        assert result.exception is None or isinstance(result.exception, SystemExit)
+        assert "3 branch(es) failed" in result.output
+
+    @patch("pr_split.cli.commit_exists", return_value=True)
     @patch("pr_split.cli._remote_names", return_value={"origin"})
     @patch("pr_split.cli._create_branches_and_commits")
     @patch("pr_split.cli.typer.confirm", return_value=True)
@@ -667,6 +728,7 @@ def test_execute_rejects_a_remote_tracking_base_from_an_old_plan(
         mock_confirm: MagicMock,
         mock_create: MagicMock,
         mock_remotes: MagicMock,
+        mock_commit_exists: MagicMock,
     ) -> None:
         mock_be.side_effect = lambda ref: ref != "refs/heads/origin/main"
         mock_plan_file = MagicMock()
@@ -696,6 +758,7 @@ def test_execute_missing_merge_base_sha(
         result = runner.invoke(app, ["execute"])
         assert result.exit_code != 0
 
+    @patch("pr_split.cli.commit_exists", return_value=True)
     @patch("pr_split.cli._create_branches_and_commits")
     @patch("pr_split.cli.check_gh_auth", return_value=True)
     @patch("pr_split.cli.is_worktree_clean", return_value=True)
@@ -710,6 +773,7 @@ def test_execute_rejects_saved_plan_with_binary_files(
         mock_clean: MagicMock,
         mock_auth: MagicMock,
         mock_create: MagicMock,
+        mock_commit_exists: MagicMock,
     ) -> None:
         mock_plan_file = MagicMock()
         mock_plan_file.git_state.branches = []
@@ -732,6 +796,7 @@ def test_execute_rejects_saved_plan_with_binary_files(
         assert "img.png" in result.output
         mock_create.assert_not_called()
 
+    @patch("pr_split.cli.commit_exists", return_value=True)
     @patch("pr_split.cli._create_branches_and_commits")
     @patch("pr_split.cli.check_gh_auth", return_value=True)
     @patch("pr_split.cli.is_worktree_clean", return_value=True)
@@ -746,6 +811,7 @@ def test_execute_rejects_unknown_dependency_before_branch_creation(
         mock_clean: MagicMock,
         mock_auth: MagicMock,
         mock_create: MagicMock,
+        mock_commit_exists: MagicMock,
     ) -> None:
         mock_plan_file = MagicMock()
         mock_plan_file.git_state.branches = []