# The golden rule: NEVER rebase pushed commits (shared history)
# Only rebase local commits that haven't been pushed yet!

# Interactive rebase — your most powerful tool:
git rebase -i HEAD~3    # Rebase last 3 commits
# Opens editor with these options for each commit:
#   pick  abc1234 Commit message 1
#   pick  def5678 Commit message 2
#   pick  ghi9012 Commit message 3

# Available actions:
#   pick (p) = use commit as-is
#   reword (r) = change commit message only
#   edit (e) = pause here to amend files or split commit
#   squash (s) = merge into previous commit (keep message)
#   fixup (f) = merge into previous commit (discard message)
#   drop (d) = remove this commit entirely

# Common rebase workflows:

# Squash last 3 "WIP" commits into one clean commit:
# Change first to "pick", rest to "squash"
# Save → Git opens editor with combined message

# Split a large commit into smaller ones:
git rebase -i HEAD~1
# Change "pick" to "edit" on target commit
# Git pauses at that commit:
git reset HEAD~1          # Unstage all files
git add feature-A.js && git commit -m "Add feature A"
git add feature-B.js && git commit -m "Add feature B"
git add feature-C.js && git commit -m "Add feature C"
git rebase --continue     # Continue rebasing

# Move a commit to a different position:
# In interactive rebase, reorder lines to change commit order!

# Fix a forgotten file in a previous commit:
git rebase -i HEAD~3
# Find the target commit → change to "edit"
# When git pauses: git add forgotten-file && git rebase --continue

# Update branch to match upstream (cleaner than merge):
git fetch origin main
git rebase origin/main    // Replays your commits on top of latest main
// Result: Linear history, no merge commits!

# When did this bug appear? Don't guess — let git tell you!

git bisect start
git bisect bad              # Current version has the bug
git bisect good v2.0.0      # This version was working fine

# Git automatically checks out a middle commit.
# You test it, then:

git bisect good             # This version works → bug was introduced AFTER
git bisect bad              # This version is broken → bug was introduced BEFORE

# Repeat ~5-7 times (binary search halves the search space each time!)
# Git tells you exactly which commit introduced the bug:
# abc1234 is the first bad commit
# commit message: "Refactored auth module"

git bisect reset            # Done — return to original branch

# For automated testing (scriptable bisect):
git bisect start
git bisect bad HEAD
git bisect good v2.0.0
git bisect run npm test      # Runs test command automatically at each step!
# Output: abc1234 is the first bad commit (after N tests)

# Pro tip: Use bisect for ANY regression, not just code bugs:
# - Performance regression (bisect + benchmark script)
# - Build breakage (bisect + compile check)
# - Test failure (bisect + specific test)

# Basic stash (saves tracked files only):
git stash                    # Stashes everything with default message
git stash push -m "WIP: OAuth login half-done"  # Named stash

# See what's stashed:
git stash list
# stash@{0}: On feature/auth: WIP: OAuth login half-done
# stash@{1}: On main: Quick experiment

# Restore stashed changes:
git stash pop               # Apply AND remove from stash list
git stash apply             # Apply BUT keep in stash list (safer)
git stash apply stash@{1}   # Restore a specific stash

# Stash specific files only:
git stash push -m "Config changes" src/config.js .env.example

# Include untracked AND ignored files:
git stash push -u -m "Everything"     # Includes new untracked files
git stash push -a -m "Really everything"  // Even ignored files!

# Show what changed in a stash:
git stash show -p stash@{0}   // Full diff of the stash

# Drop or clear:
git stash drop stash@{0}     // Remove one
git stash clear              // Remove ALL stashes

# Create a branch from a stash:
git stash branch fix-quick-bug stash@{0}
// Creates new branch "fix-quick-bug", applies stash, drops it if successful

# Search COMMIT MESSAGES across all branches:
git log --all --grep="security" --oneline
git log --all --grep="fix" --grep="auth" --oneline  --and  (both words)
git log --all --grep="fix\|bug" --oneline       --or  (either word)

# Search CODE CONTENT through entire history:
git log -S "functionName" --oneline    // When text was added/removed
git log -G "pattern" --oneline         // Regex through diffs
git log -S "TODO" -p                   // Show actual diff where text appears

# Who wrote/changed this line?
git blame src/utils.js                  // Line-by-line author history
git blame -L 10,20 src/utils.js        // Lines 10-20 only
git blame -e src/utils.js             // Include email addresses
git blame -w src/utils.js             // Ignore whitespace changes

# Find which commit broke something (alternative to bisect for simple cases):
git log --oneline --since="2 weeks ago" -- src/auth.js
git log --oneline --author="Alice" -- src/api/

# ❌ Committed to wrong branch:
git reset --soft HEAD~1        # Undo commit, keep changes staged
git checkout correct-branch
git commit                     # Re-commit on correct branch

# ❌ Accidentally committed sensitive data:
# If NOT pushed:
git rm secrets.json
git commit -m "Remove secrets"
# If already pushed: use BFG Repo Cleaner or git filter-repo

# ❌ Need to undo something?
git restore file.txt            // Discard uncommitted working directory changes
git restore --staged file.txt   // Unstage (keep changes)
git reflog                      // Recovery mode: find lost commits!

# Recover a deleted branch:
git reflog                       # Find SHA of branch tip
git branch recovered-branch abc1234

# Reset types explained:
git reset --soft HEAD~1   // Undo commit, keep changes STAGED
git reset --mixed HEAD~1   // Undo commit, keep changes UNSTAGED (default)
git reset --hard HEAD~1    // Undo commit, DISCARD all changes (dangerous!)

# Undo a specific file's changes to previous commit state:
git checkout HEAD~1 -- file.txt  // Get version from previous commit
// Or: git restore --source=HEAD~1 file.txt