Git Interview Questions with Answers

# Git Basics
# Initialize a new repository
git init

# Check repository status
git status

# Add files to staging area
git add file.txt
git add .  # Add all files

# Commit changes
git commit -m "Initial commit"

# View commit history
git log
git log --oneline --graph --decorate

# Git Configuration
# Set global username and email
git config --global user.name "Your Name"
git config --global user.email "your.email@example.com"

# Set editor
git config --global core.editor "code --wait"

# View all configurations
git config --list

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

# Set alias
git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.st status

# Git Branching
# Create a new branch
git branch feature-branch

# Switch to a branch
git checkout feature-branch
git switch feature-branch

# Create and switch in one command
git checkout -b new-feature
git switch -c new-feature

# List all branches
git branch
git branch -a  # List all including remote

# Delete a branch
git branch -d feature-branch  # Safely delete
git branch -D feature-branch  # Force delete

# Git Merging
# Merge a branch into current branch
git merge feature-branch

# Merge with no fast-forward
git merge --no-ff feature-branch

# Abort a merge
git merge --abort

# View merge conflicts
git status
git diff

# Resolve conflicts manually
# Edit files to resolve conflicts
git add <resolved-files>
git commit -m "Merge resolved"

# Merge strategy options
git merge -s recursive -X theirs feature-branch
git merge -s recursive -X ours feature-branch

# Git Rebasing
# Rebase current branch onto another branch
git rebase main

# Interactive rebase
git rebase -i HEAD~5

# Rebase with merge conflicts
git rebase --continue  # After resolving conflicts
git rebase --skip      # Skip conflicting commit
git rebase --abort     # Abort rebase

# Rebase against specific commit
git rebase --onto main feature-branch

# Rebase preserve merges
git rebase -p main

# Git Stashing
# Save uncommitted changes
git stash
git stash push -m "WIP: feature implementation"

# List all stashes
git stash list

# Apply stash (keep stash)
git stash apply
git stash apply stash@{1}

# Apply stash and drop it
git stash pop
git stash pop stash@{1}

# Show stash contents
git stash show -p stash@{0}

# Drop a stash
git stash drop stash@{0}

# Clear all stashes
git stash clear

# Git Remotes
# Add a remote repository
git remote add origin https://github.com/user/repo.git

# View remote repositories
git remote -v

# Remove a remote
git remote remove origin

# Rename a remote
git remote rename origin upstream

# Fetch from remote
git fetch origin
git fetch --all

# Pull from remote
git pull origin main
git pull --rebase origin main

# Push to remote
git push origin main
git push -u origin main

# Git Reset and Revert
# Soft reset (keep changes staged)
git reset --soft HEAD~1

# Mixed reset (keep changes unstaged)
git reset --mixed HEAD~1
git reset HEAD~1

# Hard reset (discard changes)
git reset --hard HEAD~1

# Revert a commit
git revert HEAD
git revert <commit-hash>

# Revert multiple commits
git revert HEAD~3..HEAD

# Unstage a file
git reset HEAD file.txt

# Git Cherry-Pick
# Cherry-pick a commit
git cherry-pick <commit-hash>

# Cherry-pick multiple commits
git cherry-pick <hash1> <hash2> <hash3>

# Cherry-pick range
git cherry-pick <start-hash>..<end-hash>

# Cherry-pick with edit
git cherry-pick -e <commit-hash>

# Cherry-pick with no commit
git cherry-pick -n <commit-hash>

# Abort cherry-pick
git cherry-pick --abort

# Continue cherry-pick after resolving conflicts
git cherry-pick --continue

# Git Log and History
# View commit history
git log
git log --oneline
git log --graph
git log --oneline --graph --decorate

# View log with diff
git log -p
git log -p -2

# Search commits
git log --grep="fix"
git log -S"function_name"

# View commits by author
git log --author="John"

# View commit range
git log HEAD~5..HEAD
git log main..feature

# View commit statistics
git log --stat
git log --shortstat

# Git Diff
# Show unstaged changes
git diff

# Show staged changes
git diff --staged
git diff --cached

# Compare branches
git diff main..feature
git diff main...feature  # Compare common ancestor

# Compare commits
git diff <commit1> <commit2>

# Show changed files only
git diff --name-only
git diff --name-status

# Use external diff tool
git difftool

# Ignore whitespace
git diff -w

# Git Tag
# Create a tag
git tag v1.0.0
git tag -a v1.0.0 -m "Release version 1.0.0"

# Create annotated tag
git tag -a v1.0.0 -m "First release"

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

# Push tags to remote
git push origin v1.0.0
git push --tags

# Delete a tag
git tag -d v1.0.0
git push origin --delete v1.0.0

# Checkout a tag
git checkout v1.0.0

# Git Submodule
# Add a submodule
git submodule add https://github.com/user/repo.git

# Initialize submodules
git submodule init

# Update submodules
git submodule update
git submodule update --remote

# Clone with submodules
git clone --recursive https://github.com/user/repo.git

# View submodule status
git submodule status

# Remove a submodule
git submodule deinit -f <path>
git rm -f <path>

# Git Worktree
# Create a new worktree
git worktree add ../project-feature feature-branch

# Create worktree for new branch
git worktree add -b new-feature ../project-feature main

# List worktrees
git worktree list

# Move worktree
git worktree move ../project-feature ../project-feature-new

# Prune worktrees
git worktree prune

# Remove worktree
git worktree remove ../project-feature

# Git Hooks
# List all hooks
ls .git/hooks/

# Create a pre-commit hook
# .git/hooks/pre-commit
#!/bin/sh
echo "Running pre-commit hook"
# Add validation script

# Create a commit-msg hook
# .git/hooks/commit-msg
#!/bin/sh
# Validate commit message format

# Create a post-commit hook
# .git/hooks/post-commit
#!/bin/sh
# Run after commit

# Make hooks executable
chmod +x .git/hooks/*

# Skip hooks
git commit --no-verify

# Git Bisect
# Start bisect
git bisect start

# Mark current commit as bad
git bisect bad

# Mark known good commit
git bisect good <commit-hash>

# Test and mark commits
git bisect good  # If commit is good
git bisect bad   # If commit is bad

# End bisect
git bisect reset

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

# View bisect log
git bisect log

# Git Blame
# View who changed each line
git blame file.txt

# Show commit details
git blame -c file.txt

# Show line numbers
git blame -L 10,20 file.txt

# Show authors only
git blame -s file.txt

# Show previous commits
git blame file.txt -w  # Ignore whitespace

# View blame for specific commit
git blame <commit-hash> file.txt

# Git Reflog
# View reflog
git reflog

# Show reflog for specific branch
git reflog show main

# Recover lost commit
git reflog
# Find the commit hash
git checkout <commit-hash>

# Create branch from lost commit
git branch recovered-branch <commit-hash>

# Delete reflog entries
git reflog expire --expire=now --all

# Show reflog with dates
git reflog --date=iso

# Git Clean
# Show files to clean
git clean -n
git clean --dry-run

# Remove untracked files
git clean -f
git clean -fd  # Remove directories

# Interactive clean
git clean -i

# Exclude patterns
git clean -f -e "*.log"

# Clean ignored files only
git clean -f -X

# Clean all (including ignored)
git clean -f -x

# Git Archive
# Create a tar archive
git archive --format=tar --output=project.tar main

# Create a zip archive
git archive --format=zip --output=project.zip main

# Archive specific commit
git archive --format=tar --output=project.tar <commit-hash>

# Archive with prefix
git archive --format=tar --prefix=project/ main > project.tar

# Archive specific directory
git archive --format=tar --output=project.tar main:src/

// Git Patches - Working with diffs and patches
package main

import (
    "fmt"
)

func main() {
    // Git patch commands demonstration
    commands := []string{
        "git format-patch -1 <commit>  # Create a patch from a commit",
        "git apply patch.diff          # Apply a patch without committing",
        "git am patch.diff             # Apply a patch with commit",
        "git diff > patch.diff         # Generate a patch from working directory",
    }
    
    // Patch workflow simulation
    fmt.Println("=== Git Patch Workflow ===")
    for i, cmd := range commands {
        fmt.Printf("%d. %s\n", i+1, cmd)
    }
    
    // Create a simple patch-like diff
    fmt.Println("\n=== Example Patch Format ===")
    patch := `diff --git a/file.txt b/file.txt
index 1234567..abcdefg 100644
--- a/file.txt
+++ b/file.txt
@@ -1,3 +1,4 @@
 Hello World
-This is the old content
+This is the new content
+Added another line
---
2.0.1`
    fmt.Println(patch)
}

# Git Interactive Add
# Interactive staging
git add -i
git add --interactive

# Add patches interactively
git add -p
git add --patch

# Interactive rebase
git rebase -i HEAD~5

# Interactive stash
git stash -i

# Interactive checkout
git checkout -i

# Git Aliases
# Create aliases
git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.st status
git config --global alias.ci commit

# Advanced aliases
git config --global alias.lg "log --oneline --graph --decorate"
git config --global alias.unstage "reset HEAD --"

# List aliases
git config --get-regexp alias

# Remove alias
git config --global --unset alias.co

# Alias with multiple commands
git config --global alias.stash-unapply "!git stash show -p | git apply -R"

# Git Ignore
# Create .gitignore file
# Ignore specific files
*.log
*.tmp

# Ignore directories
build/
dist/
node_modules/

# Ignore files with pattern
*.~
*.swp

# Ignore specific file
config.env

# ! - Negate pattern
!*.js

# Global .gitignore
git config --global core.excludesfile ~/.gitignore_global

# Check ignored files
git status --ignored

# Git Hooks Examples
# .git/hooks/pre-commit
#!/bin/sh
# Run linter
npm run lint

# .git/hooks/pre-push
#!/bin/sh
# Run tests before push
npm test

# .git/hooks/commit-msg
#!/bin/sh
# Validate commit message
COMMIT_MSG=$(cat $1)
if [ ${#COMMIT_MSG} -lt 10 ]; then
    echo "Commit message too short"
    exit 1
fi

# .git/hooks/pre-rebase
#!/bin/sh
# Prevent rebasing on main branch
if [ "$(git rev-parse --abbrev-ref HEAD)" = "main" ]; then
    echo "Cannot rebase on main branch"
    exit 1
fi

// Git Merge Conflict Resolution

# Step 1: See the conflict
git status

# Step 2: Open the file and see conflict markers
cat file.txt
# <<<<<<< HEAD
# Current branch changes
# =======
# Incoming branch changes
# >>>>>>> other-branch

# Step 3: Resolve conflicts manually or use merge tool
git mergetool

# Step 4: Accept changes (strategies)
git checkout --ours file.txt    # Keep current branch changes
git checkout --theirs file.txt  # Keep incoming branch changes

# Step 5: Mark as resolved
git add file.txt

# Step 6: Complete the merge
git commit -m "Resolved merge conflicts"

# Git Cherry-Pick Conflicts
# Start cherry-pick
git cherry-pick <commit-hash>

# View conflicts
git status

# Resolve conflicts in files
# Edit files to resolve

# Add resolved files
git add <resolved-files>

# Continue cherry-pick
git cherry-pick --continue

# Skip commit
git cherry-pick --skip

# Abort cherry-pick
git cherry-pick --abort

# Cherry-pick with strategy
git cherry-pick -X theirs <commit-hash>
git cherry-pick -X ours <commit-hash>

// Git Amend - Modifying the Last Commit

# Original commit
git commit -m "Initial commit with bugs"

# Fix a file and amend
echo "Fixing bug" >> file.txt
git add file.txt
git commit --amend --no-edit

# Or change the message
git commit --amend -m "Initial commit with fixed bugs"

# Change author
git commit --amend --author="John Doe <john@email.com>"

# Force push after amend (if already pushed)
git push --force origin main

# Git Advanced Commands
# Find commit by content
git log -S"functionName"

# Find commit by path
git log -- path/to/file

# Show changes in a commit
git show <commit-hash>

# Show commit count
git rev-list --count main

# Show contribution stats
git shortlog -sn

# Show branch divergence
git rev-list --count main..feature

# List all files in a commit
git ls-tree -r main

# Show object details
git cat-file -p <object-hash>

# Git Troubleshooting
# Fix detached HEAD
git checkout main
git branch -d temp-branch

# Recover deleted file
git checkout HEAD -- file.txt
git checkout <commit-hash> -- file.txt

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

# Fix wrong author
git commit --amend --author="John Doe <john@email.com>"

# Undo git add
git reset HEAD file.txt

# Remove file from tracking
git rm --cached file.txt

# Find large files
git rev-list --objects --all | git cat-file --batch-check

# Git Fork and Pull Requests
# Fork repository on GitHub
# Clone your fork
git clone https://github.com/your-username/repo.git

# Add upstream remote
git remote add upstream https://github.com/original-owner/repo.git

# Sync fork with upstream
git fetch upstream
git checkout main
git merge upstream/main
git push origin main

# Create feature branch
git checkout -b feature/new-feature
# Work on feature
git push origin feature/new-feature

# Create pull request on GitHub
# After PR is merged
git checkout main
git pull upstream main
git push origin main

# Git Squash Commits
# Squash last 3 commits
git rebase -i HEAD~3
# Replace "pick" with "squash" or "s" for commits to squash

# Squash using reset
git reset --soft HEAD~3
git commit -m "Combined commit message"

# Squash with merge
git merge --squash feature-branch
git commit -m "Squashed feature commit"

# Squash commits in a branch
git checkout feature-branch
git rebase -i main
# Squash commits as needed

# Git Amend Commit
# Modify last commit message
git commit --amend -m "New commit message"

# Add files to last commit
git add forgotten-file.txt
git commit --amend --no-edit

# Change commit author
git commit --amend --author="John Doe <john@email.com>"

# Amend and change date
git commit --amend --date="2024-01-01"

# Avoid changing commit message
git add .
git commit --amend --no-edit

# Force push amended commit
git push --force origin main

# Git Hooks - Pre-commit Examples
# .git/hooks/pre-commit
#!/bin/sh

# Run ESLint
echo "Running ESLint..."
npm run lint || exit 1

# Run Tests
echo "Running tests..."
npm test || exit 1

# Check for debugger statements
if grep -r "debugger" src/; then
    echo "Found debugger statements"
    exit 1
fi

# Check for console.log
if grep -r "console.log" src/; then
    echo "Found console.log statements"
    exit 1
fi

# Run formatter
npm run format

# Add formatted files
git add .

# Git LFS (Large File Storage)
# Install Git LFS
git lfs install

# Track large files
git lfs track "*.psd"
git lfs track "*.zip"
git lfs track "*.mp4"

# View tracked files
git lfs track

# Migrate existing files
git lfs migrate import --include="*.psd,*.zip"

# Push LFS files
git push origin main

# Pull LFS files
git lfs pull

# Check LFS status
git lfs status

# View LFS files
git lfs ls-files

# Git Subtree
# Add a subtree
git subtree add --prefix=sub/dir https://github.com/user/repo.git main

# Pull updates
git subtree pull --prefix=sub/dir https://github.com/user/repo.git main

# Push changes back
git subtree push --prefix=sub/dir https://github.com/user/repo.git main

# Split subtree
git subtree split --prefix=sub/dir -b subtree-branch

# Merge subtree changes
git subtree merge --prefix=sub/dir -m "Update subtree" main

# View subtree history
git log --oneline --graph --subdir=sub/dir

# Git Attributes
# .gitattributes file
# Set diff for specific files
*.txt diff

# Set merge strategy
*.png binary
*.jpg binary

# Set eol
*.js text eol=lf
*.sh text eol=lf
*.bat text eol=crlf

# Set language
*.js linguist-language=JavaScript
*.rb linguist-language=Ruby

# Export ignore
test/ export-ignore
*.spec.js export-ignore

# Merge driver
*.lock merge=binary

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

# Replace email
git filter-branch --env-filter '
    if [ "$GIT_AUTHOR_EMAIL" = "old@email.com" ]
    then
        export GIT_AUTHOR_EMAIL="new@email.com"
    fi
' HEAD

# Remove folder
git filter-branch --tree-filter 'rm -rf node_modules' HEAD

# Cleanup
git reflog expire --expire=now --all
git gc --prune=now

# Git Garbage Collection
# Run garbage collection
git gc

# Aggressive garbage collection
git gc --aggressive

# Prune objects
git gc --prune=now

# Auto garbage collection
git gc --auto

# Check repository size
git count-objects -v

# Show large objects
git rev-list --objects --all | git cat-file --batch-check

# Find large files
git rev-list --objects --all | grep -E ".(jpg|png|gif|mp4)"

# Git Server Setup
# Initialize bare repository
git init --bare project.git

# Clone from server
git clone user@server:/path/to/project.git

# Add remote
git remote add origin user@server:/path/to/project.git

# Push to server
git push origin main

# Setup git server with SSH
# Add users to git group
sudo usermod -a -G git user1
sudo usermod -a -G git user2

# Change permissions
chown -R git:git /path/to/project.git
chmod -R 755 /path/to/project.git

# Git Hooks - Pre-push
# .git/hooks/pre-push
#!/bin/sh

# Run tests
echo "Running tests..."
npm test
if [ $? -ne 0 ]; then
    echo "Tests failed, push aborted"
    exit 1
fi

# Check branch naming
BRANCH_NAME=$(git rev-parse --abbrev-ref HEAD)
if [[ ! $BRANCH_NAME =~ ^(feature|bugfix|hotfix)/ ]]; then
    echo "Branch name must start with feature/, bugfix/, or hotfix/"
    exit 1
fi

# Check commit messages
git log --format=%s -n 5 | while read msg; do
    if [[ ! $msg =~ ^(FEAT|FIX|DOCS|STYLE|REFACTOR|TEST): ]]; then
        echo "Invalid commit message: $msg"
        exit 1
    fi
done

# Git Worktree Example
# Create a worktree for hotfix
git worktree add ../hotfix hotfix-branch

# Navigate to worktree
cd ../hotfix

# Work on hotfix
git add .
git commit -m "Fix critical bug"

# Push changes
git push origin hotfix-branch

# Create worktree for feature
git worktree add -b feature/new-feature ../new-feature main

# List worktrees
git worktree list

# Remove worktree
git worktree remove ../hotfix

# Prune worktrees
git worktree prune

# Git Bisect Example
# Start bisect
git bisect start

# Mark current as bad
git bisect bad HEAD

# Mark known good commit
git bisect good <commit-hash>

# Test commit
# Build and test
./build.sh
./test.sh

# Mark based on test result
if test_passed; then
    git bisect good
else
    git bisect bad
fi

# Find the commit that introduced the bug
# End bisect
git bisect reset

# Automate with script
git bisect start HEAD <good-commit>
git bisect run ./test-script.sh
git bisect reset

# Git Grep
# Search in all files
git grep "functionName"

# Search with context
git grep -C 5 "functionName"

# Search by file type
git grep "functionName" -- "*.js"

# Search only file names
git grep -l "functionName"

# Count occurrences
git grep -c "functionName"

# Search in specific commit
git grep "functionName" <commit-hash>

# Search across branches
git grep "functionName" main..feature

# Ignore case
git grep -i "functionName"

# Show line numbers
git grep -n "functionName"

# Git Notes
# Add a note to commit
git notes add -m "This commit contains security fix"

# Show notes
git notes show

# Edit note
git notes edit

# Remove note
git notes remove

# Show notes with log
git log --show-notes

# List all notes
git notes list

# Push notes
git push origin refs/notes/*

# Fetch notes
git fetch origin refs/notes/*:refs/notes/*

# Merge notes
git notes merge

# Git Alias Advanced
# Alias for custom log
git config --global alias.lg "log --graph --pretty=format:'%Cred%h%Creset - %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit"

# Alias for status short
git config --global alias.s "status -s"

# Alias for amend
git config --global alias.amend "commit --amend --no-edit"

# Alias for undo
git config --global alias.undo "reset --soft HEAD^"

# Alias for cleanup
git config --global alias.cleanup "!git branch --merged | grep -v '\*' | grep -v main | xargs git branch -d"

# Alias for last commit
git config --global alias.last "log -1 HEAD"

# Alias for changelog
git config --global alias.changelog "log --oneline --decorate --graph --all"

# List all aliases
git config --get-regexp alias

# Git Hooks - Commit-msg
# .git/hooks/commit-msg
#!/bin/sh

# Get commit message
COMMIT_MSG=$(cat $1)

# Validate length
if [ ${#COMMIT_MSG} -lt 10 ]; then
    echo "Error: Commit message must be at least 10 characters"
    exit 1
fi

# Validate format
if ! echo "$COMMIT_MSG" | grep -qE "^(feat|fix|docs|style|refactor|test|chore)(\(.+\))?: .+"; then
    echo "Error: Commit message must start with type: subject"
    echo "Example: feat: Add new feature"
    exit 1
fi

# Check for issue reference
if ! echo "$COMMIT_MSG" | grep -qE "([A-Z]+-[0-9]+)"; then
    echo "Warning: No issue reference found"
    # Allow warning but don't fail
fi

exit 0

# Git Cherry-pick Multiple Commits
# Cherry-pick a range
git cherry-pick feature-branch~3..feature-branch

# Cherry-pick with merge
git cherry-pick -m 1 <merge-commit>

# Cherry-pick with strategy
git cherry-pick -X theirs <commit-hash>

# Cherry-pick multiple specific commits
git cherry-pick <hash1> <hash2> <hash3>

# Cherry-pick with edit
git cherry-pick -e <commit-hash>

# Cherry-pick without commit
git cherry-pick -n <commit-hash>
# Resolve conflicts
git commit -m "Cherry-picked changes"

# Cherry-pick and keep original author
git cherry-pick -x <commit-hash>

# Git Rebase Workflow
# Rebase feature branch on main
git checkout feature-branch
git rebase main

# Interactive rebase to squash commits
git rebase -i HEAD~5
# Replace "pick" with "squash" for commits to combine

# Rebase with merge conflicts
# Resolve conflicts in files
git add <resolved-files>
git rebase --continue

# Skip conflict commit
git rebase --skip

# Abort rebase
git rebase --abort

# Rebase with execute commands
git rebase -i HEAD~3
# Add exec command after a commit
# exec npm test

# Rebase with force push
git push --force-with-lease origin feature-branch

# Git Merge Strategies
# Fast-forward merge
git merge --ff feature-branch

# No fast-forward merge
git merge --no-ff feature-branch

# Squash merge
git merge --squash feature-branch
git commit -m "Squashed feature"

# Merge with strategy
git merge -s recursive -X ours feature-branch
git merge -s recursive -X theirs feature-branch

# Merge with patience
git merge -s recursive -X patience feature-branch

# Merge with diff-algorithm
git merge -s recursive -X diff-algorithm=histogram feature-branch

# Abort merge
git merge --abort

# View merge details
git log --graph --oneline --decorate

# Git Remote Advanced
# Show remote details
git remote show origin

# Prune remote branches
git remote prune origin

# Update remote tracking
git remote update

# Set remote URL
git remote set-url origin git@github.com:user/repo.git

# Add multiple remotes
git remote add upstream git@github.com:original/repo.git
git remote add backup git@github.com:backup/repo.git

# Fetch from specific remote
git fetch upstream

# Push to specific remote
git push upstream main

# Delete remote branch
git push origin --delete branch-name

# Rename remote branch
git branch -m old-name new-name
git push origin -u new-name
git push origin --delete old-name

# Git Tag Advanced
# Create lightweight tag
git tag v1.0.0

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

# Create signed tag
git tag -s v1.0.0 -m "Signed release"

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

# Show tag details
git show v1.0.0

# Verify signed tag
git tag -v v1.0.0

# Delete local tag
git tag -d v1.0.0

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

# Push specific tag
git push origin v1.0.0

# Push all tags
git push --tags

# Create branch from tag
git checkout -b new-branch v1.0.0

# Git Submodule Advanced
# Add submodule with specific branch
git submodule add -b develop https://github.com/user/repo.git

# Update submodule to latest
git submodule update --remote

# Update all submodules
git submodule update --init --recursive

# Update submodule to specific commit
cd submodule
git checkout <commit-hash>
cd ..
git add submodule
git commit -m "Update submodule"

# Show submodule changes
git diff --submodule

# Show submodule summary
git submodule summary

# Synchronize submodule URL
git submodule sync

# Remove submodule
git submodule deinit -f submodule
git rm -f submodule
rm -rf .git/modules/submodule

# Git Hooks - Post-commit
# .git/hooks/post-commit
#!/bin/sh

# Get commit hash
COMMIT_HASH=$(git rev-parse HEAD)

# Log commit
echo "Commit: $COMMIT_HASH" >> .git/commit.log

# Send notification
notify-send "Commit created" "Hash: $COMMIT_HASH"

# Run CI/CD trigger
curl -X POST http://ci-server.com/build -H "Content-Type: application/json" -d "{"commit":"$COMMIT_HASH"}"

# Update documentation
./scripts/update-docs.sh

# Send email notification
echo "Commit $COMMIT_HASH created" | mail -s "New Commit" team@example.com

// Git Sparse Checkout - Checkout Specific Files/Directories

# Enable sparse checkout
git config core.sparseCheckout true

# Option 1: Using sparse-checkout file (older method)
echo "src/" >> .git/info/sparse-checkout
echo "docs/" >> .git/info/sparse-checkout

# Option 2: Using sparse-checkout command (newer method)
git sparse-checkout init --cone

# Add patterns to include
git sparse-checkout add src/
git sparse-checkout add docs/
git sparse-checkout add README.md

# List currently included patterns
git sparse-checkout list

# Remove a pattern
git sparse-checkout disable

# Reapply sparse checkout patterns
git sparse-checkout reapply

# Example: Only checkout frontend files
git sparse-checkout set frontend/ public/ src/

# Git Grep Advanced
# Search with regex
git grep -E "functions+w+"

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

# Search with count
git grep -c "pattern"

# Search with context lines
git grep -B 5 -A 5 "pattern"

# Search with file patterns
git grep "pattern" -- "*.js" "*.ts"

# Search excluding files
git grep "pattern" -- "*.js" ":(exclude)*.test.js"

# Search with line numbers
git grep -n "pattern"

# Show matching files only
git grep -l "pattern"

# Show non-matching files
git grep -L "pattern"

# Search in specific commit range
git grep "pattern" HEAD~5..HEAD

# Git Blame Advanced
# Show blame with commit info
git blame -c file.txt

# Show blame with line numbers
git blame -L 10,20 file.txt

# Show blame with email
git blame -e file.txt

# Show blame with time
git blame -t file.txt

# Show blame ignoring whitespace
git blame -w file.txt

# Show blame with previous commits
git blame -f file.txt

# Show blame in porcelain format
git blame --porcelain file.txt

# Show blame for specific revision
git blame <commit-hash> file.txt

# Show blame for multiple files
git blame file1.txt file2.txt

# Show blame with score
git blame -s file.txt

# Git Bisect Advanced
# Start bisect with good and bad
git bisect start HEAD <good-commit>

# Bisect with skip
git bisect skip

# Bisect with visual
git bisect visualize

# Bisect with log
git bisect log > bisect.log

# Bisect with script
git bisect run ./test.sh

# Bisect with multiple scripts
git bisect run ./build.sh && ./test.sh

# Bisect with branch
git bisect start
git bisect bad feature-branch
git bisect good main

# End bisect with branch
git bisect reset main

# Show bisect status
git bisect status

# Bisect with custom command
git bisect run git grep -q "error"

# Git Reflog Advanced
# View reflog for all branches
git reflog show --all

# View reflog with date
git reflog --date=iso

# View reflog with relative date
git reflog --date=relative

# Show reflog entries
git reflog --oneline

# View reflog for specific branch
git reflog show feature-branch

# Delete reflog entries older than 90 days
git reflog expire --expire=90.days.ago

# Delete reflog entries for stale branches
git reflog expire --expire-unreachable=now --all

# Show reflog with graph
git reflog --graph

# View reflog in porcelain format
git reflog --format=porcelain

# Git Filter-Repo (Modern)
# Install git-filter-repo
pip install git-filter-repo

# Remove file from history
git filter-repo --path file.txt --invert-paths

# Replace email
git filter-repo --email-callback '
    return email if email != "old@email.com" else "new@email.com"
'

# Rename file
git filter-repo --path-rename old.txt:new.txt

# Remove folder
git filter-repo --path node_modules --invert-paths

# Analyze repository
git filter-repo --analyze

# Force push after filtering
git push origin --force --all

# Git Large File Storage Advanced
# Install LFS
git lfs install

# Track patterns
git lfs track "*.psd" "*.zip" "*.mp4"

# List tracked patterns
git lfs track

# View LFS files
git lfs ls-files

# Migrate existing files
git lfs migrate import --include="*.psd,*.zip"

# Push LFS files
git lfs push origin main

# Pull LFS files
git lfs pull

# Check LFS status
git lfs status

# Clean LFS cache
git lfs clean

# Prune LFS files
git lfs prune

# Verify LFS installation
git lfs version

# Git Sparse Checkout
# Enable sparse checkout
git config core.sparseCheckout true

# Set sparse checkout patterns
echo "src/" >> .git/info/sparse-checkout
echo "!src/tests/" >> .git/info/sparse-checkout

# Read sparse checkout patterns
git sparse-checkout init --cone

# Add patterns
git sparse-checkout add src/

# Set patterns
git sparse-checkout set src/ docs/

# Reapply sparse checkout
git sparse-checkout reapply

# List patterns
git sparse-checkout list

# Disable sparse checkout
git config core.sparseCheckout false

# Git Partial Clone
# Clone with blobless
git clone --filter=blob:none <url>

# Clone with treeless
git clone --filter=tree:0 <url>

# Clone with sparse
git clone --filter=blob:none --sparse <url>

# Fetch blobs on demand
git fetch --filter=blob:none

# Checkout files
git checkout main

# Show partial clone info
git rev-list --objects --all --filter=blob:none

# Deepen shallow clone
git fetch --deepen=100

# Unshallow clone
git fetch --unshallow

# Convert to partial clone
git repack -a -d --write-bitmap-index

# Git Shallow Clone
# Shallow clone with depth
git clone --depth 1 <url>

# Shallow clone with history
git clone --depth 50 <url>

# Fetch more history
git fetch --depth=100

# Unshallow clone
git fetch --unshallow

# Shallow clone with branch
git clone --depth 1 --branch main <url>

# Convert to full clone
git fetch --unshallow

# Check shallow status
git rev-parse --is-shallow-repository

# Fetch with depth
git fetch --depth=50 origin main

# Clone single branch
git clone --single-branch --branch main <url>

# Git Bundle
# Create a bundle
git bundle create repo.bundle --all

# Create bundle with specific branch
git bundle create repo.bundle main

# Create bundle with tags
git bundle create repo.bundle --tags

# Verify bundle
git bundle verify repo.bundle

# List bundle contents
git bundle list-heads repo.bundle

# Clone from bundle
git clone repo.bundle my-repo

# Fetch from bundle
git fetch repo.bundle

# Pull from bundle
git pull repo.bundle main

# Create bundle from specific commits
git bundle create repo.bundle HEAD~10..HEAD

# Git Describe
# Describe current commit
git describe

# Describe with tags
git describe --tags

# Describe with all refs
git describe --all

# Describe with abbrev
git describe --abbrev=7

# Describe with long format
git describe --long

# Describe with match
git describe --match "v*"

# Describe with dirty marker
git describe --dirty

# Describe for specific commit
git describe <commit-hash>

# Describe with exact match
git describe --exact-match

# Describe with first parent
git describe --first-parent

# Git Shortlog
# Show shortlog
git shortlog

# Show shortlog with summary
git shortlog -s

# Show shortlog with email
git shortlog -e

# Show shortlog with count
git shortlog -sn

# Show shortlog with commit count
git shortlog -sn --all

# Show shortlog with file changes
git shortlog -sn -- -- "*.js"

# Show shortlog by date
git shortlog -sn --since="2024-01-01"

# Show shortlog by author
git shortlog -sn --author="John"

# Show shortlog with number of commits
git shortlog -sn | head -10

# Show shortlog with email and count
git shortlog -sen

# Git Rev-List
# List all commits
git rev-list --all

# List commits in branch
git rev-list main

# Count commits
git rev-list --count main

# List commits with message
git rev-list --oneline main

# List commits with date
git rev-list --date=iso main

# List commits with author
git rev-list --author="John" main

# List commits with grep
git rev-list --grep="fix" main

# List commits with range
git rev-list main..feature

# List commits with first parent
git rev-list --first-parent main

# List commits with objects
git rev-list --objects main

# Git Name-Rev
# Show commit reference
git name-rev <commit-hash>

# Show with tags
git name-rev --tags <commit-hash>

# Show with refs
git name-rev --refs=refs/heads/* <commit-hash>

# Show with always
git name-rev --always <commit-hash>

# Show with undefined
git name-rev --undefined <commit-hash>

# Show with name-only
git name-rev --name-only <commit-hash>

# Show with stdin
echo <commit-hash> | git name-rev --stdin

# Show with multiple commits
git name-rev <hash1> <hash2> <hash3>

# Show with skip
git name-rev --skip=2 <commit-hash>

# Git Show-Ref
# Show all refs
git show-ref

# Show heads
git show-ref --heads

# Show tags
git show-ref --tags

# Show specific ref
git show-ref refs/heads/main

# Show with hash
git show-ref --hash=7

# Show with verify
git show-ref --verify refs/heads/main

# Show with heads and tags
git show-ref --heads --tags

# Show with pattern
git show-ref "*feature*"

# Show with quiet
git show-ref --quiet refs/heads/main

# Show with exclusive
git show-ref --exclude-existing

# Git Symbolic-Ref
# Read symbolic ref
git symbolic-ref HEAD

# Set symbolic ref
git symbolic-ref HEAD refs/heads/main

# Read short ref
git symbolic-ref --short HEAD

# Read with quiet
git symbolic-ref -q HEAD

# Set with force
git symbolic-ref -f HEAD refs/heads/main

# Read for specific ref
git symbolic-ref refs/remotes/origin/HEAD

# Delete symbolic ref
git symbolic-ref -d HEAD

# Show with message
git symbolic-ref -m "Switch to main" HEAD refs/heads/main

# Read with show-ref
git symbolic-ref --show-ref HEAD

# Git Update-Ref
# Update ref to commit
git update-ref refs/heads/new-branch <commit-hash>

# Delete ref
git update-ref -d refs/heads/branch-to-delete

# Update ref with message
git update-ref -m "Moving branch" refs/heads/branch <commit-hash>

# Create symbolic ref
git update-ref --stdin
# create refs/heads/new-branch <commit-hash>^0

# Update multiple refs
git update-ref refs/heads/branch1 <hash1>
git update-ref refs/heads/branch2 <hash2>

# Update with force
git update-ref -f refs/heads/branch <commit-hash>

# Update with no deref
git update-ref --no-deref refs/heads/branch <commit-hash>

# Show current ref
git symbolic-ref HEAD

# Git Hash-Object
# Compute hash of content
git hash-object file.txt

# Store object in database
git hash-object -w file.txt

# Store with type
git hash-object -t blob -w file.txt

# Store from stdin
echo "content" | git hash-object -w --stdin

# Read object
git cat-file -p <hash>

# Show object type
git cat-file -t <hash>

# Compute hash with path
git hash-object --path=file.txt file.txt

# Compute hash without storing
git hash-object --no-filters file.txt

# Store multiple objects
git hash-object -w file1.txt file2.txt

# Show object in tree
git ls-tree HEAD

# Git Cat-File
# Show object content
git cat-file -p <hash>

# Show object type
git cat-file -t <hash>

# Show object size
git cat-file -s <hash>

# Show pretty content
git cat-file -p HEAD

# Show tree content
git cat-file -p HEAD^{tree}

# Show commit content
git cat-file -p HEAD

# Show blob content
git cat-file -p HEAD:file.txt

# Show with batch
git cat-file --batch

# Show with batch-check
git cat-file --batch-check

# Show with textconv
git cat-file --textconv file.txt

# Git Ls-Files
# List tracked files
git ls-files

# List with stage
git ls-files --stage

# List with others
git ls-files --others

# List with ignored
git ls-files --ignored

# List with exclude
git ls-files --exclude-standard

# List with modified
git ls-files --modified

# List with deleted
git ls-files --deleted

# List with cached
git ls-files --cached

# List with error
git ls-files --error-unmatch file.txt

# List with full name
git ls-files --full-name

# Git Ls-Tree
# List tree contents
git ls-tree HEAD

# List recursively
git ls-tree -r HEAD

# List with tree only
git ls-tree -t HEAD

# List with long format
git ls-tree -l HEAD

# List with name only
git ls-tree --name-only HEAD

# List with full tree
git ls-tree --full-tree HEAD

# List with path
git ls-tree HEAD:src/

# List with object ID
git ls-tree -r HEAD --object-only

# List with commit
git ls-tree HEAD -- src/ docs/

# List with abbrev
git ls-tree --abbrev=7 HEAD

# Git Ls-Remote
# List remote branches
git ls-remote origin

# List remote heads
git ls-remote --heads origin

# List remote tags
git ls-remote --tags origin

# List with refs
git ls-remote origin refs/heads/*

# List with specific ref
git ls-remote origin main

# List with upload-pack
git ls-remote --upload-pack

# List with exit code
git ls-remote --exit-code origin

# List with quiet
git ls-remote --quiet origin

# List with symref
git ls-remote --symref origin

# List with sort
git ls-remote --sort=refname origin

# Git Diff Advanced
# Show diff between commits
git diff <commit1> <commit2>

# Show diff between branches
git diff main..feature

# Show diff with 3-dots
git diff main...feature

# Show diff with stat
git diff --stat

# Show diff with patch
git diff --patch

# Show diff with color
git diff --color

# Show diff with ignore spaces
git diff -w

# Show diff with name-only
git diff --name-only

# Show diff with find-copies
git diff -C

# Show diff with find-renames
git diff --find-renames

# Git Format-Patch
# Generate patch for commit
git format-patch -1 <commit-hash>

# Generate patches for range
git format-patch <start>..<end>

# Generate patches with subject
git format-patch --subject-prefix="PATCH" HEAD~3

# Generate patches with output
git format-patch -o patches/ HEAD~3

# Generate patches with number
git format-patch -n HEAD~3

# Generate patches with thread
git format-patch --thread HEAD~3

# Generate patches with cover-letter
git format-patch --cover-letter HEAD~3

# Generate patches for current branch
git format-patch main

# Generate patches for all commits
git format-patch --all

# Generate patches with signoff
git format-patch --signoff HEAD~3

# Git Am (Apply Mailbox)
# Apply patch series
git am patches/*.patch

# Apply with 3-way merge
git am -3 patch.diff

# Apply with directory
git am --directory=src/ patch.diff

# Apply with signoff
git am --signoff patch.diff

# Apply with keep
git am --keep patch.diff

# Apply with ignore
git am --ignore-whitespace patch.diff

# Apply with fallback
git am --fallback patch.diff

# Continue after conflict
git am --continue

# Skip patch
git am --skip

# Abort am
git am --abort

// Git Log Advanced Usage - Formatting and Filtering

# Basic log with formatting
git log --pretty=format:"%h - %s (%cr) <%an>"

# Graph view with decorations
git log --graph --oneline --decorate --all

# Filter by author
git log --author="John Doe"

# Filter by commit message
git log --grep="fix"
git log --grep="feature" --grep="bug" --all-match

# Filter by date range
git log --since="2 weeks ago"
git log --until="2023-01-01"

# Filter by files
git log -- file.txt
git log -- src/ README.md

# Show commit stats
git log --stat
git log --shortstat

# Show diff
git log -p

# Limit number of commits
git log -5

# Custom format with colors
git log --pretty=format:"%C(yellow)%h%Creset - %C(blue)%s%Creset %C(red)%cr%Creset (%an)"

# Git Revert Advanced
# Revert a commit
git revert <commit-hash>

# Revert with edit
git revert -e <commit-hash>

# Revert with no commit
git revert -n <commit-hash>

# Revert with mainline
git revert -m 1 <merge-commit>

# Revert with strategy
git revert --strategy=recursive <commit-hash>

# Revert with strategy options
git revert -X theirs <commit-hash>

# Revert range
git revert <start>..<end>

# Revert with signoff
git revert --signoff <commit-hash>

# Revert with no-edit
git revert --no-edit <commit-hash>

# Continue revert
git revert --continue

# Git Reset Advanced
# Soft reset
git reset --soft HEAD~1

# Mixed reset
git reset --mixed HEAD~1

# Hard reset
git reset --hard HEAD~1

# Reset to commit
git reset --hard <commit-hash>

# Reset with merge
git reset --merge HEAD~1

# Reset with keep
git reset --keep HEAD~1

# Reset with path
git reset HEAD -- file.txt

# Reset with patch
git reset --patch HEAD

# Reset with quiet
git reset --quiet HEAD~1

# Reset with no-edit
git reset --no-edit HEAD~1

# Git Checkout Advanced
# Checkout branch
git checkout main

# Checkout commit
git checkout <commit-hash>

# Checkout file
git checkout -- file.txt

# Checkout with patch
git checkout -p HEAD

# Checkout with merge
git checkout --merge main

# Checkout with orphan
git checkout --orphan new-branch

# Checkout with track
git checkout --track origin/feature

# Checkout with force
git checkout -f main

# Checkout with quiet
git checkout -q main

# Checkout with progress
git checkout --progress main

# Git Switch
# Switch branch
git switch main

# Switch with create
git switch -c new-branch

# Switch with force
git switch -f main

# Switch with discard
git switch --discard-changes main

# Switch with merge
git switch --merge main

# Switch with progress
git switch --progress main

# Switch with quiet
git switch -q main

# Switch with detach
git switch --detach <commit-hash>

# Switch with orphan
git switch --orphan new-branch

# Switch with track
git switch --track origin/feature

# Git Restore
# Restore file
git restore file.txt

# Restore staged file
git restore --staged file.txt

# Restore to commit
git restore --source=<commit-hash> file.txt

# Restore with staged
git restore --staged --source=<commit-hash> file.txt

# Restore with worktree
git restore --worktree file.txt

# Restore with checkout
git restore --checkout file.txt

# Restore with merge
git restore --merge file.txt

# Restore with patch
git restore -p file.txt

# Restore multiple files
git restore file1.txt file2.txt

# Restore all files
git restore .

# Git Stash Advanced
# Stash with message
git stash push -m "WIP: Feature work"

# Stash with untracked
git stash push -u

# Stash with all
git stash push -a

# Stash with keep-index
git stash push --keep-index

# Stash with path
git stash push -- src/

# Stash with patch
git stash push -p

# Apply stash with index
git stash apply --index

# Apply stash with quiet
git stash apply -q

# Pop stash with index
git stash pop --index

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

# Git Log Advanced
# Log with graph
git log --graph --oneline --decorate

# Log with pretty format
git log --pretty=format:"%h - %s (%cr) <%an>"

# Log with date format
git log --date=iso

# Log with author
git log --author="John"

# Log with grep
git log --grep="fix"

# Log with file
git log -- file.txt

# Log with full diff
git log -p

# Log with stats
git log --stat

# Log with first parent
git log --first-parent

# Log with range
git log HEAD~5..HEAD

# Git Blame Advanced
# Blame with ignore
git blame -w file.txt

# Blame with previous
git blame -f file.txt

# Blame with email
git blame -e file.txt

# Blame with time
git blame -t file.txt

# Blame with line range
git blame -L 10,20 file.txt

# Blame with reverse
git blame --reverse <commit-hash> file.txt

# Blame with progress
git blame --progress file.txt

# Blame with date format
git blame --date=iso file.txt

# Blame with score
git blame -s file.txt

# Blame with porcelain
git blame --porcelain file.txt

# Git Grep Advanced
# Grep with count
git grep -c pattern

# Grep with name only
git grep -l pattern

# Grep with non-match
git grep -L pattern

# Grep with context
git grep -C 5 pattern

# Grep with before context
git grep -B 5 pattern

# Grep with after context
git grep -A 5 pattern

# Grep with word boundary
git grep -w pattern

# Grep with regex
git grep -E "pattern"

# Grep with ignore case
git grep -i pattern

# Grep with file type
git grep pattern -- "*.js"

# Git Show Advanced
# Show commit
git show <commit-hash>

# Show with format
git show --pretty=format:"%h - %s"

# Show with oneline
git show --oneline

# Show with diff
git show --diff

# Show with stat
git show --stat

# Show with raw
git show --raw

# Show with patch
git show --patch

# Show with no-patch
git show --no-patch

# Show with quiet
git show -q

# Show with abbrev
git show --abbrev-commit

# Git Rev-Parse
# Parse revision
git rev-parse HEAD

# Parse short hash
git rev-parse --short HEAD

# Parse branch
git rev-parse --abbrev-ref HEAD

# Parse symbolic ref
git rev-parse --symbolic-full-name HEAD

# Parse git dir
git rev-parse --git-dir

# Parse path
git rev-parse --show-toplevel

# Parse prefix
git rev-parse --show-prefix

# Parse is-inside
git rev-parse --is-inside-work-tree

# Parse is-inside-git-dir
git rev-parse --is-inside-git-dir

# Parse with verify
git rev-parse --verify HEAD

# Git Config Advanced
# List all config
git config --list

# List with show-origin
git config --list --show-origin

# Get specific config
git config user.name

# Set config
git config user.name "John Doe"

# Set config global
git config --global user.email "john@email.com"

# Set config local
git config --local core.editor "vim"

# Set config system
git config --system core.editor "vim"

# Delete config
git config --unset user.name

# Delete config global
git config --global --unset user.email

# Edit config
git config --edit

# Git Help
# Show help
git help

# Show help for command
git help commit

# Show help with verbose
git help -v

# Show help with guide
git help -g

# Show help with web
git help -w commit

# Show help with info
git help -i commit

# Show help with man
git help -m commit

# Show help with all
git help -a

# Show help with user-manual
git help user-manual

# Show help with tutorial
git help tutorial

// Git Detached HEAD - How to Fix

# Scenario: You're in detached HEAD state
# This happens when you checkout a specific commit
git checkout abc1234

# Option 1: Create a new branch from the detached HEAD
git branch new-branch
git checkout new-branch
# Or combine both:
git checkout -b new-branch

# Option 2: Switch back to a branch
git checkout main
# This will show a warning if you have uncommitted changes

# Option 3: Keep changes by creating a branch
git switch -c my-new-branch
git add .
git commit -m "Saved changes from detached HEAD"

# Option 4: Reset to a branch (discard changes)
git reset --hard main

# Option 5: Merge the commit into an existing branch
git checkout main
git merge abc1234

# Option 6: Cherry-pick the commit
git checkout main
git cherry-pick abc1234

# Check current state
git status
git log --oneline

# Git Daemon
# Start git daemon
git daemon

# Start with base-path
git daemon --base-path=/path/to/repos

# Start with port
git daemon --port=9418

# Start with export-all
git daemon --export-all

# Start with verbose
git daemon --verbose

# Start with syslog
git daemon --syslog

# Start with enable
git daemon --enable=receive-pack

# Start with user
git daemon --user=git

# Start with group
git daemon --group=git

# Start with inetd
git daemon --inetd

# Git Hooks - Post-Receive
# .git/hooks/post-receive
#!/bin/sh

# Deploy to production
while read oldrev newrev refname; do
    branch=$(git rev-parse --symbolic --abbrev-ref $refname)
    if [ "$branch" = "main" ]; then
        echo "Deploying to production..."
        git --work-tree=/var/www/html checkout -f
        echo "Deployment complete"
        
        # Run post-deploy scripts
        /var/www/html/scripts/post-deploy.sh
        
        # Send notification
        echo "Deployed commit: $newrev" | mail -s "Production Deploy" team@example.com
    fi
done

# Git Hooks - Pre-commit Advanced
# .git/hooks/pre-commit
#!/bin/sh

# Run multiple checks

# Check for trailing whitespace
git diff --cached --check || exit 1

# Run linter
if [ -f package.json ]; then
    npm run lint || exit 1
fi

# Run formatter
if [ -f .prettierrc ]; then
    npm run format
    git add .
fi

# Check for debugger statements
if git diff --cached | grep -E "^+.*debugger"; then
    echo "Found debugger statements"
    exit 1
fi

# Check for console.log
if git diff --cached | grep -E "^+.*console.log"; then
    echo "Found console.log statements"
    exit 1
fi

# Run tests for modified files
if git diff --cached --name-only | grep -E ".(js|ts|py)$" > /dev/null; then
    npm test || exit 1
fi

# Git Advanced Workflows
# Monorepo with Git
# Use submodules for large projects
git submodule add https://github.com/user/lib.git lib/

# Use subtree for better integration
git subtree add --prefix=lib https://github.com/user/lib.git main

# Git with CI/CD
# .github/workflows/ci.yml
name: CI
on: [push, pull_request]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: Run tests
        run: npm test

# Git with semantic versioning
# Use tags for releases
git tag -a v1.0.0 -m "Release version 1.0.0"
git push origin v1.0.0

# Git with conventional commits
# Commit format: type(scope): subject
# Example: feat(auth): Add login feature
# Example: fix(api): Fix user validation

# Complete Git Workflow
# Initialize a new repository
mkdir project
cd project
git init

# Create initial structure
echo "# Project" > README.md
mkdir src docs tests
echo "node_modules/" > .gitignore

# Add and commit
git add .
git commit -m "feat: Initial project setup"

# Create feature branch
git checkout -b feature/new-feature

# Work on feature
echo "console.log('Hello World');" > src/main.js
git add src/main.js
git commit -m "feat: Add main.js with hello world"

# Push feature branch
git push origin feature/new-feature

# Create pull request on GitHub
# After PR is approved and merged

# Update main branch
git checkout main
git pull origin main

# Create release tag
git tag -a v1.0.0 -m "Release version 1.0.0"
git push origin v1.0.0

# Create hotfix branch
git checkout -b hotfix/critical-bug main
git add .
git commit -m "fix: Critical bug fix"
git push origin hotfix/critical-bug

# Merge hotfix
git checkout main
git merge --no-ff hotfix/critical-bug
git push origin main

# Clean up branches
git branch -d feature/new-feature
git branch -d hotfix/critical-bug
git push origin --delete feature/new-feature
git push origin --delete hotfix/critical-bug