Recap — Working Tree → Index → Commit Flow

# Working Tree → Index → Commit Flow The most underused Git feature is the staging area. It's what lets you craft good commits instead of dumping everything into one giant commit. ## The three areas ``` [Working Tree] → [Staging Area / Index] → [Repository] edits in files what's queued to commit permanent history ``` Each area is a separate state. ## Status ```bash git status # Changes not staged for commit: ← Working Tree changes # modified: app.py # Changes to be committed: ← Staged # new file: README.md # Untracked files: ← In working tree, not tracked yet # new_script.py ``` Three categories shown. ## Move from working tree → staging ```bash git add file.txt # stage a specific file git add src/ # stage a directory git add . # stage everything in current dir + subdirs git add -A # stage all changes (including deletions outside cwd) git add -p # patch mode: stage hunks selectively git add -i # interactive mode (menu) ``` The `-p` option is the killer feature: review each chunk; choose what to include. ``` @@ -1,5 +1,5 @@ -def greeting(): - return "hi" +def greeting(): + return "hello" Stage this hunk [y,n,q,a,d,s,e,?]? ``` Lets you split a messy working tree into clean atomic commits. ## Move from staging → commit ```bash git commit -m "message" # commit what's staged git commit # opens editor for message git commit --amend # rewrite the last commit (changes its SHA!) ``` After commit: staged area is clear; working tree unchanged. ## Move from staging back to working tree (unstage) ```bash git restore --staged file.txt # unstage; changes stay in working tree # OR (older syntax): git reset HEAD file.txt ``` ## Discard working tree changes ```bash git restore file.txt # discard unstaged changes; back to last commit # OR (older syntax): git checkout -- file.txt ``` Both `restore` and `checkout` work; `restore` is the modern recommendation. ## Diffing ```bash git diff # working tree vs staged git diff --staged # staged vs last commit git diff HEAD # all changes (working + staged) vs last commit git diff main..feature # between branches ``` ## Committing well A good commit: - Contains ONE logical change. - Has a clear message. - Tests pass at that commit (history can be bisected). Bad commit examples: - "WIP" / "stuff" / "fix" — no information. - "Refactor + add feature + fix typo" — three changes; should be three commits. - "Asdf" — autopilot. ### Good commit message format ``` Short summary (50 chars or less) Longer explanation if needed, wrapped at ~72 chars. Explain WHY, not WHAT (the diff shows what). Reference issues if relevant. Closes #123 ``` Examples of good messages: - `fix(auth): handle empty password by raising ValidationError` - `Add rate limiting to /api/login endpoint (Closes #456)` - `Refactor user service to use repository pattern` ## Amending If you forgot something or made a typo in the last commit: ```bash # Edit files, stage them git add forgotten_file.py # Combine with the last commit git commit --amend # also opens editor for new message git commit --amend --no-edit # keep old message ``` Amend creates a NEW commit (different SHA) replacing the old. If you've already pushed, you'd need `--force` to update remote (dangerous if others have pulled). ## Common staging mistakes 1. **`git add .` without reviewing.** Includes accidental files (.env, __pycache__). 2. **Committing without staging.** `git commit -m "x"` only commits staged; modified-but-not-staged stays out. 3. **`git commit -a`.** Auto-stages tracked files. Convenient but skips the staging review. 4. **Forgetting to commit after merge.** Merge conflicts resolved → still need `git commit` to finalize. 5. **Amending shared commits.** Rewriting history that others have pulled = bad. ## .gitignore Prevent files from being tracked: ``` # .gitignore __pycache__/ *.pyc .env .venv/ node_modules/ dist/ .DS_Store *.log ``` `git status` won't show ignored files. For project-specific ignores: `.gitignore` in repo (committed). For user-specific: `~/.gitignore_global` (configured once globally). To ignore a file that's already tracked, `.gitignore` alone doesn't help; you must: ```bash git rm --cached file.txt # untrack but keep in working tree echo "file.txt" >> .gitignore git commit ``` ## Useful shortcuts ```bash git commit -am "msg" # add + commit all tracked changes git diff --stat # summary instead of full diff git log --oneline -10 # last 10 commits, brief git log --graph --oneline # ASCII DAG visualization ``` ## Takeaway Three areas: working tree (edits) → staging (queued for commit) → repository (histor