Complete Git expertise system for ALL git operations...
MANDATORY: Always Use Backslashes on Windows for File Paths
When using Edit or Write tools on Windows, you MUST use backslashes (\) in file paths, NOT forward slashes (/).
Examples:
D:/repos/project/file.tsxD:\repos\project\file.tsxThis applies to:
NEVER create new documentation files unless explicitly requested by the user.
Comprehensive guide for ALL Git operations from basic to advanced, including dangerous operations with safety guardrails.
Safety First - Before ANY Destructive Operation:
# ALWAYS check status first
git status
git log --oneline -10
# For risky operations, create a safety branch
git branch backup-$(date +%Y%m%d-%H%M%S)
# Remember: git reflog is your safety net (90 days default)
git reflog
User Preference Check:
This skill provides COMPLETE Git expertise for ANY Git operation, no matter how advanced, niche, or risky. It covers:
MUST use this skill for:
CRITICAL: Before ANY destructive operation (reset --hard, force push, filter-repo, etc.):
# Example safety pattern for dangerous operations
echo "⚠️ WARNING: This operation is DESTRUCTIVE and will:"
echo " - Permanently delete uncommitted changes"
echo " - Rewrite Git history"
echo " - [specific risks for the operation]"
echo ""
echo "Safety recommendation: Creating backup branch first..."
git branch backup-before-reset-$(date +%Y%m%d-%H%M%S)
echo ""
echo "To recover if needed: git reset --hard backup-before-reset-XXXXXXXX"
echo ""
read -p "Are you SURE you want to proceed? (yes/NO): " confirm
if [[ "$confirm" != "yes" ]]; then
echo "Operation cancelled."
exit 1
fi
ALWAYS ASK at the start of ANY Git task: "Would you like me to:
Respect this choice throughout the session.
Git behavior and workflows differ across platforms and hosting providers:
Windows (Git Bash/PowerShell):
Linux/macOS:
Hosting Platforms:
# Initialize new repository
git init
git init --initial-branch=main # Specify default branch name
# Clone repository
git clone <url>
git clone <url> <directory>
git clone --depth 1 <url> # Shallow clone (faster, less history)
git clone --branch <branch> <url> # Clone specific branch
git clone --recurse-submodules <url> # Include submodules
# User identity (required for commits)
git config --global user.name "Your Name"
git config --global user.email "your.email@example.com"
# Default branch name
git config --global init.defaultBranch main
# Line ending handling (Windows)
git config --global core.autocrlf true # Windows
git config --global core.autocrlf input # macOS/Linux
# Editor
git config --global core.editor "code --wait" # VS Code
git config --global core.editor "vim"
# Diff tool
git config --global diff.tool vscode
git config --global difftool.vscode.cmd 'code --wait --diff $LOCAL $REMOTE'
# Merge tool
git config --global merge.tool vscode
git config --global mergetool.vscode.cmd 'code --wait $MERGED'
# 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 'reset HEAD --'
git config --global alias.last 'log -1 HEAD'
git config --global alias.visual '!gitk'
# View configuration
git config --list
git config --global --list
git config --local --list
git config user.name # Get specific value
# Check status
git status
git status -s # Short format
git status -sb # Short with branch info
# Add files
git add <file>
git add . # Add all changes in current directory
git add -A # Add all changes in repository
git add -p # Interactive staging (patch mode)
# Remove files
git rm <file>
git rm --cached <file> # Remove from index, keep in working directory
git rm -r <directory>
# Move/rename files
git mv <old> <new>
# Commit
git commit -m "message"
git commit -am "message" # Add and commit tracked files
git commit --amend # Amend last commit
git commit --amend --no-edit # Amend without changing message
git commit --allow-empty -m "message" # Empty commit (useful for triggers)
# View history
git log
git log --oneline
git log --graph --oneline --all --decorate
git log --stat # Show file statistics
git log --patch # Show diffs
git log -p -2 # Show last 2 commits with diffs
git log --since="2 weeks ago"
git log --until="2025-01-01"
git log --author="Name"
git log --grep="pattern"
git log -- <file> # History of specific file
git log --follow <file> # Follow renames
# Show changes
git diff # Unstaged changes
git diff --staged # Staged changes
git diff HEAD # All changes since last commit
git diff <branch> # Compare with another branch
git diff <commit1> <commit2>
git diff <commit> # Changes since specific commit
git diff <branch1>...<branch2> # Changes between branches
# Show commit details
git show <commit>
git show <commit>:<file> # Show file at specific commit
# List branches
git branch # Local branches
git branch -r # Remote branches
git branch -a # All branches
git branch -v # With last commit info
git branch -vv # With tracking info
# Create branch
git branch <branch-name>
git branch <branch-name> <start-point> # From specific commit/tag
# Switch branch
git switch <branch-name>
git checkout <branch-name> # Old syntax, still works
# Create and switch
git switch -c <branch-name>
git checkout -b <branch-name>
git switch -c <branch-name> <start-point>
# Delete branch
git branch -d <branch-name> # Safe delete (only if merged)
git branch -D <branch-name> # Force delete (even if not merged)
# Rename branch
git branch -m <old-name> <new-name>
git branch -m <new-name> # Rename current branch
# Set upstream tracking
git branch --set-upstream-to=origin/<branch>
git branch -u origin/<branch>
Git Flow:
main/master: Production-ready codedevelop: Integration branch for featuresfeature/*: New featuresrelease/*: Release preparationhotfix/*: Production fixesGitHub Flow:
main: Always deployablefeature/*: Short-lived feature branchesTrunk-Based Development:
main: Single branchGitLab Flow:
production, staging, mainmain# Fast-forward merge (default if possible)
git merge <branch>
# Force merge commit (even if fast-forward possible)
git merge --no-ff <branch>
# Squash merge (combine all commits into one)
git merge --squash <branch>
# Then commit manually: git commit -m "Merged feature X"
# Merge with specific strategy
git merge -s recursive <branch> # Default strategy
git merge -s ours <branch> # Always use "our" version
git merge -s theirs <branch> # Always use "their" version (requires merge-theirs)
git merge -s octopus <branch1> <branch2> <branch3> # Merge multiple branches
# Merge with strategy options
git merge -X ours <branch> # Prefer "our" changes in conflicts
git merge -X theirs <branch> # Prefer "their" changes in conflicts
git merge -X ignore-all-space <branch>
git merge -X ignore-space-change <branch>
# Abort merge
git merge --abort
# Continue after resolving conflicts
git merge --continue
# When merge conflicts occur
git status # See conflicted files
# Conflict markers in files:
# <<<<<<< HEAD
# Your changes
# =======
# Their changes
# >>>>>>> branch-name
# Resolve conflicts manually, then:
git add <resolved-file>
git commit # Complete the merge
# Use mergetool
git mergetool
# Accept one side completely
git checkout --ours <file> # Keep our version
git checkout --theirs <file> # Keep their version
git add <file>
# View conflict diff
git diff # Show conflicts
git diff --ours # Compare with our version
git diff --theirs # Compare with their version
git diff --base # Compare with base version
# List conflicts
git diff --name-only --diff-filter=U
⚠️ WARNING: Rebase rewrites history. Never rebase commits that have been pushed to shared branches!
# Basic rebase
git rebase <base-branch>
git rebase origin/main
# Interactive rebase (POWERFUL)
git rebase -i <base-commit>
git rebase -i HEAD~5 # Last 5 commits
# Interactive rebase commands:
# p, pick = use commit
# r, reword = use commit, but edit message
# e, edit = use commit, but stop for amending
# s, squash = use commit, but meld into previous commit
# f, fixup = like squash, but discard commit message
# x, exec = run command (rest of line) using shell
# b, break = stop here (continue rebase later with 'git rebase --continue')
# d, drop = remove commit
# l, label = label current HEAD with a name
# t, reset = reset HEAD to a label
# Rebase onto different base
git rebase --onto <new-base> <old-base> <branch>
# Continue after resolving conflicts
git rebase --continue
# Skip current commit
git rebase --skip
# Abort rebase
git rebase --abort
# Preserve merge commits
git rebase --preserve-merges <base> # Deprecated
git rebase --rebase-merges <base> # Modern approach
# Autosquash (with fixup commits)
git commit --fixup <commit>
git rebase -i --autosquash <base>
# Apply specific commit to current branch
git cherry-pick <commit>
# Cherry-pick multiple commits
git cherry-pick <commit1> <commit2>
git cherry-pick <commit1>..<commit5>
# Cherry-pick without committing
git cherry-pick -n <commit>
git cherry-pick --no-commit <commit>
# Continue after resolving conflicts
git cherry-pick --continue
# Abort cherry-pick
git cherry-pick --abort
# List remotes
git remote
git remote -v # With URLs
# Add remote
git remote add <name> <url>
git remote add origin https://github.com/user/repo.git
# Change remote URL
git remote set-url <name> <new-url>
# Remove remote
git remote remove <name>
git remote rm <name>
# Rename remote
git remote rename <old> <new>
# Show remote info
git remote show <name>
git remote show origin
# Prune stale remote branches
git remote prune origin
git fetch --prune
# Fetch from remote (doesn't merge)
git fetch
git fetch origin
git fetch --all # All remotes
git fetch --prune # Remove stale remote-tracking branches
# Pull (fetch + merge)
git pull
git pull origin <branch>
git pull --rebase # Fetch + rebase instead of merge
git pull --no-ff # Always create merge commit
git pull --ff-only # Only if fast-forward possible
# Set default pull behavior
git config --global pull.rebase true # Always rebase
git config --global pull.ff only # Only fast-forward
# Push to remote
git push
git push origin <branch>
git push origin <local-branch>:<remote-branch>
# Push new branch and set upstream
git push -u origin <branch>
git push --set-upstream origin <branch>
# Push all branches
git push --all
# Push tags
git push --tags
git push origin <tag-name>
# Delete remote branch
git push origin --delete <branch>
git push origin :<branch> # Old syntax
# Delete remote tag
git push origin --delete <tag>
git push origin :refs/tags/<tag>
# ⚠️ DANGEROUS: Force push (overwrites remote history)
# ALWAYS ASK USER FOR CONFIRMATION FIRST
git push --force
git push -f
# ⚠️ SAFER: Force push with lease (fails if remote updated)
git push --force-with-lease
git push --force-with-lease=<ref>:<expected-value>
Force Push Safety Protocol:
Before ANY force push, execute this safety check:
echo "⚠️ DANGER: Force push will overwrite remote history!"
echo ""
echo "Remote branch status:"
git fetch origin
git log --oneline origin/<branch> ^<branch> --decorate
if [ -z "$(git log --oneline origin/<branch> ^<branch>)" ]; then
echo "✓ No commits will be lost (remote is behind local)"
else
echo "❌ WARNING: Remote has commits that will be LOST:"
git log --oneline --decorate origin/<branch> ^<branch>
echo ""
echo "These commits from other developers will be destroyed!"
fi
echo ""
echo "Consider using --force-with-lease instead of --force"
echo ""
read -p "Type 'force push' to confirm: " confirm
if [[ "$confirm" != "force push" ]]; then
echo "Cancelled."
exit 1
fi
# Stash changes
git stash
git stash save "message"
git stash push -m "message"
# Stash including untracked files
git stash -u
git stash --include-untracked
# Stash including ignored files
git stash -a
git stash --all
# List stashes
git stash list
# Show stash contents
git stash show
git stash show -p # With diff
git stash show stash@{2}
# Apply stash (keep in stash list)
git stash apply
git stash apply stash@{2}
# Pop stash (apply and remove)
git stash pop
git stash pop stash@{2}
# Drop stash
git stash drop
git stash drop stash@{2}
# Clear all stashes
git stash clear
# Create branch from stash
git stash branch <branch-name>
git stash branch <branch-name> stash@{1}
# Git 2.51+ : Import/Export stashes (share stashes between machines)
# Export stash to a file
git stash store --file=stash.patch stash@{0}
# Import stash from a file
git stash import --file=stash.patch
# Share stashes like branches/tags
git stash export > my-stash.patch
git stash import < my-stash.patch
⚠️ WARNING: reset can permanently delete changes!
# Soft reset (keep changes staged)
git reset --soft <commit>
git reset --soft HEAD~1 # Undo last commit, keep changes staged
# Mixed reset (default - keep changes unstaged)
git reset <commit>
git reset HEAD~1 # Undo last commit, keep changes unstaged
# ⚠️ HARD reset (DELETE all changes - DANGEROUS!)
# ALWAYS create backup branch first!
git branch backup-$(date +%Y%m%d-%H%M%S)
git reset --hard <commit>
git reset --hard HEAD~1 # Undo last commit and DELETE all changes
git reset --hard origin/<branch> # Reset to remote state
# Unstage files
git reset HEAD <file>
git reset -- <file>
# Reset specific file to commit
git checkout <commit> -- <file>
# Revert commit (creates new commit that undoes changes)
# Safer than reset for shared branches
git revert <commit>
# Revert without creating commit
git revert -n <commit>
git revert --no-commit <commit>
# Revert merge commit
git revert -m 1 <merge-commit> # Keep first parent
git revert -m 2 <merge-commit> # Keep second parent
# Revert multiple commits
git revert <commit1> <commit2>
git revert <commit1>..<commit5>
# Continue after resolving conflicts
git revert --continue
# Abort revert
git revert --abort
reflog is your safety net - it tracks all HEAD movements for 90 days (default)
# View reflog
git reflog
git reflog show
git reflog show <branch>
# More detailed reflog
git log -g # Reflog as log
git log -g --all
# Find lost commits
git reflog --all
git fsck --lost-found
# Recover deleted branch
git reflog # Find commit where branch existed
git branch <branch-name> <commit-hash>
# Recover from hard reset
git reflog # Find commit before reset
git reset --hard <commit-hash>
# Recover deleted commits
git cherry-pick <commit-hash>
# Reflog expiration (change retention)
git config gc.reflogExpire "90 days"
git config gc.reflogExpireUnreachable "30 days"
# Start bisect
git bisect start
# Mark current commit as bad
git bisect bad
# Mark known good commit
git bisect good <commit>
# Test each commit, then mark as good or bad
git bisect good # Current commit is good
git bisect bad # Current commit is bad
# Automate with test script
git bisect run <test-script>
# Bisect shows the first bad commit
# Finish bisect
git bisect reset
# Skip commit if unable to test
git bisect skip
⚠️ WARNING: clean permanently deletes untracked files!
# Show what would be deleted (dry run - ALWAYS do this first!)
git clean -n
git clean --dry-run
# Delete untracked files
git clean -f
# Delete untracked files and directories
git clean -fd
# Delete untracked and ignored files
git clean -fdx
# Interactive clean
git clean -i
# List worktrees
git worktree list
# Add new worktree
git worktree add <path> <branch>
git worktree add ../project-feature feature-branch
# Add worktree for new branch
git worktree add -b <new-branch> <path>
# Remove worktree
git worktree remove <path>
# Prune stale worktrees
git worktree prune
# Add submodule
git submodule add <url> <path>
# Initialize submodules (after clone)
git submodule init
git submodule update
# Clone with submodules
git clone --recurse-submodules <url>
# Update submodules
git submodule update --remote
git submodule update --init --recursive
# Execute command in all submodules
git submodule foreach <command>
git submodule foreach git pull origin main
# Remove submodule
git submodule deinit <path>
git rm <path>
rm -rf .git/modules/<path>
⚠️ EXTREMELY DANGEROUS: Rewrites entire repository history!
# Install git-filter-repo (not built-in)
# pip install git-filter-repo
# Remove file from all history
git filter-repo --path <file> --invert-paths
# Remove directory from all history
git filter-repo --path <directory> --invert-paths
# Change author info
git filter-repo --name-callback 'return name.replace(b"Old Name", b"New Name")'
git filter-repo --email-callback 'return email.replace(b"old@email.com", b"new@email.com")'
# Remove large files
git filter-repo --strip-blobs-bigger-than 10M
# ⚠️ After filter-repo, force push required
git push --force --all
git push --force --tags
Safety protocol for filter-repo:
echo "⚠️⚠️⚠️ EXTREME DANGER ⚠️⚠️⚠️"
echo "This operation will:"
echo " - Rewrite ENTIRE repository history"
echo " - Change ALL commit hashes"
echo " - Break all existing clones"
echo " - Require all team members to re-clone"
echo " - Cannot be undone after force push"
echo ""
echo "MANDATORY: Create full backup:"
git clone --mirror <repo-url> backup-$(date +%Y%m%d-%H%M%S)
echo ""
echo "Notify ALL team members before proceeding!"
echo ""
read -p "Type 'I UNDERSTAND THE RISKS' to continue: " confirm
if [[ "$confirm" != "I UNDERSTAND THE RISKS" ]]; then
echo "Cancelled."
exit 1
fi
⚠️ DANGER: Changing pushed commits requires force push!
# Amend last commit
git commit --amend
# Amend without changing message
git commit --amend --no-edit
# Change author of last commit
git commit --amend --author="Name <email>"
# ⚠️ Force push required if already pushed
git push --force-with-lease
⚠️ DANGER: Interactive rebase on pushed commits!
# Interactive rebase
git rebase -i HEAD~5
# Change author of older commits
git rebase -i <commit>^
# Mark commit as "edit"
# When stopped:
git commit --amend --author="Name <email>" --no-edit
git rebase --continue
# ⚠️ Force push required
git push --force-with-lease
Pull Requests:
# Install GitHub CLI
# https://cli.github.com/
# Create PR
gh pr create
gh pr create --title "Title" --body "Description"
gh pr create --base main --head feature-branch
# List PRs
gh pr list
# View PR
gh pr view
gh pr view <number>
# Check out PR locally
gh pr checkout <number>
# Review PR
gh pr review
gh pr review --approve
gh pr review --request-changes
gh pr review --comment
# Merge PR
gh pr merge
gh pr merge --squash
gh pr merge --rebase
gh pr merge --merge
# Close PR
gh pr close <number>
GitHub Actions:
# .github/workflows/ci.yml
name: CI
on: [push, pull_request]
jobs:
test:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Run tests
run: npm test
Pull Requests:
# Install Azure DevOps CLI
# https://docs.microsoft.com/en-us/cli/azure/install-azure-cli
# Create PR
az repos pr create --title "Title" --description "Description"
az repos pr create --source-branch feature --target-branch main
# List PRs
az repos pr list
# View PR
az repos pr show --id <id>
# Complete PR
az repos pr update --id <id> --status completed
# Branch policies
az repos policy list
az repos policy create --config policy.json
Azure Pipelines:
# azure-pipelines.yml
trigger:
- main
pool:
vmImage: 'ubuntu-latest'
steps:
- script: npm test
displayName: 'Run tests'
Pull Requests:
# Create PR (via web or Bitbucket CLI)
bb pr create
# Review PR
bb pr list
bb pr view <id>
# Merge PR
bb pr merge <id>
Bitbucket Pipelines:
# bitbucket-pipelines.yml
pipelines:
default:
- step:
script:
- npm test
Merge Requests:
# Install GitLab CLI (glab)
# https://gitlab.com/gitlab-org/cli
# Create MR
glab mr create
glab mr create --title "Title" --description "Description"
# List MRs
glab mr list
# View MR
glab mr view <id>
# Merge MR
glab mr merge <id>
# Close MR
glab mr close <id>
GitLab CI:
# .gitlab-ci.yml
stages:
- test
test:
stage: test
script:
- npm test
# Garbage collection
git gc
git gc --aggressive # More thorough, slower
# Prune unreachable objects
git prune
# Verify repository
git fsck
git fsck --full
# Optimize repository
git repack -a -d --depth=250 --window=250
# Git 2.51+: Path-walk repacking (generates smaller packs)
# More efficient delta compression by walking paths
git repack --path-walk -a -d
# Count objects
git count-objects -v
# Repository size
du -sh .git
# Find large files in history
git rev-list --objects --all |
git cat-file --batch-check='%(objecttype) %(objectname) %(objectsize) %(rest)' |
sed -n 's/^blob //p' |
sort --numeric-sort --key=2 |
tail -n 10
# Git LFS (Large File Storage)
git lfs install
git lfs track "*.psd"
git lfs track "*.zip"
git add .gitattributes
git add file.psd
git commit -m "Add large file"
# List LFS files
git lfs ls-files
# Fetch LFS files
git lfs fetch
git lfs pull
# Shallow clone (faster, less disk space)
git clone --depth 1 <url>
# Unshallow (convert to full clone)
git fetch --unshallow
# Fetch more history
git fetch --depth=100
# Lightweight tag
git tag <tag-name>
git tag v1.0.0
# Annotated tag (recommended - includes metadata)
git tag -a <tag-name> -m "message"
git tag -a v1.0.0 -m "Release version 1.0.0"
# Tag specific commit
git tag -a <tag-name> <commit>
# Signed tag (GPG signature)
git tag -s <tag-name> -m "message"
# List tags
git tag
git tag -l "v1.*" # Pattern matching
# Show tag info
git show <tag-name>
# Delete local tag
git tag -d <tag-name>
# Delete remote tag
git push origin --delete <tag-name>
git push origin :refs/tags/<tag-name>
# Push tags
git push origin <tag-name>
git push --tags # All tags
git push --follow-tags # Only annotated tags
# Hooks location: .git/hooks/
# pre-commit: Run before commit
# Example: .git/hooks/pre-commit
#!/bin/bash
npm run lint || exit 1
# prepare-commit-msg: Edit commit message before editor opens
# commit-msg: Validate commit message
#!/bin/bash
msg=$(cat "$1")
if ! echo "$msg" | grep -qE "^(feat|fix|docs|style|refactor|test|chore):"; then
echo "Error: Commit message must start with type (feat|fix|docs|...):"
exit 1
fi
# post-commit: Run after commit
# pre-push: Run before push
# post-checkout: Run after checkout
# post-merge: Run after merge
# Make hook executable
chmod +x .git/hooks/pre-commit
# pre-receive: Run before refs are updated
# update: Run for each branch being updated
# post-receive: Run after refs are updated
# Example: Reject force pushes
#!/bin/bash
while read oldrev newrev refname; do
if [ "$oldrev" != "0000000000000000000000000000000000000000" ]; then
if ! git merge-base --is-ancestor "$oldrev" "$newrev"; then
echo "Error: Force push rejected"
exit 1
fi
fi
done
Detached HEAD:
# You're in detached HEAD state
git branch temp # Create branch at current commit
git switch main
git merge temp
git branch -d temp
Merge conflicts:
# During merge/rebase
git status # See conflicted files
# Edit files to resolve conflicts
git add <resolved-files>
git merge --continue # or git rebase --continue
# Abort and start over
git merge --abort
git rebase --abort
Accidentally deleted branch:
# Find branch in reflog
git reflog
# Create branch at commit
git branch <branch-name> <commit-hash>
Committed to wrong branch:
# Move commit to correct branch
git switch correct-branch
git cherry-pick <commit>
git switch wrong-branch
git reset --hard HEAD~1 # Remove from wrong branch
Pushed sensitive data:
# ⚠️ URGENT: Remove from history immediately
git filter-repo --path <sensitive-file> --invert-paths
git push --force --all
# Then: Rotate compromised credentials immediately!
Large commit by mistake:
# Before pushing
git reset --soft HEAD~1
git reset HEAD <large-file>
git commit -m "message"
# After pushing - use filter-repo or BFG
Recover after hard reset:
git reflog
git reset --hard <commit-before-reset>
Recover deleted file:
git log --all --full-history -- <file>
git checkout <commit>^ -- <file>
Recover deleted commits:
git reflog # Find commit hash
git cherry-pick <commit>
# or
git merge <commit>
# or
git reset --hard <commit>
Recover from corrupted repository:
# Verify corruption
git fsck --full
# Attempt repair
git gc --aggressive
# Last resort: clone from remote
Conventional Commits format:
<type>(<scope>): <subject>
<body>
<footer>
Types:
feat: New featurefix: Bug fixdocs: Documentationstyle: Formatting (no code change)refactor: Code restructuringtest: Adding testschore: MaintenanceExample:
feat(auth): add OAuth2 authentication
Implement OAuth2 flow for Google and GitHub providers.
Includes token refresh and revocation.
Closes #123
feature/user-auth, fix/header-crashgit diff --staged).gitignore, environment variables)# Environment files
.env
.env.local
*.env
# Dependencies
node_modules/
vendor/
venv/
# Build outputs
dist/
build/
*.exe
*.dll
*.so
# IDE
.vscode/
.idea/
*.swp
*.swo
# OS files
.DS_Store
Thumbs.db
# Logs
*.log
logs/
# Temporary files
tmp/
temp/
*.tmp
# Store credentials (cache for 1 hour)
git config --global credential.helper cache
git config --global credential.helper 'cache --timeout=3600'
# Store credentials (permanent - use with caution)
git config --global credential.helper store
# Windows: Use Credential Manager
git config --global credential.helper wincred
# macOS: Use Keychain
git config --global credential.helper osxkeychain
# Linux: Use libsecret
git config --global credential.helper /usr/share/doc/git/contrib/credential/libsecret/git-credential-libsecret
# Generate SSH key
ssh-keygen -t ed25519 -C "your_email@example.com"
ssh-keygen -t rsa -b 4096 -C "your_email@example.com" # If ed25519 not supported
# Start ssh-agent
eval "$(ssh-agent -s)"
# Add key to ssh-agent
ssh-add ~/.ssh/id_ed25519
# Test connection
ssh -T git@github.com
ssh -T git@ssh.dev.azure.com
# Generate GPG key
gpg --full-generate-key
# List keys
gpg --list-secret-keys --keyid-format LONG
# Configure Git to sign commits
git config --global user.signingkey <key-id>
git config --global commit.gpgsign true
# Sign commits
git commit -S -m "message"
# Verify signatures
git log --show-signature
# Git-secrets (AWS tool)
git secrets --install
git secrets --register-aws
# Gitleaks
gitleaks detect
# Pre-commit hook
#!/bin/bash
if git diff --cached | grep -E "(password|secret|api_key)" ; then
echo "Potential secret detected!"
exit 1
fi
# Windows (CRLF in working directory, LF in repository)
git config --global core.autocrlf true
# macOS/Linux (LF everywhere)
git config --global core.autocrlf input
# No conversion (not recommended)
git config --global core.autocrlf false
# Use .gitattributes for consistency
# .gitattributes:
* text=auto
*.sh text eol=lf
*.bat text eol=crlf
# macOS/Windows: Case-insensitive filesystems
# Linux: Case-sensitive filesystem
# Enable case sensitivity in Git
git config --global core.ignorecase false
# Rename file (case-only change)
git mv --force myfile.txt MyFile.txt
# Git always uses forward slashes internally
# Works on all platforms:
git add src/components/Header.jsx
# Windows-specific tools may need backslashes in some contexts
CRITICAL: Git Bash is the primary Git environment on Windows!
Git Bash (MINGW/MSYS2) automatically converts Unix-style paths to Windows paths for native executables, which can cause issues with Git operations.
Path Conversion Behavior:
# Automatic conversions that occur:
/foo → C:/Program Files/Git/usr/foo
/foo:/bar → C:\msys64\foo;C:\msys64\bar
--dir=/foo → --dir=C:/msys64/foo
# What triggers conversion:
# ✓ Leading forward slash (/) in arguments
# ✓ Colon-separated path lists
# ✓ Arguments after - or , with path components
# What's exempt from conversion:
# ✓ Arguments containing = (variable assignments)
# ✓ Drive specifiers (C:)
# ✓ Arguments with ; (already Windows format)
# ✓ Arguments starting with // (Windows switches)
Controlling Path Conversion:
# Method 1: MSYS_NO_PATHCONV (Git for Windows only)
# Disable ALL path conversion for a command
MSYS_NO_PATHCONV=1 git command --option=/path
# Permanently disable (use with caution - can break scripts)
export MSYS_NO_PATHCONV=1
# Method 2: MSYS2_ARG_CONV_EXCL (MSYS2)
# Exclude specific argument patterns
export MSYS2_ARG_CONV_EXCL="*" # Exclude everything
export MSYS2_ARG_CONV_EXCL="--dir=;/test" # Specific prefixes
# Method 3: Manual conversion with cygpath
cygpath -u "C:\path" # → Unix format: /c/path
cygpath -w "/c/path" # → Windows format: C:\path
cygpath -m "/c/path" # → Mixed format: C:/path
# Method 4: Workarounds
# Use double slashes: //e //s instead of /e /s
# Use dash notation: -e -s instead of /e /s
# Quote paths with spaces: "/c/Program Files/file.txt"
Shell Detection in Git Workflows:
# Method 1: $MSYSTEM (Most Reliable for Git Bash)
case "$MSYSTEM" in
MINGW64) echo "Git Bash 64-bit" ;;
MINGW32) echo "Git Bash 32-bit" ;;
MSYS) echo "MSYS environment" ;;
esac
# Method 2: uname -s (Portable)
case "$(uname -s)" in
MINGW64_NT*) echo "Git Bash 64-bit" ;;
MINGW32_NT*) echo "Git Bash 32-bit" ;;
MSYS_NT*) echo "MSYS" ;;
CYGWIN*) echo "Cygwin" ;;
Darwin*) echo "macOS" ;;
Linux*) echo "Linux" ;;
esac
# Method 3: $OSTYPE (Bash-only, fast)
case "$OSTYPE" in
msys*) echo "Git Bash/MSYS" ;;
cygwin*) echo "Cygwin" ;;
darwin*) echo "macOS" ;;
linux-gnu*) echo "Linux" ;;
esac
Git Bash Path Issues & Solutions:
# Issue: Git commands with paths fail in Git Bash
# Example: git log --follow /path/to/file fails
# Solution 1: Use relative paths
git log --follow ./path/to/file
# Solution 2: Disable path conversion
MSYS_NO_PATHCONV=1 git log --follow /path/to/file
# Solution 3: Use Windows-style paths
git log --follow C:/path/to/file
# Issue: Spaces in paths (Program Files)
# Solution: Always quote paths
git add "/c/Program Files/project/file.txt"
# Issue: Drive letter duplication (D:\dev → D:\d\dev)
# Solution: Use cygpath for conversion
file=$(cygpath -u "D:\dev\file.txt")
git add "$file"
Git Bash Best Practices:
A Git workflow using this skill should:
Quick recovery commands:
# Undo last commit (keep changes)
git reset --soft HEAD~1
# Undo changes to file
git checkout -- <file>
# Recover deleted branch
git reflog
git branch <name> <commit>
# Undo force push (if recent)
git reflog
git reset --hard <commit-before-push>
git push --force-with-lease
# Recover from hard reset
git reflog
git reset --hard <commit-before-reset>
# Find lost commits
git fsck --lost-found
git reflog --all
# Recover deleted file
git log --all --full-history -- <file>
git checkout <commit>^ -- <file>
Always activate for:
Key indicators:
This skill provides COMPLETE Git expertise. Combined with the reference files and safety guardrails, you have the knowledge to handle ANY Git operation safely and effectively.
