@codebend3r/che 1.2.2 → 1.2.3

package/README.md

@@ -257,7 +257,7 @@ All scripts share the same CLI conventions:
 | `clean-stale-branches` | Delete local branches whose upstream is gone | `clean-stale-branches-dr` |
 | `hard-reset-all-branches` | Check out every local branch and hard reset it to origin/<branch> | `hard-reset-all-branches-dr` |
 | `prune-worktrees` | Remove every linked worktree, then prune stale admin records | `prune-worktrees-dr` |
-| `sync-all-branches` | Update every branch and worktree, preserving locks and local work | `sync-all-branches-dr` |
+| `sync-all-branches` | Update every branch and worktree, pruning what has been merged | `sync-all-branches-dr` |
 | `update-from-origin` | Alias of sync-all-branches | `--dry-run` |
 | `update-local-branches` | Rebase every local branch that has an upstream onto origin | `--dry-run` |
 | **Video** | *Codecs, renaming, dedupe and metadata* | |
@@ -337,9 +337,20 @@ sync-all-branches-dr    # preview against cached remote refs; no fetch, no chang
   stashed and restored with their staged state; existing stashes are
   untouched. Dirty submodules and in-progress Git operations are reported and
   left alone.
-- **Nothing is destroyed.** It never pushes, hard resets or deletes branches.
-  Missing upstreams are reported, not treated as merged; use
-  `clean-stale-branches` for cleanup.
+- **No local change is discarded.** It never pushes. A branch is only moved
+  or deleted when Git can prove its changes already exist elsewhere:
+  - A diverged branch whose changes are all in its upstream (a stale copy of
+    a branch rebased and force-pushed from another machine, typically after
+    its parent was squash-merged) moves to the upstream instead of replaying
+    commits that would conflict.
+  - A branch whose upstream is gone is deleted, with its clean worktree (a
+    lock is dropped first), once it is proven merged into `origin/main`,
+    `master`, `dev` or `develop`: contained in it, its content already there
+    (squash merges included), or a merged GitHub PR. The tip SHA is printed so
+    you can restore it. A missing upstream alone is not treated as merged: an
+    unproven one is listed as `Upstream gone` and kept. A merged branch whose
+    worktree is dirty, mid-operation or your current checkout is kept and
+    reported.
 - **Failures are isolated.** A rebase conflict is aborted and reported while
   other branches continue, and any blocked branch makes the command exit
   non-zero. If restoring work conflicts, the recovery stash ID and worktree

package/bin/branchsync.py

@@ -1,20 +1,38 @@
-"""Non-destructive branch/worktree synchronization for sync-all-branches.
+"""Branch/worktree synchronization for sync-all-branches.
 
-Unlike the old delegated cleanup, sync preserves every checkout and local branch.
-Only disposable worktrees created here may be removed. Git locks need no special
-handling: they prevent removal/pruning, not a rebase inside the locked checkout.
+Sync rebases every branch onto its upstream inside its own checkout, locked or
+not, and keeps every local change. A branch is only moved past its own commits
+(reset to an upstream that already holds them) or deleted when a content check
+proves its changes are already upstream or in a main or dev branch. The only
+things it deletes are disposable worktrees it created itself and, with a merged
+branch whose upstream is gone, that branch's clean worktree.
 """
 
 from __future__ import annotations
 
+import json
+import shutil
 import subprocess
 import tempfile
 from dataclasses import dataclass, field
+from datetime import datetime
 from pathlib import Path
 
 from gitutils import Worktree, local_branches, worktrees
 from utils import info, run, run_output, success, warning
 
+# A branch is "merged" when it reached one of these on origin. They are also
+# never pruned themselves, whatever state their upstream is in.
+BASE_BRANCHES = ("main", "master", "dev", "develop")
+PROTECTED_BRANCHES = (*BASE_BRANCHES, "staging")
+
+_PROBE_IDENTITY = {
+    "GIT_AUTHOR_NAME": "che",
+    "GIT_AUTHOR_EMAIL": "che@localhost",
+    "GIT_COMMITTER_NAME": "che",
+    "GIT_COMMITTER_EMAIL": "che@localhost",
+}
+
 _OPERATION_FILES = (
     "rebase-merge",
     "rebase-apply",
@@ -50,7 +68,11 @@ class BranchSync:
     updated: list[str] = field(default_factory=list)
     current: list[str] = field(default_factory=list)
     local_only: list[str] = field(default_factory=list)
+    gone: list[str] = field(default_factory=list)
     restored: list[str] = field(default_factory=list)
+    reset: list[str] = field(default_factory=list)
+    deleted: list[str] = field(default_factory=list)
+    merged_kept: list[str] = field(default_factory=list)
     blocked: list[str] = field(default_factory=list)
     trees: list[Worktree] = field(init=False)
 
@@ -116,8 +138,11 @@ class BranchSync:
         )
 
     def includes(self, branch: str, upstream: str) -> bool:
+        return self.is_ancestor(upstream, f"refs/heads/{branch}")
+
+    def is_ancestor(self, older: str, newer: str) -> bool:
         result = run(
-            ["git", "merge-base", "--is-ancestor", upstream, f"refs/heads/{branch}"],
+            ["git", "merge-base", "--is-ancestor", older, newer],
             cwd=self.root,
             check=False,
             capture=True,
@@ -128,6 +153,33 @@ class BranchSync:
             )
         return result.returncode == 0
 
+    def adds_nothing(self, branch: str, target: str) -> bool:
+        """True when merging ``branch`` into ``target`` would leave its tree unchanged.
+
+        Decided by content, not ancestry: a squash-merged branch, or a stale copy
+        of an upstream that was rebased and force-pushed elsewhere, shares no
+        commits with ``target`` even though every change it carries is already
+        there. A conflict, unrelated histories, or a git older than 2.38 (no
+        ``--write-tree``) all answer False, so doubt never discards anything.
+        """
+        merged = run(
+            ["git", "merge-tree", "--write-tree", target, f"refs/heads/{branch}"],
+            cwd=self.root,
+            check=False,
+            capture=True,
+        )
+        if merged.returncode or not merged.stdout:
+            return False
+        tree = merged.stdout.splitlines()[0]
+        return tree == run_output(["git", "rev-parse", f"{target}^{{tree}}"], cwd=self.root)
+
+    def keep_gone(self, branch: str, upstream: str) -> None:
+        # Usually a merged PR whose remote branch was deleted, or one closed
+        # unmerged. Nothing is left to pull, so it is not a failure; keep it
+        # for the user to review.
+        info(f"  🪦 Upstream gone: {branch} ({upstream}); branch and worktree retained")
+        self.gone.append(branch)
+
     def save_wip(self, branch: str, path: Path) -> str:
         if not self.dirty(path):
             return ""
@@ -206,10 +258,21 @@ class BranchSync:
             info(f"  = Up to date: {branch} (local commits kept){f' in {path}' if path else ''}")
             self.current.append(branch)
             return
+        # Replaying commits whose content the upstream already holds conflicts
+        # for nothing: the usual cause is a parent branch squash-merged into main
+        # and this branch rebased and force-pushed from another machine. When a
+        # diverged branch adds nothing to its upstream, moving it there discards
+        # no change. A branch merely behind fast-forwards through the rebase.
+        stale = not self.is_ancestor(f"refs/heads/{branch}", upstream) and self.adds_nothing(
+            branch, upstream
+        )
         if self.dry_run:
-            info(
-                f"  🌵 Would update {branch} from {upstream}{f' in {path}' if path else ''}; stash/restore WIP if needed"
+            action = (
+                f"reset {branch} to {upstream} (its changes are already there)"
+                if stale
+                else f"update {branch} from {upstream}"
             )
+            info(f"  🌵 Would {action}{f' in {path}' if path else ''}; stash/restore WIP if needed")
             return
 
         temporary: Path | None = None
@@ -220,6 +283,29 @@ class BranchSync:
                 path = temporary / "checkout"
                 run(["git", "worktree", "add", "--quiet", str(path), branch], cwd=self.root)
             oid = self.save_wip(branch, path)
+            if stale:
+                info(
+                    f"⏩ Resetting {branch} to {upstream} in {path}; its changes are already there"
+                )
+                # --keep, not --hard: WIP is already stashed, and --keep refuses
+                # rather than overwrite anything that slipped past the stash.
+                moved = (
+                    run(
+                        ["git", "reset", "--quiet", "--keep", upstream], cwd=path, check=False
+                    ).returncode
+                    == 0
+                )
+                if not moved:
+                    warning(f"  ❌ Reset failed for {branch} in {path}")
+                    self.block(branch, f"reset failed in {path}; original commits retained")
+                restored = self.restore_wip(branch, path, oid)
+                if moved and restored:
+                    if self.includes(branch, upstream):
+                        self.reset.append(branch)
+                        success(f"  ✅ Reset to upstream: {branch}")
+                    else:
+                        self.block(branch, "verification failed: fetched upstream not included")
+                return
             info(f"⬇️ Rebasing {branch} in {path} (lock preserved)")
             # DELIBERATE DIVERGENCE: one fetched snapshot instead of pull's
             # per-branch fetch. Disable autostash/updateRefs so Git cannot
@@ -289,6 +375,159 @@ class BranchSync:
                         f"temporary worktree retained for inspection: {temporary / 'checkout'}",
                     )
 
+    def bases(self) -> list[str]:
+        return [ref for name in BASE_BRANCHES if self.has_ref(ref := f"refs/remotes/origin/{name}")]
+
+    def merged_reason(self, branch: str) -> str:
+        """How ``branch`` reached a main or dev branch on origin, or "" if unproven.
+
+        Four proofs, cheapest first: the tip is contained in the base; merging it
+        would leave the base's tree unchanged (``adds_nothing``, a squash merge
+        or a stale copy of rebased work); a one-commit probe of the branch's net
+        change is already in the base by patch ID (a squash merge whose lines
+        the base has since changed again, which ``adds_nothing`` sees as a
+        conflict); or GitHub reports a merged PR whose head is the tip, with no
+        local commit newer than the merge (covers stacked PRs rebased and
+        force-pushed before a squash).
+        """
+        tip = run_output(["git", "rev-parse", "--verify", f"refs/heads/{branch}"], cwd=self.root)
+        for base in self.bases():
+            label = base.removeprefix("refs/remotes/")
+            if (
+                run(
+                    ["git", "merge-base", "--is-ancestor", tip, base],
+                    cwd=self.root,
+                    check=False,
+                    capture=True,
+                ).returncode
+                == 0
+            ):
+                return f"contained in {label}"
+            if self.adds_nothing(branch, base):
+                return f"its content is already in {label}"
+            fork = run_output(["git", "merge-base", base, tip], cwd=self.root, check=False)
+            if not fork:
+                continue
+            probe = run_output(
+                ["git", "commit-tree", f"{tip}^{{tree}}", "-p", fork, "-m", "che squash probe"],
+                cwd=self.root,
+                check=False,
+            )
+            if probe:
+                cherry = run_output(["git", "cherry", base, probe], cwd=self.root, check=False)
+                if cherry.startswith("-"):
+                    return f"squash-merged into {label}"
+        return self.merged_pull_request(branch, tip)
+
+    def merged_pull_request(self, branch: str, tip: str) -> str:
+        origin = run_output(["git", "remote", "get-url", "origin"], cwd=self.root, check=False)
+        # The patch-ID proofs work from cached refs; this one is a network call.
+        if self.dry_run or "github.com" not in origin or shutil.which("gh") is None:
+            return ""
+        listing = run(
+            [
+                "gh",
+                "pr",
+                "list",
+                "--state",
+                "merged",
+                "--head",
+                branch,
+                "--json",
+                "number,headRefOid,mergedAt",
+            ],
+            cwd=self.root,
+            check=False,
+            capture=True,
+        )
+        if listing.returncode:
+            return ""
+        try:
+            pulls = json.loads(listing.stdout or "[]")
+        except json.JSONDecodeError:
+            return ""
+        tip_time = int(run_output(["git", "log", "-1", "--format=%ct", tip], cwd=self.root))
+        for pull in pulls:
+            contains = (
+                run(
+                    ["git", "merge-base", "--is-ancestor", tip, pull["headRefOid"]],
+                    cwd=self.root,
+                    check=False,
+                    capture=True,
+                ).returncode
+                == 0
+            )
+            merged_at = datetime.fromisoformat(pull["mergedAt"]).timestamp()
+            if contains or tip_time <= merged_at:
+                return f"PR #{pull['number']} merged"
+        return ""
+
+    def keep_worktree(self, tree: Worktree) -> str:
+        """Why a merged branch's worktree must stay, or "" when it can go."""
+        path = Path(tree.path)
+        if path.resolve() in (self.root.resolve(), Path(self.trees[0].path).resolve()):
+            return "checked out here"
+        if not path.is_dir():
+            return ""
+        if in_progress(path):
+            return f"operation in progress in {path}"
+        if self.dirty(path):
+            return f"uncommitted work in {path}"
+        return ""
+
+    def drop_gone(self, branch: str, upstream: str, occupied: dict[str, Path]) -> None:
+        """Delete ``branch`` and its clean worktree when merged; otherwise keep it.
+
+        DELIBERATE DIVERGENCE: a gone upstream used to be "not proof of a
+        merge" and was only reported. It is still not proof (a PR can be closed
+        unmerged), but it is the trigger, and the merge is proven separately by
+        :meth:`merged_reason`; an unproven branch is kept and reported as
+        `Upstream gone`, not as a failure. A merged branch's worktree is removed
+        with it when clean, and a lock is dropped first, since the branch is
+        finished; a dirty, in-progress or caller checkout is kept.
+        """
+        if branch in PROTECTED_BRANCHES:
+            info(f"  🛡️ Protected: {branch} (upstream gone)")
+            return
+        reason = self.merged_reason(branch)
+        if not reason:
+            self.keep_gone(branch, upstream)
+            return
+        tip = run_output(["git", "rev-parse", "--short", f"refs/heads/{branch}"], cwd=self.root)
+        path = occupied.get(branch)
+        tree = next((t for t in self.trees if path and Path(t.path) == path), None)
+        if tree is not None and (why := self.keep_worktree(tree)):
+            info(f"  ⏭️ Merged, kept: {branch} ({reason}; {why})")
+            self.merged_kept.append(f"{branch}: {why}")
+            return
+        if self.dry_run:
+            info(f"  🌵 Would delete merged: {branch} at {tip} ({reason})")
+            return
+        if tree is not None:
+            if tree.locked:
+                run(["git", "worktree", "unlock", tree.path], cwd=self.root, check=False)
+            removed = run(
+                [
+                    "git",
+                    "worktree",
+                    "remove",
+                    *(["--force"] if not Path(tree.path).is_dir() else []),
+                    tree.path,
+                ],
+                cwd=self.root,
+                check=False,
+            )
+            if removed.returncode:
+                self.block(branch, f"merged ({reason}) but worktree removal refused: {tree.path}")
+                return
+        if run(["git", "branch", "-D", branch], cwd=self.root, check=False).returncode:
+            self.block(branch, f"merged ({reason}) but branch deletion failed")
+            return
+        self.deleted.append(branch)
+        success(
+            f"  🗑️ Deleted merged: {branch} at {tip} ({reason}) - restore with: git branch {branch} {tip}"
+        )
+
     def update(self) -> None:
         occupied = self.occupied()
         for branch, upstream in local_branches("upstream", cwd=self.root):
@@ -298,10 +537,10 @@ class BranchSync:
                 info(f"  ℹ️ Local only: {branch} (no remote counterpart)")  # noqa: RUF001
                 self.local_only.append(branch)
                 continue
-            if not self.has_ref(upstream):
-                self.block(branch, f"upstream gone: {upstream}; branch and worktree retained")
-                continue
             try:
+                if not self.has_ref(upstream):
+                    self.drop_gone(branch, upstream, occupied)
+                    continue
                 self.sync_branch(branch, upstream, occupied)
             except (subprocess.CalledProcessError, OSError) as exc:
                 self.block(branch, f"preflight failed: {exc}")
@@ -310,15 +549,23 @@ class BranchSync:
         success("═══ summary ═══")
         for label, names in (
             ("Updated", self.updated),
+            ("Reset to upstream", self.reset),
             ("Up to date", self.current),
+            ("Deleted (merged)", self.deleted),
             ("Tracked new", tracked),
             ("Local only", self.local_only),
+            ("Upstream gone", self.gone),
             ("WIP restored", self.restored),
         ):
             info(f"{label}: {len(names)} ({', '.join(names)})")
+        if self.gone:
+            info("  Review them; clean-stale-branches removes them once you are sure.")
+        info(f"Merged, kept: {len(self.merged_kept)}")
+        for reason in self.merged_kept:
+            info(f"  • {reason}")
         info(f"Blocked: {len(self.blocked)}")
         for reason in self.blocked:
             warning(f"  • {reason}")
         info(
-            "Caller checkout, existing worktree paths, locks and local commits preserved. Nothing pushed."
+            "Caller checkout, unmerged branches, dirty worktrees and every local change preserved. Nothing pushed."
         )

package/bin/commands.py

@@ -282,7 +282,7 @@ COMMANDS: tuple[Command, ...] = (
         flags=("--dry-run", "--author=", "--limit="),
         category="git",
         icon="🔄",
-        summary="Update every branch and worktree, preserving locks and local work",
+        summary="Update every branch and worktree, pruning what has been merged",
         script="git/sync-all-branches.py",
         sound=7,
         dry_run="env",

package/bin/git/prune-worktrees.py

@@ -1,14 +1,18 @@
 #!/usr/bin/env python3
 """🌿 Remove every linked worktree in the current repository, then prune records.
 
-The main worktree (the one containing .git) is always left untouched.
+The main worktree (the one containing .git) is always left untouched. A locked
+worktree is unlocked first, since a lock only guards against an accidental
+removal and this command is the deliberate one. A worktree with uncommitted
+changes is kept, lock and all, unless --force is given; one failure never stops
+the rest.
 
 Usage:
   prune-worktrees.py [--dry-run] [--force]
 
 Options:
   --dry-run    Show what would be removed, change nothing
-  --force      Pass --force to 'git worktree remove' (drops dirty trees)
+  --force      Remove worktrees with uncommitted changes too
   --help       Show help
 
 Env:
@@ -22,7 +26,7 @@ from pathlib import Path
 
 sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
 
-from gitutils import park_main_worktree, skip_git_hooks, worktrees
+from gitutils import park_main_worktree, skip_git_hooks, worktree_is_clean, worktrees
 from utils import (
     add_bool_flag,
     build_parser,
@@ -37,7 +41,7 @@ from utils import (
     warning,
 )
 
-__version__ = "1.3.0"
+__version__ = "1.4.0"
 
 
 def main(argv: list[str] | None = None) -> int:
@@ -54,7 +58,7 @@ def main(argv: list[str] | None = None) -> int:
     add_bool_flag(
         parser,
         "--force",
-        help="Pass --force to 'git worktree remove' (drops dirty trees)",
+        help="Remove worktrees with uncommitted changes too",
     )
     args = parser.parse_args(argv)
 
@@ -69,7 +73,7 @@ def main(argv: list[str] | None = None) -> int:
     main_wt = park_main_worktree("prune", dry_run=args.dry_run)
 
     info("🔍 Listing worktrees...")
-    linked = [worktree.path for worktree in worktrees(main_wt)[1:]]
+    linked = worktrees(main_wt)[1:]
 
     if not linked:
         success("✨ No linked worktrees. Running prune anyway... 🎉")
@@ -83,20 +87,54 @@ def main(argv: list[str] | None = None) -> int:
 
     if args.dry_run:
         warning(f"🌵 {len(linked)} worktree(s) would be removed:")
-        for path in linked:
-            warning(f"  • 🪦 {path}")
+        for worktree in linked:
+            note = " (locked; would unlock first)" if worktree.locked else ""
+            warning(f"  • 🪦 {worktree.path}{note}")
         info("📜 Would also run: git worktree prune --verbose")
         dry_run_complete("removed")
         return 0
 
-    remove_args = ["--force"] if args.force else []
-    for path in linked:
-        warning(f"🗑️  Removing: {path}")
-        run(["git", "worktree", "remove", *remove_args, path], cwd=main_wt)
+    removed = 0
+    kept: list[str] = []
+    for worktree in linked:
+        warning(f"🗑️  Removing: {worktree.path}")
+        # DELIBERATE DIVERGENCE: a lock used to abort the whole run with git's
+        # "cannot remove a locked working tree". Unlock, but only once the
+        # removal is certain to be allowed, so a kept worktree keeps its lock.
+        # A checkout whose directory is gone has no work left to lose.
+        gone = not Path(worktree.path).is_dir()
+        if not (args.force or gone) and not worktree_is_clean(worktree.path):
+            warning("  ⏭️  Uncommitted changes; kept (use --force to remove)")
+            kept.append(worktree.path)
+            continue
+        if worktree.locked:
+            info("  🔓 Unlocking")
+            run(["git", "worktree", "unlock", worktree.path], cwd=main_wt, check=False)
+        removal = run(
+            [
+                "git",
+                "worktree",
+                "remove",
+                *(["--force"] if args.force or gone else []),
+                worktree.path,
+            ],
+            cwd=main_wt,
+            check=False,
+        )
+        if removal.returncode:
+            warning(f"  ❌ Could not remove: {worktree.path}")
+            kept.append(worktree.path)
+        else:
+            removed += 1
 
     info("🧹 Pruning stale worktree records...")
     run(["git", "worktree", "prune", "--verbose"], cwd=main_wt)
-    success(f"✨ Removed {len(linked)} worktree(s). 🎉")
+    success(f"✨ Removed {removed} worktree(s). 🎉")
+    if kept:
+        warning(f"⚠️  {len(kept)} worktree(s) kept:")
+        for path in kept:
+            warning(f"  • {path}")
+        return 1
     return 0
 
 

package/bin/git/sync-all-branches.py

@@ -1,10 +1,14 @@
 #!/usr/bin/env python3
-"""🔄 Update every branch and worktree, keeping checkouts, locks and local work.
+"""🔄 Update every branch and worktree, and prune what has been merged.
 
-Fetch once, rebase branches onto their upstream (or origin/<branch>), and track
-new origin branches authored by you. Dirty tracked/untracked work is saved in
-an exact recovery stash and restored with its index. Conflicts are reported;
-independent branches continue. Nothing is pushed, hard reset or deleted.
+Fetch once, delete branches (and their clean worktrees) that were merged into a
+main or dev branch and whose upstream is gone, rebase the rest onto their
+upstream (or origin/<branch>), and track new origin branches authored by you.
+Worktrees stay worktrees and are updated in place. A branch whose changes are
+all already upstream moves to its upstream instead of replaying them. Dirty
+tracked/untracked work is saved in an exact recovery stash and restored with
+its index. Conflicts are reported; independent branches continue. Nothing is
+pushed. No local change is ever discarded.
 
 Usage:
   sync-all-branches.py [--dry-run] [--author=EMAIL] [--limit=N]
@@ -45,7 +49,7 @@ from utils import (
     warning,
 )
 
-__version__ = "3.0.0"
+__version__ = "3.2.0"
 
 
 def track_new(sync: BranchSync, author: str, limit: int) -> list[str]:
@@ -79,7 +83,7 @@ def track_new(sync: BranchSync, author: str, limit: int) -> list[str]:
 def main(argv: list[str] | None = None) -> int:
     parser = build_parser(
         prog="sync-all-branches",
-        description="🔄 Update every branch and worktree, preserving locks and local work.",
+        description="🔄 Update every branch and worktree, and prune what has been merged.",
     )
     add_bool_flag(
         parser,
@@ -119,8 +123,9 @@ def main(argv: list[str] | None = None) -> int:
     original = current_branch(root) or run_output(["git", "rev-parse", "--short", "HEAD"], cwd=root)
     info(f"📍 Keeping caller checkout: {original}")
     # DELIBERATE DIVERGENCE: the old sync parked on main and delegated cleanup.
-    # Preserve active workspaces instead, and never discard a gone-upstream
-    # branch merely because its remote was deleted. Dry-run must not fetch.
+    # Preserve active workspaces instead, and never delete a gone-upstream
+    # branch merely because its remote was deleted: only once it is proven
+    # merged (BranchSync.drop_gone). Dry-run must not fetch.
     if args.dry_run:
         info("🌵 Cached remote refs only; no fetch. Results reflect the last fetch.")
     else:

package/bin/gitutils.py

@@ -142,6 +142,7 @@ def local_branches(*fields: str, sort: str = "", cwd: str | Path | None = None)
 class Worktree(NamedTuple):
     path: str
     branch: str  # "" when detached (or bare): it pins no branch
+    locked: bool = False  # `git worktree lock`: git refuses to remove or prune it
 
 
 def worktrees(cwd: str | Path | None = None) -> list[Worktree]:
@@ -162,6 +163,8 @@ def worktrees(cwd: str | Path | None = None) -> list[Worktree]:
             # Every record opens with its `worktree` line, so this belongs to
             # the last one appended.
             found[-1] = found[-1]._replace(branch=line.removeprefix("branch refs/heads/"))
+        elif line == "locked" or line.startswith("locked "):
+            found[-1] = found[-1]._replace(locked=True)
     return found
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codebend3r/che",
-  "version": "1.2.2",
+  "version": "1.2.3",
   "description": "Helper scripts shared across machines, called by name from your shell and browsable through one menu",
   "keywords": [
     "cli",

package/shell/che.bash

@@ -1,4 +1,4 @@
-# che 1.2.2 - generated file, do not edit.
+# che 1.2.3 - generated file, do not edit.
 #
 # Generated from bin/commands.py by `che install`.
 # To change a wrapper, edit that manifest and run `che install` again.
@@ -151,13 +151,13 @@ prune-worktrees-dr() {
   che_notify 7 $?
 }
 
-# Update every branch and worktree, preserving locks and local work
+# Update every branch and worktree, pruning what has been merged
 sync-all-branches() {
   DRY_RUN=false "$CHE_PYTHON" "$CHE_BIN/git/sync-all-branches.py" "$@"
   che_notify 7 $?
 }
 
-# Update every branch and worktree, preserving locks and local work (preview only)
+# Update every branch and worktree, pruning what has been merged (preview only)
 sync-all-branches-dr() {
   DRY_RUN=true "$CHE_PYTHON" "$CHE_BIN/git/sync-all-branches.py" "$@"
   che_notify 7 $?

package/shell/che.fish

@@ -1,4 +1,4 @@
-# che 1.2.2 - generated file, do not edit.
+# che 1.2.3 - generated file, do not edit.
 #
 # Generated from bin/commands.py by `che install`.
 # To change a wrapper, edit that manifest and run `che install` again.
@@ -88,12 +88,12 @@ function prune-worktrees-dr --description 'Remove every linked worktree, then pr
     che_notify 7 $status
 end
 
-function sync-all-branches --description 'Update every branch and worktree, preserving locks and local work'
+function sync-all-branches --description 'Update every branch and worktree, pruning what has been merged'
     env DRY_RUN=false "$CHE_PYTHON" "$CHE_BIN/git/sync-all-branches.py" $argv
     che_notify 7 $status
 end
 
-function sync-all-branches-dr --description 'Update every branch and worktree, preserving locks and local work (preview only)'
+function sync-all-branches-dr --description 'Update every branch and worktree, pruning what has been merged (preview only)'
     env DRY_RUN=true "$CHE_PYTHON" "$CHE_BIN/git/sync-all-branches.py" $argv
     che_notify 7 $status
 end

package/shell/che.zsh

@@ -1,4 +1,4 @@
-# che 1.2.2 - generated file, do not edit.
+# che 1.2.3 - generated file, do not edit.
 #
 # Generated from bin/commands.py by `che install`.
 # To change a wrapper, edit that manifest and run `che install` again.
@@ -157,13 +157,13 @@ prune-worktrees-dr() {
   che_notify 7 $?
 }
 
-# Update every branch and worktree, preserving locks and local work
+# Update every branch and worktree, pruning what has been merged
 sync-all-branches() {
   DRY_RUN=false "$CHE_PYTHON" "$CHE_BIN/git/sync-all-branches.py" "$@"
   che_notify 7 $?
 }
 
-# Update every branch and worktree, preserving locks and local work (preview only)
+# Update every branch and worktree, pruning what has been merged (preview only)
 sync-all-branches-dr() {
   DRY_RUN=true "$CHE_PYTHON" "$CHE_BIN/git/sync-all-branches.py" "$@"
   che_notify 7 $?

package/shell/completions/_che

@@ -1,5 +1,5 @@
 #compdef che
-# che 1.2.2 - generated file, do not edit.
+# che 1.2.3 - generated file, do not edit.
 #
 # Generated from bin/commands.py by `che install`.
 # To change a wrapper, edit that manifest and run `che install` again.
@@ -89,8 +89,8 @@ _che() {
     'hard-reset-all-branches-dr:Check out every local branch and hard reset it to origin/<branch> (preview)'
     'prune-worktrees:Remove every linked worktree, then prune stale admin records'
     'prune-worktrees-dr:Remove every linked worktree, then prune stale admin records (preview)'
-    'sync-all-branches:Update every branch and worktree, preserving locks and local work'
-    'sync-all-branches-dr:Update every branch and worktree, preserving locks and local work (preview)'
+    'sync-all-branches:Update every branch and worktree, pruning what has been merged'
+    'sync-all-branches-dr:Update every branch and worktree, pruning what has been merged (preview)'
     'update-from-origin:Alias of sync-all-branches'
     'update-local-branches:Rebase every local branch that has an upstream onto origin'
     'show-codecs:Report media files outside the Direct Play codec/container set'

package/shell/completions/che.bash

@@ -1,4 +1,4 @@
-# che 1.2.2 - generated file, do not edit.
+# che 1.2.3 - generated file, do not edit.
 #
 # Generated from bin/commands.py by `che install`.
 # To change a wrapper, edit that manifest and run `che install` again.

package/shell/completions/che.fish

@@ -1,4 +1,4 @@
-# che 1.2.2 - generated file, do not edit.
+# che 1.2.3 - generated file, do not edit.
 #
 # Generated from bin/commands.py by `che install`.
 # To change a wrapper, edit that manifest and run `che install` again.
@@ -13,8 +13,8 @@ complete -c che -n __fish_use_subcommand -a hard-reset-all-branches -d 'Check ou
 complete -c che -n __fish_use_subcommand -a hard-reset-all-branches-dr -d 'Check out every local branch and hard reset it to origin/<branch> (preview)'
 complete -c che -n __fish_use_subcommand -a prune-worktrees -d 'Remove every linked worktree, then prune stale admin records'
 complete -c che -n __fish_use_subcommand -a prune-worktrees-dr -d 'Remove every linked worktree, then prune stale admin records (preview)'
-complete -c che -n __fish_use_subcommand -a sync-all-branches -d 'Update every branch and worktree, preserving locks and local work'
-complete -c che -n __fish_use_subcommand -a sync-all-branches-dr -d 'Update every branch and worktree, preserving locks and local work (preview)'
+complete -c che -n __fish_use_subcommand -a sync-all-branches -d 'Update every branch and worktree, pruning what has been merged'
+complete -c che -n __fish_use_subcommand -a sync-all-branches-dr -d 'Update every branch and worktree, pruning what has been merged (preview)'
 complete -c che -n __fish_use_subcommand -a update-from-origin -d 'Alias of sync-all-branches'
 complete -c che -n __fish_use_subcommand -a update-local-branches -d 'Rebase every local branch that has an upstream onto origin'
 complete -c che -n __fish_use_subcommand -a show-codecs -d 'Report media files outside the Direct Play codec/container set'