gitbash 1.9.1 → 2.0.1

package/commands/commit.sh

@@ -1,87 +1,67 @@
 #!/usr/bin/env bash
-# shellcheck disable=SC2155
 
 # Source common utilities
-SOURCE_DIR="$(cd "$(dirname "${BASH_SOURCE[0]:-$0}")" && pwd)"
+SOURCE_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 # shellcheck source=_utils.sh
 source "$SOURCE_DIR/_utils.sh"
 
-# Stage all changes and commit with a message.
+# Stage changes and commit with a message.
 # If no commit message argument is given, prompt the user for one.
 commit() {
   local should_push=false
   local staged_only=false
   local amend_mode=false
   local show_prefix_menu=false
+  local force_with_lease=false
   local msg_parts=()
 
   # Parse arguments
   while [[ $# -gt 0 ]]; do
-    case $1 in
+    case "$1" in
       -v|--version)
         echo "gitbash ${FUNCNAME[0]} v$VERSION"
         return 0
         ;;
       -h|--help)
         cat << 'EOF'
-Usage: commit [MESSAGE] [OPTIONS]
+Usage: commit [OPTIONS] [MESSAGE...] [-- MESSAGE...]
 
-Stage all changes (git add -A) and commit with a message.
+Commit your changes with a message.
 
 Options:
-  -p, --push      Push to origin after successful commit
-  -s, --staged    Commit only staged changes (skip prompt, ignore unstaged)
-  -a, --amend     Amend the last commit instead of creating a new one
-  -t, --type      Show conventional commit type selector (feat, fix, docs, etc.)
-  -h, --help      Show this help message
+  -p, --push              Push to the remote after a successful commit
+  -s, --staged            Commit only staged changes
+  -a, --amend             Amend the last commit (keeps its message if none is given)
+  -t, --type              Show conventional commit type selector (feat, fix, docs, etc.)
+  -y, --yes               Don't ask for confirmations (untracked files, staged/all)
+      --force-with-lease  Allow overwriting the remote branch when pushing (after amend/rebase)
+  --                      Everything after this is the message (even if it starts with '-')
+  -h, --help              Show this help message
+
+What gets committed:
+  - Only staged changes          → commits them
+  - Only unstaged/untracked      → stages everything (lists new files first) and commits
+  - Both staged and unstaged     → asks: [s]taged only (default) or [a]ll
+
+Pushing (-p):
+  - New branches are pushed with tracking (-u)
+  - If the remote has new commits you don't have, they are fast-forwarded
+  - If your branch and the remote diverged, you are asked whether to rebase,
+    merge or abort. Nothing is rewritten without asking.
+  - After --amend, you are asked before force-pushing (--force-with-lease)
 
 Conventional Commit Types (with --type):
-  feat:     A new feature
-  fix:      A bug fix
-  docs:     Documentation only changes
-  style:    Code style changes (formatting, whitespace)
-  refactor: Code change that neither fixes a bug nor adds a feature
-  perf:     Performance improvement
-  test:     Adding or fixing tests
-  build:    Build system or dependency changes
-  ci:       CI/CD configuration changes
-  chore:    Other changes that don't modify src or test files
-
-Interactive mode (no message):
-  $ commit
-  Commit message: fix login bug
-  [main 1a2b3c4] fix login bug
-   1 file changed, 5 insertions(+), 2 deletions(-)
-
-With message argument:
-  $ commit implement new feature
-  [main 5d6e7f8] implement new feature
-   3 files changed, 42 insertions(+), 8 deletions(-)
-
-With type selector:
-  $ commit -t fix broken tests
-  # Shows type menu, then commits as "fix: broken tests"
-
-Amend last commit:
-  $ commit --amend fix typo in docs
-  [main abc123] fix typo in docs
-   1 file changed, 1 insertion(+)
-
-With push option:
-  $ commit update documentation -p
-  [main 9a8b7c6] update documentation
-   1 file changed, 10 insertions(+), 3 deletions(-)
-  Pushing 'main' to origin...
-  ✓ Successfully pushed 'main' to origin.
+  feat, fix, docs, style, refactor, perf, test, build, ci, chore
 
 Examples:
   commit                                    # Interactive mode
   commit add user validation                # Quick commit
   commit refactor auth module --push        # Commit and push
-  commit -p update dependencies             # Commit and push (short flag)
   commit -s -p fix bug                      # Commit only staged and push
   commit -t add user endpoint               # Conventional commit with type menu
-  commit --amend fix typo                   # Amend last commit
+  commit --amend                            # Amend, keep the message
+  commit --amend fix typo                   # Amend with a new message
+  commit -- -1 is not a valid index         # Message starting with '-'
 
 EOF
         return 0
@@ -102,37 +82,100 @@ EOF
         show_prefix_menu=true
         shift
         ;;
+      -y|--yes)
+        GITBASH_ASSUME_YES=1
+        shift
+        ;;
+      --force-with-lease)
+        force_with_lease=true
+        shift
+        ;;
+      --)
+        shift
+        msg_parts+=("$@")
+        break
+        ;;
       -*)
-        echo "Unknown option: $1"
-        echo "Usage: commit [message] [-p|--push] [-s|--staged] [-a|--amend] [-t|--type]"
+        print_error "Unknown option: $1"
+        echo "Usage: commit [-p] [-s] [-a] [-t] [-y] [--force-with-lease] [message...]" >&2
         return 1
         ;;
       *)
-        # Collect all non-flag arguments as message parts
         msg_parts+=("$1")
         shift
         ;;
     esac
   done
 
-  # Join message parts with spaces (handle empty array for set -u)
+  require_git_repo || return 1
+
   local msg=""
   if [[ ${#msg_parts[@]} -gt 0 ]]; then
     msg="${msg_parts[*]}"
   fi
 
-  # If no commit message was provided...
-  if [ -z "$msg" ]; then
-    # Prompt the user for a commit message (no newline, no extra spaces)
+  # -----------------------------
+  # 1. Decide what to commit (before asking for a message)
+  # -----------------------------
+  local has_staged has_unstaged untracked
+  has_staged=$(git diff --cached --name-only 2>/dev/null)
+  has_unstaged=$(git diff --name-only 2>/dev/null)
+  # ls-files only looks below the current directory; 'git add -A' stages the whole repository
+  untracked=$(git -C "$(git rev-parse --show-toplevel)" ls-files --others --exclude-standard 2>/dev/null)
+
+  # mode: staged | all | none (amend without new changes)
+  local mode
+  if [[ "$staged_only" == true ]]; then
+    if [[ -z "$has_staged" && "$amend_mode" == false ]]; then
+      print_error "No staged changes to commit."
+      return 1
+    fi
+    mode="staged"
+  elif [[ -n "$has_staged" && ( -n "$has_unstaged" || -n "$untracked" ) ]]; then
+    echo "You have both staged and unstaged changes."
+    local choice="s"
+    if [[ "${GITBASH_ASSUME_YES:-}" != "1" ]]; then
+      gb_choice choice "Commit [s]taged only or [a]ll changes? (S/a):" "sa" "s"
+    fi
+    if [[ "$choice" == "a" ]]; then mode="all"; else mode="staged"; fi
+  elif [[ -n "$has_staged" ]]; then
+    mode="staged"
+  elif [[ -n "$has_unstaged" || -n "$untracked" ]]; then
+    mode="all"
+  elif [[ "$amend_mode" == true ]]; then
+    mode="none"
+  else
+    echo "Nothing to commit - working tree clean."
+    return 1
+  fi
+
+  # List new files before staging everything, so secrets don't slip in unnoticed
+  if [[ "$mode" == "all" && -n "$untracked" ]]; then
+    echo "New (untracked) files that will be added:"
+    printf '%s\n' "$untracked" | sed 's/^/  + /'
+    if ! gb_confirm "Add these files to the commit?" y; then
+      echo "Commit cancelled. Stage what you want and use 'commit -s', or add files to .gitignore."
+      return 1
+    fi
+  fi
+
+  # -----------------------------
+  # 2. Commit message
+  # -----------------------------
+  if [[ -z "$msg" && ( "$amend_mode" == false || "$show_prefix_menu" == true ) ]]; then
     prompt_read "Commit message: " msg
   fi
+  if [[ -z "$msg" && "$amend_mode" == false ]]; then
+    print_error "Empty commit message - commit cancelled."
+    return 1
+  fi
 
-  # Show conventional commit type menu if requested
   if [[ "$show_prefix_menu" == true ]]; then
-    if ! command -v fzf >/dev/null 2>&1; then
-      print_error "fzf is required for type selector. Install it or provide message directly."
+    if [[ -z "$msg" ]]; then
+      print_error "Empty commit message - commit cancelled."
       return 1
     fi
+    require_fzf || return 1
 
     local type_options="feat     - A new feature
 fix      - A bug fix
@@ -146,136 +189,57 @@ ci       - CI/CD configuration changes
 chore    - Other changes that don't modify src/test files"
 
     local selected_type
-    selected_type=$(echo "$type_options" | fzf --prompt="Commit type > " \
+    selected_type=$(run_fzf --prompt="Commit type > " \
               -i \
               --reverse \
               --border \
               --header="Select conventional commit type" \
               --no-multi \
-              --bind=enter:accept \
-    ) </dev/tty || true
+              <<< "$type_options"
+    ) || true
 
     if [[ -z "$selected_type" ]]; then
-      echo "Aborted."
-      return 1
+      echo "Commit cancelled."
+      return 0
     fi
 
-    # Extract just the type keyword (first word)
-    local type_keyword
-    type_keyword=$(echo "$selected_type" | awk '{print $1}')
-    
-    # Prepend to message
-    msg="${type_keyword}: ${msg}"
+    msg="${selected_type%% *}: ${msg}"
     print_info "Commit message: $msg"
   fi
 
-  # Build commit flags
-  local commit_flags=()
+  # -----------------------------
+  # 3. Commit
+  # -----------------------------
+  local commit_args=()
   if [[ "$amend_mode" == true ]]; then
-    commit_flags+=("--amend")
+    commit_args+=("--amend")
   fi
-
-  # Check if there are staged changes
-  local has_staged
-  has_staged=$(git diff --cached --name-only)
-  
-  local has_unstaged
-  has_unstaged=$(git diff --name-only)
-
-  # For amend mode, we might not need new changes
-  if [[ "$amend_mode" == true ]]; then
-    if [[ -z "$has_staged" && -z "$has_unstaged" ]]; then
-      print_info "Amending commit message only..."
-      git commit --amend -m "$msg"
-    else
-      # Has changes to add
-      if [[ "$staged_only" == true ]]; then
-        if [[ -z "$has_staged" ]]; then
-          print_info "Amending commit message only (no staged changes)..."
-          git commit --amend -m "$msg"
-        else
-          print_info "Amending with staged changes..."
-          git commit --amend -m "$msg"
-        fi
-      else
-        print_info "Amending with all changes..."
-        git add -A && git commit --amend -m "$msg"
-      fi
-    fi
-  # If --staged flag is set, only commit staged changes
-  elif [[ "$staged_only" == true ]]; then
-    if [[ -z "$has_staged" ]]; then
-      echo "No staged changes to commit."
-      return 1
-    fi
-    echo "Committing staged changes only..."
-    git commit -m "$msg"
-  # If there are both staged and unstaged changes, ask what to commit
-  elif [[ -n "$has_staged" && -n "$has_unstaged" ]]; then
-    echo
-    echo "You have both staged and unstaged changes."
-    echo
-    prompt_read "Commit [s]taged only, or [a]ll changes? (s/a): " commit_choice
-    
-    case "$commit_choice" in
-      [sS])
-        # Commit only staged changes
-        echo "Committing staged changes only..."
-        git commit -m "$msg"
-        ;;
-      [aA]|*)
-        # Stage all and commit
-        echo "Staging all changes and committing..."
-        git add -A && git commit -m "$msg"
-        ;;
-    esac
-  elif [[ -n "$has_staged" ]]; then
-    # Only staged changes exist
-    echo "Committing staged changes..."
-    git commit -m "$msg"
+  if [[ -n "$msg" ]]; then
+    commit_args+=("-m" "$msg")
   else
-    # No staged changes, stage all and commit
-    git add -A && git commit -m "$msg"
+    commit_args+=("--no-edit")
   fi
 
-  # Push if requested and commit was successful
-  if [[ $? -eq 0 && "$should_push" == true ]]; then
-    current_branch=$(git rev-parse --abbrev-ref HEAD)
-    
-    # Check if remote has updates and pull first
-    git fetch origin "$current_branch" 2>/dev/null
-    local local_commit=$(git rev-parse HEAD)
-    local remote_commit=$(git rev-parse "origin/$current_branch" 2>/dev/null)
-    
-    if [[ -n "$remote_commit" && "$local_commit" != "$remote_commit" ]]; then
-      # Check if we're behind the remote
-      if git merge-base --is-ancestor "$local_commit" "$remote_commit" 2>/dev/null; then
-        print_info "Remote has updates. Pulling first..."
-        git pull --rebase origin "$current_branch"
-        if [[ $? -ne 0 ]]; then
-          print_warning "Failed to pull remote changes. Please resolve conflicts and try again."
-          return 1
-        fi
-        print_success "Pulled latest changes."
-      elif ! git merge-base --is-ancestor "$remote_commit" "$local_commit" 2>/dev/null; then
-        # Branches have diverged
-        print_info "Remote has diverged. Pulling with rebase..."
-        git pull --rebase origin "$current_branch"
-        if [[ $? -ne 0 ]]; then
-          print_warning "Failed to pull remote changes. Please resolve conflicts and try again."
-          return 1
-        fi
-        print_success "Rebased on latest changes."
-      fi
-    fi
-    
-    print_info "Pushing '$current_branch' to origin..."
-    git push origin "$current_branch"
-    if [[ $? -eq 0 ]]; then
-      print_success "Successfully pushed '$current_branch' to origin."
-    else
-      print_warning "Failed to push '$current_branch' to origin."
+  if [[ "$mode" == "all" ]]; then
+    if ! git add -A; then
+      print_error "Failed to stage changes."
       return 1
     fi
   fi
+
+  if ! git commit "${commit_args[@]}"; then
+    print_error "Commit failed."
+    return 1
+  fi
+
+  # -----------------------------
+  # 4. Push
+  # -----------------------------
+  if [[ "$should_push" == true ]]; then
+    local push_args=()
+    [[ "$amend_mode" == true ]] && push_args+=("--amend")
+    [[ "$force_with_lease" == true ]] && push_args+=("--force-with-lease")
+    gb_sync_and_push ${push_args[@]+"${push_args[@]}"} || return 1
+  fi
+  return 0
 }

package/commands/commits.sh

@@ -1,16 +1,12 @@
 #!/usr/bin/env bash
-# shellcheck disable=SC2155
 
 # Source common utilities
-SOURCE_DIR="$(cd "$(dirname "${BASH_SOURCE[0]:-$0}")" && pwd)"
+SOURCE_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 # shellcheck source=_utils.sh
 source "$SOURCE_DIR/_utils.sh"
 
 # List recent commits and optionally revert selected ones
 commits() {
-    # -----------------------------
-    # 0. Check for help/version flag
-    # -----------------------------
     if [[ "${1:-}" == "-v" || "${1:-}" == "--version" ]]; then
         echo "gitbash ${FUNCNAME[0]} v$VERSION"
         return 0
@@ -25,24 +21,20 @@ Arguments:
   COUNT         Number of commits to show (default: 20)
 
 Navigation:
-  ↑/↓ or j/k    Navigate through commits
+  ↑/↓           Navigate through commits
   TAB           Select/deselect commit for revert
   Enter         Revert selected commit(s)
   ESC/Ctrl-C    Exit without action
 
 Notes:
-  - Shows commits from newest to oldest
-  - Preview shows full commit diff
-  - Multiple commits can be selected for revert
-  - Reverts are done in reverse order (oldest first) to avoid conflicts
+  - Preview shows the full commit diff
+  - Selected commits are reverted newest first, whatever order you picked them in
+  - Merge commits are reverted against their first parent (the branch they were merged into)
   - Each revert creates a new commit
 
 Examples:
   $ commits
-  # Shows last 20 commits
-
   $ commits 50
-  # Shows last 50 commits
 
 Requirements:
   - Must be in a git repository
@@ -52,50 +44,49 @@ EOF
         return 0
     fi
 
-    # -----------------------------
-    # 1. Check prerequisites
-    # -----------------------------
     require_git_repo || return 1
-    require_fzf || return 1
 
-    # -----------------------------
-    # 2. Get commit count
-    # -----------------------------
     local count="${1:-20}"
-    local abort_label="✖ Abort"
+    if ! [[ "$count" =~ ^[1-9][0-9]*$ ]]; then
+        print_error "COUNT must be a positive number (got '$count')."
+        return 1
+    fi
+    require_fzf || return 1
+
     local current_branch
-    current_branch=$(git rev-parse --abbrev-ref HEAD)
+    current_branch=$(gb_current_branch) || current_branch="(detached HEAD)"
 
     # -----------------------------
-    # 3. Build commit list
+    # Build commit list (fields separated by \x1f, subject last)
     # -----------------------------
-    local commit_list
-    commit_list=$(git log -n "$count" --format="%h|%s|%cr|%an" | while IFS='|' read -r hash subject date author; do
-        # Truncate subject if too long
+    local commit_list="" hash date author subject
+    while IFS=$'\x1f' read -r hash date author subject; do
+        [[ -z "$hash" ]] && continue
         if [[ ${#subject} -gt 60 ]]; then
             subject="${subject:0:57}..."
         fi
-        printf "%-8s  %-60s  %-15s  %s\t%s\n" "$hash" "$subject" "$date" "$author" "$hash"
-    done)
+        commit_list+=$(printf "%-10s  %-60s  %-15s  %s" "$hash" "$subject" "$date" "$author")
+        commit_list+=$'\t'"$hash"$'\n'
+    done < <(git log -n "$count" --format='%h%x1f%cr%x1f%an%x1f%s' 2>/dev/null)
 
     if [[ -z "$commit_list" ]]; then
         echo "No commits found."
         return 0
     fi
 
-    # Add abort option
-    commit_list+=$'\n'"$abort_label"$'\t'
+    local pager preview
+    pager=$(gb_diff_pager)
+    preview='
+        hash=$(printf "%s" {} | cut -f2)
+        git show --stat --color=always "$hash" 2>/dev/null
+        echo
+        echo "─────────────────────────────────────────────────────"
+        echo
+        git show --color=always --format= "$hash" 2>/dev/null | head -300 | __PAGER__'
+    preview="${preview//__PAGER__/$pager}"
 
-    # Create temp file
-    local commit_file
-    commit_file=$(mktemp)
-    echo "$commit_list" > "$commit_file"
-
-    # -----------------------------
-    # 4. Run fzf picker
-    # -----------------------------
     local selection
-    selection=$(fzf \
+    selection=$(run_fzf \
         --prompt="Commits on '$current_branch' > " \
         -i \
         --reverse \
@@ -105,96 +96,72 @@ Showing last $count commits" \
         --multi \
         --delimiter=$'\t' \
         --with-nth=1 \
-        --bind=enter:accept \
-        --preview='
-            line={}
-            if [[ "$line" == "✖ Abort"* ]]; then
-                echo "Exit without action";
-            else
-                hash=$(echo "$line" | cut -f2)
-                echo "Commit: $hash";
-                echo "";
-                git show --stat --color=always "$hash" 2>/dev/null;
-                echo "";
-                echo "─────────────────────────────────────────────────────";
-                echo "";
-                git show --color=always "$hash" 2>/dev/null | head -100 | delta --light 2>/dev/null || git show --color=always "$hash" 2>/dev/null | head -100;
-            fi
-        ' \
+        --preview="$preview" \
         --preview-window=right:50% \
-        < "$commit_file"
-    ) </dev/tty || true
-
-    # Cleanup temp file
-    rm -f "$commit_file"
+        <<< "$commit_list"
+    ) || true
 
-    # ESC or Ctrl-C
     if [[ -z "$selection" ]]; then
         echo "Exited."
         return 0
     fi
 
-    # Abort option
-    if echo "$selection" | grep -q "^$abort_label"; then
-        echo "Aborted."
-        return 0
-    fi
-
     # -----------------------------
-    # 5. Extract commit hashes and confirm revert
+    # Order newest first (fzf returns them in the order they were picked)
     # -----------------------------
-    local commits_to_revert=()
-
+    local picked=() line
     while IFS= read -r line; do
-        [[ "$line" == "✖ Abort"* ]] && continue
-        local hash
-        hash=$(echo "$line" | cut -f2)
-        if [[ -n "$hash" ]]; then
-            commits_to_revert+=("$hash")
-        fi
+        hash=$(printf '%s' "$line" | cut -f2)
+        [[ -n "$hash" ]] && picked+=("$hash")
     done <<< "$selection"
 
-    if [[ ${#commits_to_revert[@]} -eq 0 ]]; then
+    # Walk the history newest first and keep the picked commits in that order
+    local to_revert=() full picked_full=" " short
+    for short in "${picked[@]}"; do
+        picked_full+="$(git rev-parse --verify --quiet "$short^{commit}") "
+    done
+    while IFS= read -r full; do
+        [[ "$picked_full" == *" $full "* ]] && to_revert+=("$full")
+        [[ ${#to_revert[@]} -eq ${#picked[@]} ]] && break
+    done < <(git rev-list --topo-order HEAD 2>/dev/null)
+
+    if [[ ${#to_revert[@]} -eq 0 ]]; then
         echo "No commits selected."
         return 0
     fi
 
-    echo ""
-    echo "Selected commits to revert:"
-    for hash in "${commits_to_revert[@]}"; do
-        local subject
-        subject=$(git log -1 --format="%s" "$hash")
-        echo "  - $hash: $subject"
+    echo
+    echo "Commits to revert (newest first):"
+    for hash in "${to_revert[@]}"; do
+        echo "  - $(git log -1 --format='%h %s' "$hash")"
+    done
+    echo
+
+    if ! gb_confirm "Revert these ${#to_revert[@]} commit(s)?" n; then
+        echo "Revert cancelled."
+        return 0
+    fi
+
+    local parents revert_args
+    for hash in "${to_revert[@]}"; do
+        revert_args=(--no-edit)
+        parents=$(git rev-list --parents -n 1 "$hash" | wc -w | tr -d ' ')
+        if [[ "$parents" -gt 2 ]]; then
+            print_info "$(git rev-parse --short "$hash") is a merge commit - reverting it against its first parent."
+            revert_args+=(-m 1)
+        fi
+        if git revert "${revert_args[@]}" "$hash"; then
+            print_success "Reverted $(git rev-parse --short "$hash")"
+        else
+            if git rev-parse --verify --quiet REVERT_HEAD >/dev/null; then
+                print_error "Reverting $(git rev-parse --short "$hash") stopped with conflicts."
+                echo "  Resolve them and run 'git revert --continue', or 'git revert --abort' to cancel this revert." >&2
+            else
+                print_error "Failed to revert $(git rev-parse --short "$hash")."
+            fi
+            return 1
+        fi
     done
-    echo ""
-
-    local confirm
-    prompt_read "Revert these ${#commits_to_revert[@]} commit(s)? (y/N): " confirm
-    case "$confirm" in
-        [yY][eE][sS]|[yY])
-            print_info "Reverting commits..."
-            
-            # Reverse the array to revert oldest first (avoids conflicts)
-            local reversed=()
-            for ((i=${#commits_to_revert[@]}-1; i>=0; i--)); do
-                reversed+=("${commits_to_revert[$i]}")
-            done
-
-            for hash in "${reversed[@]}"; do
-                echo "Reverting $hash ..."
-                if git revert --no-edit "$hash"; then
-                    print_success "Reverted $hash"
-                else
-                    print_error "Failed to revert $hash (conflict?)"
-                    echo "  Resolve the conflict and run 'git revert --continue'"
-                    return 1
-                fi
-            done
-            echo ""
-            print_success "All selected commits reverted."
-            ;;
-        *)
-            echo "Revert cancelled."
-            ;;
-    esac
+    echo
+    print_success "All selected commits reverted."
 }