@shaykec/bridge 0.4.24 → 0.4.26

package/modules/git/content.md

@@ -0,0 +1,128 @@
+# Git - Version Control Fundamentals
+
+<!-- hint:slides topic="Git fundamentals: three areas (working directory, staging, repository), branches, merging strategies, and conflict resolution" slides="5" -->
+
+## What is Git?
+
+Git is a distributed version control system that tracks changes in source code during software development. It allows multiple developers to work on the same codebase simultaneously without overwriting each other's work.
+
+## Core Concepts
+
+### Repository
+A Git repository (repo) is a directory that Git tracks. It contains all your project files plus a hidden `.git` directory that stores the complete history of changes.
+
+```bash
+git init           # Create a new repository
+git clone <url>    # Clone an existing repository
+```
+
+### The Three Areas
+
+Git has three main areas where your files live:
+
+1. **Working Directory** — your actual files on disk
+2. **Staging Area (Index)** — files marked to be included in the next commit
+3. **Repository (HEAD)** — the committed history
+
+```
+Working Directory → git add → Staging Area → git commit → Repository
+```
+
+```mermaid
+flowchart LR
+    WD[Working Directory] -->|git add| SA[Staging Area]
+    SA -->|git commit| Repo[Repository]
+```
+
+### Commits
+
+A commit is a snapshot of your staged changes. Each commit has:
+- A unique SHA-1 hash (e.g., `a1b2c3d`)
+- Author and timestamp
+- A commit message describing the change
+- A pointer to its parent commit(s)
+
+```bash
+git add file.txt           # Stage a file
+git commit -m "message"    # Commit staged changes
+git log                    # View commit history
+```
+
+### Branches
+
+A branch is a lightweight movable pointer to a commit. The default branch is usually `main` or `master`.
+
+```bash
+git branch feature         # Create a new branch
+git checkout feature       # Switch to it
+git checkout -b feature    # Create + switch in one step
+git branch -d feature      # Delete a branch
+```
+
+### Merging
+
+Merging combines work from different branches.
+
+```bash
+git checkout main
+git merge feature          # Merge feature into main
+```
+
+**Fast-forward merge:** When the target branch hasn't diverged, Git just moves the pointer forward.
+
+**Three-way merge:** When both branches have new commits, Git creates a merge commit.
+
+### Merge Conflicts
+
+When Git can't automatically merge changes (both branches modified the same lines), you get a conflict:
+
+```
+<<<<<<< HEAD
+your changes
+=======
+their changes
+>>>>>>> feature
+```
+
+Resolve by editing the file, removing the markers, then:
+```bash
+git add file.txt
+git commit
+```
+
+## Common Workflows
+
+### Undoing Changes
+
+```bash
+git checkout -- file.txt   # Discard working directory changes
+git reset HEAD file.txt    # Unstage a file
+git revert <commit>        # Create a new commit that undoes a previous one
+git reset --hard <commit>  # Dangerous: discard all changes after a commit
+```
+
+### Remote Repositories
+
+```bash
+git remote add origin <url>   # Add a remote
+git push origin main          # Push to remote
+git pull origin main          # Fetch + merge from remote
+git fetch origin              # Fetch without merging
+```
+
+### Stashing
+
+Temporarily save uncommitted changes:
+```bash
+git stash                  # Stash changes
+git stash pop              # Restore stashed changes
+git stash list             # List all stashes
+```
+
+## Best Practices
+
+1. **Commit often** — small, focused commits are easier to understand and revert
+2. **Write good commit messages** — explain WHY, not just WHAT
+3. **Use branches** — keep main/master clean, develop features on branches
+4. **Pull before push** — avoid merge conflicts by staying up to date
+5. **Don't commit secrets** — use `.gitignore` for sensitive files

package/modules/git/exercises.md

@@ -0,0 +1,53 @@
+# Git Exercises
+
+## Exercise 1: Selective Staging
+
+**Task:** Create three files: `a.txt`, `b.txt`, `c.txt`. Commit only `a.txt` and `c.txt` in one commit, then `b.txt` in a separate commit.
+
+**Validation:**
+- [ ] `git log` shows exactly 2 new commits
+- [ ] First commit contains only `a.txt` and `c.txt`
+- [ ] Second commit contains only `b.txt`
+
+**Hints:**
+1. Use `git add` with specific filenames
+2. Check `git status` between steps to verify what's staged
+3. `git add a.txt c.txt` then `git commit`, then `git add b.txt` then `git commit`
+
+---
+
+## Exercise 2: Undo a Mistake
+
+**Task:** Make a commit with a typo in the file content. Then use `git revert` to undo it without losing history.
+
+**Validation:**
+- [ ] The typo commit exists in the log
+- [ ] A revert commit follows it
+- [ ] The file no longer contains the typo
+- [ ] `git log` shows both the mistake and the fix
+
+**Hints:**
+1. Commit the typo normally
+2. `git revert HEAD` creates a new commit that undoes the last one
+3. Check the file content after reverting
+
+---
+
+## Exercise 3: Branch Workflow
+
+**Task:** Simulate a feature branch workflow:
+1. Create a `develop` branch from `main`
+2. Create a `feature/login` branch from `develop`
+3. Make 2 commits on `feature/login`
+4. Merge `feature/login` into `develop`
+5. Merge `develop` into `main`
+
+**Validation:**
+- [ ] `main` contains all changes from the feature branch
+- [ ] The branch history shows the correct merge path
+- [ ] `git branch` shows only `main` (clean up branches after merge)
+
+**Hints:**
+1. Use `git checkout -b` to create and switch in one step
+2. After merging, delete branches with `git branch -d`
+3. Use `git log --graph --oneline` to visualize the history

package/modules/git/game.yaml

@@ -0,0 +1,190 @@
+games:
+  - type: command-sprint
+    title: "Git Command Sprint"
+    challenges:
+      - prompt: "Initialize a new Git repository in the current directory."
+        answer: "git init"
+        alternates: ["git init ."]
+        timeLimit: 18
+      - prompt: "Stage all changed files in the working directory."
+        answer: "git add ."
+        alternates: ["git add -A", "git add --all"]
+        timeLimit: 15
+      - prompt: "Create a commit with the message 'Add login form'."
+        answer: "git commit -m \"Add login form\""
+        alternates: ["git commit -m 'Add login form'"]
+        timeLimit: 20
+      - prompt: "Create and switch to a new branch named feature/auth."
+        answer: "git checkout -b feature/auth"
+        alternates: ["git switch -c feature/auth"]
+        timeLimit: 20
+      - prompt: "Show the commit log as a compact one-line-per-commit."
+        answer: "git log --oneline"
+        alternates: ["git log --oneline -n 20", "git log --pretty=oneline"]
+        timeLimit: 18
+      - prompt: "Discard all local changes in src/utils.js (restore to last commit)."
+        answer: "git checkout -- src/utils.js"
+        alternates: ["git restore src/utils.js"]
+        timeLimit: 22
+      - prompt: "Undo the last commit but keep your changes staged."
+        answer: "git reset --soft HEAD~1"
+        alternates: ["git reset --soft HEAD^"]
+        timeLimit: 22
+      - prompt: "Merge the main branch into your current branch."
+        answer: "git merge main"
+        alternates: ["git merge origin/main"]
+        timeLimit: 18
+      - prompt: "Rebase your current branch onto main."
+        answer: "git rebase main"
+        alternates: ["git rebase origin/main"]
+        timeLimit: 20
+      - prompt: "Abort an in-progress merge (return to pre-merge state)."
+        answer: "git merge --abort"
+        alternates: []
+        timeLimit: 20
+
+  - type: scenario
+    title: "Merge Conflict Crisis"
+    startHealth: 5
+    steps:
+      - id: start
+        situation: "You're on branch feature/checkout-ui. You haven't pulled from main in a week. Your teammate merged a big refactor. You run `git pull origin main` and Git reports merge conflicts in 3 files: src/App.jsx, src/components/Header.jsx, and package.json. What do you do first?"
+        choices:
+          - text: "Open each conflicted file and read the conflict markers."
+            consequence: "Smart. You inspect the conflicts before taking action."
+            health: 1
+            next: inspect
+          - text: "Run git merge --abort, then git pull --rebase origin main."
+            consequence: "Rebasing first can simplify conflicts, but you haven't seen them yet."
+            health: 0
+            next: rebase_path
+          - text: "Run git checkout --theirs . to accept all incoming changes."
+            consequence: "Danger! That discards all your work. You'd lose your feature code."
+            health: -2
+            next: bad_choice
+      - id: inspect
+        situation: "You open App.jsx and see conflict markers (<<<<<<< HEAD, =======, >>>>>>> main). The conflict is in the router setup: your version added a new route; main refactored the whole routing. What's your strategy?"
+        choices:
+          - text: "Manually resolve: keep my new route and adapt it to main's refactor."
+            consequence: "Correct. You integrate both sets of changes properly."
+            health: 1
+            next: resolve_one
+          - text: "Use git checkout --ours App.jsx to keep my version for this file."
+            consequence: "That keeps your route but may not work with main's refactor—integration issues ahead."
+            health: -1
+            next: ours_path
+          - text: "Delete the conflict markers and fix any syntax errors after."
+            consequence: "Risky. You might introduce broken code or lose logic."
+            health: -2
+            next: quick_fix
+      - id: resolve_one
+        situation: "You've resolved App.jsx. Header.jsx has a simpler conflict: both branches changed the same prop name. package.json has version conflicts. What next?"
+        choices:
+          - text: "Resolve Header.jsx and package.json, then git add . and git commit."
+            consequence: "Good. You resolve all files, stage them, and complete the merge."
+            health: 1
+            next: success
+          - text: "Run git add App.jsx only, commit, then deal with the others later."
+            consequence: "Leaving conflicts unresolved will block the merge. You need to fix all conflicted files."
+            health: -1
+            next: partial_fail
+          - text: "Use a merge tool (e.g. git mergetool) to resolve the rest."
+            consequence: "Using a tool is fine. You resolve the remaining conflicts."
+            health: 1
+            next: success
+      - id: rebase_path
+        situation: "You aborted and ran git pull --rebase. Now you're mid-rebase with conflicts. Git says 'Resolve conflicts, then run git add <file> and git rebase --continue.' What do you do?"
+        choices:
+          - text: "Resolve each conflicted file, git add them, then git rebase --continue."
+            consequence: "Right. That's the correct rebase flow."
+            health: 1
+            next: success
+          - text: "Run git rebase --skip to skip this commit."
+            consequence: "Only skip if you truly want to discard that commit. Usually you resolve."
+            health: -1
+            next: skip_warning
+          - text: "Run git rebase --abort to cancel the rebase entirely."
+            consequence: "You're back to square one. Merge might have been simpler."
+            health: -1
+            next: abort_path
+      - id: ours_path
+        situation: "You used --ours for App.jsx. Now Header.jsx and package.json still have conflicts. The build fails because your App.jsx doesn't match main's imports. What now?"
+        choices:
+          - text: "Undo the merge, then resolve all three files properly this time."
+            consequence: "Wise. Starting fresh with a careful resolve is better."
+            health: 1
+            next: start
+          - text: "Patch Header.jsx and package.json manually to fix the build."
+            consequence: "You salvage it, but it took extra work. Learning moment."
+            health: 0
+            next: success
+          - text: "Push as-is and ask your teammate to fix the build."
+            consequence: "Not a good habit. You own your merge resolution."
+            health: -2
+            next: bad_choice
+      - id: quick_fix
+        situation: "You removed the markers quickly. A test fails: the new route renders a 404. You realize you dropped a line during the quick fix. What do you do?"
+        choices:
+          - text: "Re-read the conflict, restore the correct logic, and re-run tests."
+            consequence: "Good recovery. Take your time with conflicts."
+            health: 1
+            next: success
+          - text: "Revert the merge commit and redo the merge more carefully."
+            consequence: "Also valid. Clean slate, proper resolution."
+            health: 0
+            next: success
+          - text: "Comment out the failing test and move on."
+            consequence: "Never a good idea. Tech debt and hidden bugs."
+            health: -2
+            next: bad_choice
+      - id: success
+        situation: "Merge complete. Your branch is updated with main, conflicts resolved, and the build passes. Well done!"
+        choices:
+          - text: "Continue working."
+            consequence: "You've navigated the merge conflict successfully."
+            health: 0
+            next: end
+      - id: partial_fail
+        situation: "Git won't complete the merge—there are still unmerged paths. You need to resolve and stage every conflicted file before committing."
+        choices:
+          - text: "Go back and resolve Header.jsx and package.json, then add and commit."
+            consequence: "You fix the mistake and complete the merge correctly."
+            health: 0
+            next: success
+          - text: "Give up and run git merge --abort."
+            consequence: "You abort and will need to redo the pull and resolution."
+            health: -1
+            next: abort_path
+      - id: skip_warning
+        situation: "You skipped a commit. If that commit had important changes, they're now gone. The rebase continues with more conflicts. Do you have more conflict resolution to do?"
+        choices:
+          - text: "Yes, resolve the next conflicts and git rebase --continue."
+            consequence: "You work through the remaining conflicts."
+            health: 0
+            next: success
+          - text: "Run git rebase --abort and try a regular merge instead."
+            consequence: "Sometimes merge is simpler than rebase when conflicts are many."
+            health: 0
+            next: abort_path
+      - id: abort_path
+        situation: "You've aborted. You're back on your branch before the merge/rebase. Main still has the refactor. What now?"
+        choices:
+          - text: "Pull with merge, then resolve conflicts carefully in all files."
+            consequence: "You try again with a clearer approach."
+            health: 0
+            next: start
+          - text: "Ask your teammate to resolve the conflicts for you."
+            consequence: "Learning to resolve conflicts is a core skill. Give it a shot."
+            health: -1
+            next: bad_choice
+      - id: bad_choice
+        situation: "That choice cost you. You've either lost work, created tech debt, or passed the buck. Merge conflicts demand care. Try to recover or restart."
+        choices:
+          - text: "Start over with a fresh mindset."
+            consequence: "Every conflict is a chance to practice."
+            health: 0
+            next: start
+          - text: "Accept the consequences and continue."
+            consequence: "Sometimes we learn the hard way."
+            health: 0
+            next: end

package/modules/git/module.yaml

@@ -0,0 +1,44 @@
+slug: git
+title: "Git - Version Control Fundamentals"
+version: 1.0.0
+description: "Master Git from scratch — commits, branches, merges, and collaboration workflows."
+category: developer-skills
+tags: [git, version-control, terminal, collaboration]
+difficulty: beginner
+
+xp:
+  read: 10
+  walkthrough: 40
+  exercise: 25
+  quiz: 20
+  quiz-perfect-bonus: 10
+  game: 25
+  game-perfect-bonus: 15
+
+time:
+  quick: 5
+  read: 15
+  guided: 45
+
+prerequisites: []
+related: [github, command-line]
+
+triggers:
+  - "How do I undo a commit?"
+  - "What's the difference between merge and rebase?"
+  - "How do I resolve merge conflicts?"
+  - "How does Git branching work?"
+
+visuals:
+  diagrams: [diagram-mermaid, diagram-flow]
+  quiz-types: [quiz-drag-order, quiz-timed-choice]
+  game-types: [command-sprint, scenario]
+  playground: bash
+  web-embeds: true
+  slides: true
+
+sources:
+  - url: "https://git-scm.com/doc"
+    label: "Official Git Documentation"
+  - url: "https://git-scm.com/book/en/v2"
+    label: "Pro Git Book"

package/modules/git/quick-ref.md

@@ -0,0 +1,67 @@
+# Git Quick Reference
+
+## Setup
+| Command | Purpose |
+|---|---|
+| `git init` | Create new repo |
+| `git clone <url>` | Clone existing repo |
+| `git config --global user.name "Name"` | Set name |
+| `git config --global user.email "email"` | Set email |
+
+## Daily Workflow
+| Command | Purpose |
+|---|---|
+| `git status` | See what's changed |
+| `git add <file>` | Stage specific file |
+| `git add .` | Stage everything |
+| `git commit -m "msg"` | Commit staged changes |
+| `git diff` | See unstaged changes |
+| `git diff --staged` | See staged changes |
+| `git log --oneline` | Compact history |
+
+## Branching
+| Command | Purpose |
+|---|---|
+| `git branch` | List branches |
+| `git branch <name>` | Create branch |
+| `git checkout <name>` | Switch branch |
+| `git checkout -b <name>` | Create + switch |
+| `git merge <branch>` | Merge into current |
+| `git branch -d <name>` | Delete branch |
+
+## Remote
+| Command | Purpose |
+|---|---|
+| `git remote -v` | List remotes |
+| `git push origin <branch>` | Push branch |
+| `git pull origin <branch>` | Fetch + merge |
+| `git fetch` | Download only |
+
+## Undo
+| Scenario | Command |
+|---|---|
+| Discard working changes | `git checkout -- <file>` |
+| Unstage a file | `git reset HEAD <file>` |
+| Undo last commit (keep changes) | `git reset --soft HEAD~1` |
+| Undo a pushed commit | `git revert <sha>` |
+| Discard everything | `git reset --hard HEAD` |
+
+## Stash
+| Command | Purpose |
+|---|---|
+| `git stash` | Save dirty state |
+| `git stash pop` | Restore + delete stash |
+| `git stash list` | Show all stashes |
+| `git stash drop` | Delete top stash |
+
+## Decision Tree: "How Do I Undo?"
+
+```
+Did you commit it?
+├── No → Is it staged?
+│   ├── Yes → git reset HEAD <file>
+│   └── No → git checkout -- <file>
+└── Yes → Did you push it?
+    ├── No → git reset --soft HEAD~1
+    └── Yes → git revert <sha>
+```

package/modules/git/quiz.md

@@ -0,0 +1,89 @@
+# Git Quiz
+
+## Question 1
+
+What does `git add` do?
+
+A) Commits your changes to the repository
+B) Moves files from the working directory to the staging area
+C) Creates a new file in the repository
+D) Pushes your changes to a remote server
+
+<!-- ANSWER: B -->
+<!-- EXPLANATION: git add stages changes — it marks modified or new files to be included in the next commit. It moves them from the working directory to the staging area (index). It does NOT commit them or push them anywhere. -->
+
+## Question 2
+
+You have uncommitted changes on `main` and want to switch to another branch. What's the safest approach?
+
+A) `git checkout other-branch` (just switch)
+B) `git stash` then `git checkout other-branch`
+C) `git reset --hard HEAD` then `git checkout other-branch`
+D) `git commit -a -m "wip"` then `git checkout other-branch`
+
+<!-- ANSWER: B -->
+<!-- EXPLANATION: git stash temporarily saves your uncommitted changes so you can switch branches cleanly. Option A might fail or carry changes to the other branch. Option C would DESTROY your changes. Option D works but pollutes your commit history with "wip" commits. -->
+
+## Question 3
+
+What's the difference between `git fetch` and `git pull`?
+
+A) They do the same thing
+B) `fetch` downloads changes; `pull` downloads AND merges them
+C) `fetch` is for branches; `pull` is for files
+D) `pull` is faster because it skips the staging area
+
+<!-- ANSWER: B -->
+<!-- EXPLANATION: git fetch downloads changes from the remote but doesn't modify your working directory or current branch. git pull is essentially git fetch + git merge — it fetches AND integrates the changes. fetch is safer when you want to inspect changes before merging. -->
+
+## Question 4
+
+You accidentally committed a file with a secret API key. The commit has NOT been pushed. What should you do?
+
+A) Delete the file and make a new commit
+B) Use `git reset --soft HEAD~1` to undo the commit, remove the secret, recommit
+C) Use `git revert HEAD` to undo the commit
+D) Just add the file to `.gitignore`
+
+<!-- ANSWER: B -->
+<!-- EXPLANATION: git reset --soft HEAD~1 undoes the last commit but keeps changes staged. You can then remove the secret and recommit. Option A still leaves the secret in git history. Option C creates a revert commit but the secret remains in history. Option D only prevents future tracking, not past commits. Since the commit hasn't been pushed, reset is safe. -->
+
+## Question 5
+
+What happens when you create a new Git branch?
+
+A) All files are copied to a new directory
+B) A new pointer is created pointing to the current commit
+C) A new repository is created
+D) The working directory is cleared
+
+<!-- ANSWER: B -->
+<!-- EXPLANATION: A Git branch is just a lightweight pointer (40-byte file) to a commit SHA. No files are copied. This is why creating branches in Git is nearly instantaneous, unlike older version control systems like SVN that actually copied directories. -->
+
+## Question 6
+
+<!-- VISUAL: drag-order -->
+
+Put these git commands in the correct order for a typical feature branch workflow:
+
+A) `git add .`
+B) `git checkout -b feature/my-feature`
+C) `git push -u origin feature/my-feature`
+D) `git commit -m "Implement feature"`
+
+<!-- ANSWER: B,A,D,C -->
+<!-- EXPLANATION: First create the branch (B), then stage changes (A), then commit (D), then push to set upstream (C). -->
+
+## Question 7
+
+<!-- VISUAL: drag-order -->
+
+Put these steps in the correct order to resolve a merge conflict:
+
+A) Edit the conflicted files to resolve the conflict
+B) `git add` the resolved files
+C) `git merge other-branch` (or pull, which triggers merge)
+D) `git commit` to complete the merge
+
+<!-- ANSWER: C,A,B,D -->
+<!-- EXPLANATION: You merge first (C), which may create conflicts. Then edit the conflicted files (A), stage them (B), and commit to complete the merge (D). -->

package/modules/git/resources.md

@@ -0,0 +1,49 @@
+# Git — Resources
+
+## Official Docs
+
+- [Git Reference Manual](https://git-scm.com/doc) — Complete command reference and man pages.
+- [Pro Git Book (free online)](https://git-scm.com/book/en/v2) — Scott Chacon & Ben Straub. The definitive Git book, covers everything from basics to internals.
+- [GitHub Docs — Git Handbook](https://docs.github.com/en/get-started/using-git/about-git) — Beginner-friendly Git overview from GitHub.
+
+## Videos
+
+- [Git Explained in 100 Seconds](https://www.youtube.com/watch?v=hwP7WQkmECE) — Fireship. Fast conceptual overview.
+- [Git for Professionals](https://www.youtube.com/watch?v=Uszj_k0DGsg) — Tobias Günther (freeCodeCamp). Deeper workflows, rebase, reflog.
+- [Git MERGE vs REBASE](https://www.youtube.com/watch?v=0chZFIZLR_0) — Fireship. Visual comparison of the two strategies.
+- [So You Think You Know Git (FOSDEM 2024)](https://www.youtube.com/watch?v=aolI_Rz0ZqY) — Scott Chacon. Tips and lesser-known features.
+- [How Git Works Under the Hood](https://www.youtube.com/watch?v=lG90LZotrpo) — Tech With Tim, 20 min. Understanding the object model (blobs, trees, commits).
+- [Advanced Git Tutorial](https://www.youtube.com/watch?v=qsTthZi23VE) — Academind. Interactive rebase, cherry-pick, stash.
+
+## Articles and Readings
+
+- [Atlassian Git Tutorials](https://www.atlassian.com/git/tutorials) — Well-illustrated guides covering beginner to advanced topics.
+- [Git Flight Rules](https://github.com/k88hudson/git-flight-rules) — GitHub repo. "What to do when things go wrong" — cookbook for common Git problems.
+- [Conventional Commits](https://www.conventionalcommits.org/) — Specification for structured commit messages used by many teams.
+- [A Visual Git Reference](https://marklodato.github.io/visual-git-guide/index-en.html) — Mark Lodato. Diagrams showing how each command changes the DAG.
+- [Oh Shit, Git!?!](https://ohshitgit.com/) — Plain-English solutions for common Git mistakes.
+
+## Books
+
+- **Pro Git** by Scott Chacon & Ben Straub — Free, covers everything. [Read online](https://git-scm.com/book/en/v2).
+- **Git Pocket Guide** by Richard E. Silverman — Quick reference for everyday commands.
+
+## Interactive and Visual Tools
+
+- [Learn Git Branching](https://learngitbranching.js.org/) — Interactive browser game that teaches branching, merging, and rebasing visually.
+- [Oh My Git!](https://ohmygit.org/) — Open-source game that teaches Git with a visual interface.
+- [Visualizing Git](https://git-school.github.io/visualizing-git/) — Type commands and see the commit graph update in real time.
+- [GitHub Skills](https://skills.github.com/) — Hands-on courses that run directly in GitHub repos.
+- [Git Explorer](https://gitexplorer.com/) — Find the right Git command by describing what you want to do.
+
+## Podcasts
+
+- [Changelog — Git episodes](https://changelog.com/topic/git) — Interviews with Git maintainers and workflow discussions.
+- [Software Engineering Daily — Version Control](https://softwareengineeringdaily.com/?s=git) — Episodes covering Git internals and large-scale workflows.
+
+## Tools
+
+- [lazygit](https://github.com/jesseduffield/lazygit) — Terminal UI for Git that makes complex operations visual.
+- [GitLens (VS Code)](https://marketplace.visualstudio.com/items?itemName=eamodio.gitlens) — In-editor blame, history, and comparison.
+- [Meld](https://meldmerge.org/) — Visual diff and merge tool, useful for conflict resolution.
+- [git-delta](https://github.com/dandavison/delta) — Syntax-highlighting pager for `git diff` output.