@icarusmx/creta 1.5.12 → 1.5.14

package/lib/exercises/01-developing-muscle-for-nvim.md

@@ -0,0 +1,528 @@
+# Developing Muscle Memory for Neovim
+
+<!-- vim: set foldmethod=marker foldlevel=0: -->
+
+## 📖 LazyVim Reading Guide {{{
+
+**Start with:** `zM` (close all folds) → Navigate with `za` (toggle fold under cursor)
+
+This document uses fold markers `{{{` and `}}}` for organized reading.
+
+**Important keys for this exercise:**
+- `j` - Move down line by line
+- `}` - Jump to next paragraph (you'll practice this!)
+- `{` - Jump to previous paragraph
+
+}}}
+
+## 🎯 Purpose {{{
+
+This exercise puts you on the vim mastery path by teaching keyboard-driven navigation.
+
+**What you'll learn:**
+- The `}` and `{` commands for paragraph jumping
+- How to navigate without touching the mouse
+- Building muscle memory for efficient code reading
+
+}}}
+
+## Part 1: The `}` Command {{{
+
+### What `}` Does {{{
+
+In vim/neovim, the **`}`** command jumps forward to the next paragraph (empty line-separated block of text).
+
+Press `}` right now. You'll skip past this text block and land after the next empty line.
+
+Go ahead - press it a few times. Get a feel for the rhythm.
+
+}}}
+
+### Why This Matters {{{
+
+When reading documentation, you don't need to read every word linearly. You're skimming for structure:
+
+- Section titles
+- Code blocks
+- Key concepts
+- Things that look relevant to your task
+
+The `}` command lets you **skim at keyboard speed**. No mouse, no scrolling lag, no hand movement.
+
+}}}
+
+### Practice Zone: Press `}` Multiple Times {{{
+
+This section has several paragraphs separated by empty lines. Your task: Press `}` repeatedly and notice how you hop from paragraph to paragraph.
+
+Here's the first paragraph. It's about nothing in particular - just giving you something to jump over. The goal is to feel the rhythm of movement.
+
+Here's the second paragraph. Notice how `}` jumped you here instantly? That's the point. You're not scrolling pixel by pixel - you're jumping conceptually.
+
+Third paragraph here. By now you should be feeling the pattern. Empty line = paragraph boundary. `}` = jump forward. `{` (which we'll cover later) = jump backward.
+
+Fourth paragraph. Keep going! Press `}` again and skip past this one too.
+
+Fifth paragraph. You're getting good at this! The movement should start to feel natural.
+
+Sixth paragraph. Notice how your eyes don't even read every word anymore? You're scanning for structure, not content. That's efficient reading.
+
+Seventh paragraph. This is what developers mean when they talk about "keyboard-driven workflow" - your hands never leave home row.
+
+Eighth paragraph. Let's keep building content to jump through. The more paragraphs we have, the more you'll internalize this movement.
+
+Ninth paragraph. Starting to feel natural yet? The key is **not thinking about it** - just pressing `}` whenever you want to skip forward.
+
+Tenth paragraph. Alright, you've earned a break. But remember - this is just the foundation. Next we'll combine `}` with fold control.
+
+}}}
+
+### The Backward Jump (`{`) {{{
+
+Of course, you can also jump backward. The **`{`** command does the opposite of `}` - it jumps to the previous paragraph.
+
+Try it now: Press `{` a few times and go back up through the paragraphs you just skipped.
+
+This is useful when you:
+
+- Jumped too far and need to backtrack
+- Want to re-read something you skimmed past
+- Are searching for something and need to move bidirectionally
+
+}}}
+
+### Combining `}` and `{` for Bidirectional Scanning {{{
+
+Now you have both directions. This means you can:
+
+- **`}` `}` `}`** - Skip forward three paragraphs
+- **`{` `{`** - Backtrack two paragraphs
+- Find what you need without touching the mouse
+# TODO: add zM command and za reference here. 
+This is the foundation of keyboard-driven navigation. Everything else builds on this.
+
+}}}
+
+### Why We Started Here {{{
+
+You might be wondering: "Why focus so much on `}` when this is a fold navigation guide?"
+
+**Answer:** Because `}` is the **muscle memory foundation**. Before you can efficiently navigate 1,000-line files with folds, you need to be comfortable jumping around without thinking about it.
+
+Folds are just **structure on top of paragraphs**. Once `}` is automatic, fold navigation will feel like a natural extension.
+
+}}}
+
+### Practice Exercise {{{
+
+Before moving on, do this:
+
+1. Press **`gg`** to jump to the top of this file
+2. Press **`}`** until you get back to this section
+3. Notice how you skimmed the entire file in ~10 keystrokes
+
+That's the power of paragraph jumping. Now let's layer in fold control.
+
+}}}
+
+}}}
+
+## Part 2: Fold Control - The Overview Commands {{{
+
+### The `zM` Command (Close All Folds) {{{
+
+**What it does:** Closes all folds in the file, leaving only top-level headers visible.
+
+**Why it's powerful:** Instant table of contents. You see the structure of the entire file at a glance.
+
+Before going into **`zM`** remember also **`za`** 
+
+**Try it now:**
+
+1. Press **`zM`**
+2. Watch this entire file collapse into just section headers
+3. You just turned a 400+ line file into ~20 lines of overview
+
+This is **zoom-out mode**. You're seeing the forest, not the trees.
+
+**When to use `zM`:**
+
+- Just opened a new file and want to understand structure
+- Got lost deep in a section and need to reorient
+- Looking for a specific section but don't remember where it is
+- Want to copy/paste a section header
+
+}}}
+
+### The `za` Command (Toggle Current Fold) {{{
+
+**What it does:** Opens or closes the fold your cursor is on.
+
+**Why it's powerful:** Targeted exploration. Open only what matters, keep everything else collapsed.
+
+**Try it now:**
+
+1. Make sure you pressed `zM` to collapse everything
+2. Move your cursor to a section header (use `j`/`k` or `}`)
+3. Press **`za`**
+4. Watch that section expand
+5. Press **`za`** again
+6. Watch it collapse
+
+This is **zoom-in mode**. You're focusing on one thing at a time.
+
+**The `za` rhythm:**
+
+- See interesting header → **`za`** (open)
+- Read the content
+- Done reading → **`za`** (close)
+- Move to next section
+
+}}}
+
+### The `zR` Command (Open All Folds) {{{
+
+**What it does:** Opens all folds in the file, showing everything.
+
+**Why it's powerful:** Sometimes you need to see the full picture. Or search across all content.
+
+**Try it now:**
+
+1. Press **`zR`**
+2. Watch the entire file expand
+
+**When to use `zR`:**
+
+- Searching for text (`:/ search term`)
+- Need to compare content across sections
+- Reading linearly from start to finish
+- Copying large chunks of text
+
+**Note:** After using `zR`, you can always press `zM` to collapse everything again. These commands are reversible and instant.
+
+}}}
+
+### Combining `}` and Fold Commands - The Core Workflow {{{
+
+Now we layer the two skills:
+
+**The Exploration Pattern:**
+
+1. **`zM`** - Collapse everything (see overview)
+2. **`}` `}` `}`** - Jump between section headers
+3. **`za`** - Open interesting section
+4. Read what matters
+5. **`za`** - Close it
+6. Repeat
+
+**Try this right now:**
+
+1. Press **`zM`** (collapse all)
+2. Press **`gg`** (go to top)
+3. Press **`}`** until you reach "Part 3: Precision Navigation"
+4. Press **`za`** (open that section)
+5. Skim the content
+6. Press **`za`** (close it)
+7. Press **`}`** to move to next section
+
+Did you feel that? You just navigated ~200 lines in ~10 keystrokes.
+
+**That's the workflow.** Everything else is just refinement.
+
+}}}
+
+### Why This Changes Everything {{{
+
+Before fold markers, navigating a large file meant:
+
+- Scrolling (slow, imprecise)
+- Ctrl+F searching (requires knowing exact text)
+- Getting lost (no sense of structure)
+- Context switching (opening multiple files)
+
+With fold markers + LazyVim:
+
+- **`zM`** = Instant table of contents
+- **`}`** = Skip to what matters
+- **`za`** = Read only relevant sections
+- Never lose your place
+- Never feel overwhelmed
+
+This is **progressive disclosure in a text file**. It's the UX pattern that makes complex interfaces usable, now applied to documentation.
+
+}}}
+
+}}}
+
+## Part 3: Precision Navigation - Advanced Movement {{{
+
+### Go to Top (`gg`) and Bottom (`G`) {{{
+
+**`gg`** - Jump to the first line of the file
+**`G`** - Jump to the last line of the file
+
+These are your **anchors**. No matter where you are, you can instantly return to the boundaries.
+
+**When to use:**
+
+- **`gg`** - Start over, return to overview
+- **`G`** - See conclusion, check file end
+- Combined with `zM` for instant reorientation
+
+**Try it:**
+
+1. Press **`G`** (you're at the bottom)
+2. Press **`gg`** (back to top)
+3. Press **`zM`** (collapsed overview)
+4. Press **`G`** (see end of file, still collapsed)
+
+}}}
+
+### Go to Line Number (`22G`) {{{
+
+**Format:** `{number}G` - Jump to specific line number
+
+**Examples:**
+
+- **`22G`** - Jump to line 22
+- **`150G`** - Jump to line 150
+- **`1G`** - Same as `gg` (first line)
+
+**When this is powerful:**
+
+- Compiler errors: "Error on line 342" → **`342G`**
+- Reviewing PR diffs: "Check line 89" → **`89G`**
+- Debugging logs: "Line 1523 shows the issue" → **`1523G`**
+- Documentation references: "See line 67 for example"
+
+**Combined with folds:**
+
+1. Press **`zM`** (collapse all)
+2. Press **`150G`** (jump to line 150)
+3. Press **`za`** (open fold at that line)
+
+You just navigated to a specific location in a 1,000-line file in **3 keystrokes**.
+
+}}}
+
+### Relative Line Numbers (`22j`, `15k`) {{{
+
+**Format:** `{number}j` or `{number}k` - Move N lines down/up
+
+**Examples:**
+
+- **`5j`** - Move 5 lines down
+- **`10k`** - Move 10 lines up
+
+**When this is useful:**
+
+- You see something 5 lines down → **`5j`**
+- Need to go back 3 lines → **`3k`**
+- Scanning sections with precise movement
+
+**Pro tip:** If you enable relative line numbers (`:set relativenumber`), you can see exactly how many lines away something is and jump directly.
+
+}}}
+
+### Jump to Fold Boundaries (`]]`, `[[`, `]z`, `[z`) {{{
+
+Now that you're comfortable with folds, let's add precision:
+
+**`]]`** - Jump to **next fold start**
+**`[[`** - Jump to **previous fold start**
+**`]z`** - Jump to **end of current fold**
+**`[z`** - Jump to **start of current fold**
+
+**Scenarios:**
+
+**Scenario 1: Scanning fold headers without opening**
+
+1. **`zM`** (collapse all)
+2. **`]]` `]]` `]]`** (jump between section starts)
+3. Faster than `}` when you want fold-to-fold movement
+
+**Scenario 2: Check fold boundaries**
+
+1. Open a fold with **`za`**
+2. Press **`]z`** (jump to end of current fold)
+3. Press **`[z`** (jump back to start of fold)
+
+**When to use:**
+
+- **`]]` / `[[`** - Fast section-to-section navigation
+- **`]z` / `[z`** - Understand fold scope
+- Combined with `zM` for structural scanning
+
+}}}
+
+}}}
+
+## Part 4: Your Daily Workflow - Quick Reference {{{
+
+### The Standard Exploration Pattern {{{
+
+```
+Open file → zM (overview)
+          ↓
+       }}}}} (scan headers)
+          ↓
+       za (open section)
+          ↓
+       Read content
+          ↓
+       za (close)
+          ↓
+       Repeat
+```
+
+}}}
+
+### Common Workflows {{{
+
+**1. Find Specific Section:**
+
+```
+zM → }}} → za → read → za
+```
+
+**2. Check File Structure:**
+
+```
+gg → zM → G → gg
+```
+
+**3. Jump to Known Line:**
+
+```
+zM → 342G → za
+```
+
+**4. Scan Multiple Sections:**
+
+```
+zM → ]] ]] za → read → za → ]] za → read
+```
+
+**5. Compare Two Sections:**
+
+```
+zM → 100G → za → read → 250G → za → read
+```
+
+}}}
+
+}}}
+
+## Complete Command Reference {{{
+
+### Paragraph Navigation {{{
+- **`}`** - Next paragraph
+- **`{`** - Previous paragraph
+}}}
+
+### Fold Control {{{
+- **`zM`** - Close all folds (overview mode)
+- **`zR`** - Open all folds (full view)
+- **`za`** - Toggle current fold
+- **`zo`** - Open current fold
+- **`zc`** - Close current fold
+}}}
+
+### Position Jumps {{{
+- **`gg`** - First line
+- **`G`** - Last line
+- **`{number}G`** - Jump to line number (e.g., `22G`)
+- **`{number}j`** - Move N lines down (e.g., `5j`)
+- **`{number}k`** - Move N lines up (e.g., `10k`)
+}}}
+
+### Fold Boundaries {{{
+- **`]]`** - Next fold start
+- **`[[`** - Previous fold start
+- **`]z`** - End of current fold
+- **`[z`** - Start of current fold
+}}}
+
+### Pro Tips {{{
+- **`Ctrl+d`** - Scroll half page down
+- **`Ctrl+u`** - Scroll half page up
+- **`%`** - Jump to matching bracket/fold marker
+- **`:set foldlevel=1`** - Show level 1 folds only
+}}}
+
+}}}
+
+## What's Next? {{{
+
+### You've Built the Muscle Memory {{{
+
+If you've been navigating this file using the commands as you learned them, you've already internalized the workflow. Your fingers know:
+
+- **`zM`** when you need overview
+- **`}`** when you want to skip forward
+- **`za`** when you want to read something
+- **`gg`** / **`G`** when you need anchors
+
+That's it. That's the foundation.
+
+}}}
+
+### Where to Practice {{{
+
+**Other markdown files in this project:**
+
+Look for files with fold markers (they'll have `{{{` and `}}}` in them):
+
+```bash
+# Find all markdown files with fold markers
+rg --type md '\{\{\{' -l
+```
+
+**Your own notes:**
+
+Start adding fold markers to your own documentation:
+
+```markdown
+## Section Name {{{
+
+Content here...
+
+}}}
+```
+
+Add this vim modeline at the top of any markdown file:
+
+```markdown
+<!-- vim: set foldmethod=marker foldlevel=0: -->
+```
+
+Now your notes are navigable with the same workflow.
+
+}}}
+
+### The Philosophy {{{
+
+**Navigation is reading strategy.**
+
+When you navigate well, you:
+
+- Find what matters faster
+- Understand structure before details
+- Never feel overwhelmed
+- Build knowledge systematically
+
+Fold markers + LazyVim + muscle memory = **documentation that scales**.
+
+Whether it's 100 lines or 10,000 lines, the workflow stays the same:
+
+**`zM` → `}}}` → `za` → read → `za` → repeat**
+
+}}}
+
+}}}
+
+---
+
+You just navigated hundreds of lines without scrolling once. Welcome to keyboard mastery.
+
+**Made with 🏛️ by icarus.mx** - Teaching developers to navigate complexity.

package/lib/exercises/{iterm2-pane-navigation.md → 02-iterm2-pane-navigation.md}

@@ -27,7 +27,7 @@ That's **three keys** just to move between panes. Way too much!
 ## ✅ Solution: Customize to Cmd + 0 (or any key you prefer) {{{
 
 You can change iTerm2's pane navigation shortcuts to something simpler.
-
+# TODO: in the end i used the GUI with cmd + , and added control and now move between panes with ctrl + 1, ctrl + 2
 **Popular options:**
 - `Cmd + 0` (simple, one-handed)
 - `Cmd + Arrow` (directional)