git-worktrees 0.4.2__tar.gz → 0.4.3__tar.gz

{git_worktrees-0.4.2 → git_worktrees-0.4.3}/AGENTS.md

@@ -300,10 +300,10 @@ regions. `git merge-tree` reports a conflict, and a diff cannot tell that
 from real work left over. There is no content probe that answers this.
 
 So the forge answers it, asked last because it costs a round trip and only
-where git already failed. A merged request is cross-checked against
-`unpushed_count`: it speaks for what reached it, never for commits nobody
-pushed, and no upstream at all stays `unknown` rather than becoming zero.
-`--no-forge` keeps a run offline.
+where git already failed. A merged request with a configured upstream that
+Git reports as `[gone]` permits pruning, subject to the worktree protections.
+When the upstream exists, `unpushed_count` checks for local commits it lacks.
+No upstream configured stays `unknown`. `--no-forge` keeps a run offline.
 
 ## Three verdicts, and the third is not a softer second
 

{git_worktrees-0.4.2 → git_worktrees-0.4.3}/CHANGELOG.md

@@ -17,6 +17,14 @@ not in here, whatever it cost to build.
 A release closes with a `### Choices` section when a decision in it is worth
 the reader's time: what was chosen, and what the alternative failed to do.
 
+## 0.4.3 - 2026-09-22
+
+### Fixed
+
+`gwp` can prune a branch whose pull request is merged and whose configured
+upstream is gone. Branches with no upstream configured remain unknown.
+Forge-confirmed branches with ignored files require `--delete-ignored`.
+
 ## 0.4.2 - 2026-09-22
 
 CLI behavior is unchanged from 0.4.1.

{git_worktrees-0.4.2 → git_worktrees-0.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: git-worktrees
-Version: 0.4.2
+Version: 0.4.3
 Summary: Git worktree commands that refuse to lose work.
 Project-URL: Bug reports, https://github.com/MihaiBojin/worktrees/issues/new
 Project-URL: Source, https://github.com/MihaiBojin/worktrees
@@ -223,10 +223,12 @@ Where git cannot tell, the forge is asked. A branch merged as part of a
 stack is that case: its changes reach the head branch across several
 squashes, so the intermediate state it holds differs from the final one in
 the same regions, and a diff cannot separate a stale branch from one with
-work left. A merged pull request settles it, cross-checked against the
-commits an upstream has not got, because a request speaks for what reached
-it and nothing about what never did. `--no-forge` decides from git alone, and
-so does a run whose fetch just failed.
+work left. A merged pull request with a configured upstream that is gone
+makes the branch eligible for pruning. When the upstream still exists,
+unpushed commits keep the branch. A branch with no upstream configured
+stays `unknown`. Worktree protections still apply, including the check for
+ignored files. `--no-forge` decides from git alone, and so does a run whose
+fetch just failed.
 
 The question goes to the repository the command is standing in and nowhere
 else. `GH_REPO` and `GITLAB_REPO` beat that directory, so both are dropped

{git_worktrees-0.4.2 → git_worktrees-0.4.3}/README.md

@@ -197,10 +197,12 @@ Where git cannot tell, the forge is asked. A branch merged as part of a
 stack is that case: its changes reach the head branch across several
 squashes, so the intermediate state it holds differs from the final one in
 the same regions, and a diff cannot separate a stale branch from one with
-work left. A merged pull request settles it, cross-checked against the
-commits an upstream has not got, because a request speaks for what reached
-it and nothing about what never did. `--no-forge` decides from git alone, and
-so does a run whose fetch just failed.
+work left. A merged pull request with a configured upstream that is gone
+makes the branch eligible for pruning. When the upstream still exists,
+unpushed commits keep the branch. A branch with no upstream configured
+stays `unknown`. Worktree protections still apply, including the check for
+ignored files. `--no-forge` decides from git alone, and so does a run whose
+fetch just failed.
 
 The question goes to the repository the command is standing in and nowhere
 else. `GH_REPO` and `GITLAB_REPO` beat that directory, so both are dropped

{git_worktrees-0.4.2 → git_worktrees-0.4.3}/pyproject.toml

@@ -9,7 +9,7 @@ authors = [
 ]
 # Static, and the single source of truth for the version. Bump it in a pull
 # request and run `uv lock`; the release tag only has to agree with it.
-version = "0.4.2"
+version = "0.4.3"
 # The standard library answers every question this asks. A dependency here
 # would be paid on every invocation, and an invocation is 67 ms of which 25 ms
 # is the interpreter starting.

{git_worktrees-0.4.2 → git_worktrees-0.4.3}/src/worktrees/forge.py

@@ -6,9 +6,9 @@ state it holds differs from the final one in the same regions, so a stale
 branch whose work is upstream and a branch with real work left look exactly
 alike to a diff.
 
-The forge knows. It is asked last, because it costs a round trip and because
-it can be wrong about work pushed after the merge, which is why the answer is
-cross-checked against the commits an upstream has not got.
+The forge is asked after the content checks. An existing upstream is checked
+for unpushed commits. A merged request with a missing configured upstream
+permits pruning, subject to the worktree protections.
 """
 
 from __future__ import annotations

{git_worktrees-0.4.2 → git_worktrees-0.4.3}/src/worktrees/repo.py

@@ -59,6 +59,11 @@ def upstream_of(branch: str) -> None:
     """The upstream a branch tracks. Failure means unknown, not none."""
 
 
+@git("for-each-ref --format=%(upstream:track) refs/heads/$branch")
+def upstream_tracking(branch: str) -> None:
+    """Tracking status, including [gone] for a missing configured upstream."""
+
+
 @git("rev-list --count $a..$b", ok=(0, 128))
 def count_between(a: str, b: str) -> None:
     """How many commits b has that a does not."""

{git_worktrees-0.4.2 → git_worktrees-0.4.3}/src/worktrees/verdicts.py

@@ -185,11 +185,9 @@ def _forge_reason(
     Returns (reason, verdict), or ("", "") when the forge said nothing and
     the content probes keep the answer.
 
-    A merged request speaks for what was pushed. Commits an upstream has not
-    got were never in it, and a branch with no upstream at all leaves that
-    unknown rather than zero: branches made here do not track, so "no
-    upstream" is the normal state for exactly the ones this would otherwise
-    reap.
+    A merged request with a missing configured upstream permits pruning.
+    An existing upstream is checked for unpushed commits. A branch with no
+    tracking configuration stays unknown.
     """
     request = forge.request_for(branch, repo=repo)
     if request is None or request.state not in ("MERGED", "CLOSED"):
@@ -198,6 +196,18 @@ def _forge_reason(
     lower = request.state.lower()
     unpushed = R.unpushed_count(branch, repo=repo)
     if unpushed is None:
+        if R.upstream_tracking(branch, repo=repo).out.strip() == "[gone]":
+            if request.state == "MERGED":
+                return (
+                    f"its {request.noun} #{request.number} is merged "
+                    "and its upstream is gone",
+                    "",
+                )
+            return (
+                f"its {request.noun} is {lower}, but its upstream is gone; "
+                "cannot check for unpushed commits",
+                UNKNOWN,
+            )
         return (
             f"its {request.noun} is {lower}, but the branch has no upstream "
             "to have been pushed to",
@@ -209,4 +219,4 @@ def _forge_reason(
             "are not in it",
             KEEP,
         )
-    return f"its {request.noun} #{request.number} is {lower}", REMOVE
+    return f"its {request.noun} #{request.number} is {lower}", ""

{git_worktrees-0.4.2 → git_worktrees-0.4.3}/tests/test_forge.py

@@ -94,6 +94,22 @@ def test_a_merged_request_cannot_speak_for_unpushed_commits(world, with_forge) -
     assert "1 commit(s) here are not in it" in row.why
 
 
+@pytest.mark.parametrize("delete_ignored", [False, True])
+def test_a_merged_request_with_an_existing_upstream_checks_ignored_files(
+    world, with_forge, delete_ignored
+):
+    with_forge([{"number": 12, "state": "MERGED"}])
+    wt = world.worktree("stacked")
+    world.commit(".gitignore", "cache\n", at=wt)
+    _push(world, "stacked", wt)
+    (wt / "cache").write_text("keep\n")
+    rows = verdicts.assess(
+        R.worktrees(), "", "refs/heads/main", "main", delete_ignored, ask_forge=True
+    )
+    row = next(v for v in rows if v.branch == "stacked")
+    assert row.verdict == (verdicts.REMOVE if delete_ignored else verdicts.KEEP)
+
+
 def test_no_upstream_is_unknown_rather_than_zero(world, with_forge) -> None:
     """Branches made here do not track, so this is the normal state for
     exactly the ones a merged request would otherwise reap."""
@@ -109,6 +125,88 @@ def test_no_upstream_is_unknown_rather_than_zero(world, with_forge) -> None:
     assert "no upstream" in row.why
 
 
+@pytest.fixture
+def gone_upstream(world):
+    wt = world.worktree("stacked")
+    sha = world.commit("s.txt", "s\n", at=wt)
+    _push(world, "stacked", wt)
+    world.git(
+        "update-ref", "-d", "refs/heads/stacked", sha, at=world.root / "stacked.git"
+    )
+    world.git("fetch", "--prune", "origin")
+    assert world.git("config", "--get", "branch.stacked.merge") == "refs/heads/stacked"
+    assert not R.upstream_of("stacked")
+    assert R.unpushed_count("stacked") is None
+    return wt
+
+
+@pytest.mark.parametrize("state", ["MERGED", "CLOSED", "OPEN", None])
+def test_a_gone_upstream_requires_a_merged_request(
+    world, with_forge, gone_upstream, state
+):
+    with_forge([{"number": 12, "state": state}] if state else [])
+    rows = verdicts.assess(
+        R.worktrees(), "", "refs/heads/main", "main", False, ask_forge=True
+    )
+    row = next(v for v in rows if v.branch == "stacked")
+    assert row.verdict == (verdicts.REMOVE if state == "MERGED" else verdicts.UNKNOWN)
+    if state == "MERGED":
+        assert row.why == "its pull request #12 is merged and its upstream is gone"
+    elif state == "CLOSED":
+        assert "upstream is gone" in row.why
+
+
+@pytest.mark.parametrize("protection", ["dirty", "ignored", "locked", "current"])
+def test_a_merged_request_with_a_gone_upstream_keeps_worktree_protections(
+    world, with_forge, gone_upstream, protection
+):
+    with_forge([{"number": 12, "state": "MERGED"}])
+    if protection == "dirty":
+        (gone_upstream / "s.txt").write_text("unfinished\n")
+    elif protection == "ignored":
+        world.git("config", "core.excludesFile", str(world.root / "ignore"))
+        (world.root / "ignore").write_text("cache\n")
+        (gone_upstream / "cache").write_text("keep\n")
+    elif protection == "locked":
+        world.git("worktree", "lock", str(gone_upstream))
+    rows = verdicts.assess(
+        R.worktrees(),
+        "",
+        "refs/heads/main",
+        "main",
+        False,
+        here=str(gone_upstream) if protection == "current" else "",
+        ask_forge=True,
+    )
+    row = next(v for v in rows if v.branch == "stacked")
+    assert row.verdict == verdicts.KEEP
+
+
+def test_prune_removes_a_merged_branch_with_a_gone_upstream(
+    world, with_forge, gone_upstream
+):
+    bin_dir = with_forge([{"number": 12, "state": "MERGED"}])
+    env = env_for(world)
+    env["PATH"] = f"{bin_dir}{os.pathsep}{env['PATH']}"
+    proc = subprocess.run(
+        [
+            sys.executable,
+            "-c",
+            "from worktrees.cli import gwp; raise SystemExit(gwp())",
+            "--no-fetch",
+            "--yes",
+        ],
+        cwd=str(world.repo),
+        capture_output=True,
+        text=True,
+        env=env,
+    )
+    assert proc.returncode == 0, proc.stderr
+    assert not gone_upstream.exists()
+    assert not R.ref_exists("refs/heads/stacked")
+    assert world.repo.exists()
+
+
 def test_an_open_request_decides_nothing(world, with_forge) -> None:
     with_forge([{"number": 12, "state": "OPEN"}])
     wt = world.worktree("live")

{git_worktrees-0.4.2 → git_worktrees-0.4.3}/uv.lock

@@ -40,7 +40,7 @@ wheels = [
 
 [[package]]
 name = "git-worktrees"
-version = "0.4.2"
+version = "0.4.3"
 source = { editable = "." }
 
 [package.optional-dependencies]