Git and GitHub Notes — Version Control and Collaborative Workflows

Your local files that you actively edit.
Status: Untracked or Modified

Files marked for inclusion in the next commit.
Status: Staged

Permanent snapshots stored in .git directory.
Status: Committed

Modify Files (Working) → Stage Changes → Commit to Repository

Commit - points to tree + parent commit + author info
  ↓
Tree - represents directory structure
  ↓
Blob - actual file contents (immutable)
  ↓
Tag - reference to specific commit (optional)

brew install git
git --version

sudo apt update
sudo apt install git
git --version

# Download from: https://git-scm.com/download/win
# Run installer and follow prompts
# Verify installation
git --version

# Set your name (appears in commits)
git config --global user.name "Your Name"

# Set your email (appears in commits)
git config --global user.email "you@example.com"

# Set default editor for commit messages
git config --global core.editor "vim"

# Verify configuration
git config --list

# View only global settings
git config --global --list

# View configuration files
cat ~/.gitconfig

# Enable colored output
git config --global color.ui true

# Set default branch name to main
git config --global init.defaultBranch main

# Enable automatic garbage collection
git config --global gc.auto 4096

# Configure paging (less) for large outputs
git config --global core.pager "less -x1,5"

# Add helpful aliases
git config --global alias.st status
git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.ci commit
git config --global alias.unstage 'restore --staged'
git config --global alias.last 'log -1 HEAD'
git config --global alias.visual 'log --graph --oneline --all'

# Create a new directory
mkdir my-project
cd my-project

# Initialize Git repository
git init

# Verify .git directory was created
ls -la

.git/
  ├── objects/        # Stores all commits, trees, blobs
  ├── refs/           # References to branches and tags
  ├── HEAD            # Points to current branch
  ├── config          # Repository configuration
  ├── hooks/          # Scripts that run on Git events
  └── logs/           # Reference logs

# View current config (inherits from global)
git config --local user.name

# Override with project-specific settings
git config --local user.name "Project-Specific Name"
git config --local user.email "project@example.com"

# These only apply to this repository

# Full status output
git status

# Short format (more concise)
git status -s

# Include branch tracking info
git status -sb

# Show untracked files separately
git status --short

 M = Modified
A  = Added
D  = Deleted
R  = Renamed
C  = Copied
U  = Updated but unmerged
?? = Untracked

First column  = staging area
Second column = working directory

# Stage specific file
git add filename.txt

# Stage multiple files
git add file1.js file2.js file3.js

# Stage all changes in current directory
git add .

# Stage all changes everywhere
git add -A

# Stage only modified files (not new files)
git add -u

# Stage with confirmation (interactive)
git add -i

# Interactive patch staging - choose hunks to stage
git add -p

# View what you staged
git diff --staged

# Unstage specific file
git restore --staged filename.txt

# Unstage all changes
git restore --staged .

# Simple commit with message
git commit -m "Add user authentication feature"

# Multi-line commit message (opens editor)
git commit -m "Add authentication" -m "Implement JWT token validation"

# Automatically stage tracked files and commit
git commit -am "Fix login bug"

# Open editor for detailed commit message
git commit

# Amend previous commit (reuse same message)
git commit --amend --no-edit

# Amend and edit message
git commit --amend

# ❌ BAD: What is being done
git commit -m "Update login"

# ❌ BAD: Too vague
git commit -m "Fix stuff"

# ✅ GOOD: What and why
git commit -m "Implement JWT authentication for API endpoints

- Add token generation on login
- Validate tokens on protected routes
- Store refresh tokens securely
- Fixes #123"

# ✅ GOOD: Conventional Commits format
git commit -m "feat(auth): implement JWT token validation

Enables secure API authentication for user endpoints.
Tokens expire after 24 hours and include refresh mechanism.

Closes #456"

type(scope): subject

body

footer

# Show all commits in current branch
git log

# One line per commit (compact)
git log --oneline

# Show last 10 commits
git log -n 10

# Show commits by specific author
git log --author="John Doe"

# Show commits in date range
git log --since="2025-01-01" --until="2025-06-01"

# Show commits matching search term
git log --grep="authentication"

# Show commits affecting specific file
git log filename.js

# Show changes in each commit (-p = patch)
git log -p

# Pretty graphical view with branches
git log --graph --oneline --all --decorate

# Show statistics
git log --stat

# Custom format
git log --pretty=format:"%h %an %ar - %s"

commit abc1234def5678 (HEAD -> main)
Author: John Doe <john@example.com>
Date:   Mon Nov 3 10:30:45 2025 +0800

    Add JWT authentication

    - Implement token generation
    - Validate tokens on routes

commit xyz9876abc3210
Author: Jane Smith <jane@example.com>
Date:   Sun Nov 2 14:22:10 2025 +0800

    Fix user registration bug

# List local branches
git branch

# List remote branches
git branch -r

# List all branches
git branch -a

# Create new branch (doesn't switch to it)
git branch feature/user-profile

# Create and switch to new branch
git checkout -b feature/user-profile

# Modern syntax (Git 2.23+)
git switch -c feature/user-profile

# Switch to existing branch
git checkout feature/user-profile

# Modern syntax
git switch feature/user-profile

# Switch to previous branch
git checkout -

# Delete branch (safe - prevents deleting unmerged branches)
git branch -d feature/user-profile

# Force delete branch
git branch -D feature/user-profile

# Rename branch
git branch -m old-name new-name

# Rename current branch
git branch -m new-name

main (production releases only)
  ↑
release/v1.0 (release preparation)
  ↑
develop (integration branch)
  ↑
feature/* (individual features)
bugfix/* (bug fixes)
hotfix/* (emergency production fixes)

# Start feature branch from develop
git checkout develop
git checkout -b feature/new-feature

# Do work, commit regularly
git add .
git commit -m "Implement new feature"

# When ready, create pull request to develop
# After review and merge to develop

# Create release branch when preparing release
git checkout -b release/v1.0 develop

# Fix release issues only
git commit -m "Fix typo in error message"

# When ready, merge to main with tag
git checkout main
git merge --no-ff release/v1.0
git tag -a v1.0 -m "Release version 1.0"

# Merge back to develop
git checkout develop
git merge --no-ff release/v1.0

main (always deployable, production)
  ↑
feature/* (features/fixes - short-lived)
  ↓
Pull Request → Code Review → Merge → Deploy

# Create branch from main
git checkout -b fix/login-bug

# Make commits
git commit -m "Fix login redirect issue"

# Push to GitHub
git push -u origin fix/login-bug

# Create pull request on GitHub
# After review and approval, merge to main
# GitHub automatically deploys main to production

main (always in releasable state)
  ↑
short-lived branches (< 1 day)
  ↓
Commit → Merge → Deploy

# Switch to target branch (usually main)
git checkout main

# Merge feature branch into main
git merge feature/new-feature

# Git creates a merge commit automatically
# This preserves complete branch history

# Merge all commits from feature branch into single commit
git merge --squash feature/new-feature

# Still need to commit the squashed changes
git commit -m "Merge feature: add user profile

Implements complete user profile functionality including:
- Profile page with bio and avatar
- Profile editing with validation
- Profile deletion option"

# Reapply feature commits on top of main
git merge --ff-only feature/new-feature

# Or explicitly use rebase
git rebase main feature/new-feature
git checkout main
git merge --ff-only feature/new-feature

# When merge conflict occurs, files contain:

<<<<<<< HEAD
// Your changes (from current branch)
function login(user) {
    validate(user);
    return authenticate(user);
}
=======
// Incoming changes (from branch being merged)
function login(user) {
    checkCredentials(user);
    return authorizeUser(user);
}
>>>>>>> feature/auth-update

# 1. View conflicted files
git status

# 2. View conflicts in detail
git diff

# 3. Edit the file to resolve conflicts
#    Remove conflict markers and keep desired code

# 4. Stage the resolved file
git add resolved-file.js

# 5. Complete the merge
git commit -m "Merge feature/auth-update with conflict resolution"

# Or abort the merge if something went wrong
git merge --abort

# View configured remotes
git remote -v

# Add new remote
git remote add origin https://github.com/username/project.git

# Remove remote
git remote remove origin

# Rename remote
git remote rename origin upstream

# View remote details
git remote show origin

# Change remote URL (HTTPS to SSH)
git remote set-url origin git@github.com:username/project.git

# Clone entire repository
git clone https://github.com/username/project.git

# Clone to specific directory
git clone https://github.com/username/project.git my-folder

# Clone specific branch only
git clone -b develop https://github.com/username/project.git

# Shallow clone (fewer commits for faster download)
git clone --depth 5 https://github.com/username/project.git

# Shallow clone with history
git clone --depth 5 --deepen 10 https://github.com/username/project.git

# Fetch: Download remote changes (no integration)
git fetch origin

# Fetch all remotes
git fetch --all

# Fetch and show what changed
git fetch origin && git log origin/main ^main

# Pull: Fetch + merge (downloads and integrates)
git pull origin main

# Pull with rebase instead of merge
git pull --rebase origin main

# Pull and automatically stash local changes
git pull --autostash

# Push current branch to remote
git push origin main

# Push to remote and track it
git push -u origin feature/new-feature

# Push all branches
git push --all

# Push all tags
git push --tags

# Push specific branch
git push origin feature/user-auth

# Force push (overwrite remote - use with caution!)
git push --force

# Safe force push (doesn't overwrite others' work)
git push --force-with-lease

# Delete remote branch
git push origin --delete feature/old-feature

# Push with pull request (GitPython or GitHub CLI)
gh pr create --title "Add user profile" --body "Implements #123"

# Create feature branch
git checkout -b feature/user-dashboard

# Make changes and commits
git add .
git commit -m "Add dashboard component"

# Push to GitHub
git push -u origin feature/user-dashboard

# Create PR via GitHub web interface or CLI
gh pr create --title "Add user dashboard" \
  --body "Implements #234: User dashboard with stats and charts"

# Install GitHub CLI
# brew install gh (macOS)
# or from https://cli.github.com

# Login to GitHub
gh auth login

# Create pull request
gh pr create --title "Add feature" --body "Description"

# View your PRs
gh pr list

# Check PR status
gh pr checks <pr-number>

# Close PR without merging
gh pr close <pr-number>

## Summary
Brief description of what this PR does.

## Changes
- Added user authentication system
- Implemented JWT token validation
- Created auth middleware

## Related Issues
Closes #123
Relates to #456

## Testing
- Tested login with valid credentials
- Tested login with invalid credentials
- Tested token refresh

## Screenshots
[Add relevant screenshots if UI changes]

## Checklist
- [x] Tests added/updated
- [x] Documentation updated
- [x] No breaking changes
- [ ] Ready for review

# Make additional changes
git add .
git commit -m "Address review feedback: add error handling"

# Push updates (forces update to same PR)
git push origin feature/new-feature

# Force push if you rewrote history
git push --force-with-lease origin feature/new-feature

# The PR automatically updates with new commits

# Option 1: Create merge commit (preserves branch history)
# Recommended for: Feature branches, large changes

# Option 2: Squash and merge (clean history)
# Recommended for: Small fixes, single feature commits

# Option 3: Rebase and merge (linear history)
# Recommended for: Teams using rebase workflow

# You can set default strategy in GitHub repo settings:
# Settings → General → Pull Requests → Default merge method

# Save current changes (working directory and staging area)
git stash

# Save with descriptive message
git stash save "WIP: user profile feature"

# List all stashes
git stash list

# Show contents of stash
git stash show stash@{0}

# Show stash with diff
git stash show -p stash@{0}

# Apply stash and keep it
git stash apply stash@{0}

# Apply latest stash and remove it
git stash pop

# Delete specific stash
git stash drop stash@{0}

# Delete all stashes
git stash clear

# Create branch from stash
git stash branch new-branch

# Rebase last 3 commits (opens editor)
git rebase -i HEAD~3

# Rebase from specific commit
git rebase -i abc1234

# In the editor, you can:
# pick   - include commit as-is
# reword - change commit message
# squash - combine with previous commit
# fixup  - combine and discard message
# drop   - remove commit

pick a1b2c3d Add user model
squash x9y8z7w Fix user model validation
pick p8q7r6s Create user repository

# Squash combines the 2nd commit into the 1st
# Final result: 2 commits instead of 3

# Switch to feature branch
git checkout feature/payment

# Rebase onto main (moves all feature commits on top of main)
git rebase main

# Resolve any conflicts that occur
# git add resolved-files
# git rebase --continue

# If something goes wrong
git rebase --abort

# Force push rebased branch (if already pushed)
git push --force-with-lease origin feature/payment

# Apply specific commit to current branch
git cherry-pick abc1234

# Apply multiple commits
git cherry-pick abc1234 def5678 ghi9012

# Apply commits from another branch
git cherry-pick main~5..main

# Cherry-pick without committing (review first)
git cherry-pick --no-commit abc1234

# Abort cherry-pick if conflicts occur
git cherry-pick --abort

# Start bisect session
git bisect start

# Mark current commit as bad (contains bug)
git bisect bad HEAD

# Mark a known good commit
git bisect good v1.0

# Git checks out midpoint, you test it
# Mark as good or bad based on testing
git bisect good  # if working
git bisect bad   # if broken

# Git continues narrowing down
# Eventually finds exact commit that broke it

# End bisect session
git bisect reset

# Automate with script
git bisect run ./test-suite.sh

# View all reference changes
git reflog

# Show detailed reflog
git reflog show

# Recover accidentally deleted branch
git reflog
# Find the commit where branch was at
git checkout -b recovered-branch abc1234

# Undo a reset
git reflog
git reset --hard commit-before-reset

# View reflog for specific ref
git reflog show main

# Create issue (web interface or CLI)
gh issue create --title "Bug: login fails with spaces in password" \
  --body "Steps to reproduce..."

# List issues
gh issue list

# View issue details
gh issue view 123

# Close issue
gh issue close 123 --comment "Fixed in PR #456"

# Link commits to issues
# Use 'Closes #123' in commit message or PR description
git commit -m "Fix login bug - Closes #123"

# When PR merges, GitHub auto-closes the issue

# Create .github/workflows/ci.yml file

name: CI

on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v3

      - uses: actions/setup-node@v3
        with:
          node-version: '18'

      - run: npm install

      - run: npm run lint

      - run: npm run test

      - run: npm run build

# 1. Push HTML files to main branch (or docs/ folder)
# 2. Go to repo Settings → Pages
# 3. Select source (main or gh-pages branch)
# 4. GitHub builds and publishes automatically

# Your site is now at: https://username.github.io/repository

# For project documentation
# Push to docs/ folder and enable in settings

# Create gist via CLI
gh gist create filename.js

# Create secret gist (unlisted)
gh gist create --public filename.js

# List your gists
gh gist list

# View gist contents
gh gist view gist-id

# Edit gist
gh gist edit gist-id

# Delete gist
gh gist delete gist-id

# Clone gist
git clone https://gist.github.com/username/gist-id.git

# Generate ED25519 key (recommended - modern & secure)
ssh-keygen -t ed25519 -C "your_email@example.com"
# Save to: ~/.ssh/id_ed25519

# Or generate RSA key (4096 bits - widely compatible)
ssh-keygen -t rsa -b 4096 -C "your_email@example.com"
# Save to: ~/.ssh/id_rsa

# Add key to SSH agent
eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519

# Copy public key to clipboard
cat ~/.ssh/id_ed25519.pub | pbcopy  # macOS
cat ~/.ssh/id_ed25519.pub | xclip -selection clipboard  # Linux

# Test connection
ssh -T git@github.com

# Expected output:
# Hi username! You've successfully authenticated, but
# GitHub does not provide shell access.

# If fails, check configuration
ssh -vT git@github.com

# Create/edit ~/.ssh/config

Host github.com-personal
    HostName github.com
    User git
    IdentityFile ~/.ssh/id_ed25519_personal

Host github.com-work
    HostName github.com
    User git
    IdentityFile ~/.ssh/id_ed25519_work

# Use in git commands:
git remote add origin git@github.com-personal:username/repo.git
git clone git@github.com-work:company/project.git

# Create token in GitHub Settings → Developer settings → Personal access tokens
# Select scopes: repo, read:user, user:email

# Use as password when cloning via HTTPS
git clone https://username:ghp_xxx@github.com/username/repo.git

# Store token securely using credential manager
git config --global credential.helper cache

# Or use environment variable
export GITHUB_TOKEN="ghp_xxx"
git clone https://github.com/username/repo.git

# Blobs: File contents (immutable)
git hash-object filename.txt

# Trees: Directory structure
git cat-file -p main^{tree}

# Commits: Snapshots with metadata
git cat-file -p main

# Tags: Labels for specific commits
git cat-file -p v1.0

Commit: abc1234
  ├─ Author: John Doe <john@example.com>
  ├─ Date: 2025-11-03
  ├─ Message: "Add user profile"
  ├─ Tree: xyz9876 (represents files at this commit)
  └─ Parent: def5678 (previous commit)

Tree: xyz9876
  ├─ user.js (blob: 8f4k2m1)
  ├─ profile.js (blob: q2w3e4r)
  └─ styles/ (tree: 5t6y7u8)

# Branches stored in .git/refs/heads/
cat .git/refs/heads/main
# Output: abc1234def5678...

# Remote references in .git/refs/remotes/
cat .git/refs/remotes/origin/main

# HEAD points to current branch
cat .git/HEAD
# Output: ref: refs/heads/main

# Detached HEAD (pointing to commit, not branch)
git checkout abc1234  # You're now in detached state
cat .git/HEAD
# Output: abc1234  (direct commit reference)

# View index contents
git ls-files

# View index with status
git ls-files --stage

# Clear index (dangerous!)
git rm --cached -r .

# Update index after external file changes
git update-index --add --cacheinfo

# Undo uncommitted changes in working directory
git checkout filename.js
# or (modern)
git restore filename.js

# Undo staged changes (keep working directory)
git restore --staged filename.js
# or (older)
git reset HEAD filename.js

# Undo last commit (keep changes)
git reset --soft HEAD~1

# Undo last commit (discard changes)
git reset --hard HEAD~1

# Revert commit (create new commit that undoes it)
git revert abc1234

# Revert merge commit (specify which parent to keep)
git revert -m 1 merge-commit-sha

# Accidentally committed to wrong branch
git reset --soft HEAD~1
git stash
git checkout correct-branch
git stash pop
git commit -m "..."

# Committed to main instead of feature branch
git reset --soft HEAD~1  # Keep changes
git checkout -b feature/new-feature
git commit -m "..."

# Need to update branch name before push
git branch -m old-name new-name
git push -u origin new-name
git push origin --delete old-name

# Typo in commit message
git commit --amend -m "Corrected message"
# Then force push if already pushed
git push --force-with-lease origin branch-name

# View all conflicted files
git diff --name-only --diff-filter=U

# View detailed conflict
git diff filename.js

# Use your version entirely
git checkout --ours filename.js
git add filename.js

# Use their version entirely
git checkout --theirs filename.js
git add filename.js

# Use external merge tool
git mergetool

# After resolving all conflicts
git add .
git commit -m "Resolve merge conflicts"

# Or abort the merge
git merge --abort

# ❌ BAD: Too many unrelated changes
git add .
git commit -m "Update stuff"

# ✅ GOOD: Related changes, logical commit
git add src/auth/login.js src/auth/login.test.js
git commit -m "feat(auth): add password reset functionality

- Add reset token generation
- Add email sending for reset link
- Add password validation rules

Closes #234"

# Use staging area strategically
git add -p  # Stage changes hunk by hunk
git diff --staged  # Review what you're committing
git commit -m "..."  # Commit reviewed changes

# Feature branches
feature/user-authentication
feature/payment-integration

# Bug fix branches
bugfix/login-redirect-issue
fix/null-pointer-exception

# Release branches
release/v1.0
release/v2.1.0

# Hotfix branches
hotfix/critical-security-patch
hotfix/production-crash

# Maintenance branches
maintenance/update-dependencies
chore/code-cleanup

# Personal experimentation
sandbox/test-new-framework
spike/investigate-performance

# Delete merged branches locally
git branch -d feature/completed-feature

# Delete all merged branches
git branch -d $(git branch --merged | grep -v "*")

# Find branches merged into main
git branch --merged main

# Find branches NOT merged into main
git branch --no-merged main

# Clean up tracking branches
git remote prune origin

# Clean up object database
git gc

# View and cleanup
git reflog expire --expire=now --all
git gc --prune=now

# Bad commit message
Fixed stuff

# Good commit message
Fix user profile display bug

The profile view was failing when user bio contained
special characters. This was due to improper HTML
escaping in the template.

Changes:
- Add HTML entity encoding to bio field
- Add test case for special characters
- Update documentation

Closes #456

# As a reviewer:
1. Clone the branch locally to test
   git fetch origin pull/123/head:pr-123
   git checkout pr-123

2. Test the changes thoroughly
   npm install && npm run test

3. Review code for:
   - Correctness
   - Performance
   - Security
   - Style consistency
   - Test coverage

4. Leave constructive comments
   gh pr review 123 --approve
   # or
   gh pr review 123 --request-changes

5. Approve when satisfied
   # Comment: "Looks good! Approved"

# As a developer:
1. Implement feedback
   git add .
   git commit -m "Address review feedback: add error handling"

2. Push updates
   git push origin feature/branch

3. Request re-review
   gh pr review --request-review @reviewer-name

# Create annotated tag (recommended)
git tag -a v1.0.0 -m "Release version 1.0.0"

# Create lightweight tag (simple reference)
git tag v1.0.0

# List tags
git tag -l

# View tag details
git show v1.0.0

# Push tags to GitHub
git push origin --tags

# Delete tag locally
git tag -d v1.0.0

# Delete tag remotely
git push origin --delete v1.0.0

# Create release on GitHub with notes
gh release create v1.0.0 --title "Version 1.0.0" --notes "Release notes..."

v[MAJOR].[MINOR].[PATCH]-[PRERELEASE]+[BUILD]

v1.2.3           # Version 1, minor release 2, patch 3
v2.0.0-beta      # Pre-release version
v1.0.0-alpha.1   # Pre-release with identifier

# Hooks located in .git/hooks/

# Create pre-commit hook (runs before commit)
cat > .git/hooks/pre-commit <<'EOF'
#!/bin/bash
npm run lint
npm run test
EOF

chmod +x .git/hooks/pre-commit

# Shared hooks (commit to repo)
mkdir -p .githooks

# Update git config to use .githooks directory
git config core.hooksPath .githooks

# Common hooks:
# pre-commit       - before commit
# prepare-commit-msg - modify commit message
# commit-msg       - validate commit message
# post-commit      - after commit
# pre-push         - before push

# Install pre-commit
pip install pre-commit

# Create .pre-commit-config.yaml
repos:
  - repo: https://github.com/psf/black
    rev: 23.1.0
    hooks:
      - id: black

  - repo: https://github.com/pre-commit/pre-commit-hooks
    rev: v4.4.0
    hooks:
      - id: trailing-whitespace
      - id: end-of-file-fixer
      - id: check-yaml
      - id: check-added-large-files

# Setup pre-commit
pre-commit install

# Run manually on all files
pre-commit run --all-files

# Shallow clone (faster for CI/CD)
git clone --depth 1 repo-url

# Unshallow later if needed
git fetch --unshallow

# Sparse checkout (clone only specific directories)
git clone --filter=blob:none --sparse repo-url
cd repo
git sparse-checkout set path/to/dir

# Partial clone (saves bandwidth)
git clone --filter=blob:none repo-url

# Git LFS for large files
git lfs install
git lfs track "*.bin"
git add .gitattributes

# Enable auto garbage collection (default)
git config --global gc.auto 4096

# Manual garbage collection
git gc --aggressive

# Reduce pack size
git gc --prune=now

# Enable object file delta compression
git config --global core.compression 9

# Use credential helper for faster auth
git config --global credential.helper cache
git config --global credential.helper 'cache --timeout=3600'

# Scenario: Large refactor needs to be split across commits
git reset HEAD~5  # Unstage last 5 commits
git add .
git status -s | head -20  # See all changes

# Stage first logical unit
git add src/auth/*.js
git commit -m "refactor(auth): simplify token handling"

# Stage next unit
git add src/api/*.js
git commit -m "refactor(api): restructure endpoints"

# Push when ready
git push origin feature/refactor

# Later: squash all into one for cleaner main history
git merge --squash feature/refactor
git commit -m "Merge refactor: reorganize codebase

- Simplified authentication system
- Restructured API endpoints
- Updated error handling"

# Show all configuration and their sources
git config --list --show-origin

# Show specific config value
git config user.name

# Edit global config in editor
git config --global --edit

# Set different email for specific repo
git config user.email "work@company.com"

# Enable rerere (reuse recorded resolution)
git config --global rerere.enabled true

# Set merge conflict style
git config --global merge.conflictstyle diff3

# Enable auto-correct for mistyped commands
git config --global help.autocorrect 20

# Set default push behavior
git config --global push.default simple
git config --global push.default current

# Enable push.autoSetupRemote (Git 2.37+)
git config --global push.autoSetupRemote true

# Set default pull strategy
git config --global pull.rebase true
git config --global pull.ff only

# Configure commit template
git config --global commit.template ~/.gitmessage

# Set up signing commits with GPG
git config --global user.signingkey YOUR_GPG_KEY
git config --global commit.gpgsign true

# Ignore file mode changes
git config core.fileMode false

# Case-sensitive file names
git config core.ignorecase false

# Enable filesystem monitoring (Git 2.35+)
git config --global core.fsmonitor true

# Set credential cache timeout
git config --global credential.helper 'cache --timeout=3600'

# Add with intent to add (track but don't stage content)
git add -N file.txt

# Force add ignored files
git add -f ignored-file.txt

# Dry run (show what would be added)
git add -n .

# Verbose output
git add -v .

# Add only modified files, not new files
git add --ignore-removal .

# Update only already tracked files
git add --no-all -u

# Amend and change author
git commit --amend --author="Name <email@example.com>"

# Commit with specific date
git commit --date="2025-01-01 10:00:00"

# Empty commit (trigger CI)
git commit --allow-empty -m "Trigger CI"

# Commit without hooks
git commit --no-verify

# Sign commit with GPG
git commit -S -m "Signed commit"

# Commit with trailer
git commit -m "Fix bug" --trailer "Reviewed-by: John <john@example.com>"

# Fixup commit (for autosquash)
git commit --fixup=abc1234

# Squash commit (for autosquash)
git commit --squash=abc1234

# Reuse commit message from another commit
git commit -C HEAD~1

# Reuse message but edit it
git commit -c HEAD~1

# List branches with pattern
git branch --list "feature/*"

# List branches containing commit
git branch --contains abc1234

# List branches not containing commit
git branch --no-contains abc1234

# Create branch from specific commit
git branch feature-name abc1234

# Track remote branch
git branch --track feature origin/feature

# Set upstream for current branch
git branch --set-upstream-to=origin/main

# Unset upstream
git branch --unset-upstream

# Copy branch
git branch -c old-name new-name

# Show branches and their upstreams
git branch -vv

# Sort branches by committerdate
git branch --sort=-committerdate

# List branches sorted by last commit
git for-each-ref --sort=-committerdate refs/heads/ --format='%(committerdate:short) %(refname:short)'

# Show commits by multiple authors
git log --author="John\\|Jane"

# Show commits with specific string in message
git log --grep="bug fix"

# Show commits that changed specific function
git log -L :functionName:path/to/file.js

# Show commits adding or removing specific string
git log -S"searchString"

# Show commits changing specific text (regex)
git log -G"regex pattern"

# Show commits in date range
git log --since="2 weeks ago"

# Show commits only in current branch
git log main..feature

# Show commits in either branch but not both
git log main...feature

# Show reflog for specific branch
git reflog show main

# Pretty format with colors
git log --pretty=format:"%C(yellow)%h%Creset %C(blue)%an%Creset %C(green)%ar%Creset - %s"

# Show commits since tag
git log v1.0..HEAD

# Show commits between two tags
git log v1.0..v2.0

# Count commits by author
git shortlog -sn

# Show word diff
git diff --word-diff

# Show character diff
git diff --word-diff-regex=.

# Patience algorithm (better results)
git diff --patience

# Histogram algorithm
git diff --histogram

# Highlight moved code
git diff --color-moved

# Show function context
git diff -W

# Show context lines
git diff -U10  # 10 lines of context

# Diff between working tree and commit
git diff HEAD~2

# Diff branch point
git diff $(git merge-base main feature)..feature

# Ignore specific files
git diff -- . ':!package-lock.json'

# Stash with message
git stash push -m "Work in progress on feature"

# Stash including untracked files
git stash -u

# Stash everything including ignored files
git stash -a

# Stash only specific files
git stash push -m "message" -- file1.js file2.js

# Stash and keep index (staged changes)
git stash --keep-index

# Show full diff of stash
git stash show -p stash@{0}

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

# Apply stash to different branch
git checkout other-branch
git stash apply stash@{2}

# Stash with patch mode
git stash -p

# Stash only staged changes
git stash push --staged

# Rebase with autostash
git rebase --autostash main

# Rebase with strategy
git rebase -X theirs main  # Prefer their changes
git rebase -X ours main    # Prefer our changes

# Rebase preserving merges
git rebase --rebase-merges main

# Interactive rebase with autosquash
git rebase -i --autosquash main

# Rebase onto specific commit
git rebase --onto new-base old-base branch

# Rebase and execute command after each commit
git rebase -x "npm test" main

# Rebase with committer date
git rebase --committer-date-is-author-date main

# Edit todo list during rebase
git rebase --edit-todo

# Cherry-pick range of commits
git cherry-pick abc1234..def5678

# Cherry-pick excluding start commit
git cherry-pick abc1234^..def5678

# Cherry-pick with strategy
git cherry-pick -X theirs abc1234

# Cherry-pick and sign off
git cherry-pick -s abc1234

# Cherry-pick empty commits
git cherry-pick --allow-empty abc1234

# Cherry-pick with mainline parent (for merge commits)
git cherry-pick -m 1 merge-commit

# Cherry-pick from another repository
git --git-dir=../other-repo/.git format-patch -k -1 --stdout abc1234 | git am -3 -k

# List tags matching pattern
git tag -l "v1.*"

# Create annotated tag
git tag -a v1.0.0 -m "Version 1.0.0"

# Tag with GPG signature
git tag -s v1.0.0 -m "Signed version 1.0.0"

# Verify signed tag
git tag -v v1.0.0

# Delete remote tag
git push origin :refs/tags/v1.0.0

# Push annotated tags only
git push origin --follow-tags

# Sort tags by version
git tag --sort=version:refname

# Sort tags by date
git tag --sort=-creatordate

# List tags containing commit
git tag --contains abc1234

# Get latest tag
git describe --tags --abbrev=0

# Archive specific tag
git archive --format=zip --output=v1.0.0.zip v1.0.0

# Beautiful log
git config --global alias.lg "log --graph --oneline --decorate --all"
git config --global alias.lol "log --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit"

# Contributors
git config --global alias.contributors 'shortlog -sn'
git config --global alias.who 'shortlog -sne --all'

# Undo shortcuts
git config --global alias.undo 'reset HEAD~1 --mixed'
git config --global alias.undohard 'reset HEAD~1 --hard'

# List all aliases
git config --global alias.alias '!git config --get-regexp ^alias\\. | sed -e s/^alias\\.// -e s/\\ /\\ =\\ /'

# Find who changed specific line
git blame file.txt

# Find who changed line range
git blame -L 10,20 file.txt

# Search commits for string
git log --all --grep='search term'

# Find deleted file
git log --all --full-history -- path/to/file.txt

# Restore deleted file
git checkout $(git rev-list -n 1 HEAD -- deleted-file.txt)^ -- deleted-file.txt

# Show file at specific commit
git show HEAD~3:path/to/file.txt

# Count commits
git rev-list --count HEAD

# Find common ancestor
git merge-base branch1 branch2

# Clean untracked files (dry run)
git clean -n

# Clean everything
git clean -fdx

# Assume file unchanged
git update-index --assume-unchanged file.txt

# Skip worktree (better than assume-unchanged)
git update-index --skip-worktree file.txt

# Export repository to archive
git archive --format=zip --output=project.zip HEAD

# Create bundle (portable repo)
git bundle create repo.bundle --all

# Search in all branches
git grep "search term" $(git rev-list --all)

# Delete gone remote branches
git branch -vv | grep ': gone]' | awk '{print $1}' | xargs git branch -D

# Show repository statistics
git count-objects -vH

# Verify repository integrity
git fsck

# Authentication
gh auth login
gh auth logout
gh auth status

# Repository operations
gh repo create my-new-repo
gh repo clone owner/repo
gh repo fork owner/repo
gh repo view owner/repo

# Pull Requests
gh pr create --title "Title" --body "Body"
gh pr list
gh pr view 123
gh pr checkout 123
gh pr checks
gh pr merge 123
gh pr review 123 --approve
gh pr review 123 --request-changes
gh pr close 123

# Issues
gh issue create --title "Bug" --body "Description"
gh issue list
gh issue view 123
gh issue close 123
gh issue reopen 123

# Releases
gh release create v1.0.0
gh release list
gh release view v1.0.0
gh release download v1.0.0

# Gists
gh gist create file.txt
gh gist list
gh gist view gist-id
gh gist edit gist-id

# Actions
gh workflow list
gh workflow view workflow-name
gh run list
gh run view run-id
gh run watch

# Secrets
gh secret set SECRET_NAME
gh secret list

# API calls
gh api /user
gh api repos/:owner/:repo/issues

# Press '?' on any page to see shortcuts

# Repository shortcuts:
# t - File finder
# w - Branch selector
# s - Focus search
# l - Edit labels (on issues)
# y - Freeze URL to current commit

# Line highlighting
https://github.com/user/repo/blob/main/file.js#L10
https://github.com/user/repo/blob/main/file.js#L10-L20

# Diff/Patch URLs
https://github.com/user/repo/pull/123.diff
https://github.com/user/repo/pull/123.patch

# Ignore whitespace in diff
https://github.com/user/repo/pull/123?w=1

# Adjust tab size
https://github.com/user/repo/blob/main/file.js?ts=4

# Blame view
https://github.com/user/repo/blame/main/file.js

# Undo last commit but keep changes
git reset --soft HEAD~1

# Undo last commit and discard changes
git reset --hard HEAD~1

# Recover deleted branch
git reflog
git checkout -b recovered-branch <commit-sha>

# Undo bad merge
git reset --hard HEAD~1  # If not pushed
git revert -m 1 <merge-commit>  # If pushed

# Fix wrong commit message
git commit --amend -m "Correct message"

# Remove file from all history
git filter-branch --tree-filter 'rm -f passwords.txt' HEAD

# Or use BFG (faster)
bfg --delete-files passwords.txt

# Recover lost commits
git fsck --lost-found

# Fix detached HEAD
git checkout main
git branch temp-branch <commit-sha>

# Undo git reset --hard
git reflog
git reset --hard HEAD@{1}

# Remove untracked files safely
git clean -n  # Dry run first
git clean -fd  # Then remove

# Fix "pathspec did not match"
git rm --cached <file>
git commit -m "Remove file from tracking"

# Enable garbage collection
git config --global gc.auto 4096

# Manual garbage collection
git gc --aggressive --prune=now

# Enable delta compression
git config --global core.compression 9

# Enable parallel operations
git config --global core.preloadindex true

# Use filesystem monitoring
git config --global core.fsmonitor true

# Shallow clone for faster CI
git clone --depth 1 repo-url

# Sparse checkout for large repos
git clone --filter=blob:none --sparse repo-url
git sparse-checkout set path/to/dir

# Git LFS for large files
git lfs install
git lfs track "*.psd"
git add .gitattributes

# Repack repository
git repack -a -d --depth=250 --window=250

# Node.js
node_modules/
npm-debug.log*
.env
dist/
build/

# Python
__pycache__/
*.py[cod]
venv/
.pytest_cache/

# Java
*.class
target/
*.jar
*.war

# macOS
.DS_Store
.AppleDouble

# Windows
Thumbs.db
Desktop.ini

# IDEs
.vscode/
.idea/
*.swp
*.swo

# Logs
*.log
logs/

# Secrets
*.pem
*.key
.env
secrets.yml