# You are on main with a commit that belongs on a feature branch.

# Option A: the target branch does not exist yet
git branch feature-x          # create feature-x pointing at the bad commit
git reset --hard HEAD~1       # move main back one commit
git switch feature-x          # your commit is now safely on feature-x

# Option B: the target branch already exists
git switch feature-x
git cherry-pick main          # copy main's tip commit onto feature-x
git switch main
git reset --hard HEAD~1       # remove it from main

# Keep changes staged (ready to re-commit)
git reset --soft HEAD~1

# Keep changes in the working tree, unstaged (the default)
git reset --mixed HEAD~1
# same as:
git reset HEAD~1

# 1. ROTATE THE SECRET FIRST. Treat it as leaked.

# If you have NOT pushed yet and it is only in the last commit:
git rm --cached .env
echo ".env" >> .gitignore
git commit --amend --no-edit

# If it is deeper in history (or already pushed), use git-filter-repo:
pip install git-filter-repo
git filter-repo --path .env --invert-paths
# or replace just the secret string everywhere:
git filter-repo --replace-text <(echo 'mySecret123==>REMOVED')

# Then force-push every branch; all collaborators must re-clone:
git push origin --force --all

git rebase -i HEAD~3

# An editor opens with:
#   pick a1b2c3 first commit
#   pick d4e5f6 second commit
#   pick 7g8h9i third commit
#
# Change the 2nd and 3rd "pick" to "squash" (or "s"):
#   pick   a1b2c3 first commit
#   squash d4e5f6 second commit
#   squash 7g8h9i third commit
#
# Save and close. A second editor lets you write the combined message.

# Fast alternative if you just want one commit on top of main:
git reset --soft HEAD~3
git commit -m "Single clean commit message"

git reflog
# You'll see something like:
#   a1b2c3 HEAD@{0}: reset: moving to HEAD~3
#   d4e5f6 HEAD@{1}: commit: the work you thought was gone
#   ...

# Restore the branch to the state before the reset:
git reset --hard HEAD@{1}

# Or, safer, inspect first then create a branch at that point:
git checkout -b recovered d4e5f6

git commit --amend -m "Correct commit message"
git push --force-with-lease

# To reword an OLDER commit, use interactive rebase and mark it "reword":
git rebase -i HEAD~4
# change "pick" to "reword" on the target line, save, edit the message
git push --force-with-lease

git stash push -m "wip before pulling"
git pull --rebase
git stash pop      # reapply your changes on top of the freshly pulled code

# If 'pop' produces conflicts, resolve them, then:
git add <resolved-files>
git stash drop     # remove the stash entry once applied cleanly

git merge --abort        # restore to pre-merge state
git rebase --abort       # bail out of a rebase
git cherry-pick --abort  # bail out of a cherry-pick

# If a merge already completed and you want to undo it:
git reset --hard ORIG_HEAD   # ORIG_HEAD points to where you were before the merge

git switch my-branch
git cherry-pick a1b2c3d              # apply that commit here (new SHA)

# Multiple commits at once:
git cherry-pick a1b2c3d f4e5g6h

# A continuous range (exclusive of the first):
git cherry-pick startHash..endHash

# Apply the changes but don't commit yet (lets you tweak first):
git cherry-pick -n a1b2c3d

# Fix your config going forward:
git config --global user.name "Correct Name"
git config --global user.email "correct@email.com"

# Fix only the last commit:
git commit --amend --reset-author --no-edit

# Fix the author across many past commits with filter-repo:
git filter-repo --commit-callback '
  if commit.author_email == b"wrong@email.com":
      commit.author_email = b"correct@email.com"
      commit.author_name  = b"Correct Name"
'

git bisect start
git bisect bad                 # current commit has the bug
git bisect good v1.0.0         # this older tag was fine

# Git checks out a midpoint commit. Test it, then:
git bisect good                # ...if the midpoint is fine
git bisect bad                 # ...if the midpoint has the bug
# Repeat until Git prints "<sha> is the first bad commit".

git bisect reset               # return to where you started

# Automate it with a test command (exit 0 = good, non-zero = bad):
git bisect start HEAD v1.0.0
git bisect run npm test

# Quick context switch on the same checkout:
git stash push -u -m "wip feature"   # -u also stashes untracked files
git switch hotfix
# ...do the hotfix...
git switch feature
git stash pop

# Keep BOTH active at the same time in separate folders:
git worktree add ../hotfix-tree hotfix
# now ../hotfix-tree is a full checkout of the hotfix branch
git worktree remove ../hotfix-tree   # clean up when done

# Find the tip commit of the deleted branch:
git reflog
# look for the last "checkout: moving from <branch>" or commit on it

# Recreate the branch at that commit:
git branch recovered-branch a1b2c3d

# If nothing useful in reflog, search dangling commits:
git fsck --no-reflogs --lost-found
# then: git branch recovered-branch <dangling-sha>

git rebase -i HEAD~3
# Mark the oversized commit with "edit" instead of "pick", save.

# Git pauses ON that commit. Undo it but keep the changes:
git reset HEAD~1

# Now stage and commit in coherent chunks (use -p to pick hunks):
git add -p src/feature-a.js
git commit -m "feat: add feature A"
git add src/feature-b.js
git commit -m "feat: add feature B"

# When the working tree is clean, resume the rebase:
git rebase --continue