# Run garbage collection manually
git gc
 
# Aggressive GC — slower but more thorough compression
git gc --aggressive
 
# Preview what gc would do
git gc --dry-run

# Check current thresholds
git config gc.auto          # default: 6700 (loose objects before auto-gc)
git config gc.autoPackLimit # default: 50 (packfiles before auto-repack)
 
# Disable auto-gc (if using git maintenance instead)
git config gc.auto 0
 
# Customize thresholds
git config --global gc.auto 10000

# Control how long unreachable objects survive
git config gc.reflogExpire            # default: 90 days
git config gc.reflogExpireUnreachable  # default: 30 days
git config gc.pruneExpire              # default: 2 weeks
 
# For safety on shared servers, extend these:
git config gc.pruneExpire "1 month"

# Aggressive GC with custom window and depth
git gc --aggressive --prune=now
 
# Check the size before and after
git count-objects -v
# count: 0           ← loose objects
# size: 0            ← loose object size (KB)
# in-pack: 52341     ← packed objects
# packs: 1           ← number of packfiles
# size-pack: 18230   ← packfile size (KB)

# Register the current repo for scheduled maintenance
git maintenance register
 
# Start the background scheduler
git maintenance start

# Run a specific task manually
git maintenance run --task=commit-graph
git maintenance run --task=loose-objects
git maintenance run --task=incremental-repack
 
# Run all scheduled tasks at once
git maintenance run
 
# See what's registered
git config --global --get-regexp maintenance

# Customize the schedule for specific tasks
git config maintenance.commit-graph.schedule hourly
git config maintenance.loose-objects.schedule daily
git config maintenance.incremental-repack.schedule weekly
 
# Unregister a repo from maintenance
git maintenance unregister
 
# Stop the background scheduler entirely
git maintenance stop

# Generate the commit-graph file
git commit-graph write --reachable
 
# Generate with changed-paths Bloom filters (speeds up path-limited log)
git commit-graph write --reachable --changed-paths
 
# Verify the commit-graph is consistent
git commit-graph verify

# Write commit-graph on every gc/fetch/repack
git config --global fetch.writeCommitGraph true
git config --global gc.writeCommitGraph true
 
# Or just use git maintenance, which handles this automatically
git maintenance start

# Write commit-graph with Bloom filters
git commit-graph write --reachable --changed-paths
 
# Now this is much faster:
git log --oneline -- src/components/Header.tsx

# Enable the built-in fsmonitor daemon
git config core.fsmonitor true
 
# Verify it's running
git fsmonitor--daemon status
 
# Check the improvement
time git status   # With fsmonitor: ~0.1s vs ~2s without

# Install Watchman
brew install watchman    # macOS
# See https://facebook.github.io/watchman/docs/install for other platforms
 
# Configure Git to use Watchman
git config core.fsmonitor "$(which watchman)"
 
# Or use the helper query script
git config core.fsmonitor .git/hooks/query-watchman

# Enable untracked cache
git config core.untrackedCache true
 
# Update the untracked cache
git update-index --untracked-cache
 
# Check if it's active
git config core.untrackedCache

# Clone with sparse checkout
git clone --filter=blob:none --sparse https://github.com/org/monorepo.git
cd monorepo
 
# Only root files are checked out initially
ls
# README.md  package.json  ...
 
# Add the directories you work on
git sparse-checkout set --cone packages/frontend packages/shared
 
# Verify
git sparse-checkout list
# packages/frontend
# packages/shared
 
# Your working tree now only has:
# monorepo/
# ├── packages/
# │   ├── frontend/    ← fully checked out
# │   └── shared/      ← fully checked out
# ├── README.md
# └── package.json
 
# Add more directories later
git sparse-checkout add tools/linting
 
# Temporarily get everything (e.g., for a full build)
git sparse-checkout disable
 
# Re-enable
git sparse-checkout set --cone packages/frontend packages/shared

# --filter=blob:none: don't download file contents until needed
# --sparse: only check out root files initially
git clone --filter=blob:none --sparse https://github.com/org/monorepo.git
cd monorepo
 
# Set your working directories
git sparse-checkout set --cone packages/frontend packages/shared
 
# Result:
# - Full commit history is available (git log, git blame work)
# - Only frontend + shared file contents are downloaded
# - Other packages' blobs are fetched on demand if needed

# Enable sparse index
git sparse-checkout init --cone --sparse-index
 
# Or on an existing sparse checkout
git config index.sparse true
 
# Verify
GIT_TRACE2_PERF=1 git status 2>&1 | grep "sparse"

# Blobless clone: skip all file contents (download on demand)
git clone --filter=blob:none <url>
 
# Treeless clone: skip tree objects too (even smaller initial clone)
git clone --filter=tree:0 <url>
 
# Size-filtered: skip blobs larger than a threshold
git clone --filter=blob:limit=1m <url>
 
# Combined filters (Git 2.27+)
git clone --filter=combine:blob:none+tree:0 <url>

# See which remote is the promisor
git config remote.origin.promisor    # true
git config remote.origin.partialCloneFilter    # blob:none

# Enable rerere
git config --global rerere.enabled true

# First encounter of a conflict
git merge feature
# CONFLICT (content): Merge conflict in app.js
# Recorded preimage for 'app.js'     ← rerere notes the conflict
 
# You resolve it manually
vim app.js    # fix the conflict markers
git add app.js
git commit
 
# Recorded resolution for 'app.js'   ← rerere saves your resolution
 
# Later, the same conflict appears (e.g., during a rebase)
git rebase main
# CONFLICT (content): Merge conflict in app.js
# Resolved 'app.js' using previous resolution.  ← automatic!
 
# Verify the auto-resolution looks correct
git diff app.js
git add app.js
git rebase --continue

# See which conflicts have recorded resolutions
git rerere status
 
# See the diff of a recorded resolution
git rerere diff
 
# Forget a specific resolution (if it was wrong)
git rerere forget app.js
 
# Clear all recorded resolutions
git rerere gc

# 1. Partial clone + sparse checkout
git clone --filter=blob:none --sparse <url>
git sparse-checkout set --cone <your-directories>
 
# 2. Enable sparse index
git config index.sparse true
 
# 3. Enable fsmonitor
git config core.fsmonitor true
 
# 4. Enable untracked cache
git config core.untrackedCache true
 
# 5. Write commit-graph with Bloom filters
git commit-graph write --reachable --changed-paths
 
# 6. Enable rerere for repeated merges
git config rerere.enabled true
 
# 7. Start background maintenance
git maintenance start

# .github/CODEOWNERS (GitHub) or CODEOWNERS (GitLab)
# Syntax: <pattern> <owners>
 
# Default owners for everything
*                       @org/core-team
 
# Frontend team owns frontend code
/packages/frontend/     @org/frontend-team
*.tsx                   @org/frontend-team
 
# Backend team owns backend code
/packages/backend/      @org/backend-team
 
# DevOps owns CI/CD and infrastructure
/.github/               @org/devops
/terraform/             @org/devops
Dockerfile              @org/devops
 
# Specific individuals for critical files
/packages/auth/         @security-lead @auth-team-lead

# Time any Git command
time git status
time git log --oneline | wc -l
 
# Enable trace output for detailed timing
GIT_TRACE=1 git status
GIT_TRACE_PERFORMANCE=1 git status
GIT_TRACE2_PERF=1 git status 2>&1 | head -30
 
# Check repository statistics
git count-objects -v
# count: 234          ← loose objects
# size: 1024          ← loose object size (KB)
# in-pack: 524130     ← packed objects
# packs: 3            ← number of packfiles
# size-pack: 182300   ← total packfile size (KB)
# prune-packable: 0
# garbage: 0
# size-garbage: 0

# Symptom: git status is slow
# Diagnose:
GIT_TRACE2_PERF=1 git status 2>&1 | grep "data\|region_leave"
# Fix:
git config core.fsmonitor true
git config core.untrackedCache true
 
# Symptom: git log is slow
# Diagnose:
time git log --oneline | wc -l
# Fix:
git commit-graph write --reachable --changed-paths
 
# Symptom: git clone is slow
# Diagnose:
du -sh .git/
# Fix:
# Use --filter=blob:none for development
# Use --depth 1 for CI/CD
 
# Symptom: Too many packfiles
# Diagnose:
git count-objects -v | grep packs
# Fix:
git repack -a -d --depth=250 --window=250
 
# Symptom: Large .git directory
# Diagnose:
git rev-list --objects --all | git cat-file --batch-check='%(objecttype) %(objectname) %(objectsize) %(rest)' | sort -rnk3 | head -20
# Fix:
# Migrate large files to LFS, filter-repo to remove from history

mkdir perf-lab && cd perf-lab
git init
 
# Create a repository with meaningful history for testing
for i in $(seq 1 100); do
    echo "content for file $i" > "file-$i.txt"
done
git add . && git commit -m "initial: add 100 files"
 
for i in $(seq 1 50); do
    echo "change $i" >> "file-$((RANDOM % 100 + 1)).txt"
    git add . && git commit -m "update $i: modify a random file"
done

# 1. Check current object storage
git count-objects -v
# Note the 'count' (loose objects) and 'in-pack' values
 
# 2. Create loose objects by making many small commits
for i in $(seq 1 30); do
    echo "extra $i" >> extra.txt
    git add . && git commit -m "extra commit $i"
done
 
# 3. Check again — more loose objects
git count-objects -v
# 'count' should have increased
 
# 4. Run garbage collection
git gc
git count-objects -v
# 'count' should be 0 (all packed)
# 'packs' should be 1
 
# 5. Check the packfile
ls -lh .git/objects/pack/

# 1. Create a larger history for measurable impact
for i in $(seq 1 200); do
    echo "more content $i" >> "file-$((RANDOM % 100 + 1)).txt"
    git add . && git commit -m "batch commit $i"
done
 
# 2. Time log traversal WITHOUT commit-graph
rm -f .git/objects/info/commit-graph
time git log --oneline | wc -l
 
# 3. Generate the commit-graph
git commit-graph write --reachable --changed-paths
 
# 4. Time log traversal WITH commit-graph
time git log --oneline | wc -l
 
# 5. Verify the file exists
ls -lh .git/objects/info/commit-graph
 
# 6. Test path-limited log (Bloom filters help here)
time git log --oneline -- file-42.txt

# 1. Create many files for a measurable difference
mkdir -p src
for i in $(seq 1 5000); do
    echo "module $i" > "src/module-$i.js"
done
git add . && git commit -m "add 5000 source files"
 
# 2. Time git status WITHOUT fsmonitor
git config core.fsmonitor false
time git status
 
# 3. Enable fsmonitor
git config core.fsmonitor true
 
# 4. Run status once to "warm up" the monitor
git status
 
# 5. Time git status WITH fsmonitor
time git status
 
# 6. Also enable untracked cache
git config core.untrackedCache true
git update-index --untracked-cache
time git status

# 1. Enable rerere
git config rerere.enabled true
 
# 2. Create conflicting branches
git checkout main 2>/dev/null || git checkout -b main
echo "main version of the config" > config.txt
git add config.txt && git commit -m "main: add config"
 
git checkout -b feature/change-config
echo "feature version of the config" > config.txt
git add config.txt && git commit -m "feature: change config"
 
git checkout main
echo "main updated config" > config.txt
git add config.txt && git commit -m "main: update config"
 
# 3. Merge — this will conflict
git merge feature/change-config
# CONFLICT (content): Merge conflict in config.txt
# Recorded preimage for 'config.txt'    ← rerere recording!
 
# 4. Resolve the conflict
echo "resolved: combined config" > config.txt
git add config.txt
git commit -m "merge: resolve config conflict"
# Recorded resolution for 'config.txt'  ← resolution saved!
 
# 5. Now simulate encountering the same conflict again
# Reset back to before the merge
git reset --hard HEAD~1
 
# 6. Merge again — rerere auto-resolves!
git merge feature/change-config
# CONFLICT (content): Merge conflict in config.txt
# Resolved 'config.txt' using previous resolution.   ← automatic!
 
# 7. Verify the resolution was applied correctly
cat config.txt
# Should show "resolved: combined config"
 
git add config.txt
git commit -m "merge: resolve config conflict (rerere)"

cd ~/perf-lab
 
# 1. Create a "monorepo" structure
mkdir -p packages/{frontend,backend,mobile,shared}
echo "import React from 'react';" > packages/frontend/App.tsx
echo "const express = require('express');" > packages/backend/server.js
echo "import SwiftUI" > packages/mobile/ContentView.swift
echo "export const utils = {};" > packages/shared/utils.ts
echo "# Monorepo" > README.md
git add . && git commit -m "monorepo structure"
 
# 2. Create a clone with sparse checkout
cd ..
git clone --sparse perf-lab perf-lab-sparse
cd perf-lab-sparse
 
# 3. Check what's available
ls
# Only root files (README.md, etc.)
ls packages/ 2>/dev/null || echo "packages/ not checked out"
 
# 4. Add only the directories you need
git sparse-checkout set --cone packages/frontend packages/shared
 
# 5. Verify
ls packages/
# frontend/  shared/  (no backend/ or mobile/)
 
ls packages/frontend/
# App.tsx
 
ls packages/backend/ 2>/dev/null || echo "backend/ not checked out (expected)"
 
# 6. Git log still has full history
git log --oneline

cd ~/perf-lab
 
# 1. Basic timing
time git status
time git log --oneline | wc -l
 
# 2. Detailed performance trace
GIT_TRACE2_PERF=1 git status 2>/tmp/git-perf.log
cat /tmp/git-perf.log | grep "region_leave" | sort -t'|' -k4 -rn | head -10
# Shows which internal operations took the longest
 
# 3. Object storage analysis
git count-objects -v
 
# 4. Find the largest objects in the repository
git rev-list --objects --all \
  | git cat-file --batch-check='%(objecttype) %(objectname) %(objectsize) %(rest)' \
  | grep blob \
  | sort -rnk3 \
  | head -10
# Shows the 10 largest blobs — candidates for LFS
 
# 5. Check if commit-graph exists and is valid
git commit-graph verify 2>&1
ls -lh .git/objects/info/commit-graph
 
# 6. Full diagnostic summary
echo "=== Repo Stats ==="
echo "Files: $(find . -not -path './.git/*' -type f | wc -l)"
echo "Commits: $(git rev-list --count HEAD)"
echo "Branches: $(git branch -a | wc -l)"
git count-objects -vH