@icarusmx/creta 1.5.12 → 1.5.14

package/lib/exercises/13-shell-aliases.md

@@ -0,0 +1,134 @@
+# Shell Aliases: Personaliza tu Terminal
+
+## Objetivo
+
+Aprende a crear alias de shell para hacer comandos más intuitivos y personalizados. Crearemos el alias `lz` (localiza recurso) para `curl`.
+
+## ¿Qué es un Alias?
+
+Un alias es un atajo personalizado para un comando. Por ejemplo:
+- En vez de escribir `curl https://icarus.mx`
+- Escribes `lz https://icarus.mx`
+
+## Por qué `lz` para curl
+
+**curl** = Client URL (Cliente de URL)
+- **Cliente**: localiza recursos para ti
+- **Universal**: usa HTTP (HyperText Transfer Protocol)
+- **lz**: "localiza recurso" - alias en español
+
+## Paso 1: Identificar tu Shell
+
+En macOS Catalina+ se usa `zsh` por defecto:
+
+```bash
+echo $SHELL
+```
+
+Si ves `/bin/zsh` → usas zsh (archivo: `~/.zshrc`)
+Si ves `/bin/bash` → usas bash (archivo: `~/.bashrc`)
+
+## Paso 2: Abrir el Archivo de Configuración
+
+Para zsh (más común en Mac):
+
+```bash
+nvim ~/.zshrc
+```
+
+O si prefieres VS Code:
+
+```bash
+code ~/.zshrc
+```
+
+## Paso 3: Agregar el Alias
+
+Al final del archivo, agrega:
+
+```bash
+# Alias personalizados
+alias lz='curl'
+```
+
+Guarda el archivo:
+- En nvim: presiona `ESC`, luego escribe `:wq` y `ENTER`
+- En VS Code: `Cmd + S`
+
+## Paso 4: Recargar la Configuración
+
+Tienes dos opciones:
+
+**Opción 1: Recargar el archivo**
+```bash
+source ~/.zshrc
+```
+
+**Opción 2: Cerrar y abrir una nueva terminal**
+
+## Paso 5: Probar el Alias
+
+```bash
+lz icarus.mx
+```
+
+Deberías ver el HTML del sitio de Icarus.
+
+## Alias Útiles para Agregar
+
+Mientras estás editando `~/.zshrc`, considera agregar:
+
+```bash
+# Alias para comandos comunes
+alias ls='ls -G'                    # ls con colores en Mac
+alias ll='ls -lah'                  # ls largo con todo
+alias ..='cd ..'                    # sube un nivel
+alias ...='cd ../..'                # sube dos niveles
+alias gs='git status'               # git status rápido
+alias ga='git add'                  # git add rápido
+alias gc='git commit -m'            # git commit con mensaje
+alias gp='git push'                 # git push rápido
+alias lz='curl'                     # localiza recurso (nuestro nuevo alias)
+
+# Alias para navegación rápida
+alias proyectos='cd ~/proyectos'
+alias icarus='cd ~/icarus'
+```
+
+## Verificar que Funciona
+
+```bash
+# Probar lz
+lz -I icarus.mx
+
+# Debería mostrar los headers del sitio
+```
+
+## Troubleshooting
+
+**Problema: "command not found: lz"**
+- Solución: Verifica que ejecutaste `source ~/.zshrc`
+
+**Problema: "No such file or directory: ~/.zshrc"**
+- Solución: Crea el archivo primero: `touch ~/.zshrc`
+
+**Problema: Sigo usando bash en vez de zsh**
+- Solución: Edita `~/.bashrc` en vez de `~/.zshrc`
+
+## Siguiente Nivel
+
+Una vez que domines los alias básicos, aprende sobre:
+- **Funciones de shell**: alias con argumentos complejos
+- **Dotfiles**: versionar tu configuración con Git
+- **Oh My Zsh**: framework para mejorar tu terminal
+
+## Recursos
+
+- `man zsh` - Manual de zsh
+- `man bash` - Manual de bash
+- `alias` - Ver todos tus alias actuales
+- `unalias lz` - Eliminar un alias temporal
+
+---
+
+**Pro tip**: Los alias se cargan cada vez que abres una terminal nueva. Si quieres un alias temporal (solo para la sesión actual), simplemente escribe `alias lz='curl'` directo en la terminal sin agregarlo al archivo.

package/lib/exercises/README.md

@@ -0,0 +1,187 @@
+# Creta Exercise Guides
+
+Progressive learning paths for modern web development - from terminal comfort to production deployment.
+
+---
+
+## 🗺️ Learning Journey
+
+These exercises follow a natural progression: **Setup → Build → Ship → Scale**
+
+Each phase builds on knowledge from previous phases.
+
+---
+
+## Phase 1: Setup & Basics
+
+**Get comfortable with your tools and avoid common mistakes**
+
+### 1. [Developing Muscle Memory for Neovim](./01-developing-muscle-for-nvim.md)
+**What:** Master vim navigation with `}`, `{`, and fold commands
+**Why:** Efficient code reading without touching the mouse
+**Time:** 15 minutes
+**Level:** 🟢 Beginner
+
+### 2. [iTerm2 Pane Navigation](./02-iterm2-pane-navigation.md)
+**What:** Custom keyboard shortcuts for terminal pane switching
+**Why:** Stop using 3-key combos to move between panes
+**Time:** 10 minutes
+**Level:** 🟢 Beginner
+
+### 3. [Git Stash Workflow](./03-git-stash-workflow.md)
+**What:** Rescue changes made on the wrong branch
+**Why:** Clean recovery when you code on `main` instead of `dev`
+**Time:** 15 minutes
+**Level:** 🟢 Beginner
+
+### 13. [Shell Aliases: Personaliza tu Terminal](./13-shell-aliases.md)
+**What:** Crear alias personalizados (lz para curl)
+**Why:** Comandos más intuitivos en español - piensa "localiza recurso"
+**Time:** 10 minutes
+**Level:** 🟢 Beginner
+
+### 4. [Array & Object Manipulation](./04-array-object-manipulation.md)
+**What:** JavaScript warmups - map, filter, reduce, destructuring
+**Why:** Foundation for real app data transformations
+**Time:** 45 minutes
+**Level:** 🟡 Intermediate
+
+---
+
+## Phase 2: Build
+
+**Create real applications with modern frameworks**
+
+### 5. [SvelteKit First Steps](./05-svelte-first-steps.md)
+**What:** Understand SvelteKit project structure and file conventions
+**Why:** Stop guessing where files go - learn the routing system
+**Time:** 30 minutes
+**Level:** 🟡 Intermediate
+
+### 6. [curl + Pipes](./06-curl-and-pipes.md)
+**What:** Process APIs in real-time with curl and bash pipes
+**Why:** Test endpoints, debug requests, automate data workflows
+**Time:** 45 minutes
+**Level:** 🟡 Intermediate
+
+### 7. [Claude API First Steps](./07-claude-api-first-steps.md)
+**What:** Call Claude API directly from terminal with curl
+**Why:** Get AI assistance without leaving your workflow
+**Time:** 30 minutes
+**Level:** 🟡 Intermediate
+
+### 8. [Playwright + Svelte Testing](./08-playwright-svelte-guide.md)
+**What:** E2E testing for SvelteKit apps with Tailwind
+**Why:** Test user flows without breaking when you change CSS
+**Time:** 2-3 hours
+**Level:** 🟡 Intermediate
+
+---
+
+## Phase 3: Ship
+
+**Deploy applications to production**
+
+### 9. [Docker First Steps](./09-docker-first-steps.md)
+**What:** Containerize Node.js apps to solve "works on my machine"
+**Why:** Consistent environments from dev to production
+**Time:** 1 hour
+**Level:** 🟡 Intermediate
+
+### 10. [Railway Deployment](./10-railway-deployment.md)
+**What:** Deploy Node.js/Express apps with custom domains
+**Why:** Ship to production in minutes, not hours
+**Time:** 45 minutes
+**Level:** 🟡 Intermediate
+
+### 11. [AWS Billing Detective](./11-aws-billing-detective.md)
+**What:** Hunt down hidden AWS costs across all regions
+**Why:** Stop getting charged for forgotten EBS volumes and Elastic IPs
+**Time:** 30-60 minutes
+**Level:** 🔴 Advanced
+
+---
+
+## Phase 4: Scale
+
+**Advanced tooling and workflow optimization**
+
+### 12. [Install Skills Command](./12-install-skills.md)
+**What:** Design a CLI skill installer with project analysis
+**Why:** Automate development workflow setup
+**Time:** Design exercise
+**Level:** 🔴 Advanced
+
+---
+
+## 🎯 How to Use These Guides
+
+### Reading in Neovim/LazyVim
+All guides have vim fold markers for structured navigation:
+
+```vim
+zM        " Close all folds (see just headers)
+za        " Toggle current fold
+zR        " Open all folds
+}         " Jump to next paragraph
+{         " Jump to previous paragraph
+```
+
+### Progressive Learning
+- **New to CLI?** Start with Phase 1
+- **Know basics?** Jump to Phase 2 (SvelteKit)
+- **Ready to deploy?** Go straight to Phase 3
+- **Optimizing workflows?** Phase 4 has advanced patterns
+
+### Hands-On Practice
+Every guide includes:
+- 🚨 **Problem** - What confusion does this solve?
+- ✅ **Solution** - Step-by-step walkthrough
+- 💪 **Practice** - Real commands to run
+- 🎯 **Outcomes** - What you'll be able to do
+
+---
+
+## 🧭 By Topic
+
+Prefer to browse by subject?
+
+### Terminal & Workflow
+- [Developing Muscle Memory for Neovim](./01-developing-muscle-for-nvim.md)
+- [iTerm2 Pane Navigation](./02-iterm2-pane-navigation.md)
+- [Git Stash Workflow](./03-git-stash-workflow.md)
+- [Shell Aliases](./13-shell-aliases.md)
+- [curl + Pipes](./06-curl-and-pipes.md)
+
+### JavaScript & Development
+- [Array & Object Manipulation](./04-array-object-manipulation.md)
+- [SvelteKit First Steps](./05-svelte-first-steps.md)
+
+### AI & APIs
+- [Claude API First Steps](./07-claude-api-first-steps.md)
+
+### Testing
+- [Playwright + Svelte Testing](./08-playwright-svelte-guide.md)
+
+### Deployment & Infrastructure
+- [Docker First Steps](./09-docker-first-steps.md)
+- [Railway Deployment](./10-railway-deployment.md)
+- [AWS Billing Detective](./11-aws-billing-detective.md)
+
+### Meta/Tooling
+- [Install Skills Command](./12-install-skills.md)
+
+---
+
+## 📚 Philosophy
+
+These guides follow Creta's design principles:
+
+**Spanish-First** - Native language where it matters (coming soon)
+**Simple Solutions** - No over-engineering, practical examples
+**Evolution Over Replacement** - Skills that grow with you
+**CLI-Native** - Work where developers work
+
+---
+
+**Questions? Issues?** Open an issue in the main Creta repo.

package/lib/exercises/utils/booklet-2up.js

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+
+import { PDFDocument } from 'pdf-lib';
+import fs from 'fs/promises';
+import path from 'path';
+
+async function createBooklet2Up(inputPath) {
+  try {
+    const filename = path.basename(inputPath, '.pdf');
+    console.log(`\n📚 Creando booklet 2-up para: ${filename}`);
+
+    const srcFile = await fs.readFile(inputPath);
+    const srcDoc = await PDFDocument.load(srcFile);
+    const totalPages = srcDoc.getPageCount();
+
+    console.log(`📄 Páginas originales: ${totalPages}`);
+
+    // Páginas necesarias (múltiplo de 4)
+    const sheetsNeeded = Math.ceil(totalPages / 4);
+    const paddedPages = sheetsNeeded * 4;
+
+    console.log(`📄 Hojas físicas: ${sheetsNeeded}`);
+
+    // Obtener tamaño de página
+    const firstPage = srcDoc.getPage(0);
+    const { width: pageWidth, height: pageHeight } = firstPage.getSize();
+
+    // Crear docs finales
+    const frontDoc = await PDFDocument.create();
+    const backDoc = await PDFDocument.create();
+
+    // Para cada hoja física
+    for (let sheet = 0; sheet < sheetsNeeded; sheet++) {
+      // Índices para booklet (0-indexed)
+      const indices = {
+        frontRight: sheet * 2,                        // 0, 2, 4, 6...
+        frontLeft: paddedPages - (sheet * 2) - 1,     // 23, 21, 19, 17...
+        backLeft: sheet * 2 + 1,                      // 1, 3, 5, 7...
+        backRight: paddedPages - (sheet * 2) - 2      // 22, 20, 18, 16...
+      };
+
+      console.log(`Hoja ${sheet + 1}:`);
+      console.log(`  Frente: [${indices.frontLeft < totalPages ? indices.frontLeft + 1 : 'blank'}] [${indices.frontRight < totalPages ? indices.frontRight + 1 : 'blank'}]`);
+      console.log(`  Reverso: [${indices.backLeft < totalPages ? indices.backLeft + 1 : 'blank'}] [${indices.backRight < totalPages ? indices.backRight + 1 : 'blank'}]`);
+
+      // FRENTE: crear hoja 2-up (landscape)
+      const frontSheet = frontDoc.addPage([pageWidth * 2, pageHeight]);
+
+      // Página derecha del frente
+      if (indices.frontRight < totalPages) {
+        const [page] = await frontDoc.copyPages(srcDoc, [indices.frontRight]);
+        const embeddedPage = await frontDoc.embedPage(page);
+        frontSheet.drawPage(embeddedPage, {
+          x: pageWidth,
+          y: 0,
+          width: pageWidth,
+          height: pageHeight
+        });
+      }
+
+      // Página izquierda del frente
+      if (indices.frontLeft < totalPages) {
+        const [page] = await frontDoc.copyPages(srcDoc, [indices.frontLeft]);
+        const embeddedPage = await frontDoc.embedPage(page);
+        frontSheet.drawPage(embeddedPage, {
+          x: 0,
+          y: 0,
+          width: pageWidth,
+          height: pageHeight
+        });
+      }
+
+      // REVERSO: crear hoja 2-up (landscape)
+      const backSheet = backDoc.addPage([pageWidth * 2, pageHeight]);
+
+      // Página izquierda del reverso
+      if (indices.backLeft < totalPages) {
+        const [page] = await backDoc.copyPages(srcDoc, [indices.backLeft]);
+        const embeddedPage = await backDoc.embedPage(page);
+        backSheet.drawPage(embeddedPage, {
+          x: 0,
+          y: 0,
+          width: pageWidth,
+          height: pageHeight
+        });
+      }
+
+      // Página derecha del reverso
+      if (indices.backRight < totalPages) {
+        const [page] = await backDoc.copyPages(srcDoc, [indices.backRight]);
+        const embeddedPage = await backDoc.embedPage(page);
+        backSheet.drawPage(embeddedPage, {
+          x: pageWidth,
+          y: 0,
+          width: pageWidth,
+          height: pageHeight
+        });
+      }
+    }
+
+    // Guardar
+    const frontPath = path.join(path.dirname(inputPath), `${filename}-FRENTE-v3.pdf`);
+    const backPath = path.join(path.dirname(inputPath), `${filename}-REVERSO-v3.pdf`);
+
+    await fs.writeFile(frontPath, await frontDoc.save());
+    await fs.writeFile(backPath, await backDoc.save());
+
+    console.log('\n✅ Creados:\n');
+    console.log(`   ${path.basename(frontPath)}`);
+    console.log(`   ${path.basename(backPath)}`);
+    console.log('\n📖 IMPRIME: FRENTE → mete hojas SIN voltear → REVERSO\n');
+
+    return { frontPath, backPath };
+
+  } catch (error) {
+    console.error('❌ Error:', error.message);
+    console.error(error.stack);
+    throw error;
+  }
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.length === 0) {
+    console.log('Uso: node booklet-2up.js <archivo.pdf>');
+    process.exit(1);
+  }
+
+  await createBooklet2Up(path.resolve(args[0]));
+  console.log('¡Listo! 🎉\n');
+}
+
+main().catch(console.error);

package/lib/exercises/utils/booklet-manual-duplex.js

@@ -0,0 +1,159 @@
+#!/usr/bin/env node
+
+import { PDFDocument } from 'pdf-lib';
+import fs from 'fs/promises';
+import path from 'path';
+
+/**
+ * Crea un booklet para impresoras de duplex manual SIN voltear
+ * (para impresoras que imprimen en la cara de abajo)
+ */
+async function createManualDuplexBooklet(inputPath) {
+  try {
+    const filename = path.basename(inputPath, '.pdf');
+    console.log(`\n📚 Creando booklet para: ${filename}`);
+
+    // Leer PDF original
+    const srcFile = await fs.readFile(inputPath);
+    const srcDoc = await PDFDocument.load(srcFile);
+    const totalPages = srcDoc.getPageCount();
+
+    console.log(`📄 Páginas originales: ${totalPages}`);
+
+    // Calcular páginas necesarias (múltiplo de 4)
+    const sheetsNeeded = Math.ceil(totalPages / 4);
+    const paddedPages = sheetsNeeded * 4;
+    const blankPages = paddedPages - totalPages;
+
+    if (blankPages > 0) {
+      console.log(`📄 Páginas en blanco añadidas: ${blankPages}`);
+    }
+
+    console.log(`📄 Total hojas físicas: ${sheetsNeeded}`);
+
+    // Crear documentos para frente y reverso
+    const frontDoc = await PDFDocument.create();
+    const backDoc = await PDFDocument.create();
+
+    // Crear página en blanco del mismo tamaño que la primera
+    const firstPage = srcDoc.getPage(0);
+    const { width, height } = firstPage.getSize();
+    const blankPage = await PDFDocument.create();
+    const blank = blankPage.addPage([width, height]);
+
+    // Algoritmo de booklet para duplex manual SIN voltear
+    // Para cada hoja física, el orden es:
+    // Frente: [última | primera]
+    // Reverso: [segunda | penúltima]
+
+    for (let sheet = 0; sheet < sheetsNeeded; sheet++) {
+      // Calcular números de página para esta hoja física (0-indexed)
+      const frontLeft = paddedPages - (sheet * 2) - 1;  // última, antepenúltima, etc
+      const frontRight = (sheet * 2);                    // primera, tercera, etc
+      const backLeft = (sheet * 2) + 1;                  // segunda, cuarta, etc
+      const backRight = paddedPages - (sheet * 2) - 2;   // penúltima, etc
+
+      console.log(`Hoja ${sheet + 1}: Frente[${frontLeft >= 0 && frontLeft < totalPages ? frontLeft + 1 : 'blank'}, ${frontRight >= 0 && frontRight < totalPages ? frontRight + 1 : 'blank'}] Reverso[${backLeft >= 0 && backLeft < totalPages ? backLeft + 1 : 'blank'}, ${backRight >= 0 && backRight < totalPages ? backRight + 1 : 'blank'}]`);
+
+      // Crear página de FRENTE (2 páginas lado a lado)
+      const frontPageDoc = await PDFDocument.create();
+      const frontPageSheet = frontPageDoc.addPage([width * 2, height]);
+
+      // Izquierda del frente
+      if (frontLeft >= 0 && frontLeft < totalPages) {
+        const [leftPage] = await frontPageDoc.copyPages(srcDoc, [frontLeft]);
+        frontPageSheet.drawPage(leftPage, { x: 0, y: 0, width, height });
+      }
+
+      // Derecha del frente
+      if (frontRight >= 0 && frontRight < totalPages) {
+        const [rightPage] = await frontPageDoc.copyPages(srcDoc, [frontRight]);
+        frontPageSheet.drawPage(rightPage, { x: width, y: 0, width, height });
+      }
+
+      // Copiar hoja de frente al documento final
+      const [finalFrontPage] = await frontDoc.copyPages(frontPageDoc, [0]);
+      frontDoc.addPage(finalFrontPage);
+
+      // Crear página de REVERSO (2 páginas lado a lado)
+      const backPageDoc = await PDFDocument.create();
+      const backPageSheet = backPageDoc.addPage([width * 2, height]);
+
+      // Izquierda del reverso
+      if (backLeft >= 0 && backLeft < totalPages) {
+        const [leftPage] = await backPageDoc.copyPages(srcDoc, [backLeft]);
+        backPageSheet.drawPage(leftPage, { x: 0, y: 0, width, height });
+      }
+
+      // Derecha del reverso
+      if (backRight >= 0 && backRight < totalPages) {
+        const [rightPage] = await backPageDoc.copyPages(srcDoc, [backRight]);
+        backPageSheet.drawPage(rightPage, { x: width, y: 0, width, height });
+      }
+
+      // Copiar hoja de reverso al documento final
+      const [finalBackPage] = await backDoc.copyPages(backPageDoc, [0]);
+      backDoc.addPage(finalBackPage);
+    }
+
+    // Como la impresora imprime del lado de abajo y las hojas salen al revés,
+    // necesitamos INVERTIR el orden de las páginas del REVERSO
+    const backPagesReversed = await PDFDocument.create();
+    const backPageCount = backDoc.getPageCount();
+    for (let i = backPageCount - 1; i >= 0; i--) {
+      const [page] = await backPagesReversed.copyPages(backDoc, [i]);
+      backPagesReversed.addPage(page);
+    }
+
+    // Guardar PDFs
+    const frontPath = path.join(path.dirname(inputPath), `${filename}-FRENTE.pdf`);
+    const backPath = path.join(path.dirname(inputPath), `${filename}-REVERSO.pdf`);
+
+    await fs.writeFile(frontPath, await frontDoc.save());
+    await fs.writeFile(backPath, await backPagesReversed.save());
+
+    console.log('\n✅ Booklets creados:\n');
+    console.log(`   📄 FRENTE: ${path.basename(frontPath)}`);
+    console.log(`   📄 REVERSO: ${path.basename(backPath)}`);
+
+    console.log('\n📖 INSTRUCCIONES DE IMPRESIÓN:\n');
+    console.log('1. Imprime el archivo FRENTE (todas las páginas)');
+    console.log('2. Toma la pila tal como salió');
+    console.log('3. Métela de nuevo en la bandeja SIN voltear');
+    console.log('   → Cara impresa ARRIBA (visible)');
+    console.log('   → Cara blanca ABAJO (donde imprimirá)');
+    console.log('4. Imprime el archivo REVERSO');
+    console.log('5. Dobla todas las hojas por la mitad');
+    console.log('6. Encuaderna por el lado IZQUIERDO\n');
+
+    return { frontPath, backPath };
+
+  } catch (error) {
+    console.error('❌ Error:', error.message);
+    throw error;
+  }
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+
+  if (args.length === 0) {
+    console.log('Uso: node booklet-manual-duplex.js <archivo.pdf>');
+    console.log('Ejemplo: node booklet-manual-duplex.js railway-deployment.pdf');
+    process.exit(1);
+  }
+
+  const inputPath = path.resolve(args[0]);
+
+  try {
+    await fs.access(inputPath);
+  } catch {
+    console.error(`❌ Archivo no encontrado: ${inputPath}`);
+    process.exit(1);
+  }
+
+  await createManualDuplexBooklet(inputPath);
+  console.log('\n¡Listo! 🎉\n');
+}
+
+main().catch(console.error);