@codebend3r/che 1.0.0 → 1.2.0

package/bin/git/checkout-my-branches.py

@@ -1,6 +1,8 @@
 #!/usr/bin/env python3
 """🌿 Check out recent remote branches authored by you that aren't yet local.
 
+Each one becomes a local branch tracking its remote. HEAD stays where it is.
+
 Usage:
   checkout-my-branches.py [--author=EMAIL] [--limit=N]
 
@@ -12,44 +14,40 @@ 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 fetch_remotes, for_each_ref, local_branches, skip_git_hooks
 from utils import (
     build_parser,
+    heading,
     info,
     log,
-    note,
+    parse_count,
     require_binary,
     run,
     run_cli,
-    run_lines,
     run_output,
     success,
     warning,
 )
 
-__version__ = "3.0.0"
+__version__ = "3.1.0"
 
 
 def main(argv: list[str] | None = None) -> int:
-    default_author = run_output(["git", "config", "user.email"], check=False).strip()
-
     parser = build_parser(
         prog="checkout-my-branches",
         description="🌿 Check out recent remote branches you authored that aren't yet local.",
     )
     parser.add_argument(
         "--author",
-        default=default_author,
+        default="",
         metavar="EMAIL",
         help="Author email to match (default: git config user.email)",
     )
-    # 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="100",
@@ -58,80 +56,61 @@ def main(argv: list[str] | None = None) -> int:
     )
     args = parser.parse_args(argv)
 
-    if not args.author:
-        warning("❌ No author email — pass --author=EMAIL or set git config user.email")
-        return 1
-
-    if not re.fullmatch(r"[0-9]+", args.limit) or int(args.limit) < 1:
-        warning(f"❌ --limit must be a positive integer (got: {args.limit})")
-        return 1
-    limit = int(args.limit)
+    limit = parse_count(args.limit, "--limit", minimum=1)
 
     require_binary("git")
+    # Read after the check for git, so a missing git says so rather than
+    # reporting that no author email is set.
+    author = args.author or run_output(["git", "config", "user.email"], check=False).strip()
+    if not author:
+        warning("❌ No author email — pass --author=EMAIL or set git config user.email")
+        return 1
 
-    note("═══════════════════════════════════════════")
-    note("🌿  checkout-my-branches")
-    note("═══════════════════════════════════════════")
+    # Nothing here checks out, but fetch and branch still fire a repo's
+    # reference-transaction hook.
+    skip_git_hooks()
 
-    if run_output(["git", "status", "--porcelain"]):
-        warning("❌ Working tree is dirty. Commit or stash before running. 🧺")
-        return 1
+    heading("🌿  checkout-my-branches")
 
-    info("📡 Fetching remotes...")
-    run(["git", "fetch", "--all", "--prune", "--quiet"])
+    fetch_remotes()
 
-    info(f"📦 Scanning {limit} most recent remote branches for author 👤 {args.author}...")
+    info(f"📦 Scanning {limit} most recent remote branches for author 👤 {author}...")
 
     checked_out = 0
     skipped = 0
     not_mine = 0
 
-    # One pass: author email + refname + symref target, newest first. %(symref)
-    # is non-empty for symbolic refs like origin/HEAD, which must be skipped -
-    # it is a pointer, not a branch anyone authored.
-    #
-    # Separator is \x01 rather than the shell version's '|': an author email or
-    # a branch name may contain a pipe, and the shell version then mis-split
-    # the record. Control characters are illegal in ref names, so \x01 is safe.
-    lines = run_lines(
-        [
-            "git",
-            "for-each-ref",
-            "--sort=-committerdate",
-            "--format=%(authoremail)%01%(refname:short)%01%(symref)",
-            "refs/remotes/origin",
-        ]
+    local = {branch for (branch,) in local_branches()}
+
+    # One pass: author email + branch name + symref target, newest first.
+    # %(symref) is non-empty for symbolic refs like origin/HEAD, which must be
+    # skipped - it is a pointer, not a branch anyone authored.
+    refs = for_each_ref(
+        "refs/remotes/origin",
+        "authoremail",
+        "refname:lstrip=3",
+        "symref",
+        sort="-committerdate",
     )
 
-    for line in lines[:limit]:
-        parts = line.split("\x01")
-        if len(parts) < 3:
-            continue
-        author_email, remote_branch, symref = parts[0], parts[1], parts[2]
-
-        if not remote_branch or symref:
+    for author_email, branch, symref in refs[:limit]:
+        if symref:
             continue
 
-        author_email = author_email.removeprefix("<").removesuffix(">")
-        if author_email != args.author:
+        if author_email.removeprefix("<").removesuffix(">") != author:
             not_mine += 1
             continue
 
-        local_branch = remote_branch.removeprefix("origin/")
-        if not local_branch or local_branch == remote_branch:
-            continue  # malformed entry — don't touch
-
-        exists = run(
-            ["git", "show-ref", "--verify", "--quiet", f"refs/heads/{local_branch}"],
-            check=False,
-            capture=True,
-        )
-        if exists.returncode == 0:
-            info(f"⏭️  Already local: {local_branch}")
+        if branch in local:
+            info(f"⏭️  Already local: {branch}")
             skipped += 1
         else:
-            log(f"🆕 Checking out: {local_branch}")
-            run(["git", "checkout", "-b", local_branch, "--track", remote_branch])
+            log(f"🆕 Checking out: {branch}")
+            # `git branch --track`, not `checkout -b`: switching to each new
+            # branch left HEAD on the last one, undoing the park on main that
+            # sync-all-branches runs this after. The full ref name cannot be
+            # mistaken for a local branch called `origin/<branch>`.
+            run(["git", "branch", "--track", branch, f"refs/remotes/origin/{branch}"])
             checked_out += 1
 
     print()

package/bin/git/clean-stale-branches.py

@@ -1,7 +1,8 @@
 #!/usr/bin/env python3
 """🧹 Delete local branches whose upstream is gone (the remote branch was deleted).
 
-Protected branches and the current branch are never deleted.
+Protected branches are never deleted, and neither is a branch checked out in a
+worktree - the current one included. Those are reported instead.
 
 Usage:
   clean-stale-branches.py [--dry-run] [--protect=BRANCH1,BRANCH2,...]
@@ -23,62 +24,41 @@ from pathlib import Path
 
 sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
 
+from gitutils import fetch_remotes, local_branches, skip_git_hooks, worktree_branch_map
 from utils import (
     add_bool_flag,
     build_parser,
+    dry_run_complete,
     env_bool,
+    heading,
     info,
-    log,
-    note,
     require_binary,
     run,
     run_cli,
-    run_lines,
     success,
     warning,
-    worktree_branch_map,
 )
 
-__version__ = "3.1.0"
+__version__ = "3.2.0"
 
 DEFAULT_PROTECTED = ("main", "master", "dev", "develop", "staging")
 
 
-def current_branch() -> str:
-    """The checked-out branch, or "" when HEAD is detached."""
-    completed = run(
-        ["git", "symbolic-ref", "--quiet", "--short", "HEAD"],
-        check=False,
-        capture=True,
-    )
-    return (completed.stdout or "").strip()
-
-
-def stale_branches(protected: set[str], skip: str) -> list[str]:
+def stale_branches(protected: set[str]) -> list[str]:
     """Local branches whose upstream is marked ``[gone]``.
 
     ``[gone]`` means the remote branch was deleted, which is what a merged and
     tidied-up PR leaves behind. It does *not* mean merged - a closed-unmerged
     PR looks identical here, same as in the shell version.
+
+    The current branch gets no special case: its worktree pins it like any
+    other checked-out branch, so ``main`` reports it alongside those.
     """
-    # Separator is \x01, not the shell version's '|': a branch may legally be
-    # named `a|b[gone]`, which made the shell version split the record wrong
-    # and delete branch `a`. Control characters are illegal in ref names.
-    found = []
-    for line in run_lines(
-        ["git", "for-each-ref", "--format=%(refname:short)%01%(upstream:track)", "refs/heads/"]
-    ):
-        branch, _, track = line.partition("\x01")
-        if not branch:
-            continue
-        if branch in protected:
-            continue
-        if branch == skip:
-            note(f"⏭️  Skipping current branch: {branch}")
-            continue
-        if "[gone]" in track:
-            found.append(branch)
-    return found
+    return [
+        branch
+        for branch, track in local_branches("upstream:track")
+        if branch not in protected and "[gone]" in track
+    ]
 
 
 def main(argv: list[str] | None = None) -> int:
@@ -101,22 +81,17 @@ def main(argv: list[str] | None = None) -> int:
     args = parser.parse_args(argv)
 
     require_binary("git")
+    skip_git_hooks()
 
     protected = set(DEFAULT_PROTECTED)
     protected.update(name for name in args.protect.split(",") if name)
 
-    header_suffix = " 🌵 (dry run)" if args.dry_run else ""
-    note("═══════════════════════════════════════════")
-    note(f"🧹  clean-stale-branches{header_suffix}")
-    note("═══════════════════════════════════════════")
+    heading("🧹  clean-stale-branches", dry_run=args.dry_run)
 
-    info("📡 Fetching + pruning remotes...")
-    # Not wrapped: the shell version ran this bare under `set -e`, so a fetch
-    # failure exited with git's own status (128), not a flattened 1.
-    run(["git", "fetch", "--all", "--prune", "--quiet"])
+    fetch_remotes()
 
     info("🔍 Scanning local branches for gone upstreams...")
-    stale = stale_branches(protected, current_branch())
+    stale = stale_branches(protected)
 
     if not stale:
         success("✨ No stale branches. All clean! 🎉")
@@ -124,8 +99,8 @@ def main(argv: list[str] | None = None) -> int:
 
     # A branch checked out in a worktree cannot be deleted — git refuses with
     # "already used by worktree". Split those out so one pinned branch doesn't
-    # abort the whole run; sync-all-branches collapses worktrees before it gets
-    # here, so this only bites when the script is run on its own.
+    # abort the whole run. Worktrees are the user's, so they are reported and
+    # left alone, never removed to free the branch.
     # One `git worktree list` for the whole set, not one per branch as the
     # shell's per-branch `worktree_for_branch` did.
     pinned_by_branch = worktree_branch_map()
@@ -136,7 +111,7 @@ def main(argv: list[str] | None = None) -> int:
         warning(f"⏭️  {len(pinned)} stale branch(es) are checked out in a worktree:")
         for branch, path in pinned:
             warning(f"  • 🌿 {branch} (in {path})")
-        info("💡 Run sync-all-branches to push and collapse those worktrees first.")
+        info("💡 Switch off or remove those worktrees, and the next run deletes their branches.")
 
     if not deletable:
         success("✨ Nothing left to delete. 🎉")
@@ -146,7 +121,7 @@ def main(argv: list[str] | None = None) -> int:
         warning(f"🌵 {len(deletable)} stale branch(es) would be deleted:")
         for branch in deletable:
             warning(f"  • 🪦 {branch}")
-        log("💡 Dry run complete. Nothing was actually deleted.")
+        dry_run_complete("deleted")
         return 0
 
     for branch in deletable:

package/bin/git/prune-worktrees.py

@@ -22,24 +22,22 @@ 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 utils import (
     add_bool_flag,
     build_parser,
+    dry_run_complete,
     env_bool,
-    find_main_branch,
+    heading,
     info,
-    log,
-    note,
     require_binary,
     run,
     run_cli,
-    run_output,
     success,
     warning,
-    worktree_paths,
 )
 
-__version__ = "1.2.0"
+__version__ = "1.3.0"
 
 
 def main(argv: list[str] | None = None) -> int:
@@ -61,60 +59,23 @@ def main(argv: list[str] | None = None) -> int:
     args = parser.parse_args(argv)
 
     require_binary("git")
+    # Parking the main worktree is a `git checkout`, which fires post-checkout.
+    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"🌿  prune-worktrees{header_suffix}")
-    note("═══════════════════════════════════════════")
+    heading("🌿  prune-worktrees", dry_run=args.dry_run)
 
     # Work from the main worktree: removing a worktree fails while standing
-    # inside it, and starting from a known-good branch keeps this predictable.
-    paths = worktree_paths()
-    if not paths:
-        warning("❌ Could not determine main worktree.")
-        return 1
-
-    main_wt = Path(paths[0])
-    linked = [p for p in paths[1:] if Path(p) != main_wt]
-
-    main_branch = find_main_branch(main_wt)
-    if not main_branch:
-        warning("❌ Neither 'main' nor 'master' exists locally — refusing to prune.")
-        return 1
-
-    current = run_output(
-        ["git", "symbolic-ref", "--quiet", "--short", "HEAD"], check=False, cwd=main_wt
-    ).strip()
-
-    if current != main_branch:
-        # Only block on tracked-file changes: untracked files (including linked
-        # worktrees nested under the main worktree) won't be touched by checkout.
-        dirty = run_output(["git", "status", "--porcelain", "--untracked-files=no"], cwd=main_wt)
-        if dirty:
-            warning("❌ Main worktree has uncommitted changes — commit or stash before pruning. 🧺")
-            return 1
-        if args.dry_run:
-            info(
-                f"🌵 Would switch main worktree to 🌿 {main_branch} (currently on {current or 'detached'})"
-            )
-        else:
-            info(f"🔀 Switching main worktree to 🌿 {main_branch} (from {current or 'detached'})")
-            run(["git", "checkout", "--quiet", main_branch], cwd=main_wt)
-    else:
-        info(f"📍 Main worktree already on 🌿 {main_branch}")
+    # inside it.
+    main_wt = park_main_worktree("prune", dry_run=args.dry_run)
 
     info("🔍 Listing worktrees...")
+    linked = [worktree.path for worktree in worktrees(main_wt)[1:]]
 
     if not linked:
         success("✨ No linked worktrees. Running prune anyway... 🎉")
         if args.dry_run:
             run(["git", "worktree", "prune", "--dry-run", "--verbose"], check=False, cwd=main_wt)
-            log("💡 Dry run complete. Nothing was actually pruned.")
+            dry_run_complete("pruned")
         else:
             run(["git", "worktree", "prune", "--verbose"], cwd=main_wt)
             success("✨ Pruned stale worktree records. 🎉")
@@ -125,7 +86,7 @@ def main(argv: list[str] | None = None) -> int:
         for path in linked:
             warning(f"  • 🪦 {path}")
         info("📜 Would also run: git worktree prune --verbose")
-        log("💡 Dry run complete. Nothing was actually removed.")
+        dry_run_complete("removed")
         return 0
 
     remove_args = ["--force"] if args.force else []