@codebend3r/che 1.1.0 → 1.2.0

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

@@ -1,34 +1,25 @@
 #!/usr/bin/env python3
-"""🔄 Sync everything: push every worktree, collapse the pushed ones, then tidy branches.
-
-A worktree is a temporary workspace. Once its commits are on origin, the
-directory holds nothing the remote does not, so it is removed and the branch
-stays behind as a plain local branch that the later steps can update normally.
-That also clears the "already used by worktree" pin, which is what otherwise
-makes main un-checkoutable and stale branches un-deletable.
+"""🔄 Sync every branch: delete merged ones, rebase the rest, check out new ones.
 
 Steps, in order:
-  1. git fetch --all --prune
-  2. Push every linked worktree's branch to origin
-  3. Remove each pushed + clean worktree, keeping its branch
-  4. Prune stale worktree admin records
-  5. Switch the main clone to the main branch
-  6. clean-stale-branches   (delete branches whose upstream is gone)
-  7. update-local-branches  (rebase every branch onto its upstream)
-  8. checkout-my-branches   (check out your remote branches that aren't local)
-
-A worktree is only collapsed when it is clean AND fully pushed. Anything else
-is kept and reported with the reason.
+  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.
 
 Usage:
-  sync-all-branches.py [--dry-run] [--no-push] [--keep-locked]
-                       [--author=EMAIL] [--limit=N]
+  sync-all-branches.py [--dry-run] [--author=EMAIL] [--limit=N]
 
 Options:
-  --dry-run        Report what would be pushed / removed / synced, change nothing
-  --no-push        Never push; only collapse worktrees that are already pushed
-  --keep-locked    Leave locked worktrees alone (default: release the lock once
-                   the worktree is pushed and clean)
+  --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
   --help           Show help
@@ -39,194 +30,60 @@ Env:
 
 from __future__ import annotations
 
+import argparse
 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 utils import (
     add_bool_flag,
-    branch_is_pushed,
     build_parser,
     env_bool,
-    find_main_branch,
+    heading,
     info,
     log,
-    main_worktree,
-    note,
     require_binary,
     run,
     run_cli,
-    run_output,
-    success,
-    warning,
-    worktree_branch_map,
-    worktree_is_clean,
 )
 
-__version__ = "1.0.0"
+__version__ = "2.1.0"
 
 SCRIPT_DIR = Path(__file__).resolve().parent
 
 
-def delegate(script: str, args: list[str], *, cwd: Path, dry_run: bool) -> None:
+def delegate(script: str, args: list[str], *, cwd: Path) -> None:
     """Run a sibling script in the main worktree, aborting the sync if it fails.
 
     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.
 
-    DRY_RUN is passed explicitly rather than inherited, so the child can never
-    disagree with the parent about which mode this is.
-    """
-    run(
-        [sys.executable, str(SCRIPT_DIR / script), *args],
-        cwd=cwd,
-        env={"DRY_RUN": "true" if dry_run else "false"},
-    )
-
-
-def collapse_worktrees(
-    *,
-    main_wt: Path,
-    push: bool,
-    keep_locked: bool,
-    dry_run: bool,
-) -> tuple[list[str], list[str], list[str]]:
-    """Push, then remove, every linked worktree that is clean and fully pushed.
-
-    Returns ``(pushed, collapsed, kept)`` for the summary. ``kept`` entries
-    carry the reason, because "nothing happened" is the one outcome a user
-    needs explained.
+    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.
     """
-    pushed: list[str] = []
-    collapsed: list[str] = []
-    kept: list[str] = []
-
-    info("🌿 Inspecting linked worktrees...")
-
-    # Snapshot the map first: removing a worktree mutates the list git reports.
-    worktrees = [
-        (branch, path)
-        for branch, path in worktree_branch_map(cwd=main_wt).items()
-        if path and Path(path) != main_wt
-    ]
-
-    if not worktrees:
-        info("  ℹ️  No linked worktrees with a branch checked out.")  # noqa: RUF001
-
-    for branch, path in worktrees:
-        # A dirty worktree holds work that only exists there. Never touch it.
-        if not worktree_is_clean(path):
-            kept.append(f"{branch} ({path}) — dirty")
-            warning(f"  ⏭️  {branch} — dirty, keeping {path}")
-            continue
-
-        # Push whatever is not on origin yet, so the directory becomes redundant.
-        if not branch_is_pushed(branch, cwd=main_wt):
-            if not push:
-                kept.append(f"{branch} ({path}) — unpushed, --no-push")
-                warning(f"  ⏭️  {branch} — unpushed and --no-push, keeping {path}")
-                continue
-
-            if dry_run:
-                info(f"  🌵 Would push: {branch} → origin")
-                pushed.append(branch)
-            else:
-                log(f"  ⬆️  Pushing {branch} → origin")
-                result = run(
-                    ["git", "-C", path, "push", "--quiet", "--set-upstream", "origin", branch],
-                    check=False,
-                )
-                if result.returncode != 0:
-                    kept.append(f"{branch} ({path}) — push failed")
-                    warning(f"  ❌ push failed for {branch}, keeping {path}")
-                    continue
-                pushed.append(branch)
-
-        # Re-check rather than assume: a push can succeed and still leave the
-        # branch behind its upstream if someone else pushed in between.
-        if not dry_run and not branch_is_pushed(branch, cwd=main_wt):
-            kept.append(f"{branch} ({path}) — still not fully pushed")
-            warning(f"  ⏭️  {branch} — still not fully pushed, keeping {path}")
-            continue
-
-        if dry_run:
-            info(f"  🌵 Would collapse: {path} (branch {branch} kept)")
-            collapsed.append(f"{branch} ({path})")
-            continue
-
-        # A lock is metadata stamped by whatever created the worktree (a tool,
-        # an agent, the user), and `git worktree remove` refuses while one is
-        # set. The lock says nothing about unsaved work — the clean and pushed
-        # gates above are what protect that — so release it rather than
-        # skipping. This is NOT --force, which is the flag that discards work.
-        if not keep_locked:
-            run(["git", "worktree", "unlock", path], check=False, capture=True, cwd=main_wt)
-
-        removed = run(["git", "worktree", "remove", path], check=False, cwd=main_wt)
-        if removed.returncode == 0:
-            success(f"  ✅ Collapsed {path} — branch {branch} kept")
-            collapsed.append(f"{branch} ({path})")
-        else:
-            kept.append(f"{branch} ({path}) — removal failed (locked?)")
-            warning(f"  ❌ Could not remove {path}")
-
-    return pushed, collapsed, kept
-
-
-def report(
-    *,
-    pushed: list[str],
-    collapsed: list[str],
-    kept: list[str],
-    started_in: Path,
-    main_wt: Path,
-) -> None:
-    """Print the worktree summary."""
-    print()
-    note("─────────────────────────────────────────────")
-    success("═══ worktree summary ═══")
-    success(f"⬆️  Pushed:    {len(pushed)}")
-    for branch in pushed:
-        success(f"  • 🌿 {branch}")
-    success(f"📦 Collapsed: {len(collapsed)}")
-    for branch in collapsed:
-        success(f"  • 🪦 {branch}")
-    if kept:
-        warning(f"⏭️  Kept:      {len(kept)}")
-        for branch in kept:
-            warning(f"  • 🌿 {branch}")
-
-    if started_in != main_wt:
-        info(f"📍 Started in {started_in}; finished in {main_wt}.")
-        if not started_in.is_dir():
-            warning(f"⚠️  {started_in} was collapsed — your shell is in a stale directory.")
-            warning(f"   Run: cd {main_wt}")
+    print(flush=True)
+    run([sys.executable, str(SCRIPT_DIR / script), *args], cwd=cwd)
 
 
 def main(argv: list[str] | None = None) -> int:
     parser = build_parser(
         prog="sync-all-branches",
-        description="🔄 Push every worktree, collapse the pushed ones, then tidy branches.",
+        description="🔄 Delete merged branches, rebase the rest, check out new ones.",
     )
     add_bool_flag(
         parser,
         "--dry-run",
         default=env_bool("DRY_RUN", False),
-        help="Report what would be pushed / removed / synced, change nothing",
-    )
-    add_bool_flag(
-        parser,
-        "--no-push",
-        allow_value=False,
-        help="Never push; only collapse worktrees that are already pushed",
-    )
-    add_bool_flag(
-        parser,
-        "--keep-locked",
-        help="Leave locked worktrees alone (default: release the lock once pushed and clean)",
+        help="Report what would be deleted / synced, change nothing",
     )
+    # Accepted and ignored, from when the sync pushed and collapsed worktrees:
+    # chip's "Update from Origin" still passes --no-push and must keep running.
+    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="",
@@ -242,123 +99,37 @@ def main(argv: list[str] | None = None) -> int:
     args = parser.parse_args(argv)
 
     require_binary("git")
+    skip_git_hooks()
 
-    inside = run(["git", "rev-parse", "--is-inside-work-tree"], check=False, capture=True)
-    if inside.returncode != 0:
-        warning("❌ Not inside a git working tree.")
-        return 1
-
-    header_suffix = " 🌵 (dry run)" if args.dry_run else ""
-    note("═══════════════════════════════════════════")
-    note(f"🔄  sync-all-branches{header_suffix}")
-    note("═══════════════════════════════════════════")
-
-    # Every later step runs from the main worktree: a worktree cannot be
-    # removed while we are standing inside it, and the delegated scripts
-    # expect the main clone.
-    main_wt_raw = main_worktree()
-    if not main_wt_raw:
-        warning("❌ Could not determine main worktree.")
-        return 1
-
-    main_wt = Path(main_wt_raw)
-    # The shell version `cd`-ed here. Passing cwd= to each call instead keeps
-    # the process's own directory untouched, so a caller that sourced this in
-    # the same shell would not be moved out from under itself.
-    started_in = Path.cwd().resolve()
+    heading("🔄  sync-all-branches", dry_run=args.dry_run)
 
-    main_branch = find_main_branch(main_wt)
-    if not main_branch:
-        warning("❌ Neither 'main' nor 'master' exists locally — refusing to sync.")
-        return 1
+    # 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)
 
-    # -----------------------------------------------------------------------
-    # Step 1 — fetch + prune
-    # -----------------------------------------------------------------------
+    # 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()
 
-    info("📡 Fetching + pruning remotes...")
-    if args.dry_run:
-        info("🌵 Would run: git fetch --all --prune")
-    else:
-        run(["git", "fetch", "--all", "--prune", "--quiet"], cwd=main_wt)
-
-    # -----------------------------------------------------------------------
-    # Steps 2-3 — push every worktree, then collapse the pushed ones
-    # -----------------------------------------------------------------------
+    # 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)
 
-    pushed, collapsed, kept = collapse_worktrees(
-        main_wt=main_wt,
-        push=not args.no_push,
-        keep_locked=args.keep_locked,
-        dry_run=args.dry_run,
-    )
-
-    # -----------------------------------------------------------------------
-    # Step 4 — prune stale admin records
-    # -----------------------------------------------------------------------
+    checkout_args = []
+    if args.author:
+        checkout_args.append(f"--author={args.author}")
+    if args.limit:
+        checkout_args.append(f"--limit={args.limit}")
 
     if args.dry_run:
-        info("🌵 Would run: git worktree prune")
+        print(flush=True)
+        info(f"🌵 Would run: checkout-my-branches {' '.join(checkout_args)}".rstrip())
     else:
-        run(["git", "worktree", "prune"], cwd=main_wt)
-
-    # -----------------------------------------------------------------------
-    # Step 5 — park on main before anything tries to delete or rebase branches
-    # -----------------------------------------------------------------------
-
-    current = run_output(
-        ["git", "symbolic-ref", "--quiet", "--short", "HEAD"], check=False, cwd=main_wt
-    ).strip()
-
-    if current != main_branch:
-        # Only tracked changes block: untracked files (including worktrees
-        # nested under the main worktree) are not touched by checkout.
-        if run_output(["git", "status", "--porcelain", "--untracked-files=no"], cwd=main_wt):
-            warning("❌ Main worktree has uncommitted changes — commit or stash first. 🧺")
-            return 1
-
-        if args.dry_run:
-            info(f"🌵 Would switch to 🌿 {main_branch} (currently on {current or 'detached'})")
-        else:
-            info(f"🔀 Switching to 🌿 {main_branch} (from {current or 'detached'})")
-            run(["git", "checkout", "--quiet", main_branch], cwd=main_wt)
-    else:
-        info(f"📍 Already on 🌿 {main_branch}")
-
-    # -----------------------------------------------------------------------
-    # Steps 6-8 — delegate to the single-purpose scripts
-    # -----------------------------------------------------------------------
-
-    delegate_args = ["--dry-run"] if args.dry_run else []
-
-    # DELIBERATE DIVERGENCE: the summary is printed even when a delegate fails.
-    # The pushes and collapses above already happened; aborting without saying
-    # which ones would leave the user guessing what state the repo is in.
-    try:
-        print()
-        delegate("clean-stale-branches.py", delegate_args, cwd=main_wt, dry_run=args.dry_run)
-
-        print()
-        delegate("update-local-branches.py", delegate_args, cwd=main_wt, dry_run=args.dry_run)
-
-        checkout_args = []
-        if args.author:
-            checkout_args.append(f"--author={args.author}")
-        if args.limit:
-            checkout_args.append(f"--limit={args.limit}")
-
-        print()
-        if args.dry_run:
-            info(f"🌵 Would run: checkout-my-branches {' '.join(checkout_args)}".rstrip())
-        else:
-            delegate("checkout-my-branches.py", checkout_args, cwd=main_wt, dry_run=args.dry_run)
-    except BaseException:
-        report(
-            pushed=pushed, collapsed=collapsed, kept=kept, started_in=started_in, main_wt=main_wt
-        )
-        raise
-
-    report(pushed=pushed, collapsed=collapsed, kept=kept, started_in=started_in, main_wt=main_wt)
+        delegate("checkout-my-branches.py", checkout_args, cwd=main_wt)
 
     log("🎉 Sync complete.")
     return 0

package/bin/git/update-local-branches.py

@@ -14,56 +14,57 @@ Options:
 
 from __future__ import annotations
 
-import re
 import sys
 from pathlib import Path
 
 sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
 
+from gitutils import (
+    current_branch,
+    fetch_remotes,
+    has_tracked_changes,
+    local_branches,
+    skip_git_hooks,
+    worktree_branch_map,
+    worktree_is_clean,
+)
 from utils import (
     add_bool_flag,
     build_parser,
+    heading,
     info,
     log,
-    note,
+    parse_count,
     require_binary,
     run,
     run_cli,
-    run_lines,
-    run_output,
     success,
     warning,
-    worktree_branch_map,
-    worktree_is_clean,
 )
 
-__version__ = "3.1.0"
+__version__ = "3.2.0"
 
 
 def branches_with_upstream() -> list[str]:
-    """Local branches that have an upstream, most recently committed first.
-
-    The separator is \\x01, not the shell version's ``|``. A branch name may
-    legally contain a pipe (``git check-ref-format`` allows it), and splitting
-    on ``|`` then treating the whole remainder as the upstream reports such a
-    branch as *having* an upstream when it does not - after which
-    ``git pull --rebase`` fails on it and the run exits non-zero. Control
-    characters are illegal in ref names, so \\x01 cannot collide.
+    """Local branches that have an upstream, most recently committed first."""
+    return [
+        branch for branch, upstream in local_branches("upstream", sort="-committerdate") if upstream
+    ]
+
+
+def rebase(git: list[str]) -> bool:
+    """Rebase onto the upstream with ``git`` (plain, or ``-C <worktree>``); abort on failure.
+
+    DELIBERATE DIVERGENCE: the shell version ran ``pull --rebase`` per branch,
+    a fetch for every branch on top of the one the run opened with. The remotes
+    are fetched once up front, so a bare ``rebase`` (onto ``@{upstream}``, with
+    the same fork-point handling ``pull --rebase`` uses) is the whole job.
     """
-    found = []
-    for line in run_lines(
-        [
-            "git",
-            "for-each-ref",
-            "--sort=-committerdate",
-            "--format=%(refname:short)%01%(upstream)",
-            "refs/heads/",
-        ]
-    ):
-        branch, _, upstream = line.partition("\x01")
-        if branch and upstream:
-            found.append(branch)
-    return found
+    if run([*git, "rebase", "--quiet"], check=False).returncode == 0:
+        return True
+    warning("  ❌ rebase failed — aborting and moving on")
+    run([*git, "rebase", "--abort"], check=False, capture=True)
+    return False
 
 
 def main(argv: list[str] | None = None) -> int:
@@ -71,8 +72,6 @@ def main(argv: list[str] | None = None) -> int:
         prog="update-local-branches",
         description="⬇️  Rebase every local branch that has an upstream onto origin.",
     )
-    # Kept as a string, not `type=int`: argparse's own int conversion would
-    # own the failure and exit before the shell version's message could print.
     parser.add_argument(
         "--limit",
         default="0",
@@ -86,31 +85,28 @@ def main(argv: list[str] | None = None) -> int:
     )
     args = parser.parse_args(argv)
 
-    if not re.fullmatch(r"[0-9]+", args.limit):
-        warning(f"❌ --limit must be a non-negative integer (got: {args.limit})")
-        return 1
-    limit = int(args.limit)
+    limit = parse_count(args.limit, "--limit")
 
     require_binary("git")
+    skip_git_hooks()
 
-    header_suffix = " 🌵 (dry run)" if args.dry_run else ""
-    note("═══════════════════════════════════════════")
-    note(f"⬇️   update-local-branches{header_suffix}")
-    note("═══════════════════════════════════════════")
+    heading("⬇️   update-local-branches", dry_run=args.dry_run)
 
-    original_branch = run_output(
-        ["git", "symbolic-ref", "--quiet", "--short", "HEAD"], check=False
-    ).strip()
+    original_branch = current_branch()
     if not original_branch:
         warning("❌ Detached HEAD — check out a branch first.")
         return 1
 
-    if not args.dry_run and run_output(["git", "status", "--porcelain"]):
+    # Tracked changes only: an untracked file survives checkout and rebase, and
+    # a linked worktree nested in this one is untracked - counting it made
+    # sync-all-branches abort right after parking had allowed the same tree.
+    if not args.dry_run and has_tracked_changes():
         warning("❌ Working tree is dirty. Commit or stash before running. 🧺")
         return 1
 
-    info("📡 Fetching remotes...")
-    run(["git", "fetch", "--all", "--quiet"])
+    # Prunes too, where this script's own fetch did not: it shares the one
+    # fetch sync-all-branches runs.
+    fetch_remotes()
 
     branches = branches_with_upstream()
     if limit > 0:
@@ -127,52 +123,46 @@ def main(argv: list[str] | None = None) -> int:
         return 0
 
     succeeded: list[str] = []
+    skipped: list[str] = []
     failed: list[str] = []
 
-    # One `git worktree list` for the whole run, not one per branch as the
-    # shell's per-branch `worktree_for_branch` did.
-    pinned_by_branch = worktree_branch_map()
-    here = Path.cwd().resolve()
+    # Branches checked out in ANOTHER worktree: every pinned one but the branch
+    # this worktree has checked out. One `git worktree list` for the whole run,
+    # not one per branch as the shell's per-branch `worktree_for_branch` did.
+    elsewhere = worktree_branch_map()
+    elsewhere.pop(original_branch, None)
 
     for branch in branches:
         # A branch checked out in another worktree cannot be checked out here —
         # git refuses with "already used by worktree". That's a mechanical
         # limit, not a conflict, so update it in place rather than counting it
         # as a failure.
-        pinned = pinned_by_branch.get(branch, "")
-
-        if pinned and Path(pinned).resolve() != here:
+        if pinned := elsewhere.get(branch):
+            # Uncommitted work in a worktree is the user's, left exactly as it
+            # is. Skipping it is not a failure, or one worktree in progress
+            # would stop every run of sync-all-branches at this step.
             if not worktree_is_clean(pinned):
                 warning(f"  ⏭️  {branch} — worktree is dirty ({pinned}), skipping")
-                failed.append(branch)
+                skipped.append(branch)
                 continue
 
             log(f"⬇️  Rebasing {branch} in its worktree ({pinned})")
-            rebase = run(["git", "-C", pinned, "pull", "--rebase", "--quiet"], check=False)
-            if rebase.returncode == 0:
-                success(f"  ✅ {branch} up to date (in {pinned})")
-                succeeded.append(branch)
-            else:
-                warning("  ❌ rebase failed — aborting and moving on")
-                run(["git", "-C", pinned, "rebase", "--abort"], check=False, capture=True)
+            git, where = ["git", "-C", pinned], f" (in {pinned})"
+        else:
+            info(f"📂 Switching to 🌿 {branch}")
+            checkout = run(["git", "checkout", "--quiet", branch], check=False, capture=True)
+            if checkout.returncode != 0:
+                warning("  ✗ checkout failed, skipping")
                 failed.append(branch)
-            continue
+                continue
 
-        info(f"📂 Switching to 🌿 {branch}")
-        checkout = run(["git", "checkout", "--quiet", branch], check=False, capture=True)
-        if checkout.returncode != 0:
-            warning("  ✗ checkout failed, skipping")
-            failed.append(branch)
-            continue
+            log(f"⬇️  Rebasing {branch} onto upstream")
+            git, where = ["git"], ""
 
-        log(f"⬇️  Rebasing {branch} onto upstream")
-        pull = run(["git", "pull", "--rebase", "--quiet"], check=False)
-        if pull.returncode == 0:
-            success(f"  ✅ {branch} up to date")
+        if rebase(git):
+            success(f"  ✅ {branch} up to date{where}")
             succeeded.append(branch)
         else:
-            warning("  ❌ rebase failed — aborting and moving on")
-            run(["git", "rebase", "--abort"], check=False, capture=True)
             failed.append(branch)
 
     info(f"🔁 Returning to 🌿 {original_branch}")
@@ -181,6 +171,10 @@ def main(argv: list[str] | None = None) -> int:
     print()
     success("═══ summary ═══")
     success(f"✅ Updated: {len(succeeded)}")
+    if skipped:
+        warning(f"⏭️  Skipped: {len(skipped)} (dirty worktree)")
+        for branch in skipped:
+            warning(f"  • 🌿 {branch}")
     if failed:
         warning(f"❌ Failed:  {len(failed)}")
         for branch in failed: