# Cherry-pick a single commit by SHA
git cherry-pick abc1234
 
# Cherry-pick the tip of a branch
git cherry-pick feature
 
# Cherry-pick multiple commits (applied in order)
git cherry-pick abc1234 def5678 ghi9012
 
# Cherry-pick a range of commits (exclusive start, inclusive end)
git cherry-pick abc1234..ghi9012
 
# Cherry-pick a range inclusive of both ends
git cherry-pick abc1234^..ghi9012

# Stage the changes without committing
git cherry-pick -n abc1234
 
# Now you can modify, combine with other changes, then commit manually
git commit -m "Combined cherry-picked changes with local fixes"

git cherry-pick -x abc1234

# Keep your current branch's version of conflicted files
git checkout --ours path/to/file
 
# Keep the cherry-picked commit's version
git checkout --theirs path/to/file

# Create the empty commit anyway (preserves history)
git cherry-pick --allow-empty
 
# Skip it
git cherry-pick --skip

# You're on main, the fix is commit abc1234
git checkout release/2.3
git cherry-pick -x abc1234
git checkout release/2.2
git cherry-pick -x abc1234

# Copy the good commit to main
git checkout main
git cherry-pick abc1234
 
# Now safely delete the abandoned branch
git branch -D failed-experiment

# Full reflog for HEAD
git reflog
 
# Same thing, more explicit
git reflog show HEAD
 
# Reflog for a specific branch
git reflog show main
 
# With timestamps
git reflog --date=iso
 
# With relative time
git reflog --date=relative
 
# Limit output
git reflog -n 20

# Oops! You just did:
git reset --hard HEAD~3    # Three commits are "gone"
 
# They're not gone! Check the reflog:
git reflog
# abc1234 HEAD@{0} reset: moving to HEAD~3
# def5678 HEAD@{1} commit: The commit you want back
# ...
 
# Recover:
git reset --hard def5678
# All three commits are back!

# Oops! You deleted a branch with unmerged work:
git branch -D experiment
# Deleted branch experiment (was abc1234).
 
# Git tells you the last commit SHA! But even if you missed it:
git reflog
# Look for the last commit on that branch
 
# Recreate the branch at that commit:
git branch experiment abc1234
# It's back, with all its commits!

# You rebased and everything went wrong
git rebase main
# ... conflicts, bad resolutions, mess
 
# Find where your branch was before the rebase:
git reflog
# Look for "rebase (start)" — the entry BEFORE it is your old state
 
# Reset back:
git reset --hard HEAD@{5}    # whatever the pre-rebase entry is

git reset --hard HEAD~5     # Move back 5 commits
git reset --hard ORIG_HEAD  # Undo — jump back to where you were

git config gc.reflogExpire 180.days
git config gc.reflogExpireUnreachable 60.days

# 1. Start bisecting
git bisect start
 
# 2. Mark the current commit as bad (it has the bug)
git bisect bad
 
# 3. Mark a known good commit (before the bug existed)
git bisect good v1.0    # Can be a tag, SHA, or branch
 
# Git checks out a commit in the middle. Test it, then:
git bisect good         # This commit doesn't have the bug
# OR
git bisect bad          # This commit has the bug
 
# Repeat until Git says:
# "abc1234 is the first bad commit"
 
# 4. When done, return to your original branch
git bisect reset

# Start and define the range
git bisect start HEAD v1.0
 
# Run automatically — script exit code 0 = good, 1-124 = bad, 125 = skip
git bisect run ./test-for-bug.sh

#!/bin/bash
# Test if the bug exists
 
# Option 1: Run a specific test
npm test -- --grep "login validation" 2>/dev/null
# Exit code 0 = test passes = commit is "good"
# Exit code 1 = test fails = commit is "bad"
 
# Option 2: Check if a file exists
if [ -f "src/problematic-file.js" ]; then
    exit 1  # bad — file shouldn't exist yet
else
    exit 0  # good — file doesn't exist
fi
 
# Option 3: Check for a string in source code
if grep -q "buggy_function" src/app.js; then
    exit 1  # bad
else
    exit 0  # good
fi

#!/bin/bash
# Build the project first
make build 2>/dev/null || exit 125   # Can't build? Skip this commit.
 
# Run the test
make test-specific 2>/dev/null

# Searching for when a feature was ADDED (not a bug)
git bisect start --term-old=before --term-new=after
 
git bisect after     # Current commit has the feature
git bisect before v1.0   # This old commit doesn't
 
# Now use your custom terms
git bisect before    # Feature not present here
git bisect after     # Feature is present here

# See the remaining suspects
git bisect visualize     # Opens gitk or log
 
# View the bisect log (useful for reporting)
git bisect log
 
# Replay a bisect session
git bisect log > bisect-log.txt
git bisect replay bisect-log.txt
 
# Skip a commit that can't be tested
git bisect skip
 
# Skip a range of untestable commits
git bisect skip v2.0..v2.1

# Blame an entire file
git blame src/app.js
 
# Blame specific lines (35 to 45)
git blame -L 35,45 src/app.js
 
# Blame starting from a line to end of function
git blame -L 35,+20 src/app.js
 
# Blame from a regex pattern
git blame -L '/function login/,/^}/' src/app.js

# Ignore whitespace changes (VERY useful)
git blame -w src/app.js
 
# Show the original commit that introduced the line
# (follows renames and copies)
git blame -C src/app.js
 
# Follow across file copies (-C -C for more aggressive detection)
git blame -C -C src/app.js
 
# Follow lines moved within the same file (-C -C -C for all files)
git blame -C -C -C src/app.js
 
# Blame as of a specific commit (not just HEAD)
git blame abc1234 -- src/app.js
 
# Show email instead of name
git blame -e src/app.js
 
# Suppress boundary commits (root commit markers)
git blame -b src/app.js

# Blame the file as it was at the commit BEFORE the reformat
git blame abc1234^ -- src/app.js

# Ignore a specific formatting commit
git blame --ignore-rev abc1234 src/app.js
 
# Ignore commits listed in a file (one SHA per line)
git blame --ignore-revs-file .git-blame-ignore-revs
 
# Set this up project-wide
git config blame.ignoreRevsFile .git-blame-ignore-revs

# When was "validateEmail" added or removed?
git log -S "validateEmail"
 
# With patch to see the actual changes
git log -S "validateEmail" -p
 
# Limit to specific files
git log -S "validateEmail" -- "*.js"
 
# With one-line output for scanning
git log -S "validateEmail" --oneline

# Find commits where any line matching a regex was changed
git log -G "validate.*Email" -p
 
# Find function signature changes
git log -G "function\s+login\(" --oneline
 
# Find TODO additions/removals
git log -G "TODO|FIXME|HACK" --oneline

# When was this configuration key added?
git log -S "API_TIMEOUT" --oneline --all
 
# Who removed the deprecated function?
git log -S "oldHelperFunction" --diff-filter=D --oneline
 
# Find all commits that touched error handling patterns
git log -G "catch\s*\(" --oneline -- "src/**/*.ts"
 
# Track a variable rename
git log -S "oldVarName" --oneline   # Find when it disappeared
git log -S "newVarName" --oneline   # Find when it appeared

# Group commits by author
git shortlog
 
# Output (interactive, grouped):
# Alice Smith (15):
#       Add user authentication
#       Fix login redirect bug
#       Update password validation
#
# Bob Jones (8):
#       Implement dashboard API
#       Add unit tests for dashboard
 
# Count only (who committed the most?)
git shortlog -s -n
#     15  Alice Smith
#      8  Bob Jones
#      3  Carol Lee

# Summary + numbered (sorted by count)
git shortlog -sn
 
# Include email
git shortlog -sne
 
# For a specific range (e.g., since last release)
git shortlog v1.0..HEAD
 
# Since a date
git shortlog --since="2024-01-01"
 
# Group by committer instead of author
git shortlog -snc
 
# Only merge commits (who is merging the most PRs?)
git shortlog -sn --merges

# Changes since last tag
git shortlog $(git describe --tags --abbrev=0)..HEAD
 
# Formatted for a changelog
git log --oneline $(git describe --tags --abbrev=0)..HEAD | sort
 
# Group by conventional commit type (if your team uses them)
git log --oneline v1.0..HEAD | grep "^[a-f0-9]* feat:" | sed 's/^[a-f0-9]* //'

# Before .mailmap:
#   5  Alice Smith <alice@company.com>
#   3  alice.smith <alice.smith@old-email.com>
#   2  asmith <asmith@personal.com>
 
# After .mailmap:
#  10  Alice Smith <alice@company.com>

mkdir cherry-pick-lab && cd cherry-pick-lab
git init
 
# Create initial file with content
cat > app.js << 'EOF'
function greet(name) {
  return "Hello, " + name;
}
 
function add(a, b) {
  return a + b;
}
 
function multiply(a, b) {
  return a * b;
}
 
module.exports = { greet, add, multiply };
EOF
 
git add app.js
git commit -m "Initial: add core utility functions"
 
# Build up some history on main
cat > app.js << 'EOF'
function greet(name) {
  return "Hello, " + name + "!";
}
 
function add(a, b) {
  return a + b;
}
 
function multiply(a, b) {
  return a * b;
}
 
module.exports = { greet, add, multiply };
EOF
git add app.js
git commit -m "feat: add exclamation to greeting"
 
cat > config.js << 'EOF'
const config = {
  port: 3000,
  host: "localhost",
  debug: false
};
module.exports = config;
EOF
git add config.js
git commit -m "feat: add configuration file"
 
# Tag this as v1.0
git tag -a v1.0 -m "Version 1.0 release"

# Create a feature branch with multiple commits
git checkout -b feature/math
 
cat > app.js << 'EOF'
function greet(name) {
  return "Hello, " + name + "!";
}
 
function add(a, b) {
  return a + b;
}
 
function subtract(a, b) {
  return a - b;
}
 
function multiply(a, b) {
  return a * b;
}
 
function divide(a, b) {
  if (b === 0) throw new Error("Division by zero");
  return a / b;
}
 
module.exports = { greet, add, subtract, multiply, divide };
EOF
git add app.js
git commit -m "feat: add subtract and divide functions"
 
cat > app.js << 'EOF'
function greet(name) {
  return "Hello, " + name + "!";
}
 
function add(a, b) {
  return a + b;
}
 
function subtract(a, b) {
  return a - b;
}
 
function multiply(a, b) {
  return a * b;
}
 
function divide(a, b) {
  if (b === 0) throw new Error("Division by zero");
  return a / b;
}
 
function power(a, b) {
  return Math.pow(a, b);
}
 
module.exports = { greet, add, subtract, multiply, divide, power };
EOF
git add app.js
git commit -m "feat: add power function"
 
# Note the SHAs
echo "Feature commits:"
git log --oneline feature/math ^main

# Get the SHA of the first feature commit
DIVIDE_SHA=$(git log --oneline feature/math ^main | tail -1 | awk '{print $1}')
echo "Cherry-picking: $DIVIDE_SHA"
 
git checkout main
git cherry-pick -x $DIVIDE_SHA

# Create a conflicting situation
git checkout main
 
# Modify the same area on main
cat > app.js << 'EOF'
function greet(name) {
  if (!name) return "Hello, stranger!";
  return "Hello, " + name + "!";
}
 
function add(a, b) {
  return a + b;
}
 
function subtract(a, b) {
  return a - b;
}
 
function multiply(a, b) {
  return a * b;
}
 
function divide(a, b) {
  if (b === 0) throw new Error("Division by zero");
  return a / b;
}
 
module.exports = { greet, add, subtract, multiply, divide };
EOF
git add app.js
git commit -m "feat: add null check to greet function"
 
# Now try to cherry-pick the power function commit (will conflict on exports line)
POWER_SHA=$(git log --oneline feature/math | head -1 | awk '{print $1}')
git cherry-pick $POWER_SHA
# CONFLICT!

git add app.js
git cherry-pick --continue

# Create a history with a bug hidden somewhere
git checkout main
 
for i in $(seq 1 10); do
  echo "// Version $i update" >> app.js
  git add app.js
  git commit -m "update: version $i changes"
done
 
# Introduce a "bug" at a known point (we'll pretend we don't know which commit)
# The bug is: config.js has debug: true (it should be false in production)
git log --oneline -5
 
# Let's edit config.js to introduce the "bug"
cat > config.js << 'EOF'
const config = {
  port: 3000,
  host: "localhost",
  debug: true
};
module.exports = config;
EOF
git add config.js
git commit -m "update: adjust config settings"
 
# Add a few more commits to bury it
for i in $(seq 11 15); do
  echo "// Version $i update" >> app.js
  git add app.js
  git commit -m "update: version $i changes"
done
 
echo "Total commits:"
git log --oneline | wc -l

# Create the test script
cat > /tmp/test-debug.sh << 'SCRIPT'
#!/bin/bash
if grep -q 'debug: true' config.js 2>/dev/null; then
    exit 1  # bad — debug should not be true
else
    exit 0  # good — debug is false (or file doesn't exist yet)
fi
SCRIPT
chmod +x /tmp/test-debug.sh
 
# Run the automated bisect
git bisect start
git bisect bad HEAD
git bisect good v1.0
git bisect run /tmp/test-debug.sh

# Don't forget to exit bisect!
git bisect reset

# Create a branch with important work
git checkout -b experiment
 
cat > experiment.js << 'EOF'
// This took 3 hours to write
function complexAlgorithm(data) {
  return data.sort((a, b) => a.priority - b.priority)
    .filter(item => item.active)
    .reduce((acc, item) => ({ ...acc, [item.id]: item }), {});
}
module.exports = { complexAlgorithm };
EOF
git add experiment.js
git commit -m "feat: implement complex sorting algorithm"
 
echo "// Additional optimization" >> experiment.js
git add experiment.js
git commit -m "perf: optimize algorithm"
 
# Record the current SHA for later verification
EXPERIMENT_TIP=$(git rev-parse HEAD)
echo "Experiment branch tip: $EXPERIMENT_TIP"
 
# Now simulate accidentally deleting the branch
git checkout main
git branch -D experiment
echo "Branch deleted! Oh no!"

# Check the reflog
git reflog | head -10
 
# Find the SHA — look for "commit: perf: optimize algorithm"
# Or use the saved SHA:
git branch experiment $EXPERIMENT_TIP
 
# Verify recovery
git log --oneline experiment -3
git checkout experiment
cat experiment.js

git checkout main
 
# Investigate the codebase
# 1. Who last modified each line of app.js?
git blame app.js
 
# 2. When was the divide function added?
git log -S "divide" --oneline
 
# 3. When was "debug: true" introduced?
git log -S "debug: true" --oneline
 
# 4. Find all commits that touched the greet function
git log -G "function greet" --oneline
 
# 5. Generate a shortlog summary
git shortlog -sn