Intermediate

# Set up a repository with diverging branches
git init three-way-demo                   # => Creates three-way-demo/ directory
cd three-way-demo                         # => Enters the new repo

echo "line1" > file.txt                   # => Creates file.txt with content "line1"
git add file.txt && git commit -m "init"  # => Records common ancestor commit C1

git checkout -b feature                   # => Creates and switches to 'feature' branch
echo "feature line" >> file.txt           # => Appends to file.txt on feature branch
git commit -am "add feature line"         # => Records commit C2 on feature branch
# => feature branch is now 1 commit ahead of main

git checkout main                         # => Returns to main branch
echo "main line" >> file.txt              # => Appends a different line on main
git commit -am "add main line"            # => Records commit C3 on main
# => main and feature have now diverged from C1

git merge feature                         # => Triggers three-way merge algorithm
# => Git finds common ancestor C1
# => Combines changes from C2 (feature) and C3 (main)
# => Creates merge commit C4 with two parents
# => Output: Merge made by the 'ort' strategy

git log --oneline --graph                 # => Shows the diamond-shaped merge topology
# => * <hash> (HEAD -> main) Merge branch 'feature'
# => |\
# => | * <hash> (feature) add feature line
# => * | <hash> add main line
# => |/
# => * <hash> init

git init conflict-demo                    # => Creates fresh repository
cd conflict-demo

echo "shared content" > shared.txt       # => Creates file on the default branch
git add shared.txt && git commit -m "base" # => Records the common ancestor

git checkout -b branch-a                  # => Creates branch-a
echo "branch-a change" > shared.txt      # => Overwrites entire file on branch-a
git commit -am "branch-a edit"           # => Records this change on branch-a

git checkout main                         # => Returns to main
echo "main change" > shared.txt          # => Overwrites same file differently on main
git commit -am "main edit"               # => Both branches now have conflicting edits

git merge branch-a                        # => Attempts the merge
# => CONFLICT (content): Merge conflict in shared.txt
# => Automatic merge failed; fix conflicts and then commit the result
# => Git sets exit code 1 and leaves repo in MERGING state

cat shared.txt                            # => Shows the conflict markers:
# => <<<<<<< HEAD
# => main change
# => =======
# => branch-a change
# => >>>>>>> branch-a
# => Lines between <<<< and ==== are HEAD (main); lines between ==== and >>>> are branch-a

echo "resolved content" > shared.txt     # => Replaces file with the resolved version
# => Developer must choose: keep ours, keep theirs, or write merged content

git add shared.txt                        # => Stages the resolved file
# => Marks conflict as resolved in the index

git commit                                # => Completes the merge with a merge commit
# => Git pre-fills commit message: "Merge branch 'branch-a'"
# => Use -m to override, or accept the default

git status                                # => Output: nothing to commit, working tree clean

git init rebase-demo                      # => Initializes new repository
cd rebase-demo

echo "v1" > app.txt && git add . && git commit -m "C1: init"  # => Creates base commit C1
echo "v2" >> app.txt && git commit -am "C2: main work"        # => Records C2 on main

git checkout -b feature HEAD~1            # => Creates feature branch from C1 (one behind main)
echo "feat" > feature.txt && git add . && git commit -m "F1: feature start"  # => Records F1
echo "feat2" >> feature.txt && git commit -am "F2: feature end"               # => Records F2
# => feature branch: C1 → F1 → F2 (misses C2 on main)

git rebase main                           # => Replays F1 and F2 on top of main (C1 → C2)
# => First, rewound head to replay your work on top of it...
# => Applying: F1: feature start  → creates F1' with new hash
# => Applying: F2: feature end    → creates F2' with new hash
# => feature is now: C1 → C2 → F1' → F2'

git log --oneline                         # => Shows linear history:
# => <hash> (HEAD -> feature) F2: feature end
# => <hash> F1: feature start
# => <hash> (main) C2: main work
# => <hash> C1: init

git checkout main && git merge feature    # => Fast-forward merge: no merge commit needed
# => Since feature is directly ahead of main, Git just moves the main pointer
# => Output: Fast-forward

git init onto-demo                        # => Creates repository for demonstration
cd onto-demo

echo "root" > f.txt && git add . && git commit -m "root"           # => Creates root commit
echo "A" >> f.txt && git commit -am "commit-A"                     # => Records A
echo "B" >> f.txt && git commit -am "commit-B"                     # => Records B on main

git checkout -b topic main               # => Creates topic branch at B
echo "C" >> f.txt && git commit -am "commit-C"  # => Records C on topic
echo "D" >> f.txt && git commit -am "commit-D"  # => Records D on topic
# => topic: root → A → B → C → D

# Suppose we only want C and D on top of root, not on top of B
git rebase --onto root commit-B topic    # => Syntax: --onto <newbase> <upstream> <branch>
# => <newbase>  = root  : where to place the moved commits
# => <upstream> = commit-B : exclude commits up to and including this
# => <branch>   = topic : the branch whose commits to move
# => Replays only C and D on top of root
# => topic becomes: root → C' → D'

git log --oneline                         # => Shows:
# => <hash> (HEAD -> topic) commit-D
# => <hash> commit-C
# => <hash> (root...) root
# => Commits A and B are no longer in topic's ancestry

git init stash-demo && cd stash-demo
echo "v1" > work.txt && git add . && git commit -m "initial"  # => Records base commit

echo "in progress" >> work.txt            # => Modifies work.txt (uncommitted change)
echo "new file" > temp.txt               # => Creates an untracked file

git status                                # => Shows:
# => Changes not staged for commit:
# =>   modified:   work.txt
# => Untracked files:
# =>   temp.txt

git stash                                 # => Saves tracked changes; untracked files NOT saved by default
# => Saved working directory and index state WIP on main: <hash> initial
# => NOTE: temp.txt is NOT stashed (untracked)

git stash --include-untracked             # => To also stash untracked files, use this flag
# => Includes temp.txt in the stash entry

git status                                # => Output: nothing to commit, working tree clean
# => Working directory is now clean; safe to switch branches or pull

git stash pop                             # => Reapplies the most recent stash entry
# => Removes stash@{0} from the stack after applying
# => Output: On branch main — Changes not staged for commit: modified: work.txt

git status                                # => work.txt is modified again; temp.txt restored
# => Stack is now empty (stash pop removes the entry)

# Continuing from Example 33 setup (or start fresh)
git init stash-list-demo && cd stash-list-demo
echo "base" > f.txt && git add . && git commit -m "base"  # => Records base commit

echo "work1" >> f.txt && git stash                        # => Stash entry 0 created
# => stash@{0}: WIP on main: <hash> base

echo "work2" >> f.txt && git stash                        # => Stash entry 1 created
# => stash@{0} is now the newest (work2), pushing work1 to stash@{1}

echo "work3" >> f.txt && git stash                        # => Stash entry 2 created
# => Stack has three entries; newest is always stash@{0}

git stash list                            # => Shows all stash entries:
# => stash@{0}: WIP on main: <hash> base   ← most recent (work3)
# => stash@{1}: WIP on main: <hash> base   ← work2
# => stash@{2}: WIP on main: <hash> base   ← oldest (work1)

git stash apply stash@{1}                 # => Applies work2 WITHOUT removing it from stack
# => Changes restored to working directory
# => stash@{1} REMAINS in the list (apply ≠ pop)

git stash drop stash@{1}                  # => Removes stash@{1} from the stack
# => Dropped stash@{1} (<hash>)

git stash list                            # => Now shows only two entries:
# => stash@{0}: WIP on main: <hash> base
# => stash@{1}: WIP on main: <hash> base   ← was stash@{2}, renumbered

git stash clear                           # => Removes ALL stash entries at once
# => Use carefully — cannot be recovered after clearing

git init tag-demo && cd tag-demo
echo "release" > app.txt && git add . && git commit -m "v1 work"  # => Creates commit to tag

git tag v1.0                              # => Creates a LIGHTWEIGHT tag at HEAD
# => Lightweight tag: just a named reference (a file in .git/refs/tags/)
# => No message, no tagger info — a simple pointer to the commit hash

git tag -a v2.0 -m "Release version 2.0" # => Creates an ANNOTATED tag at HEAD
# => -a flag: create annotated tag (a full Git object)
# => -m flag: inline message; without -m, Git opens the editor
# => Annotated tag stores: tag name, message, tagger identity, and timestamp
# => Best practice: use annotated tags for public releases

git tag                                   # => Lists all tags in alphabetical order:
# => v1.0
# => v2.0

git show v2.0                             # => Shows annotated tag metadata + the commit:
# => tag v2.0
# => Tagger: Your Name <you@example.com>
# => Date:   <timestamp>
# => Release version 2.0
# =>
# => commit <hash> (HEAD -> main, tag: v2.0, tag: v1.0)

git tag v1.1 HEAD~0                       # => Tag a specific commit (even historical ones)
# => HEAD~0 = HEAD itself; use a commit hash to tag past commits

git push origin v2.0                      # => Push a single tag to remote
git push origin --tags                    # => Push ALL local tags to remote
# => Tags are NOT pushed automatically with git push; must be explicit

git init remote-demo && cd remote-demo
echo "work" > f.txt && git add . && git commit -m "init"  # => Creates base commit

git remote add origin https://github.com/user/repo.git   # => Adds remote named 'origin'
# => 'origin' is the conventional name for the primary remote
# => Stores URL in .git/config under [remote "origin"]

git remote add upstream https://github.com/org/original.git  # => Adds a second remote
# => 'upstream' is the convention for the source repo when you fork
# => Allows fetching upstream changes without affecting origin

git remote -v                             # => Lists all remotes with their fetch and push URLs:
# => origin    https://github.com/user/repo.git (fetch)
# => origin    https://github.com/user/repo.git (push)
# => upstream  https://github.com/org/original.git (fetch)
# => upstream  https://github.com/org/original.git (push)

git remote rename origin primary          # => Renames remote 'origin' to 'primary'
# => Also renames all tracking branches: origin/main → primary/main
# => Updates .git/config automatically

git remote remove upstream                # => Removes the 'upstream' remote entirely
# => Deletes .git/config entry and all remote-tracking branches for 'upstream'
# => Does NOT affect local branches or commits

git remote -v                             # => Output now shows only 'primary'
# => primary   https://github.com/user/repo.git (fetch)
# => primary   https://github.com/user/repo.git (push)

git remote set-url primary https://github.com/user/new-repo.git  # => Changes URL
# => Useful after a repository is moved or renamed on the hosting service

# Assumes a repository with a real remote; simulate with a local bare repo
git init --bare remote.git                # => Creates a bare repository to act as remote
git clone remote.git local-repo           # => Clones it to local-repo
cd local-repo

git checkout -b feature-old               # => Creates a new branch
git push origin feature-old               # => Pushes it to the remote
# => Remote now has: main, feature-old

# Simulate remote deletion (another developer deleted the branch)
cd ../remote.git
git branch -d feature-old 2>/dev/null || true  # => Deletes from bare repo (simulating remote delete)
cd ../local-repo

git fetch                                 # => Fetches remote state; does NOT prune by default
git branch -a                             # => Shows ALL branches including remote-tracking:
# => * main
# =>   remotes/origin/HEAD -> origin/main
# =>   remotes/origin/feature-old          ← stale! branch deleted on remote
# =>   remotes/origin/main

git remote prune origin                   # => Removes stale remote-tracking refs for 'origin'
# => Pruning origin
# => [pruned] origin/feature-old
# => feature-old is removed from the local tracking list

git fetch --prune                         # => Combined: fetch + prune in one command
# => The recommended daily-use form; equivalent to fetch then prune

git branch -a                             # => Only live remote branches appear now
# => * main
# =>   remotes/origin/HEAD -> origin/main
# =>   remotes/origin/main

git init cherry-demo && cd cherry-demo
echo "main v1" > app.txt && git add . && git commit -m "M1: main init"  # => Records M1

git checkout -b feature                   # => Creates feature branch from M1
echo "feat A" >> app.txt && git commit -am "C1: feature work A"  # => Records C1
echo "bugfix" >> app.txt && git commit -am "C2: critical bugfix"  # => Records bugfix commit C2
echo "feat B" >> app.txt && git commit -am "C3: feature work B"  # => Records C3

git log --oneline                         # => Shows:
# => <hash_C3> (HEAD -> feature) C3: feature work B
# => <hash_C2> C2: critical bugfix         ← we want this on main NOW
# => <hash_C1> C1: feature work A
# => <hash_M1> (main) M1: main init

git checkout main                         # => Returns to main branch
git cherry-pick <hash_C2>                 # => Replace <hash_C2> with the actual hash shown above
# => [main <new_hash>] C2: critical bugfix
# => 1 file changed, 1 insertion(+)
# => Creates C2' — same diff as C2 but new hash, new parent (M1), new timestamp

git log --oneline                         # => Shows cherry-picked commit on main:
# => <new_hash> (HEAD -> main) C2: critical bugfix
# => <hash_M1> M1: main init
# => main now has the bugfix; feature branch is unaffected

git cherry-pick <hash_C1> <hash_C3>      # => Pick multiple commits in order
git cherry-pick <hash_C1>..<hash_C3>     # => Pick a range (excludes C1, includes C3)

git init blame-demo && cd blame-demo

# Create a file with multiple authors simulated by multiple commits
echo "line one content" > notes.txt && git add . && git commit -m "add line 1" \
  --author="Alice <alice@example.com>"   # => Records line 1 with Alice as author

echo "line two content" >> notes.txt && git commit -am "add line 2" \
  --author="Bob <bob@example.com>"       # => Records line 2 with Bob as author

echo "line three content" >> notes.txt && git commit -am "add line 3" \
  --author="Carol <carol@example.com>"   # => Records line 3 with Carol as author

git blame notes.txt                      # => Shows per-line authorship:
# => ^abc1234 (Alice 2026-03-20 10:00:00 +0700 1) line one content
# => ^def5678 (Bob   2026-03-20 10:01:00 +0700 2) line two content
# => ^ghi9012 (Carol 2026-03-20 10:02:00 +0700 3) line three content
# => Format: <short-hash> (<author> <date> <line-number>) <content>

git blame -L 2,3 notes.txt               # => Shows blame for only lines 2–3
# => -L <start>,<end> : restricts output to the specified line range
# => Useful for large files where only a section is under investigation

git blame --since=1.week notes.txt       # => Shows only blame for lines changed in last week
# => Lines unchanged longer than 1 week show ^<hash> (before the range)

git blame -w notes.txt                   # => Ignores whitespace changes when attributing blame
# => Prevents reformatting commits from claiming authorship of every line

git init reflog-demo && cd reflog-demo
echo "v1" > f.txt && git add . && git commit -m "commit 1"   # => C1
echo "v2" >> f.txt && git commit -am "commit 2"              # => C2
echo "v3" >> f.txt && git commit -am "commit 3"              # => C3

git log --oneline                         # => C3 → C2 → C1

git reset --hard HEAD~2                   # => Moves HEAD back 2 commits to C1
# => Discards C2 and C3 from branch history
# => HEAD now points to C1; C2 and C3 appear lost

git log --oneline                         # => Only shows C1 — C2 and C3 are "gone"

git reflog                                # => Shows every HEAD change, including the reset:
# => <hash_C1> (HEAD -> main) HEAD@{0}: reset: moving to HEAD~2
# => <hash_C3>                HEAD@{1}: commit: commit 3
# => <hash_C2>                HEAD@{2}: commit: commit 2
# => <hash_C1>                HEAD@{3}: commit: commit 1
# => reflog entries persist for 90 days by default

git reset --hard HEAD@{1}                 # => Recover C3 by resetting to the reflog entry
# => HEAD@{1} holds the hash of C3 before the reset happened
# => HEAD is now back at C3; C2 and C3 are fully restored

git log --oneline                         # => C3 → C2 → C1 restored
# => git reflog + reset is the rescue sequence for accidental hard resets

git init reset-demo && cd reset-demo
echo "v1" > f.txt && git add . && git commit -m "C1"   # => C1
echo "v2" >> f.txt && git commit -am "C2"              # => C2

git reset --soft HEAD~1                   # => Moves branch pointer back to C1
# => C2 commit no longer exists on branch
# => Changes from C2 remain in the INDEX (staged), ready to re-commit
# => Working directory unchanged

git status                                # => Shows: Changes to be committed: modified: f.txt
# => --soft is ideal for "amend via re-commit" without the editor workflow

git reset --mixed HEAD~1                  # => Moves pointer back, clears index
# => --mixed is the DEFAULT if no flag specified (git reset HEAD~1)
# => Changes are in working directory but NOT staged
# => git status shows: Changes not staged for commit: modified: f.txt
# => Useful for reworking a commit: unstage, re-edit, re-add, re-commit

git reset --hard HEAD~1                   # => Moves pointer back AND overwrites working dir
# => Index is cleared AND working directory files revert to HEAD~1 state
# => WARNING: Unsaved local changes are permanently lost (use with care)
# => git status shows: nothing to commit, working tree clean
# => Use when you want to abandon a commit AND all its local changes

git init revert-demo && cd revert-demo
echo "base" > app.txt && git add . && git commit -m "C1: base"    # => C1
echo "good feature" >> app.txt && git commit -am "C2: add feature" # => C2
echo "bad change" >> app.txt && git commit -am "C3: bad change"    # => C3 (the problem)
echo "more work" >> app.txt && git commit -am "C4: later work"     # => C4

git log --oneline                         # => C4 → C3 → C2 → C1
# => C3 introduced a bug that is now in production

git revert HEAD~1                         # => Reverts C3 (HEAD~1 is one behind HEAD = C3)
# => Opens editor for the revert commit message
# => Default message: "Revert 'C3: bad change'"
# => Creates C5 that exactly inverts C3's diff
# => C4 (later work) is preserved; only C3's changes are undone

git log --oneline                         # => C5(revert C3) → C4 → C3 → C2 → C1
# => C3 is still in history (audit trail preserved)
# => C5 contains the inverse patch

git revert <hash_C3> --no-edit            # => Reverts by hash; --no-edit skips the editor
# => --no-edit uses the default "Revert ..." message automatically

git revert HEAD~2..HEAD                   # => Reverts a range (C3 and C4 in this example)
# => Creates one revert commit per reverted commit
git revert --no-commit HEAD~2..HEAD       # => Stages reversals without committing
# => Allows combining multiple reverts into a single commit

git init clean-demo && cd clean-demo
echo "tracked" > tracked.txt && git add . && git commit -m "init"  # => Tracks one file

echo "untracked" > untracked.txt         # => Creates an untracked file
mkdir build && echo "artifact" > build/output.bin  # => Creates an untracked directory

git status                                # => Shows:
# => Untracked files:
# =>   untracked.txt
# =>   build/

git clean -n                              # => DRY RUN: shows what WOULD be removed
# => -n (or --dry-run): preview without deleting
# => Would remove untracked.txt
# => NOTE: build/ directory NOT shown; -d flag needed for directories

git clean -nd                             # => Dry run including untracked directories
# => Would remove untracked.txt
# => Would remove build/

git clean -fd                             # => ACTUALLY removes files AND directories
# => -f (--force): required safety flag; prevents accidental deletion
# => -d: also removes untracked directories
# => Removing untracked.txt
# => Removing build/

git clean -fdx                            # => Also removes ignored files (e.g., build artifacts)
# => -x: removes files matching .gitignore patterns too
# => Useful for clean build: removes node_modules/, target/, dist/
# => WARNING: -x removes .env files if they are gitignored

git status                                # => Output: nothing to commit, working tree clean

# Create a .gitattributes file
cat > .gitattributes << 'EOF'
# Normalize line endings to LF on commit, convert to OS-native on checkout
* text=auto                               # => Auto-detect text files; normalize to LF in repo

# Explicitly mark file types
*.sh text eol=lf                          # => Shell scripts always LF (must be LF for Unix execution)
*.bat text eol=crlf                       # => Windows batch files always CRLF

# Binary files — no line ending conversion, no diff
*.png binary                              # => Treat PNG as binary: no CR/LF mangling
*.jpg binary                              # => Same for JPEG
*.pdf binary                              # => Same for PDF
*.zip binary                              # => Same for archives

# Custom diff driver for lock files (show package name in diff header)
package-lock.json diff=json               # => Use json diff driver for lock files
yarn.lock -diff                           # => Disable diff for yarn.lock (too noisy)

# Merge strategy: always take ours for generated files
*.min.js merge=ours                       # => Minified files: keep ours on merge conflict
EOF

git add .gitattributes && git commit -m "add .gitattributes"  # => Commits the attribute rules
# => Rules apply to ALL future operations involving matched files

git ls-files --eol                        # => Shows the eol handling for each tracked file:
# => i/lf   w/lf   attr/text=auto    tracked.txt
# => i = index (stored in Git), w = working tree, attr = attribute applied

git init hook-demo && cd hook-demo
echo "code" > app.sh && git add .

# Create a pre-commit hook
cat > .git/hooks/pre-commit << 'EOF'
#!/bin/sh
# pre-commit: runs before every commit; exit non-zero to abort

# Check for debug statements left in staged files
if git diff --cached --name-only | xargs grep -l "console.log\|debugger\|TODO: REMOVE" 2>/dev/null; then
    echo "ERROR: Debug statements found. Remove before committing."
    exit 1                                # => Non-zero exit aborts the commit
fi

# Run linter on staged JS files
staged_js=$(git diff --cached --name-only --diff-filter=ACM | grep "\.js$")
if [ -n "$staged_js" ]; then
    echo "$staged_js" | xargs eslint --quiet 2>/dev/null || exit 1
    # => eslint exit code 1 if violations found; hook inherits the exit code
fi

exit 0                                    # => Exit 0 = all checks passed, proceed with commit
EOF

chmod +x .git/hooks/pre-commit            # => Must be executable; Git ignores non-executable hooks
# => chmod +x is required; this is the most common reason hooks silently don't run

git commit -m "test commit"               # => Triggers the hook automatically
# => If grep finds debug statements: "ERROR: Debug statements found." → commit aborted
# => If checks pass: commit proceeds normally

# Bypass hooks in emergencies (use sparingly)
git commit --no-verify -m "emergency fix" # => --no-verify skips ALL hooks
# => Useful when a hook is broken and blocking urgent work
# => Document usage in the commit message

git init hooks-demo2 && cd hooks-demo2
echo "app" > app.txt && git add .

# commit-msg hook: enforce Conventional Commits format
cat > .git/hooks/commit-msg << 'EOF'
#!/bin/sh
# commit-msg: receives the path to the commit message file as $1

MSG_FILE="$1"                             # => $1 = path to temporary commit message file
MSG=$(cat "$MSG_FILE")                    # => Read the proposed message

# Conventional Commits pattern: type(scope): description
PATTERN="^(feat|fix|docs|style|refactor|test|chore|ci|perf|revert)(\(.+\))?: .{1,100}$"

if ! echo "$MSG" | grep -qE "$PATTERN"; then
    echo "ERROR: Commit message must follow Conventional Commits:"
    echo "  feat(scope): add new feature"
    echo "  fix: resolve null pointer issue"
    echo "Got: $MSG"
    exit 1                                # => Aborts commit; developer must re-run with valid message
fi

exit 0                                    # => Message is valid; commit proceeds
EOF
chmod +x .git/hooks/commit-msg            # => Must be executable

# pre-push hook: run tests before allowing a push
cat > .git/hooks/pre-push << 'EOF'
#!/bin/sh
# pre-push: runs before git push executes the network operation
# Receives remote name and URL via stdin in format: <local-ref> <local-sha> <remote-ref> <remote-sha>

echo "Running tests before push..."
# Replace with your actual test command
if ! make test 2>/dev/null; then          # => Run test suite; non-zero exit aborts push
    echo "Tests failed. Push rejected."
    exit 1
fi

exit 0                                    # => Tests passed; push proceeds
EOF
chmod +x .git/hooks/pre-push              # => Must be executable

git commit -m "bad message"              # => Triggers commit-msg hook
# => ERROR: Commit message must follow Conventional Commits
# => Commit aborted

git commit -m "feat: add initial app"    # => Passes the hook; commit succeeds

# System scope: /etc/gitconfig (requires admin/sudo)
git config --system core.autocrlf false  # => Sets system-wide line ending policy
# => Applies to ALL users on this machine
# => Rarely changed; usually set by system administrators

# Global scope: ~/.gitconfig (current user, all repos)
git config --global user.name "Alice Developer"       # => Sets author name for all commits
git config --global user.email "alice@example.com"    # => Sets author email for all commits
git config --global core.editor "vim"                 # => Sets commit message editor
git config --global init.defaultBranch main           # => Sets default branch name for git init
git config --global pull.rebase true                  # => Always rebase on pull (instead of merge)
git config --global fetch.prune true                  # => Auto-prune stale remote branches on fetch

# Local scope: .git/config (current repository only)
git init local-config-demo && cd local-config-demo
git config --local user.email "alice-work@company.com"  # => Overrides global email for this repo
# => Useful for work repos that need a corporate email vs personal email elsewhere
git config --local core.hooksPath .hooks              # => Custom hooks directory in the repo
# => Allows sharing hooks via version control (unlike .git/hooks which is not tracked)

git config --list --show-origin           # => Shows all config values and their source file:
# => file:/etc/gitconfig     core.autocrlf=false
# => file:/home/alice/.gitconfig  user.name=Alice Developer
# => file:/path/.git/config  user.email=alice-work@company.com
# => Local values override global which override system

git config user.email                     # => Reads the effective value for the current repo
# => alice-work@company.com (local overrides global)

git config --unset user.email             # => Removes a config key from local scope
git config --global --unset core.editor   # => Removes a key from global scope

# Define aliases globally (available in all repositories)
git config --global alias.st status      # => 'git st' now runs 'git status'
git config --global alias.co checkout    # => 'git co feature' runs 'git checkout feature'
git config --global alias.br branch      # => 'git br' runs 'git branch'
git config --global alias.ci commit      # => 'git ci -m "msg"' runs 'git commit -m "msg"'

# Complex aliases: multi-flag log formatting
git config --global alias.lg "log --oneline --graph --decorate --all"
# => 'git lg' shows a compact graphical branch/tag view of all history

git config --global alias.last "log -1 HEAD --stat"
# => 'git last' shows the most recent commit with file change stats

# Aliases that call shell commands (prefix with !)
git config --global alias.root '!git rev-parse --show-toplevel'
# => 'git root' prints the repository root directory path
# => The ! prefix routes the alias through the shell, not git itself

git config --global alias.wip '!git add -A && git commit -m "WIP: checkpoint"'
# => 'git wip' stages everything and creates a work-in-progress checkpoint commit

# Verify the aliases were saved
cat ~/.gitconfig                          # => Shows the [alias] section:
# => [alias]
# =>     st = status
# =>     co = checkout
# =>     lg = log --oneline --graph --decorate --all
# =>     root = !git rev-parse --show-toplevel

# Use the aliases
git st                                    # => Runs: git status
git lg                                    # => Runs: git log --oneline --graph --decorate --all
git root                                  # => Prints: /path/to/repository/root

git init log-demo && cd log-demo
git config user.name "Alice" && git config user.email "alice@example.com"
echo "v1" > f.txt && git add . && git commit -m "feat: initial commit"
git config user.name "Bob" && git config user.email "bob@example.com"
echo "v2" >> f.txt && git commit -am "fix: patch bug"
git config user.name "Alice" && git config user.email "alice@example.com"
git checkout -b feature && echo "v3" >> f.txt && git commit -am "feat: add feature"
git checkout main && git merge feature --no-ff -m "Merge feature branch"
# => Builds a repository with multiple authors and a merge commit

git log --oneline                         # => Compact: one line per commit
# => <hash> (HEAD -> main) Merge feature branch
# => <hash> (feature) feat: add feature
# => <hash> fix: patch bug
# => <hash> feat: initial commit

git log --oneline --graph --all           # => Shows branch topology with ASCII art
# => *   <hash> (HEAD -> main) Merge feature branch
# => |\
# => | * <hash> (feature) feat: add feature
# => * | <hash> fix: patch bug
# => |/
# => * <hash> feat: initial commit

git log --author="Alice"                  # => Filters commits by author name (partial match)
# => Shows only commits where author contains "Alice"

git log --since="1 week ago" --until="now"  # => Date range filter
# => --since (or --after) and --until (or --before) accept human-readable dates
# => Also accepts: "2026-01-01", "yesterday", "2 days ago"

git log --grep="feat"                     # => Filters by commit message content (case-sensitive)
# => --grep accepts a regex pattern; -i flag makes it case-insensitive

git log --all --oneline -- path/to/file   # => Shows only commits touching a specific file
# => -- separator distinguishes paths from branch names

git log -n 5                              # => Shows only the last 5 commits
# => -n <number> limits output count; same as --max-count=<number>

git log --format="%h %an %s" --no-merges # => Custom format, skip merge commits
# => %h: short hash, %an: author name, %s: subject line
# => --no-merges: excludes merge commits from output

git init diff-demo && cd diff-demo
echo "original" > file.txt && git add . && git commit -m "C1"   # => Records C1

echo "modified" > file.txt               # => Modifies file.txt (unstaged)
echo "new content" > new.txt && git add new.txt  # => Stages new.txt only

git diff                                  # => Compares working tree vs index (unstaged changes)
# => Shows: file.txt changed from "original" to "modified"
# => new.txt NOT shown (it is staged, not in working tree diff)

git diff --cached                         # => Compares index vs last commit (staged changes)
# => Also written as: git diff --staged (exact synonym)
# => Shows: new.txt added with "new content"
# => file.txt NOT shown (it is not staged yet)

git add file.txt                          # => Stages file.txt
git diff HEAD                             # => Compares working tree vs HEAD commit
# => Shows ALL changes (both staged and unstaged) vs last commit
# => Equivalent to: git diff HEAD -- .

git commit -m "C2: all changes"          # => Records C2

git checkout -b feature
echo "feature work" >> file.txt && git commit -am "C3: feature"
git checkout main

git diff main..feature                    # => Shows commits in feature but not in main
# => Dot-dot: reachable from feature, not reachable from main
git diff main...feature                   # => Shows changes since branches diverged
# => Triple-dot: diff from common ancestor to feature tip (ignores main's commits)

git diff --stat main feature              # => Summary: file names + insertions/deletions
# => file.txt | 1 +
# => 1 file changed, 1 insertion(+)
# => --stat is ideal for pull request previews

git diff --name-only main feature         # => Lists only changed file names (no diff content)
# => Useful for scripts that need to process changed files

git init strategy-demo && cd strategy-demo
echo "shared content" > config.txt && git add . && git commit -m "base"

git checkout -b branch-a
echo "branch-a value" > config.txt && git commit -am "branch-a sets config"

git checkout main
echo "main value" > config.txt && git commit -am "main sets config"

# Merge with 'ours' strategy extension: on conflict, prefer our (main) version
git merge -X ours branch-a               # => Merges branch-a; conflicts auto-resolved to main's version
# => -X ours: when lines conflict, keep HEAD (current branch = main) version
# => Non-conflicting changes from branch-a are still applied
# => Output: Merge made by the 'ort' strategy

cat config.txt                            # => Shows "main value" (ours was preferred)

# Reset and try theirs
git reset --hard HEAD~1                   # => Undo the merge for demonstration
git merge -X theirs branch-a             # => Merges; conflicts auto-resolved to branch-a's version
# => -X theirs: when lines conflict, keep the incoming branch's version
cat config.txt                            # => Shows "branch-a value" (theirs was preferred)

# The 'ours' STRATEGY (not extension) is different:
git checkout main
git merge --strategy=ours branch-a        # => Entire branch-a content discarded
# => --strategy=ours (without -X): result is identical to current HEAD regardless of branch-a
# => Useful for marking branch-a as "merged" without applying any of its changes
# => Common use case: recording that an abandoned branch was intentionally discarded

git init tracking-demo && cd tracking-demo
git init --bare origin.git                # => Creates a bare repo to act as remote
git remote add origin ./origin.git        # => Registers the remote

echo "v1" > f.txt && git add . && git commit -m "init"  # => Creates a commit to push
git push -u origin main                   # => -u sets up tracking: main → origin/main
# => -u (or --set-upstream): establishes the tracking relationship
# => Output: Branch 'main' set up to track remote branch 'main' from 'origin'

git status                                # => Shows tracking info:
# => On branch main
# => Your branch is up to date with 'origin/main'.

echo "local change" >> f.txt && git commit -am "local commit"  # => Local is now ahead
git status                                # => Output:
# => Your branch is ahead of 'origin/main' by 1 commit.
# =>   (use "git push" to publish your local commits)

# Set upstream for an existing branch (already created without -u)
git checkout -b feature && echo "feat" > f2.txt && git add . && git commit -m "feat"
git push origin feature                   # => Pushes but does NOT set upstream
git branch --set-upstream-to=origin/feature feature  # => Sets tracking after the fact
# => Branch 'feature' set up to track remote branch 'feature' from 'origin'.

git branch -vv                            # => Shows all branches with tracking info:
# => * feature  <hash> [origin/feature] feat
# =>   main     <hash> [origin/main: ahead 1] local commit

git pull                                  # => Without args, pulls from the tracked upstream
# => Since tracking is configured, git knows: pull from origin, merge into main

git init merge-log-demo && cd merge-log-demo
echo "main" > f.txt && git add . && git commit -m "M1: main init"
git checkout -b feature && echo "feat" >> f.txt && git commit -am "F1: feature"
git checkout main && git merge feature --no-ff -m "Merge feature into main"
echo "M2" >> f.txt && git commit -am "M2: main continues"
git checkout -b hotfix && echo "fix" >> f.txt && git commit -am "H1: hotfix"
git checkout main && git merge hotfix --no-ff -m "Merge hotfix"
# => History: M1 → F1, M1 → M2 → Merge(F1) → M2 → H1 → Merge(H1)

git log --oneline --merges                # => Shows ONLY merge commits:
# => <hash> Merge hotfix
# => <hash> Merge feature into main

git log --oneline --no-merges             # => Hides merge commits; shows real work:
# => <hash> M2: main continues
# => <hash> H1: hotfix
# => <hash> F1: feature
# => <hash> M1: main init

git log --oneline --first-parent          # => Follows only first parent (main line):
# => <hash> Merge hotfix
# => <hash> M2: main continues
# => <hash> Merge feature into main
# => <hash> M1: main init
# => Second parents (the merged branches) are not traversed
# => Gives a clean "main line" view ignoring branch history

git log --oneline --first-parent --no-merges  # => Main line commits only, no merge commits
# => <hash> M2: main continues
# => <hash> M1: main init
# => The cleanest "what happened on main" view

git init diff-word-demo && cd diff-word-demo
cat > readme.txt << 'EOF'
The quick brown fox jumps over the lazy dog.
Hello world this is a test sentence.
EOF
git add . && git commit -m "initial"

# Make a word-level change (not a full-line replacement)
cat > readme.txt << 'EOF'
The slow brown cat jumps over the sleeping dog.
Hello world this is a revised sentence.
EOF

git diff                                  # => Default line-level diff:
# => -The quick brown fox jumps over the lazy dog.
# => +The slow brown cat jumps over the sleeping dog.
# => Shows entire lines as changed; hard to spot exactly what words changed

git diff --word-diff                      # => Word-level diff with brackets:
# => The {-quick-}{+slow+} brown {-fox-}{+cat+} jumps over the {-lazy-}{+sleeping+} dog.
# => {-removed-} in curly braces with minus; {+added+} with plus
# => Much clearer for prose changes and configuration file values

git diff --color-words                    # => Word-level with color (terminal colors):
# => Removed words shown in red, added words in green
# => Best for interactive terminal use

git diff --word-diff=porcelain            # => Machine-readable word diff format:
# => ~The·{-quick-}{+slow+}·brown·{-fox-}{+cat+}
# => Suitable for scripting and post-processing

# Whitespace handling
echo "    spaced content    " > spaces.txt && git add . && git commit -m "add spaces"
echo "  spaced content  " > spaces.txt    # => Changed only whitespace

git diff -w                               # => Ignores ALL whitespace changes
# => No output: diff is empty because only whitespace changed
# => -w (--ignore-all-space): treats whitespace as insignificant

git diff --ignore-space-at-eol            # => Ignores trailing whitespace only
# => More targeted than -w; preserves indentation differences

git init bisect-demo && cd bisect-demo

# Build a history with a bug introduced midway
for i in 1 2 3 4 5 6 7 8; do
    echo "commit $i" > version.txt       # => Creates a file to change each commit
    git add . && git commit -m "commit $i"  # => Records 8 commits
done
# Simulate a bug introduced at commit 5 by checking content
# (In real use, you would run your test suite at each step)

git bisect start                          # => Begins bisect session; puts repo in bisect mode
git bisect bad HEAD                       # => Marks current (commit 8) as bad (bug present)
# => HEAD is the "bad" end of the search range

git bisect good HEAD~7                    # => Marks commit 1 as good (bug not present)
# => Bisect now knows: good = C1, bad = C8
# => Search space: 8 commits; binary search requires at most log2(8) = 3 tests
# => Git checks out the midpoint automatically: C4 or C5

# At each step, test whether the bug is present and mark accordingly:
git bisect bad                            # => Current commit shows the bug → search earlier
# => Git checks out an earlier midpoint automatically

git bisect good                           # => Current commit does not show the bug → search later
# => Git narrows the range again

# After enough steps, Git reports:
# => <hash> is the first bad commit
# => commit <hash>
# =>     commit 5          ← the culprit commit

git bisect reset                          # => Ends bisect session; returns to original HEAD
# => Cleans up the bisect state; repository returns to normal

# Automated bisect: run a test script at each step
git bisect start HEAD HEAD~7             # => Start + bad + good in one command
git bisect run sh -c 'grep -q "bad content" version.txt && exit 1 || exit 0'
# => -c: shell command to run; exit 0 = good, exit 1 = bad, exit 125 = skip
# => Git runs the script at each midpoint automatically until the culprit is found

git init stats-demo && cd stats-demo

# Simulate multiple authors
git config user.name "Alice" && git config user.email "alice@corp.com"
echo "a1" > a.txt && git add . && git commit -m "feat: alice commit 1"
echo "a2" >> a.txt && git commit -am "feat: alice commit 2"
echo "a3" >> a.txt && git commit -am "fix: alice bugfix"

git config user.name "Bob" && git config user.email "bob@corp.com"
echo "b1" > b.txt && git add . && git commit -m "docs: bob commit 1"

git config user.name "Alice" && git config user.email "alice@corp.com"
echo "a4" >> a.txt && git commit -am "refactor: alice refactor"

git shortlog                              # => Groups commits by author, shows commit messages:
# => Alice (4):
# =>       feat: alice commit 1
# =>       feat: alice commit 2
# =>       fix: alice bugfix
# =>       refactor: alice refactor
# => Bob (1):
# =>       docs: bob commit 1

git shortlog -sn                          # => Summary with counts, sorted by number:
# => -s (--summary): show only count per author
# => -n (--numbered): sort by commit count descending
# =>      4  Alice
# =>      1  Bob

git shortlog -sne                         # => Summary with counts and emails:
# => -e (--email): append <email> to each author name
# =>      4  Alice <alice@corp.com>
# =>      1  Bob <bob@corp.com>

git shortlog -sn --since="1 month ago"   # => Activity in the last month
# => Useful for sprint retrospectives and team performance reviews

git log --format='%aN' | sort | uniq -c | sort -rn | head -10
# => Alternative: lists top 10 contributors by commit count using standard shell tools
# => %aN = author name (respects .mailmap)

git init archive-demo && cd archive-demo
echo "source code" > app.txt && git add . && git commit -m "v1"
git tag v1.0                              # => Marks the commit for archiving
echo "more code" >> app.txt && git commit -am "v2 additions"

# Create a tar.gz archive of the tagged release
git archive --format=tar.gz --output=../release-v1.0.tar.gz v1.0
# => --format: output format (tar, tar.gz, zip)
# => --output: write to file instead of stdout
# => v1.0: the tree-ish to archive (tag, branch, or commit hash)
# => Output contains only source files; .git/ directory excluded

# Create a zip of HEAD
git archive --format=zip HEAD > ../snapshot.zip
# => HEAD: archives the current working tree state
# => Equivalent to "download ZIP" on GitHub

# Add a prefix to all paths in the archive
git archive --format=tar.gz --prefix=myapp-v1.0/ --output=../prefixed.tar.gz v1.0
# => --prefix: all files placed inside myapp-v1.0/ folder in the archive
# => Standard practice for distributable source archives

# git bundle: package history for offline transfer
git bundle create ../repo.bundle --all    # => Packages ALL refs and history into a single file
# => --all: include all branches and tags
# => repo.bundle is a portable Git repository

git clone ../repo.bundle cloned-from-bundle  # => Clone directly from a bundle file
# => Works exactly like cloning from a URL
# => Useful for air-gapped environments, offline work, or backup

git bundle verify ../repo.bundle          # => Verifies bundle integrity
# => Output: The bundle contains these git objects: ...
# => Confirms the bundle is valid before transferring

# Incremental bundle (only new commits since v1.0)
git bundle create ../incremental.bundle v1.0..HEAD
# => Only packages commits reachable from HEAD but not from v1.0
# => Reduces file size for incremental transfers