gitbash 1.9.0 → 2.0.0

package/commands/unstash.sh

@@ -1,15 +1,25 @@
 #!/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"
 
+# fzf preview command for a stash list line
+_stash_preview() {
+    local pager
+    pager=$(gb_diff_pager)
+    printf '%s' '
+        sel=$(printf "%s" {} | grep -o "^stash@{[0-9]*}" || true)
+        if [[ -n "$sel" ]]; then
+            { git stash show --include-untracked -p --color=always "$sel" 2>/dev/null ||
+              git stash show -p --color=always "$sel" 2>/dev/null; } | '"$pager"'
+        else
+            echo "No preview"
+        fi'
+}
+
 unstash() {
-    # -----------------------------
-    # 0. Check for help/version flag
-    # -----------------------------
     if [[ "${1:-}" == "-v" || "${1:-}" == "--version" ]]; then
         echo "gitbash ${FUNCNAME[0]} v$VERSION"
         return 0
@@ -24,139 +34,65 @@ Interactive fuzzy finder (fzf) with preview support.
 Options:
   -h, --help    Show this help message
 
-Features:
-  - Single-select stash picker
-  - Preview stash contents before applying
-  - Apply stash to working directory
-  - Optional confirmation to drop stash after applying
-
-Navigation:
-  ↑/↓ or j/k    Navigate through stashes
-  Enter         Select and apply stash
-  ESC/Ctrl-C    Abort
-
-Examples:
-  $ unstash
-  Available stashes >
-  > stash@{0}: WIP on main: 1a2b3c4 commit message
-    stash@{1}: WIP on feature: 5d6e7f8 another commit
-    stash@{2}: On dev: 9a8b7c6 old work
-    ✖ Abort
-
-  # Navigate to desired stash and press Enter
-  
-  Applying stash@{1} ...
-  On branch main
-  Changes not staged for commit:
-    modified:   src/app.js
-
-  Drop stash@{1} now? (y/N): y
-  Dropping stash@{1} ...
-  Dropped stash@{1} (5d6e7f8abcd...)
-
 Workflow:
-  1. Select a stash from the list
-  2. Stash is applied to your working directory
-  3. Choose whether to drop (delete) the stash or keep it
-
-Requirements:
-  - fzf (fuzzy finder) - will prompt to install if not found
-  - git stash list with at least one stash
+  1. Select a stash from the list (preview shows its changes)
+  2. The stash is applied with 'git stash apply'
+  3. Choose whether to drop (delete) it (default: yes)
 
 Notes:
-  - Uses 'git stash apply' to preserve the stash initially
-  - Stash is only dropped if you confirm after successful apply
-  - Preview shows the full diff of the selected stash
-  - If apply fails, the stash is automatically kept
+  - If applying fails or causes conflicts, the stash is kept
+
+Requirements:
+  - fzf (fuzzy finder)
 
 EOF
         return 0
     fi
 
-    # -----------------------------
-    # 1. Check for fzf
-    # -----------------------------
+    require_git_repo || return 1
+
+    local stash_list
+    stash_list=$(git stash list)
+    if [[ -z "$stash_list" ]]; then
+        echo "No stashes."
+        return 0
+    fi
+
     require_fzf || return 1
 
-    # -----------------------------
-    # 2. Build menu entries
-    # -----------------------------
-    local abort_label="✖ Abort"
-
-    local choices
-    choices=$(
-        {
-            git stash list
-            echo "$abort_label"
-        }
-    )
-
-    # -----------------------------
-    # 3. Run fzf full-screen picker with preview
-    # -----------------------------
     local selection
-    selection=$(fzf --prompt="Available stashes > " \
+    selection=$(run_fzf --prompt="Available stashes > " \
               -i \
               --reverse \
               --border \
               --header="Select a stash to apply" \
               --no-multi \
-              --bind=enter:accept \
-              --preview='
-                    sel=$(echo {} | grep -o "stash@{[0-9]\+}" || true);
-                    if [[ -n "$sel" ]]; then
-                        git stash show -p "$sel" | delta --light 2>/dev/null || git stash show -p "$sel";
-                    else
-                        echo "No preview";
-                    fi
-              ' \
-              <<< "$choices"
-    ) </dev/tty || true
-
-    # ESC or Ctrl-C
-    if [[ -z "$selection" ]]; then
-        echo "Aborted."
-        return 1
-    fi
+              --preview="$(_stash_preview)" \
+              <<< "$stash_list"
+    ) || true
 
-    # Abort option
-    if [[ "$selection" == "$abort_label" ]]; then
+    if [[ -z "$selection" ]]; then
         echo "Aborted."
-        return 1
+        return 0
     fi
 
-    # -----------------------------
-    # 4. Extract stash ID safely
-    # -----------------------------
     local stash_id
-    stash_id=$(echo "$selection" | grep -o 'stash@{[0-9]\+}' || true)
-
+    stash_id=$(printf '%s' "$selection" | grep -o '^stash@{[0-9]*}' || true)
     if [[ -z "$stash_id" ]]; then
-        echo "Error: Could not determine stash ID."
+        print_error "Could not determine the stash ID."
         return 1
     fi
 
-    # -----------------------------
-    # 5. Apply the stash
-    # -----------------------------
     echo "Applying $stash_id ..."
     if ! git stash apply "$stash_id"; then
-        echo "Apply failed, kept stash."
+        print_error "Apply failed or had conflicts - the stash was kept."
         return 1
     fi
 
-    # -----------------------------
-    # 6. Confirm before dropping (default: Yes)
-    # -----------------------------
     echo
-    prompt_read "Drop $stash_id now? (Y/n): " drop_ans
-    case "$drop_ans" in
-        [nN][oO]|[nN])
-            echo "Stash NOT dropped."
-            ;;
-        *)
-            echo "Dropping $stash_id ..."
-            git stash drop "$stash_id"
-            ;;
-    esac
+    if gb_confirm "Drop $stash_id now?" y; then
+        git stash drop "$stash_id"
+    else
+        echo "Stash kept."
+    fi
 }

package/commands/update.sh

@@ -1,19 +1,21 @@
 #!/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"
 
-# Update the current branch with the latest version of master/main
+# Returns 0 if the branch is checked out in any worktree
+_update_is_checked_out() {
+  git worktree list --porcelain 2>/dev/null | grep -qxF "branch refs/heads/$1"
+}
+
+# Update the current branch with the latest version of the base branch
 update() {
-  local merge_tool="${GITBASH_MERGE_COMMAND:-fork}"
   local should_push=false
 
-  # Parse arguments
   while [[ $# -gt 0 ]]; do
-    case $1 in
+    case "$1" in
       -v|--version)
         echo "gitbash ${FUNCNAME[0]} v$VERSION"
         return 0
@@ -22,60 +24,30 @@ update() {
         cat << 'EOF'
 Usage: update [OPTIONS]
 
-Update the current feature branch with the latest changes from main/master.
+Merge the latest base branch (main/master) from the remote into the current branch.
 
 Options:
-  -p, --push    Push to origin after successful merge
+  -p, --push    Push the branch after a successful merge
+  -y, --yes     Don't ask for confirmations
   -h, --help    Show this help message
 
-Configuration:
-  - Merge tool can be set by editing the 'GITBASH_MERGE_COMMAND' variable
-  - Default: "fork" 
-
 Behavior:
-  1. Detects whether your repo uses 'main' or 'master'
-  2. Fetches the latest base branch from origin
-  3. Merges it into your current branch
-  4. Optionally pushes the updated branch to origin
-  5. Opens merge tool if conflicts occur
+  1. Detects the base branch (GITBASH_BASE_BRANCH, the remote's HEAD, main or master)
+  2. With local changes, asks: [c]ommit them, [s]tash them (restored afterwards) or [a]bort
+  3. Fetches the base branch and merges '<remote>/<base>' into your branch
+  4. Also fast-forwards your local base branch when it isn't checked out anywhere
+  5. On conflicts, lists the files and opens your merge tool (GITBASH_MERGE_COMMAND)
+  6. With --push, pushes the result (asks before rebasing if the remote diverged)
 
-Examples:
-  $ git checkout feature/LOVE-123-new-feature
-  $ update
-  Fetching latest 'main' from origin...
-  Merging updated 'main' into 'feature/LOVE-123-new-feature'...
-  ✓ 'feature/LOVE-123-new-feature' is now up-to-date with 'main'.
+  On the base branch itself, fast-forwards it from the remote instead.
 
-  ---
+Configuration (run 'gitbash --config'):
+  GITBASH_MERGE_COMMAND   Merge tool, e.g. "fork", "code", "gitkraken" (default: fork).
+                          Only read from ~/.gitbashrc and .gitbashrc-user.
 
+Examples:
+  $ update
   $ update --push
-  Fetching latest 'main' from origin...
-  Merging updated 'main' into 'feature/LOVE-123-new-feature'...
-  ✓ 'feature/LOVE-123-new-feature' is now up-to-date with 'main'.
-  Pushing 'feature/LOVE-123-new-feature' to origin...
-  ✓ Successfully pushed 'feature/LOVE-123-new-feature' to origin.
-
-  ---
-
-  $ update -p
-  Fetching latest 'main' from origin...
-  Merging updated 'main' into 'feature/dev-branch'...
-  ⚠ Merge completed with conflicts. Resolve them manually.
-  # Opens configured merge tool for conflict resolution
-
-Configuration:
-  - Merge tool can be changed by editing the 'GITBASH_MERGE_COMMAND' variable
-  - Options: "fork", "code", "gitkraken", "gitk", etc.
-
-Requirements:
-  - Must be in a git repository
-  - Must be on a feature branch (not main/master)
-  - Remote 'origin' must exist
-
-Notes:
-  - Uses fast-forward merge when possible
-  - Automatically opens merge tool if conflicts occur
-  - Local main/master is updated without checkout
 
 EOF
         return 0
@@ -84,120 +56,129 @@ EOF
         should_push=true
         shift
         ;;
+      -y|--yes)
+        GITBASH_ASSUME_YES=1
+        shift
+        ;;
       *)
-        echo "Unknown option: $1"
-        echo "Usage: update [-p|--push]"
+        print_error "Unknown option: $1"
+        echo "Usage: update [-p|--push] [-y|--yes]" >&2
         return 1
         ;;
     esac
   done
 
-  # Ensure we're in a git repo
-  if ! git rev-parse --is-inside-work-tree >/dev/null 2>&1; then
-    echo "Not inside a git repository."
+  require_git_repo || return 1
+
+  local remote current_branch base_branch
+  remote=$(gb_remote)
+  if ! current_branch=$(gb_current_branch); then
+    print_error "Detached HEAD: check out a branch first."
     return 1
   fi
-
-  current_branch=$(git rev-parse --abbrev-ref HEAD)
-
-  # Detect base branch: main or master
-  if git show-ref --verify --quiet refs/heads/main; then
-    base_branch="main"
-  elif git show-ref --verify --quiet refs/heads/master; then
-    base_branch="master"
-  else
-    echo "Could not detect 'main' or 'master' locally."
+  if ! base_branch=$(gb_base_branch); then
+    print_error "Could not detect the base branch. Set GITBASH_BASE_BRANCH with 'gitbash --config'."
     return 1
   fi
 
+  # -----------------------------
+  # On the base branch: just fast-forward it
+  # -----------------------------
   if [[ "$current_branch" == "$base_branch" ]]; then
-    # Already on main/master - just pull the latest changes
-    echo "Pulling latest changes for '$base_branch' from origin..."
-    git pull origin "$base_branch"
-    
-    if [[ $? -eq 0 ]]; then
-      echo "✓ '$base_branch' is now up-to-date."
-    else
-      echo "⚠ Failed to pull latest changes."
-      return 1
+    print_info "Pulling latest '$base_branch' from '$remote'..."
+    if git pull --ff-only "$remote" "$base_branch"; then
+      print_success "'$base_branch' is up to date."
+      return 0
     fi
-    return 0
+    print_error "Could not fast-forward '$base_branch'. It has local commits or local changes that block the update."
+    return 1
   fi
 
-  # Check for uncommitted changes before merging
+  # -----------------------------
+  # Local changes: commit, stash or abort
+  # -----------------------------
+  local stashed=false
   if [[ -n "$(git status --porcelain)" ]]; then
-    echo ""
     echo "You have uncommitted changes:"
     git status --short
-    echo ""
-    prompt_read "Commit changes before updating? (Y/n): " reply
-    if [[ "$reply" =~ ^[Nn]$ ]]; then
-      echo "⚠ Cannot merge with uncommitted changes. Commit or stash them first."
-      return 1
-    fi
-    commit
-    if [[ $? -ne 0 ]]; then
-      echo "⚠ Commit failed. Aborting update."
-      return 1
-    fi
+    echo
+    local choice="c"
+    gb_choice choice "[c]ommit them, [s]tash them for the update, or [a]bort? (C/s/a):" "csa" "c"
+    case "$choice" in
+      c)
+        if ! gb_run commit; then
+          print_error "Commit failed or was cancelled. Update aborted."
+          return 1
+        fi
+        ;;
+      s)
+        if ! git stash push --include-untracked --quiet -m "gitbash update: auto-stash"; then
+          print_error "Could not stash the changes. Update aborted."
+          return 1
+        fi
+        stashed=true
+        print_info "Changes stashed. They are restored after the update."
+        ;;
+      *)
+        echo "Update aborted."
+        return 1
+        ;;
+    esac
   fi
 
-  echo "Fetching latest '$base_branch' from origin..."
-  git fetch origin "$base_branch:$base_branch" || {
-    echo "⚠ Could not fast-forward local '$base_branch'."
+  # -----------------------------
+  # Fetch and merge
+  # -----------------------------
+  print_info "Fetching latest '$base_branch' from '$remote'..."
+  if ! git fetch --quiet "$remote" "+refs/heads/$base_branch:refs/remotes/$remote/$base_branch"; then
+    print_error "Could not fetch '$base_branch' from '$remote'."
+    [[ "$stashed" == true ]] && git stash pop --quiet
     return 1
-  }
-
-  echo "Merging updated '$base_branch' into '$current_branch'..."
-  git merge --ff --no-edit "$base_branch"
-
-  if [[ $? -eq 0 ]]; then
-    echo "✓ '$current_branch' is now up-to-date with '$base_branch'."
-    
-    # Push if requested and merge was successful
-    if [[ "$should_push" == true ]]; then
-      # 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
-          echo "Remote has updates. Pulling first..."
-          git pull --rebase origin "$current_branch"
-          if [[ $? -ne 0 ]]; then
-            echo "⚠ Failed to pull remote changes. Please resolve conflicts and try again."
-            return 1
-          fi
-          echo "✓ Pulled latest changes."
-        elif ! git merge-base --is-ancestor "$remote_commit" "$local_commit" 2>/dev/null; then
-          # Branches have diverged
-          echo "Remote has diverged. Pulling with rebase..."
-          git pull --rebase origin "$current_branch"
-          if [[ $? -ne 0 ]]; then
-            echo "⚠ Failed to pull remote changes. Please resolve conflicts and try again."
-            return 1
-          fi
-          echo "✓ Rebased on latest changes."
-        fi
-      fi
-      
-      echo "Pushing '$current_branch' to origin..."
-      git push origin "$current_branch"
-      if [[ $? -eq 0 ]]; then
-        echo "✓ Successfully pushed '$current_branch' to origin."
-      else
-        echo "⚠ Failed to push '$current_branch' to origin."
-        return 1
+  fi
+
+  # Keep the local base branch current as well (only if it can fast-forward)
+  if git show-ref --verify --quiet "refs/heads/$base_branch" && ! _update_is_checked_out "$base_branch"; then
+    git fetch --quiet . "refs/remotes/$remote/$base_branch:refs/heads/$base_branch" 2>/dev/null ||
+      print_warning "Local '$base_branch' has its own commits; it was not fast-forwarded."
+  fi
+
+  print_info "Merging '$remote/$base_branch' into '$current_branch'..."
+  if git merge --no-edit "$remote/$base_branch"; then
+    print_success "'$current_branch' is up to date with '$base_branch'."
+  else
+    local conflicts
+    conflicts=$(git diff --name-only --diff-filter=U)
+    if [[ -z "$conflicts" ]]; then
+      print_error "Merge failed (see git's message above)."
+      if [[ "$stashed" == true ]]; then
+        git stash pop --quiet || print_warning "Your changes are still in the stash: run 'git stash pop'."
       fi
+      return 1
     fi
-  else
-    echo "⚠ Merge completed with conflicts. Resolve them manually."
 
-    # Open merge tool for conflict resolution
-    if command -v "$merge_tool" >/dev/null 2>&1; then
-      "$merge_tool" .
+    print_warning "Merge conflicts in:"
+    printf '%s\n' "$conflicts" | sed 's/^/  /'
+    echo "Resolve them and run 'git commit', or cancel with 'git merge --abort'."
+    [[ "$stashed" == true ]] && echo "Your stashed changes are kept: run 'git stash pop' when done."
+
+    local -a merge_tool
+    read -r -a merge_tool <<< "${GITBASH_MERGE_COMMAND:-}"
+    if [[ ${#merge_tool[@]} -gt 0 ]] && command -v "${merge_tool[0]}" >/dev/null 2>&1; then
+      "${merge_tool[@]}" .
     fi
+    return 1
+  fi
+
+  if [[ "$stashed" == true ]]; then
+    if git stash pop --quiet; then
+      print_info "Restored your stashed changes."
+    else
+      print_warning "Restoring your changes caused conflicts. They are still in the stash (git stash list)."
+    fi
+  fi
+
+  if [[ "$should_push" == true ]]; then
+    gb_sync_and_push || return 1
   fi
-}
+  return 0
+}

package/docs/CONTRIBUTING.md

@@ -109,16 +109,27 @@ When your PR is merged:
 
 ### Testing your changes:
 ```bash
-# Test the gitbash command directly
-./bin/gitbash <command>
+# Run the test suite (bats, installed with npm install)
+npm test
 
-# Example: test the stale command
+# Run it with a specific bash, e.g. macOS's bash 3.2
+GB_BASH=/bin/bash npm test
+
+# Lint
+shellcheck -x bin/gitbash commands/*.sh
+
+# Try a command directly
 ./bin/gitbash stale --all
 ```
 
+Tests live in `test/*.bats`. Each test gets its own temporary repository with a local bare remote (`test/helpers/setup.bash`). fzf is replaced by a stub that records its arguments and answers from a plan (`test/helpers/bin/fzf`); `test/fzf_real.bats` drives the real fzf in a pseudo-terminal. Add a test for every bug fix.
+
+CI runs shellcheck and the tests on Ubuntu (bash 5) and macOS (bash 3.2 and 5).
+
 ### Code style:
-- Follow existing bash script conventions
-- Use shellcheck for linting when possible
+- Follow existing bash script conventions; scripts must work with bash 3.2
+- Commands run in a bash subprocess started by `bin/gitbash`; use the helpers in `commands/_utils.sh` (`run_fzf`, `gb_confirm`, `gb_sync_and_push`, `gb_base_branch`, ...)
+- shellcheck must pass
 - Keep functions focused and well-documented
 - Include help text for new commands/options
 - Keep the readme updated and as terse as possible

package/docs/SECURITY.md

@@ -6,10 +6,21 @@ The following versions of this project are currently receiving security updates:
 
 | Version | Supported |
 |--------|-----------|
-| 1.x.x  | ✅        |
-| < 1.0  | ❌        |
+| 2.x.x  | ✅        |
+| < 2.0  | ❌        |
 
-Security fixes are only applied to the latest minor/patch release of the **1.x.x** series. Older versions must be upgraded to receive patches.
+Security fixes are only applied to the latest minor/patch release of the **2.x.x** series. Older versions must be upgraded to receive patches.
+
+Versions before 2.0 executed repository `.gitbashrc` files as shell code, so opening a cloned repository with a malicious `.gitbashrc` could run arbitrary commands. Upgrade to 2.0 or later.
+
+---
+
+## Trust Model
+
+- Configuration files (`~/.gitbashrc`, a repository's `.gitbashrc` and `.gitbashrc-user`) are **parsed, never executed**. Only plain `GITBASH_*="value"` lines from a fixed list of settings are read; values containing `$`, backticks, backslashes or quotes are rejected.
+- A repository's committed `.gitbashrc` is treated as untrusted: it cannot set `GITBASH_MERGE_COMMAND` (the only setting that names a program to run). That setting is only read from `~/.gitbashrc` and `.gitbashrc-user`.
+- `gitbash --init` prints wrapper functions that call the installed `gitbash` binary; command code is not sourced into your shell.
+- `pr` never passes credentials from the remote URL to the browser.
 
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitbash",
-  "version": "1.9.0",
+  "version": "2.0.0",
   "description": "Opinionated git utilities for bash with fzf-powered menus",
   "author": "jaggli",
   "license": "MIT",
@@ -41,11 +41,13 @@
     "node": ">=14"
   },
   "scripts": {
+    "test": "bats test",
     "changeset": "changeset",
     "version": "changeset version",
-    "release": "npm run version && VERSION=$(node -p \"require('./package.json').version\") && git tag \"v$VERSION\" && ./bin/gitbash commit -p \"chore: release v$VERSION\" && git push --tags && npm publish"
+    "release": "npm run version && VERSION=$(node -p \"require('./package.json').version\") && ./bin/gitbash commit --yes -p \"chore: release v$VERSION\" && git tag \"v$VERSION\" && git push origin \"v$VERSION\" && npm publish"
   },
   "devDependencies": {
-    "@changesets/cli": "^2.29.8"
+    "@changesets/cli": "^2.29.8",
+    "bats": "^1.13.0"
   }
 }