@icarusmx/creta 1.5.12 → 1.5.13

package/lib/exercises/README.md

@@ -0,0 +1,180 @@
+# 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
+
+### 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)
+- [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);

package/lib/exercises/utils/booklet-simple.js

@@ -0,0 +1,136 @@
+#!/usr/bin/env node
+
+import { PDFDocument, degrees } from 'pdf-lib';
+import fs from 'fs/promises';
+import path from 'path';
+
+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 array de páginas incluyendo blancos
+    const pages = [];
+    for (let i = 0; i < totalPages; i++) {
+      pages.push(srcDoc.getPage(i));
+    }
+    // Añadir páginas en blanco si es necesario
+    const firstPage = srcDoc.getPage(0);
+    const { width, height } = firstPage.getSize();
+    for (let i = totalPages; i < paddedPages; i++) {
+      // Crear página en blanco temporal (no la añadimos al doc original)
+      pages.push(null); // null representa página en blanco
+    }
+
+    // Crear documentos finales
+    const frontDoc = await PDFDocument.create();
+    const backDoc = await PDFDocument.create();
+
+    // Para cada hoja física
+    for (let sheet = 0; sheet < sheetsNeeded; sheet++) {
+      // Calcular índices de página (0-indexed)
+      const frontLeft = paddedPages - (sheet * 2) - 1;   // última hacia adentro
+      const frontRight = (sheet * 2);                     // primera hacia afuera
+      const backLeft = (sheet * 2) + 1;                   // segunda
+      const backRight = paddedPages - (sheet * 2) - 2;    // penúltima hacia adentro
+
+      console.log(`Hoja ${sheet + 1}: Frente[${frontLeft < totalPages ? frontLeft + 1 : 'blank'}, ${frontRight < totalPages ? frontRight + 1 : 'blank'}] Reverso[${backLeft < totalPages ? backLeft + 1 : 'blank'}, ${backRight < totalPages ? backRight + 1 : 'blank'}]`);
+
+      // FRENTE: Agregar página derecha (frontRight) y luego izquierda (frontLeft)
+      // El orden importa porque así queda al doblar
+      if (frontRight < totalPages) {
+        const [copied] = await frontDoc.copyPages(srcDoc, [frontRight]);
+        frontDoc.addPage(copied);
+      } else {
+        frontDoc.addPage(frontDoc.addPage([width, height]));
+      }
+
+      if (frontLeft < totalPages) {
+        const [copied] = await frontDoc.copyPages(srcDoc, [frontLeft]);
+        frontDoc.addPage(copied);
+      } else {
+        frontDoc.addPage(frontDoc.addPage([width, height]));
+      }
+
+      // REVERSO: Agregar en el orden correcto para duplex sin voltear
+      // Izquierda primero, derecha después
+      if (backLeft < totalPages) {
+        const [copied] = await backDoc.copyPages(srcDoc, [backLeft]);
+        backDoc.addPage(copied);
+      } else {
+        backDoc.addPage(backDoc.addPage([width, height]));
+      }
+
+      if (backRight < totalPages) {
+        const [copied] = await backDoc.copyPages(srcDoc, [backRight]);
+        backDoc.addPage(copied);
+      } else {
+        backDoc.addPage(backDoc.addPage([width, height]));
+      }
+    }
+
+    // Guardar PDFs
+    const frontPath = path.join(path.dirname(inputPath), `${filename}-FRENTE-v2.pdf`);
+    const backPath = path.join(path.dirname(inputPath), `${filename}-REVERSO-v2.pdf`);
+
+    await fs.writeFile(frontPath, await frontDoc.save());
+    await fs.writeFile(backPath, await backDoc.save());
+
+    console.log('\n✅ Booklets creados:\n');
+    console.log(`   📄 FRENTE: ${path.basename(frontPath)}`);
+    console.log(`   📄 REVERSO: ${path.basename(backPath)}`);
+
+    console.log('\n📖 INSTRUCCIONES:\n');
+    console.log('1. Imprime FRENTE (todas las páginas)');
+    console.log('2. Toma la pila y métela de nuevo SIN voltear');
+    console.log('3. Imprime REVERSO');
+    console.log('4. Dobla por la mitad y encuaderna a la izquierda\n');
+
+    return { frontPath, backPath };
+
+  } catch (error) {
+    console.error('❌ Error:', error.message);
+    console.error(error);
+    throw error;
+  }
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+
+  if (args.length === 0) {
+    console.log('Uso: node booklet-simple.js <archivo.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);