feat: add remotes and stash

module-10-stash/README.md

@@ -0,0 +1,199 @@
+# Module 11: Stash
+
+## Learning Objectives
+
+By the end of this module, you will:
+- Understand what git stash is and when to use it
+- Temporarily save work without committing
+- Switch between branches without losing uncommitted changes
+- Manage multiple stashes
+- Apply and remove stashed changes
+- Understand the difference between stash pop and stash apply
+
+## Challenge Description
+
+You're working on a feature when your teammate reports a critical bug in production. You need to switch to the main branch to fix it immediately, but your current work is incomplete and not ready to commit.
+
+Your task is to:
+1. Stash your incomplete work
+2. Switch to the main branch
+3. Fix the urgent bug and commit it
+4. Return to your feature branch
+5. Restore your stashed changes
+6. Complete your feature and commit it
+
+## Key Concepts
+
+### What is Git Stash?
+
+Git stash temporarily saves your uncommitted changes (both staged and unstaged) and reverts your working directory to match the HEAD commit. Think of it as a clipboard for your changes.
+
+### When to Use Stash
+
+Use stash when you need to:
+- Switch branches but have uncommitted changes
+- Pull updates from remote but have local modifications
+- Quickly test something on a clean working directory
+- Save work temporarily without creating a commit
+- Context-switch between tasks
+
+### Stash vs Commit
+
+**Stash:**
+- Temporary storage
+- Not part of project history
+- Can be applied to different branches
+- Easy to discard if not needed
+- Local only (not pushed to remote)
+
+**Commit:**
+- Permanent part of history
+- Creates a snapshot in the project timeline
+- Associated with a specific branch
+- Should be meaningful and complete
+- Can be pushed to remote
+
+### The Stash Stack
+
+Git stash works like a stack (LIFO - Last In, First Out):
+```
+stash@{0}  <- Most recent stash (top of stack)
+stash@{1}
+stash@{2}  <- Oldest stash
+```
+
+You can have multiple stashes and apply any of them.
+
+## Useful Commands
+
+```bash
+# Stash current changes
+git stash
+git stash save "description"  # With a descriptive message
+
+# Stash including untracked files
+git stash -u
+
+# List all stashes
+git stash list
+
+# Apply most recent stash and remove it from stack
+git stash pop
+
+# Apply most recent stash but keep it in stack
+git stash apply
+
+# Apply a specific stash
+git stash apply stash@{1}
+
+# Show what's in a stash
+git stash show
+git stash show -p  # Show full diff
+
+# Drop (delete) a stash
+git stash drop stash@{0}
+
+# Clear all stashes
+git stash clear
+
+# Create a branch from a stash
+git stash branch new-branch-name
+```
+
+## Verification
+
+Run the verification script to check your solution:
+
+```bash
+.\verify.ps1
+```
+
+The verification will check that:
+- The bug fix commit exists on main
+- Your feature is completed on the feature branch
+- Changes were properly stashed and restored
+- No uncommitted changes remain
+
+## Challenge Steps
+
+1. Navigate to the challenge directory
+2. You're on feature-login with uncommitted changes
+3. Check status: `git status` (you'll see modified files)
+4. Stash your changes: `git stash save "WIP: login feature"`
+5. Verify working directory is clean: `git status`
+6. Switch to main: `git checkout main`
+7. View the bug in app.js and fix it (remove the incorrect line)
+8. Commit the fix: `git add app.js && git commit -m "Fix critical security bug"`
+9. Switch back to feature: `git checkout feature-login`
+10. Restore your work: `git stash pop`
+11. Complete the feature (the TODOs in login.js)
+12. Commit your completed feature
+13. Run verification
+
+## Tips
+
+- Always use `git stash save "message"` to describe what you're stashing
+- Use `git stash list` to see all your stashes
+- `git stash pop` applies and removes the stash (use this most often)
+- `git stash apply` keeps the stash (useful if you want to apply it to multiple branches)
+- Stashes are local - they don't get pushed to remote repositories
+- You can stash even if you have changes to different files
+- Stash before pulling to avoid merge conflicts
+- Use `git stash show -p` to preview what's in a stash before applying
+
+## Common Stash Scenarios
+
+### Scenario 1: Quick Branch Switch
+```bash
+# Working on feature, need to switch to main
+git stash
+git checkout main
+# Do work on main
+git checkout feature
+git stash pop
+```
+
+### Scenario 2: Pull with Local Changes
+```bash
+# You have local changes but need to pull
+git stash
+git pull
+git stash pop
+# Resolve any conflicts
+```
+
+### Scenario 3: Experimental Changes
+```bash
+# Try something experimental
+git stash  # Save current work
+# Make experimental changes
+# Decide you don't like it
+git restore .  # Discard experiment
+git stash pop  # Restore original work
+```
+
+### Scenario 4: Apply to Multiple Branches
+```bash
+# Same fix needed on multiple branches
+git stash
+git checkout branch1
+git stash apply
+git commit -am "Apply fix"
+git checkout branch2
+git stash apply
+git commit -am "Apply fix"
+git stash drop  # Clean up when done
+```
+
+## Stash Conflicts
+
+If applying a stash causes conflicts:
+1. Git will mark the conflicts in your files
+2. Resolve conflicts manually (like merge conflicts)
+3. Stage the resolved files: `git add <file>`
+4. The stash is automatically dropped after successful pop
+5. If you used `apply`, manually drop it: `git stash drop`
+
+## What You'll Learn
+
+Git stash is an essential tool for managing context switches in your daily workflow. It lets you maintain a clean working directory while preserving incomplete work, making it easy to handle interruptions, urgent fixes, and quick branch switches. Mastering stash makes you more efficient and helps avoid the temptation to make "WIP" commits just to switch branches. Think of stash as your temporary workspace that follows you around.