# Merge creates a merge commit -- history shows the branches and where they joined
git checkout feature
git merge main

# Rebase replays feature commits on top of main -- history looks linear,
# as if you started your feature from the latest main all along
git checkout feature
git rebase main

# Rebase last 3 commits
git rebase -i HEAD~3

# Rebase onto main
git rebase -i main

# Clean up commits before PR
git rebase -i HEAD~5

# In editor:
pick abc123 Add feature
squash def456 Fix typo
squash 789abc Fix another typo
reword 123def Update docs

# Result: 2 clean commits instead of 5

# Apply commit abc123 to current branch -- creates a NEW commit with the same diff
git cherry-pick abc123

# Cherry-pick multiple commits (applied in order, left to right)
git cherry-pick abc123 def456

# Cherry-pick without auto-committing -- useful when you want to combine
# changes from multiple cherry-picks into a single commit
git cherry-pick -n abc123

# Stash all tracked, modified files (untracked files are NOT included by default)
git stash

# Stash with a descriptive message -- critical when you have multiple stashes
git stash save "WIP: working on payment validation logic"

# List stashes
git stash list

# Apply latest stash
git stash apply

# Apply and remove stash
git stash pop

# Apply specific stash
git stash apply stash@{2}

# Drop stash
git stash drop stash@{0}

# Clear all stashes
git stash clear

# Stash including untracked files
git stash -u

# Stash including ignored files
git stash -a

# Create branch from stash
git stash branch new-branch stash@{0}

# View reflog -- shows every HEAD movement with timestamps
git reflog

# Reflog for specific branch
git reflog show feature-branch

# Recover lost commits: find the hash in reflog, then create a branch pointing to it
git reflog
# Find commit hash
git checkout abc123
git branch recovered-branch

# Oops, deleted branch!
git branch -D important-feature

# Find it in reflog
git reflog
# See: abc123 HEAD@{5}: commit: important work

# Recover
git checkout abc123
git branch important-feature

# Start bisect -- enter binary search mode
git bisect start

# Mark current commit as bad (the bug exists here)
git bisect bad

# Mark a known good commit (the bug did not exist here)
git bisect good abc123

# Git automatically checks out the commit halfway between good and bad.
# Test it manually, then tell Git what you found:
git bisect good  # bug is NOT present in this commit
# or
git bisect bad   # bug IS present in this commit

# Repeat -- each step cuts the remaining commits in half.
# After ~7 steps for 100 commits, Git tells you the exact first bad commit.

# End bisect and return to your original branch
git bisect reset

# Fully automated: bisect runs "npm test" at each step.
# If the test exits 0, the commit is good; non-zero means bad.
# This can find the offending commit in minutes, unattended.
git bisect start HEAD abc123
git bisect run npm test

# Create a worktree: checks out feature-branch in a sibling directory.
# No need to stash or commit -- your current branch stays exactly as is.
git worktree add ../feature-2 feature-branch

# List all worktrees (shows paths and checked-out branches)
git worktree list

# Remove worktree when done (deletes the directory too)
git worktree remove ../feature-2

# View any object's content by its hash
git cat-file -p abc123

# View the object's type (blob, tree, commit, tag)
git cat-file -t abc123

# View the tree (directory listing) of the latest commit
git cat-file -p HEAD^{tree}
# Output: mode, type, hash, and filename for each entry

# .git/refs/heads/   -- local branches (each file = one branch)
# .git/refs/tags/    -- tags
# .git/refs/remotes/ -- remote-tracking branches

# A branch is just a file containing a commit hash
cat .git/refs/heads/main
# Output: a1b2c3d4e5f6789012345678901234567890abcd

# HEAD tells Git which branch you are on (or which commit, if detached)
cat .git/HEAD
# Output: ref: refs/heads/main

# View the index -- shows file mode, blob hash, stage number, and filename
git ls-files --stage
# 100644 8b137891... 0    README.md
# 100644 a5c19667... 0    package.json

# Stage number 0 = normal. During merge conflicts:
# Stage 1 = common ancestor, Stage 2 = ours, Stage 3 = theirs

# Keep feature branch updated
git checkout feature
git fetch origin
git rebase origin/main

# Resolve conflicts if any
git add .
git rebase --continue

# Force push (safe)
git push --force-with-lease origin feature

# Make changes
git add .
git commit --fixup abc123

# Auto-squash during rebase
git rebase -i --autosquash main

# Hooks live here (NOT tracked by Git -- this is the sharing problem)
ls .git/hooks/

# Common hooks and when they fire:
# pre-commit    -- before commit executes (lint, format, fast tests)
# commit-msg    -- after you write the message (enforce format like "JIRA-123: ...")
# pre-push      -- before push sends data (run integration tests, block pushes to main)
# post-merge    -- after merge completes (auto-run "npm install" when package.json changes)
# prepare-commit-msg -- before editor opens (auto-populate ticket number from branch name)

#!/bin/sh
# .git/hooks/pre-commit
# Runs BEFORE every git commit. Non-zero exit = commit aborted.

# Run linter on staged files only (fast feedback)
npm run lint
if [ $? -ne 0 ]; then
  echo "Linting failed! Fix the issues above and try again."
  exit 1  # Abort the commit
fi

# Run fast unit tests (skip slow integration tests here)
npm run test:unit -- --bail
if [ $? -ne 0 ]; then
  echo "Unit tests failed! Commit aborted."
  exit 1
fi

# Basic shortcuts -- save keystrokes on the commands you use most
git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.ci commit
git config --global alias.st status

# Complex aliases -- encode team knowledge into short commands
# This one-liner shows a beautiful, compact branch graph
git config --global alias.lg "log --oneline --graph --all --decorate"

# "Undo the last staging" -- safer than remembering the full reset syntax
git config --global alias.unstage "reset HEAD --"

# Show what you committed today (useful for standup prep)
git config --global alias.today "log --since='midnight' --oneline --author='$(git config user.email)'"

# Show the diff of what is staged (the most common "wait, what am I about to commit?" check)
git config --global alias.staged "diff --cached"

# Use them exactly like built-in commands
git co main
git lg
git today

git reset --soft HEAD~1

git reset --hard HEAD~1

git reflog
git reset --hard abc123

# On wrong-branch
git reset --hard HEAD~1

# Switch to correct branch
git checkout correct-branch
git cherry-pick abc123

# Use filter-branch (old way)
git filter-branch --tree-filter 'rm -f passwords.txt' HEAD

# Use filter-repo (recommended)
git filter-repo --path passwords.txt --invert-paths