@codebend3r/che 1.2.0 → 1.2.2

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

@@ -250,6 +250,20 @@ COMMANDS: tuple[Command, ...] = (
         tags=("branch", "delete", "prune"),
         prompts=(Prompt("--protect", "Extra branches to protect", help="Comma separated"),),
     ),
+    Command(
+        name="hard-reset-all-branches",
+        flags=("--dry-run", "--force"),
+        category="git",
+        icon="💣",
+        summary="Check out every local branch and hard reset it to origin/<branch>",
+        script="git/hard-reset-all-branches.py",
+        sound=4,
+        dry_run="env",
+        destructive=True,
+        needs=("git",),
+        tags=("branch", "reset", "origin", "worktree"),
+        prompts=(Prompt("--force", "Also discard uncommitted changes", kind="bool"),),
+    ),
     Command(
         name="prune-worktrees",
         flags=("--dry-run", "--force"),
@@ -268,13 +282,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 +297,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/hard-reset-all-branches.py

@@ -0,0 +1,250 @@
+#!/usr/bin/env python3
+"""💣 Check out every local branch and hard reset it to origin/<branch>.
+
+Fetch once, then for each local branch that has an origin/<branch> and differs
+from it: check it out and ``git reset --hard`` to the origin state. A branch
+checked out in another worktree is reset inside that worktree instead. Local
+commits are dropped (they stay in the reflog); untracked files are left alone.
+Returns to the starting branch at the end.
+
+Uncommitted changes to tracked files are never discarded without --force:
+the current worktree refuses to start, another dirty worktree is skipped.
+
+Usage:
+  hard-reset-all-branches.py [--dry-run] [--force]
+
+Options:
+  --dry-run    Show what would be reset and what it would drop, change nothing
+  --force      Also discard uncommitted changes to tracked files
+  --help       Show help
+
+Env:
+  DRY_RUN=true Same as --dry-run (used by the shell -dr wrapper)
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from branchsync import in_progress
+from gitutils import (
+    current_branch,
+    fetch_remotes,
+    for_each_ref,
+    has_tracked_changes,
+    local_branches,
+    skip_git_hooks,
+    worktree_branch_map,
+)
+from utils import (
+    add_bool_flag,
+    build_parser,
+    dry_run_complete,
+    env_bool,
+    heading,
+    info,
+    log,
+    require_binary,
+    run,
+    run_cli,
+    run_output,
+    success,
+    warning,
+)
+
+__version__ = "1.0.0"
+
+
+def origin_names(cwd: Path) -> set[str]:
+    """Branch names under ``refs/remotes/origin/``, minus the ``HEAD`` symref."""
+    return {
+        branch
+        for branch, symref in for_each_ref(
+            "refs/remotes/origin/", "refname:lstrip=3", "symref", cwd=cwd
+        )
+        if not symref
+    }
+
+
+def divergence(branch: str, cwd: Path) -> tuple[int, int]:
+    """``(local-only commits, origin-only commits)`` between ``branch`` and origin.
+
+    Full refs throughout, so a tag named like the branch cannot be picked instead.
+    """
+    counts = run_output(
+        [
+            "git",
+            "rev-list",
+            "--left-right",
+            "--count",
+            f"refs/heads/{branch}...refs/remotes/origin/{branch}",
+        ],
+        cwd=cwd,
+    ).split()
+    return int(counts[0]), int(counts[1])
+
+
+def describe(ahead: int, behind: int) -> str:
+    parts = []
+    if ahead:
+        parts.append(f"drops {ahead} local commit(s)")
+    if behind:
+        parts.append(f"picks up {behind} from origin")
+    return ", ".join(parts)
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser(
+        prog="hard-reset-all-branches",
+        description="💣 Check out every local branch and hard reset it to origin/<branch>.",
+    )
+    add_bool_flag(
+        parser,
+        "--dry-run",
+        default=env_bool("DRY_RUN", True),
+        help="Show what would be reset and what it would drop, change nothing",
+    )
+    add_bool_flag(
+        parser,
+        "--force",
+        help="Also discard uncommitted changes to tracked files",
+    )
+    args = parser.parse_args(argv)
+
+    require_binary("git")
+    skip_git_hooks()
+
+    heading("💣  hard-reset-all-branches", dry_run=args.dry_run)
+
+    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"]))
+
+    original = current_branch(root)
+    if not original:
+        warning("❌ Detached HEAD — check out a branch first.")
+        return 1
+
+    if in_progress(root):
+        warning("❌ A rebase, merge or similar is in progress here — finish or abort it first.")
+        return 1
+
+    if has_tracked_changes(root) and not args.force:
+        if not args.dry_run:
+            warning("❌ Working tree is dirty. Commit, stash or pass --force to discard. 🧺")
+            return 1
+        warning("⚠️  Working tree is dirty: a real run refuses without --force.")
+
+    # Fetched in a dry run too: the preview is only worth reading if it
+    # compares against what origin holds now. A fetch touches no local branch.
+    fetch_remotes()
+
+    remote = origin_names(root)
+    no_origin: list[str] = []
+    in_sync: list[str] = []
+    targets: list[tuple[str, int, int]] = []
+    for (branch,) in local_branches(cwd=root):
+        if branch not in remote:
+            no_origin.append(branch)
+            continue
+        ahead, behind = divergence(branch, root)
+        if ahead or behind:
+            targets.append((branch, ahead, behind))
+        else:
+            in_sync.append(branch)
+
+    if no_origin:
+        info(f"⏭️  {len(no_origin)} branch(es) have no origin/<branch>, left alone:")
+        for branch in no_origin:
+            info(f"  • 🌿 {branch}")
+
+    if not targets:
+        success(f"✨ All {len(in_sync)} branch(es) with an origin already match it. 🎉")
+        return 0
+
+    # Branches checked out in ANOTHER worktree cannot be checked out here, so
+    # they are reset where they are. The current branch is not among them: it
+    # is checked out (a no-op) and reset like the rest.
+    elsewhere = worktree_branch_map(root)
+    elsewhere.pop(original, None)
+
+    if args.dry_run:
+        warning(f"🌵 {len(targets)} branch(es) would be hard reset to origin:")
+        for branch, ahead, behind in targets:
+            where = f" (in {elsewhere[branch]})" if branch in elsewhere else ""
+            warning(f"  • 💣 {branch}{where} — {describe(ahead, behind)}")
+        dry_run_complete("reset")
+        return 0
+
+    reset: list[str] = []
+    skipped: list[tuple[str, str]] = []
+    failed: list[str] = []
+    checkout = ["git", "checkout", "--quiet", *(["--force"] if args.force else [])]
+
+    for branch, ahead, behind in targets:
+        if pinned := elsewhere.get(branch):
+            path = Path(pinned)
+            if in_progress(path):
+                warning(f"  ⏭️  {branch} — operation in progress in {pinned}, skipping")
+                skipped.append((branch, "operation in progress"))
+                continue
+            # Uncommitted work in another worktree is the user's; only --force
+            # may throw it away.
+            if has_tracked_changes(path) and not args.force:
+                warning(f"  ⏭️  {branch} — worktree is dirty ({pinned}), skipping")
+                skipped.append((branch, "dirty worktree"))
+                continue
+            log(f"💣 Resetting {branch} in its worktree ({pinned})")
+            git, where = ["git", "-C", pinned], f" (in {pinned})"
+        else:
+            info(f"📂 Switching to 🌿 {branch}")
+            if run([*checkout, branch], check=False, capture=True, cwd=root).returncode != 0:
+                warning("  ✗ checkout failed, skipping")
+                failed.append(branch)
+                continue
+            log(f"💣 Resetting {branch} to origin/{branch}")
+            git, where = ["git", "-C", str(root)], ""
+
+        before = run_output([*git, "rev-parse", "--short", "HEAD"])
+        completed = run(
+            [*git, "reset", "--hard", "--quiet", f"refs/remotes/origin/{branch}"],
+            check=False,
+            capture=True,
+        )
+        if completed.returncode != 0:
+            warning(f"  ❌ reset failed: {(completed.stderr or '').strip()}")
+            failed.append(branch)
+            continue
+        success(f"  ✅ {branch} matches origin{where} (was {before}; {describe(ahead, behind)})")
+        reset.append(branch)
+
+    info(f"🔁 Returning to 🌿 {original}")
+    run(["git", "checkout", "--quiet", original], cwd=root)
+
+    print()
+    success("═══ summary ═══")
+    success(f"✅ Reset:    {len(reset)}")
+    if in_sync:
+        success(f"✨ In sync:  {len(in_sync)}")
+    if reset:
+        info("💡 Dropped commits stay reachable for a while: git reflog show <branch>")
+    if skipped:
+        warning(f"⏭️  Skipped:  {len(skipped)}")
+        for branch, reason in skipped:
+            warning(f"  • 🌿 {branch} ({reason})")
+    if failed:
+        warning(f"❌ Failed:   {len(failed)}")
+        for branch in failed:
+            warning(f"  • 💥 {branch}")
+        return 1
+
+    success("🎉 All clean!")
+    return 0
+
+
+if __name__ == "__main__":
+    run_cli(main)