@codebend3r/che 1.2.0 → 1.2.1

package/README.md

@@ -221,7 +221,7 @@ have used, and `che help <command>` prints that script's own `--help`.
 | `checkout-my-branches` | Check out recent remote branches you authored that aren't local yet |  |
 | `clean-stale-branches` | Delete local branches whose upstream is gone | `clean-stale-branches-dr` |
 | `prune-worktrees` | Remove every linked worktree, then prune stale admin records | `prune-worktrees-dr` |
-| `sync-all-branches` | Delete merged branches, rebase the rest, check out new ones; branches only | `sync-all-branches-dr` |
+| `sync-all-branches` | Update every branch and worktree, preserving locks and local work | `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* | |
@@ -363,24 +363,42 @@ Every script follows the same shape, described in full at the top of
 ## Syncing branches
 
 ```sh
-sync-all-branches       # delete merged branches, rebase the rest, check out new ones
-sync-all-branches-dr    # preview only
-update-from-origin      # alias of sync-all-branches
+sync-all-branches       # update branches and worktrees, keeping locks and local work
+sync-all-branches-dr    # preview cached remote refs; no fetch or changes
+update-from-origin     # alias of sync-all-branches
 ```
 
-Only branches change. The sync deletes local branches whose upstream is gone,
-`pull --rebase`s every branch with an upstream, and creates local tracking
-branches for the remote branches you authored that aren't local yet, without
-switching to them. It ends with the main clone on `main`.
-
-It **never pushes**, **never touches a worktree** and **never runs the repo's
-git hooks**. A branch checked out in a linked worktree is rebased in place
-there when that worktree is clean; a stale one is reported and kept, since git
-won't delete a branch a worktree has checked out. The branch scripts
-(`clean-stale-branches`, `update-local-branches`, `checkout-my-branches`,
-`prune-worktrees`, `sync-all-branches`) point `core.hooksPath` at `/dev/null`
-for every git they run, so a lefthook or husky pre-commit, pre-push or
-post-checkout never fires on a checkout or a rebase.
+Fetches once and rebases every local branch onto its upstream, falling back to
+`origin/<branch>` when no upstream is configured. Branches in existing
+worktrees, including locked ones, update **inside their own checkout**. Dirty
+tracked and untracked work is temporarily stashed and restored with its staged
+state; unrelated existing stashes survive. Nested registered worktrees are
+excluded from their parent's stash. Dirty submodules and existing Git operations
+are reported and left alone.
+
+It **never pushes, hard resets or deletes local branches**, and preserves every
+existing worktree directory, lock and checkout, including the caller's branch.
+Unoccupied branches use temporary worktrees that are removed after updating.
+New origin branches authored by you become local tracking branches without
+switching HEAD. Missing upstreams are reported, not treated as proof of a merge;
+use `clean-stale-branches` separately when you want branch cleanup.
+
+Rebase conflicts are aborted and reported while other branches continue. If
+restoring WIP conflicts, the exact recovery stash is retained and its ID and
+worktree path are printed. A blocked branch makes the command exit nonzero even
+when other branches updated. Local-only branches are reported without inventing
+a remote target. Ahead counts may remain because local commits are kept; clearing
+them would require pushing or discarding work. Avoid concurrent edits or Git
+operations while the sync temporarily saves WIP.
+
+The `-dr` preview does not fetch and only inspects cached remote refs. It changes
+no branches, working files, locks or stashes. Legacy `--no-push` and
+`--keep-locked` flags are still accepted for compatibility.
+
+Like the other branch scripts (`clean-stale-branches`, `update-local-branches`,
+`checkout-my-branches`, `prune-worktrees`), sync retains che's existing policy of
+pointing `core.hooksPath` at `/dev/null` for its Git commands so bookkeeping does
+not run repository hooks.
 
 ## External tools
 

package/bin/branchsync.py

@@ -0,0 +1,324 @@
+"""Non-destructive 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.
+"""
+
+from __future__ import annotations
+
+import subprocess
+import tempfile
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from gitutils import Worktree, local_branches, worktrees
+from utils import info, run, run_output, success, warning
+
+_OPERATION_FILES = (
+    "rebase-merge",
+    "rebase-apply",
+    "MERGE_HEAD",
+    "CHERRY_PICK_HEAD",
+    "REVERT_HEAD",
+    "BISECT_START",
+)
+
+
+def git_path(path: Path, name: str) -> Path:
+    result = Path(run_output(["git", "rev-parse", "--git-path", name], cwd=path))
+    return result if result.is_absolute() else path / result
+
+
+def operation_branch(path: Path) -> str:
+    """A rebase/bisect detaches HEAD but still reserves its original branch."""
+    for name in ("rebase-merge/head-name", "rebase-apply/head-name", "BISECT_START"):
+        file = git_path(path, name)
+        if file.is_file():
+            return file.read_text().splitlines()[0].removeprefix("refs/heads/")
+    return ""
+
+
+def in_progress(path: Path) -> bool:
+    return any(git_path(path, name).exists() for name in _OPERATION_FILES)
+
+
+@dataclass
+class BranchSync:
+    root: Path
+    dry_run: bool
+    updated: list[str] = field(default_factory=list)
+    current: list[str] = field(default_factory=list)
+    local_only: list[str] = field(default_factory=list)
+    restored: list[str] = field(default_factory=list)
+    blocked: list[str] = field(default_factory=list)
+    trees: list[Worktree] = field(init=False)
+
+    def __post_init__(self) -> None:
+        self.trees = worktrees(self.root)
+
+    def block(self, branch: str, reason: str) -> None:
+        message = f"{branch}: {reason}"
+        self.blocked.append(message)
+        warning(f"  ❌ {message}")
+
+    def occupied(self) -> dict[str, Path]:
+        result: dict[str, Path] = {}
+        for tree in self.trees:
+            path = Path(tree.path)
+            branch = tree.branch
+            if not branch and path.is_dir():
+                branch = operation_branch(path)
+            if branch:
+                result[branch] = path
+            else:
+                info(f"  ℹ️ Detached worktree unchanged (no upstream): {path}")  # noqa: RUF001
+        return result
+
+    def pathspecs(self, path: Path) -> list[str]:
+        """Never stash another registered checkout nested inside this one.
+
+        Restrict status and stash by the same literal pathspecs, so untracked
+        siblings still count as WIP while a nested worktree stays untouched.
+        """
+        specs = ["."]
+        for tree in self.trees:
+            nested = Path(tree.path)
+            if nested != path and nested.is_relative_to(path):
+                specs.append(f":(exclude,literal){nested.relative_to(path).as_posix()}")
+        return specs
+
+    def dirty(self, path: Path) -> bool:
+        return bool(
+            run_output(
+                [
+                    "git",
+                    "status",
+                    "--porcelain",
+                    "-z",
+                    "--untracked-files=all",
+                    "--",
+                    *self.pathspecs(path),
+                ],
+                cwd=path,
+            )
+        )
+
+    def has_ref(self, ref: str) -> bool:
+        return (
+            run(
+                ["git", "show-ref", "--verify", "--quiet", ref],
+                cwd=self.root,
+                check=False,
+                capture=True,
+            ).returncode
+            == 0
+        )
+
+    def includes(self, branch: str, upstream: str) -> bool:
+        result = run(
+            ["git", "merge-base", "--is-ancestor", upstream, f"refs/heads/{branch}"],
+            cwd=self.root,
+            check=False,
+            capture=True,
+        )
+        if result.returncode not in (0, 1):
+            raise subprocess.CalledProcessError(
+                result.returncode, result.args, stderr=result.stderr
+            )
+        return result.returncode == 0
+
+    def save_wip(self, branch: str, path: Path) -> str:
+        if not self.dirty(path):
+            return ""
+        # A superproject stash cannot preserve dirty submodule working copies.
+        submodules = run(
+            ["git", "submodule", "foreach", "--quiet", "--recursive", "git status --porcelain"],
+            cwd=path,
+            check=False,
+            capture=True,
+        )
+        if submodules.returncode or submodules.stdout:
+            raise OSError(f"dirty/unreadable submodule in {path}; left untouched")
+        before = run_output(["git", "rev-parse", "--verify", "refs/stash"], cwd=path, check=False)
+        run(
+            [
+                "git",
+                "stash",
+                "push",
+                "--include-untracked",
+                "--message",
+                f"che sync-all-branches: {branch}",
+                "--",
+                *self.pathspecs(path),
+            ],
+            cwd=path,
+        )
+        oid = run_output(["git", "rev-parse", "--verify", "refs/stash"], cwd=path)
+        if not oid or oid == before:
+            raise OSError(
+                f"could not verify a new recovery stash in {path}; inspect git stash list"
+            )
+        info(f"  🧺 Recovery stash for {branch} in {path}: {oid}")
+        if self.dirty(path):
+            raise OSError(f"worktree remains dirty; left untouched, recovery stash {oid} in {path}")
+        return oid
+
+    def restore_wip(self, branch: str, path: Path, oid: str) -> bool:
+        if not oid:
+            return True
+        # Worktrees share refs/stash. Never pop the latest entry or drop a
+        # recovery copy until both working-copy and index restoration succeed.
+        if run(["git", "stash", "apply", "--index", oid], cwd=path, check=False).returncode:
+            self.block(
+                branch, f"WIP restoration conflicted in {path}; recovery stash retained: {oid}"
+            )
+            return False
+        entries = run_output(["git", "stash", "list", "--format=%gd%x01%H"], cwd=path)
+        matching = next(
+            (
+                ref
+                for line in entries.splitlines()
+                for ref, sha in [line.split("\x01")]
+                if sha == oid
+            ),
+            "",
+        )
+        if (
+            not matching
+            or run(["git", "stash", "drop", "--quiet", matching], cwd=path, check=False).returncode
+        ):
+            self.block(branch, f"WIP restored in {path}, but recovery stash not dropped: {oid}")
+            return False
+        self.restored.append(branch)
+        return True
+
+    def sync_branch(self, branch: str, upstream: str, occupied: dict[str, Path]) -> None:
+        path = occupied.get(branch)
+        if path is not None:
+            if not path.is_dir():
+                self.block(branch, f"worktree unavailable: {path}")
+                return
+            if in_progress(path):
+                self.block(branch, f"operation in progress in {path}; left untouched")
+                return
+        if self.includes(branch, upstream):
+            info(f"  = Up to date: {branch} (local commits kept){f' in {path}' if path else ''}")
+            self.current.append(branch)
+            return
+        if self.dry_run:
+            info(
+                f"  🌵 Would update {branch} from {upstream}{f' in {path}' if path else ''}; stash/restore WIP if needed"
+            )
+            return
+
+        temporary: Path | None = None
+        oid = ""
+        try:
+            if path is None:
+                temporary = Path(tempfile.mkdtemp(prefix="che-sync-"))
+                path = temporary / "checkout"
+                run(["git", "worktree", "add", "--quiet", str(path), branch], cwd=self.root)
+            oid = self.save_wip(branch, path)
+            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
+            # compete with our exact WIP recovery or move unrelated branches.
+            rebased = (
+                run(
+                    [
+                        "git",
+                        "-c",
+                        "rebase.autoStash=false",
+                        "-c",
+                        "rebase.updateRefs=false",
+                        "rebase",
+                        "--no-autostash",
+                        upstream,
+                    ],
+                    cwd=path,
+                    check=False,
+                ).returncode
+                == 0
+            )
+            if not rebased:
+                warning(f"  ❌ Rebase failed for {branch} in {path}")
+                if in_progress(path):
+                    # Abort only the rebase we started. Failure to abort is
+                    # fatal: applying WIP or continuing is no longer safe.
+                    abort = run(["git", "rebase", "--abort"], cwd=path, check=False)
+                    if abort.returncode:
+                        warning(f"STOP: cannot abort in {path}; recovery stash: {oid or 'none'}")
+                        raise SystemExit(1)
+                self.block(branch, f"rebase failed in {path}; original commits retained")
+            restored = self.restore_wip(branch, path, oid)
+            if rebased and restored:
+                if self.includes(branch, upstream):
+                    self.updated.append(branch)
+                    success(f"  ✅ Updated: {branch}")
+                else:
+                    self.block(branch, "verification failed: fetched upstream not included")
+        except (subprocess.CalledProcessError, OSError) as exc:
+            self.block(
+                branch, f"{exc}; inspect {path}; recovery stash: {oid or 'see git stash list'}"
+            )
+        except KeyboardInterrupt:
+            warning(
+                f"Interrupted in {path}; inspect status before resuming. Recovery stash: {oid or 'see git stash list'}"
+            )
+            raise
+        finally:
+            # Never use TemporaryDirectory here: its automatic recursive
+            # deletion would erase files if a hook or recovery left a dirty tree.
+            if temporary is not None:
+                if not (temporary / "checkout").exists():
+                    temporary.rmdir()
+                elif (
+                    not in_progress(temporary / "checkout")
+                    and run(
+                        ["git", "worktree", "remove", str(temporary / "checkout")],
+                        cwd=self.root,
+                        check=False,
+                    ).returncode
+                    == 0
+                ):
+                    temporary.rmdir()
+                else:
+                    self.block(
+                        branch,
+                        f"temporary worktree retained for inspection: {temporary / 'checkout'}",
+                    )
+
+    def update(self) -> None:
+        occupied = self.occupied()
+        for branch, upstream in local_branches("upstream", cwd=self.root):
+            if not upstream and self.has_ref(f"refs/remotes/origin/{branch}"):
+                upstream = f"refs/remotes/origin/{branch}"
+            if not upstream:
+                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:
+                self.sync_branch(branch, upstream, occupied)
+            except (subprocess.CalledProcessError, OSError) as exc:
+                self.block(branch, f"preflight failed: {exc}")
+
+    def summary(self, tracked: list[str]) -> None:
+        success("═══ summary ═══")
+        for label, names in (
+            ("Updated", self.updated),
+            ("Up to date", self.current),
+            ("Tracked new", tracked),
+            ("Local only", self.local_only),
+            ("WIP restored", self.restored),
+        ):
+            info(f"{label}: {len(names)} ({', '.join(names)})")
+        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."
+        )

package/bin/commands.py

@@ -268,13 +268,13 @@ COMMANDS: tuple[Command, ...] = (
         flags=("--dry-run", "--author=", "--limit="),
         category="git",
         icon="🔄",
-        summary="Delete merged branches, rebase the rest, check out new ones; branches only",
+        summary="Update every branch and worktree, preserving locks and local work",
         script="git/sync-all-branches.py",
         sound=7,
         dry_run="env",
         destructive=True,
         needs=("git",),
-        tags=("branch", "sync", "pull", "prune"),
+        tags=("branch", "sync", "pull", "worktree"),
     ),
     Command(
         name="update-from-origin",
@@ -283,8 +283,7 @@ COMMANDS: tuple[Command, ...] = (
         icon="⬇️",
         summary="Alias of sync-all-branches",
         script="git/sync-all-branches.py",
-        # A real run, spelled the way sync-all-branches tells its own children;
-        # a `--dry-run` typed after it still wins.
+        # A real run by default; a `--dry-run` typed after it still wins.
         args=("--dry-run=false",),
         sound=7,
         destructive=True,

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

@@ -1,42 +1,35 @@
 #!/usr/bin/env python3
-"""🔄 Sync every branch: delete merged ones, rebase the rest, check out new ones.
+"""🔄 Update every branch and worktree, keeping checkouts, locks and local work.
 
-Steps, in order:
-  1. Switch the main clone to the main branch
-  2. Fetch + prune every remote, once for the whole run
-  3. clean-stale-branches   (delete branches whose upstream is gone)
-  4. update-local-branches  (rebase every branch onto its upstream)
-  5. checkout-my-branches   (track your remote branches that aren't local)
-
-Only branches change. It never pushes, never adds, removes or prunes a
-worktree, and never runs a repo's git hooks: pushing and worktrees are the
-user's call, and a lefthook or husky pre-commit or pre-push gates the user's
-own work, not this bookkeeping. A branch checked out in a linked worktree is
-rebased in place there; a stale one is reported, not deleted. The main clone
-ends on main: new branches are created without being checked out.
+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.
 
 Usage:
   sync-all-branches.py [--dry-run] [--author=EMAIL] [--limit=N]
 
 Options:
-  --dry-run        Report what would be deleted / synced, change nothing
-  --author=EMAIL   Passed through to checkout-my-branches
-  --limit=N        Passed through to checkout-my-branches
+  --dry-run        Preview cached refs only; no fetch or changes
+  --author=EMAIL   Author of new origin branches (default: git config user.email)
+  --limit=N        Recent origin refs to scan for new branches (default: 100)
   --help           Show help
 
 Env:
-  DRY_RUN=true     Same as --dry-run (used by the .zshrc -dr wrapper)
+  DRY_RUN=true     Same as --dry-run (used by the shell -dr wrapper)
 """
 
 from __future__ import annotations
 
 import argparse
+import subprocess
 import sys
 from pathlib import Path
 
 sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
 
-from gitutils import fetch_remotes, park_main_worktree, skip_git_hooks
+from branchsync import BranchSync
+from gitutils import current_branch, fetch_remotes, for_each_ref, local_branches, skip_git_hooks
 from utils import (
     add_bool_flag,
     build_parser,
@@ -44,94 +37,108 @@ from utils import (
     heading,
     info,
     log,
+    parse_count,
     require_binary,
     run,
     run_cli,
+    run_output,
+    warning,
 )
 
-__version__ = "2.1.0"
-
-SCRIPT_DIR = Path(__file__).resolve().parent
-
-
-def delegate(script: str, args: list[str], *, cwd: Path) -> None:
-    """Run a sibling script in the main worktree, aborting the sync if it fails.
+__version__ = "3.0.0"
 
-    The shell version invoked these under ``set -e``, so a non-zero exit from
-    any of them ended the run. ``check=True`` reproduces that: a branch that
-    could not be rebased is a reason to stop and look, not to sail on.
 
-    The blank line before each one is flushed: a child writes straight to the
-    shared stdout, so an unflushed separator would surface after its output
-    whenever the sync is piped.
-    """
-    print(flush=True)
-    run([sys.executable, str(SCRIPT_DIR / script), *args], cwd=cwd)
+def track_new(sync: BranchSync, author: str, limit: int) -> list[str]:
+    tracked: list[str] = []
+    local = {branch for (branch,) in local_branches(cwd=sync.root)}
+    refs = for_each_ref(
+        "refs/remotes/origin/",
+        "authoremail:trim",
+        "refname:lstrip=3",
+        "symref",
+        sort="-committerdate",
+        cwd=sync.root,
+    )
+    for email, branch, symref in refs[:limit]:
+        if symref or email != author or branch in local:
+            continue
+        if sync.dry_run:
+            info(f"🌵 Would track: {branch}")
+            continue
+        if run(
+            ["git", "branch", "--track", branch, f"refs/remotes/origin/{branch}"],
+            cwd=sync.root,
+            check=False,
+        ).returncode:
+            sync.block(branch, "could not create tracking branch")
+        else:
+            tracked.append(branch)
+    return tracked
 
 
 def main(argv: list[str] | None = None) -> int:
     parser = build_parser(
         prog="sync-all-branches",
-        description="🔄 Delete merged branches, rebase the rest, check out new ones.",
+        description="🔄 Update every branch and worktree, preserving locks and local work.",
     )
     add_bool_flag(
         parser,
         "--dry-run",
         default=env_bool("DRY_RUN", False),
-        help="Report what would be deleted / synced, change nothing",
+        help="Preview cached refs only; no fetch or changes",
     )
-    # Accepted and ignored, from when the sync pushed and collapsed worktrees:
-    # chip's "Update from Origin" still passes --no-push and must keep running.
+    # Compatibility with chip and older wrappers. Neither pushing nor lock
+    # removal is ever part of syncing, regardless of these legacy flags.
     add_bool_flag(parser, "--no-push", allow_value=False, help=argparse.SUPPRESS)
     add_bool_flag(parser, "--keep-locked", help=argparse.SUPPRESS)
     parser.add_argument(
         "--author",
         default="",
         metavar="EMAIL",
-        help="Passed through to checkout-my-branches",
+        help="Author of new origin branches (default: git config user.email)",
     )
     parser.add_argument(
         "--limit",
-        default="",
+        default="100",
         metavar="N",
-        help="Passed through to checkout-my-branches",
+        help="Recent origin refs to scan for new branches (default: 100)",
     )
     args = parser.parse_args(argv)
-
+    limit = parse_count(args.limit, "--limit", minimum=1)
     require_binary("git")
     skip_git_hooks()
-
     heading("🔄  sync-all-branches", dry_run=args.dry_run)
-
-    # Every later step runs from the main worktree, because the delegated
-    # scripts expect the main clone. Passing cwd= to each call rather than
-    # `cd`-ing keeps the process's own directory untouched.
-    main_wt = park_main_worktree("sync", dry_run=args.dry_run)
-
-    # The one fetch of the run. Each delegated script fetches when run on its
-    # own; here they inherit the marker fetch_remotes leaves and skip theirs.
-    fetch_remotes()
-
-    # Dry-run travels as an explicit --dry-run=true|false, never as DRY_RUN in
-    # the environment, so a child can never disagree with the parent about
-    # which mode this is - whatever DRY_RUN it inherited.
-    mode = [f"--dry-run={'true' if args.dry_run else 'false'}"]
-    delegate("clean-stale-branches.py", mode, cwd=main_wt)
-    delegate("update-local-branches.py", mode, cwd=main_wt)
-
-    checkout_args = []
-    if args.author:
-        checkout_args.append(f"--author={args.author}")
-    if args.limit:
-        checkout_args.append(f"--limit={args.limit}")
-
+    if run_output(["git", "rev-parse", "--is-inside-work-tree"], check=False) != "true":
+        warning("❌ Not inside a git working tree.")
+        return 1
+    root = Path(run_output(["git", "rev-parse", "--show-toplevel"]))
+    author = args.author or run_output(["git", "config", "user.email"], cwd=root, check=False)
+    if not author:
+        warning("❌ No author email; pass --author=EMAIL or set git config user.email.")
+        return 1
+    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.
     if args.dry_run:
-        print(flush=True)
-        info(f"🌵 Would run: checkout-my-branches {' '.join(checkout_args)}".rstrip())
+        info("🌵 Cached remote refs only; no fetch. Results reflect the last fetch.")
     else:
-        delegate("checkout-my-branches.py", checkout_args, cwd=main_wt)
-
-    log("🎉 Sync complete.")
+        fetch_remotes()
+    sync = BranchSync(root, args.dry_run)
+    sync.update()
+    try:
+        tracked = track_new(sync, author, limit)
+    except (subprocess.CalledProcessError, OSError) as exc:
+        sync.block("new origin branches", str(exc))
+        tracked = []
+    sync.summary(tracked)
+    if sync.blocked:
+        warning(
+            "Sync partially completed; blocked branches need attention. Remaining independent branches were attempted."
+        )
+        return 1
+    log("🎉 Preview complete." if args.dry_run else "🎉 Sync complete.")
     return 0
 
 

package/bin/gitutils.py

@@ -150,12 +150,12 @@ def worktrees(cwd: str | Path | None = None) -> list[Worktree]:
     The first entry is always the main worktree; callers drop it themselves so
     the distinction stays explicit at the call site.
 
-    The shell version parsed this with ``awk '{print $2}'``, which splits on
-    whitespace and so truncated any worktree path containing a space. Taking
-    the whole remainder of the line keeps such paths intact.
+    DELIBERATE DIVERGENCE: the shell version split on whitespace. NUL-delimited
+    porcelain preserves spaces, tabs, backslashes and newlines in paths without
+    Git's quoted-path escaping, so commands can route to the exact checkout.
     """
     found: list[Worktree] = []
-    for line in run_output(["git", "worktree", "list", "--porcelain"], cwd=cwd).splitlines():
+    for line in run_output(["git", "worktree", "list", "--porcelain", "-z"], cwd=cwd).split("\0"):
         if line.startswith("worktree "):
             found.append(Worktree(line.removeprefix("worktree "), ""))
         elif line.startswith("branch refs/heads/"):

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codebend3r/che",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "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.0 - generated file, do not edit.
+# che 1.2.1 - 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.
@@ -138,13 +138,13 @@ prune-worktrees-dr() {
   che_notify 7 $?
 }
 
-# Delete merged branches, rebase the rest, check out new ones; branches only
+# Update every branch and worktree, preserving locks and local work
 sync-all-branches() {
   DRY_RUN=false "$CHE_PYTHON" "$CHE_BIN/git/sync-all-branches.py" "$@"
   che_notify 7 $?
 }
 
-# Delete merged branches, rebase the rest, check out new ones; branches only (preview only)
+# Update every branch and worktree, preserving locks and local work (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.0 - generated file, do not edit.
+# che 1.2.1 - 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.
@@ -78,12 +78,12 @@ function prune-worktrees-dr --description 'Remove every linked worktree, then pr
     che_notify 7 $status
 end
 
-function sync-all-branches --description 'Delete merged branches, rebase the rest, check out new ones; branches only'
+function sync-all-branches --description 'Update every branch and worktree, preserving locks and local work'
     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 'Delete merged branches, rebase the rest, check out new ones; branches only (preview only)'
+function sync-all-branches-dr --description 'Update every branch and worktree, preserving locks and local work (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.0 - generated file, do not edit.
+# che 1.2.1 - 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.
@@ -144,13 +144,13 @@ prune-worktrees-dr() {
   che_notify 7 $?
 }
 
-# Delete merged branches, rebase the rest, check out new ones; branches only
+# Update every branch and worktree, preserving locks and local work
 sync-all-branches() {
   DRY_RUN=false "$CHE_PYTHON" "$CHE_BIN/git/sync-all-branches.py" "$@"
   che_notify 7 $?
 }
 
-# Delete merged branches, rebase the rest, check out new ones; branches only (preview only)
+# Update every branch and worktree, preserving locks and local work (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.0 - generated file, do not edit.
+# che 1.2.1 - 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.
@@ -85,8 +85,8 @@ _che() {
     'clean-stale-branches-dr:Delete local branches whose upstream is gone (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:Delete merged branches, rebase the rest, check out new ones; branches only'
-    'sync-all-branches-dr:Delete merged branches, rebase the rest, check out new ones; branches only (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)'
     '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.0 - generated file, do not edit.
+# che 1.2.1 - 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.0 - generated file, do not edit.
+# che 1.2.1 - 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.
@@ -11,8 +11,8 @@ complete -c che -n __fish_use_subcommand -a clean-stale-branches -d 'Delete loca
 complete -c che -n __fish_use_subcommand -a clean-stale-branches-dr -d 'Delete local branches whose upstream is gone (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 'Delete merged branches, rebase the rest, check out new ones; branches only'
-complete -c che -n __fish_use_subcommand -a sync-all-branches-dr -d 'Delete merged branches, rebase the rest, check out new ones; branches only (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 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'