@icarusmx/creta 1.5.10 → 1.5.11

package/bin/creta.js

@@ -78,8 +78,9 @@ if (command && isCommandHelpRequest(args)) {
   process.exit(0)
 }
 
-// ASCII Logo
-console.log(`
+// Show logo for interactive commands (skip for utility commands)
+function showLogo() {
+  console.log(`
 █████████████████████████
 █   █   █   █   █   █   █
 █ C █ R █ E █ T █ A █ █ █
@@ -89,16 +90,19 @@ console.log(`
 Bienvenido al taller de software
 Salgamos de este laberinto 🏛️
 `)
+}
 
 if (!command) {
   // Default behavior: show main menu
+  showLogo()
   await startMainMenu()
   process.exit(0)
 }
 
 if (command.startsWith('portafolio')) {
+  showLogo()
   const level = command === 'portafolio' ? 0 : parseInt(command.split('-')[1]) || 0
-  
+
   // Check if we're in an existing Creta project
   if (level > 0 && isInCretaProject()) {
     await unstuckProject(level)
@@ -106,20 +110,25 @@ if (command.startsWith('portafolio')) {
     await createPortfolioProject(level)
   }
 } else if (command === 'enunciados') {
+  showLogo()
   // Start enunciados selector
   await startEnunciadosSelector()
 } else if (command === 'sintaxis') {
+  showLogo()
   // Start sintaxis selector with interactive sandbox lessons
   await startSintaxisSelector()
 } else if (command === 'code') {
+  showLogo()
   // Start interactive coding session
   const session = new CretaCodeSession()
   await session.start()
 } else if (command === 'papers') {
+  showLogo()
   // Start papers selector
   const executor = new PapersExecutor()
   await executor.execute()
 } else if (command === 'aws') {
+  showLogo()
   // Show AWS billing detective guide
   const viewer = new AWSGuideViewer()
   await viewer.start()
@@ -637,6 +646,7 @@ function showHelp() {
   console.log("📖 Documentación de comandos:")
   console.log("  creta ls             - Documentación en español del comando ls")
   console.log("  creta cd             - Documentación en español del comando cd")
+  console.log("  creta curl           - Documentación en español del comando curl")
   console.log("  creta git status     - Documentación en español de git status")
   console.log("  creta [comando]      - Documentación de cualquier comando soportado\n")
 
@@ -1858,7 +1868,7 @@ async function startVimSetupTutorial() {
 // Helper function to detect command help requests
 function isCommandHelpRequest(args) {
   // List of supported commands for help
-  const basicCommands = ['ls', 'cd', 'mkdir', 'touch', 'wc']
+  const basicCommands = ['ls', 'cd', 'mkdir', 'touch', 'wc', 'curl']
   const gitCommands = ['git status', 'git add', 'git commit', 'git push', 'git log']
 
   const commandString = args.join(' ')

package/lib/data/command-help/curl.js

@@ -0,0 +1,80 @@
+export const curl = {
+  command: 'curl',
+  description: 'Realiza peticiones HTTP desde la terminal - tu herramienta para APIs',
+  usage: 'curl [opciones] [URL]',
+  commonOptions: [
+    {
+      flag: '-X',
+      description: 'Especifica el método HTTP (GET, POST, PUT, DELETE)'
+    },
+    {
+      flag: '-H',
+      description: 'Agrega un header a la petición'
+    },
+    {
+      flag: '-d',
+      description: 'Envía datos en el body (JSON, form data, etc.)'
+    },
+    {
+      flag: '-i',
+      description: 'Incluye los headers de respuesta en el output'
+    },
+    {
+      flag: '-L',
+      description: 'Sigue redirects automáticamente'
+    },
+    {
+      flag: '-o',
+      description: 'Guarda el output en un archivo'
+    },
+    {
+      flag: '-s',
+      description: 'Modo silencioso (no muestra progreso)'
+    },
+    {
+      flag: '-v',
+      description: 'Modo verbose (muestra toda la comunicación)'
+    }
+  ],
+  examples: [
+    {
+      command: 'curl https://api.github.com',
+      description: 'GET simple - obtiene datos de una API'
+    },
+    {
+      command: 'curl -i https://api.github.com/users/octocat',
+      description: 'GET con headers de respuesta incluidos'
+    },
+    {
+      command: 'curl -X POST https://api.ejemplo.com/users -H "Content-Type: application/json" -d \'{"nombre": "Juan"}\'',
+      description: 'POST con JSON - envía datos a una API'
+    },
+    {
+      command: 'curl -X POST https://httpbin.org/post -d "nombre=Juan&edad=25"',
+      description: 'POST con form data - formato URL-encoded'
+    },
+    {
+      command: 'curl -H "Authorization: Bearer tu_token_aqui" https://api.ejemplo.com/protected',
+      description: 'GET con autenticación - usa un token JWT'
+    },
+    {
+      command: 'curl -L https://github.com',
+      description: 'Sigue redirects automáticamente (importante para URLs acortadas)'
+    },
+    {
+      command: 'curl -o archivo.json https://api.ejemplo.com/data',
+      description: 'Descarga la respuesta y guárdala en un archivo'
+    },
+    {
+      command: 'curl -v https://api.ejemplo.com',
+      description: 'Modo verbose - ve toda la negociación HTTP (útil para debugging)'
+    }
+  ],
+  relatedLesson: 'APIs y HTTP',
+  tips: [
+    'Pro tip: usa -i siempre para ver los status codes (200, 404, 500) en la respuesta',
+    'Para APIs modernas siempre agrega el header: -H "Content-Type: application/json"',
+    'curl -L es esencial cuando trabajas con URLs acortadas o redirects',
+    'Combina -s (silencioso) con herramientas como jq para parsear JSON: curl -s url | jq'
+  ]
+}

package/lib/data/command-help/index.js

@@ -4,6 +4,7 @@ export { cd } from './cd.js'
 export { mkdir } from './mkdir.js'
 export { touch } from './touch.js'
 export { wc } from './wc.js'
+export { curl } from './curl.js'
 
 // Git commands
 export { gitStatus } from './git-status.js'
@@ -20,6 +21,7 @@ export const commandMap = {
   'mkdir': 'mkdir',
   'touch': 'touch',
   'wc': 'wc',
+  'curl': 'curl',
 
   // Git
   'git status': 'gitStatus',

package/lib/data/lessons/sintaxis/curl-pipes.js

@@ -0,0 +1,221 @@
+export const CURL_PIPES = {
+  id: 'curl-pipes',
+
+  intro: {
+    definition: 'curl + pipes: Procesando APIs en tiempo real',
+    explanation: 'Aprende a combinar curl con pipes para extraer insights de APIs sin guardar archivos intermedios.',
+    detail: 'En el mundo real, usarás curl diariamente para consultar APIs, monitorear servicios, y extraer datos. Combinado con pipes (grep, wc, sed), puedes procesar respuestas JSON instantáneamente.'
+  },
+
+  steps: [
+    // --- Introducción a curl ---
+    {
+      type: 'command-intro',
+      command: 'curl',
+      description: 'curl: Cliente HTTP para la terminal',
+      explanation: 'curl descarga datos de URLs sin abrir el navegador. Es la herramienta #1 para trabajar con APIs REST, probar endpoints, y automatizar descargas.',
+      example: 'curl https://api.github.com\ncurl -s https://jsonplaceholder.typicode.com/users/1',
+      instruction: 'Úsalo para traer datos desde cualquier URL. El flag -s (silent) oculta el progreso.'
+    },
+
+    {
+      type: 'text',
+      content: '\nVamos a usar JSONPlaceholder, una API REST falsa para practicar.\n\nAPI endpoints disponibles:\n  • https://jsonplaceholder.typicode.com/users (lista de 10 usuarios)\n  • https://jsonplaceholder.typicode.com/posts (100 posts)\n  • https://jsonplaceholder.typicode.com/comments (500 comentarios)\n'
+    },
+
+    { type: 'pause' },
+
+    // --- Práctica 1: curl básico ---
+    {
+      type: 'text',
+      content: '📝 Práctica 1: Fetch básico con curl\n\nVamos a traer datos de un usuario. El flag -s (silent) oculta la barra de progreso para ver solo el JSON.'
+    },
+
+    {
+      type: 'interactive-command',
+      prompt: 'Ejecuta: curl -s https://jsonplaceholder.typicode.com/users/1',
+      expectedCommand: 'curl -s https://jsonplaceholder.typicode.com/users/1',
+      explanation: '¡Perfecto! Viste un objeto JSON con datos del usuario #1.\n\nNota: El JSON se mostró sin formato (una línea larga). En producción usarías jq para formatearlo, pero con pipes podemos extraer lo que necesitamos.'
+    },
+
+    { type: 'pause' },
+
+    // --- curl + grep ---
+    {
+      type: 'text',
+      content: '🔍 Combinando curl con grep\n\nNo siempre necesitas TODO el JSON. A veces solo quieres buscar un campo específico.\n\nPuedes enviar la salida de curl directamente a grep sin guardar archivos.'
+    },
+
+    {
+      type: 'code',
+      title: 'curl + grep en acción',
+      code: `# Buscar el email en la respuesta JSON
+curl -s https://jsonplaceholder.typicode.com/users/1 | grep "email"
+
+# Buscar todos los nombres de usuario
+curl -s https://jsonplaceholder.typicode.com/users | grep "name"
+
+# Buscar posts que mencionan "dolor"
+curl -s https://jsonplaceholder.typicode.com/posts | grep "dolor"`,
+      after: ['', 'El pipe | conecta stdout de curl al stdin de grep.', 'grep filtra solo las líneas que contienen el patrón.']
+    },
+
+    { type: 'pause' },
+
+    // --- Práctica 2: curl + grep ---
+    {
+      type: 'text',
+      content: '📝 Práctica 2: Filtrar respuestas con grep\n\nVamos a buscar el campo "email" en un usuario.'
+    },
+
+    {
+      type: 'interactive-command',
+      prompt: 'Ejecuta: curl -s https://jsonplaceholder.typicode.com/users/1 | grep "email"',
+      expectedCommand: 'curl -s https://jsonplaceholder.typicode.com/users/1 | grep "email"',
+      explanation: '¡Exacto! grep filtró la respuesta y solo mostró la línea que contiene "email".\n\nViste algo como: "email": "Sincere@april.biz"\n\nEsto es útil cuando solo necesitas un campo específico y no quieres parsear todo el JSON.'
+    },
+
+    { type: 'pause' },
+
+    // --- curl + wc ---
+    {
+      type: 'text',
+      content: '🔢 Contando datos con wc\n\nwc (word count) puede contar líneas, palabras, o caracteres.\n\nCombinado con curl, puedes contar registros en APIs sin procesar el JSON completo.'
+    },
+
+    {
+      type: 'code',
+      title: 'curl + wc para análisis rápido',
+      code: `# Contar líneas en la respuesta (aprox. registros)
+curl -s https://jsonplaceholder.typicode.com/users | wc -l
+
+# Contar palabras en la respuesta
+curl -s https://jsonplaceholder.typicode.com/posts/1 | wc -w
+
+# Contar caracteres (tamaño de la respuesta)
+curl -s https://jsonplaceholder.typicode.com/posts | wc -c`,
+      after: ['', 'wc -l cuenta líneas, wc -w palabras, wc -c caracteres.', 'Útil para monitorear tamaños de respuesta o estimar registros.']
+    },
+
+    { type: 'pause' },
+
+    // --- Práctica 3: curl + wc ---
+    {
+      type: 'text',
+      content: '📝 Práctica 3: Contar líneas en respuesta\n\nVamos a contar cuántas líneas tiene la respuesta de /users.'
+    },
+
+    {
+      type: 'interactive-command',
+      prompt: 'Ejecuta: curl -s https://jsonplaceholder.typicode.com/users | wc -l',
+      expectedCommand: 'curl -s https://jsonplaceholder.typicode.com/users | wc -l',
+      explanation: '¡Correcto! Viste un número (probablemente alrededor de 500-700 líneas).\n\nEsto te da una idea rápida del tamaño de la respuesta sin tener que leer todo el JSON.'
+    },
+
+    { type: 'pause' },
+
+    // --- Múltiples pipes ---
+    {
+      type: 'text',
+      content: '⛓️ Encadenando múltiples pipes\n\nEl verdadero poder viene cuando combinas curl + grep + wc.\n\nPuedes hacer análisis complejos en una sola línea.'
+    },
+
+    {
+      type: 'code',
+      title: 'Triple combo: curl + grep + wc',
+      code: `# ¿Cuántos usuarios tienen email con "biz"?
+curl -s https://jsonplaceholder.typicode.com/users | grep "biz" | wc -l
+
+# ¿Cuántas veces aparece "id" en la respuesta?
+curl -s https://jsonplaceholder.typicode.com/posts | grep "id" | wc -l
+
+# Buscar posts con "sunt" y contar cuántos
+curl -s https://jsonplaceholder.typicode.com/posts | grep "sunt" | wc -l`,
+      after: ['', 'Cada pipe pasa su output al siguiente comando.', 'curl → grep (filtra) → wc (cuenta)', 'Puedes encadenar cuantos pipes necesites.']
+    },
+
+    { type: 'pause' },
+
+    // --- Práctica 4: múltiples pipes ---
+    {
+      type: 'text',
+      content: '📝 Práctica 4: curl + grep + wc\n\nVamos a contar cuántos emails aparecen en /users (buscando líneas con "email").'
+    },
+
+    {
+      type: 'interactive-command',
+      prompt: 'Ejecuta: curl -s https://jsonplaceholder.typicode.com/users | grep "email" | wc -l',
+      expectedCommand: 'curl -s https://jsonplaceholder.typicode.com/users | grep "email" | wc -l',
+      explanation: '¡Excelente! Viste el número de líneas que contienen "email".\n\nEn este caso probablemente 10 (uno por usuario).\n\nEsta técnica es SUPER útil en el mundo real:\n  • Monitorear APIs (¿cuántos errores en logs?)\n  • Contar registros sin parsear JSON\n  • Análisis rápido de respuestas HTTP'
+    },
+
+    { type: 'pause' },
+
+    // --- Escenarios del mundo real ---
+    {
+      type: 'text',
+      content: '🌍 Escenarios del mundo real\n\nAquí hay ejemplos que usarás en tu día a día como developer:'
+    },
+
+    {
+      type: 'code',
+      title: 'Casos de uso profesionales',
+      code: `# 1. Monitoreo de API: ¿está respondiendo?
+curl -s https://api.miapp.com/health | grep "ok"
+
+# 2. Análisis de logs: ¿cuántos errores en las últimas 24h?
+curl -s https://logs.miapp.com/today | grep "ERROR" | wc -l
+
+# 3. Testing: ¿la API devuelve el status code correcto?
+curl -s -w "%{http_code}" https://api.miapp.com/users | grep "200"
+
+# 4. Data pipeline: descargar, filtrar, y guardar
+curl -s https://api.datos.com/export | grep "activo" > usuarios-activos.txt
+
+# 5. Comparación: ¿cuántos posts vs comments?
+curl -s https://jsonplaceholder.typicode.com/posts | wc -l
+curl -s https://jsonplaceholder.typicode.com/comments | wc -l`,
+      after: ['', 'Estos patrones son DIARIOS en DevOps, backend, y testing.', 'curl + pipes reemplaza scripts complejos con one-liners simples.']
+    },
+
+    { type: 'pause' },
+
+    // --- Tips pro ---
+    {
+      type: 'text',
+      content: '💡 Pro Tips\n\n1. Siempre usa -s (silent) para evitar info de progreso en pipes\n2. Usa -i para ver headers HTTP (status codes, content-type)\n3. Combina con head/tail para limitar resultados\n4. grep -i hace búsquedas case-insensitive\n5. En producción, usa jq para parsear JSON correctamente\n\nEjemplo avanzado:\n  curl -s https://api.github.com/users/github | grep -i "login"\n'
+    },
+
+    { type: 'pause' },
+
+    // --- Ejercicio final ---
+    {
+      type: 'text',
+      content: '🎯 Ejercicio final: Análisis completo\n\nVamos a hacer un análisis real: ¿cuántos posts mencionan "qui" en su contenido?'
+    },
+
+    {
+      type: 'interactive-command',
+      prompt: 'Ejecuta: curl -s https://jsonplaceholder.typicode.com/posts | grep "qui" | wc -l',
+      expectedCommand: 'curl -s https://jsonplaceholder.typicode.com/posts | grep "qui" | wc -l',
+      explanation: '¡PERFECTO! Acabas de:\n  1. Descargar 100 posts desde una API REST\n  2. Filtrar solo los que contienen "qui"\n  3. Contar cuántos matches encontraste\n\nTodo en una sola línea, sin archivos intermedios.\n\nEsta es la esencia del trabajo con APIs en terminal: rápido, eficiente, y scripteable.'
+    },
+
+    { type: 'pause' },
+
+    // --- Conclusión ---
+    {
+      type: 'text',
+      content: '🎓 Conclusión\n\nAprendiste a:\n  ✅ Usar curl para fetch de APIs\n  ✅ Combinar curl + grep para filtrar respuestas\n  ✅ Usar curl + wc para análisis rápido\n  ✅ Encadenar múltiples pipes (curl + grep + wc)\n  ✅ Aplicar estos patrones a escenarios reales\n\nEstas técnicas son FUNDAMENTALES para:\n  • DevOps (monitoreo, health checks)\n  • Backend development (testing APIs)\n  • Data engineering (ETL pipelines)\n  • Automation (scripts de CI/CD)\n\nLa próxima vez que necesites consultar una API, ya no abrirás Postman.\nUsarás curl + pipes directo en tu terminal. 🚀'
+    },
+
+    { type: 'pause' },
+
+    // --- Maze completion ---
+    {
+      type: 'maze-completion',
+      message: '¡Has completado: APIs con curl! 🔥',
+      unlocked: 'Dominas curl + pipes para procesar APIs en tiempo real'
+    }
+  ]
+}

package/lib/data/menus.js

@@ -26,6 +26,12 @@ export const SINTAXIS_LESSONS = [
     title: '4. Escribe scripts',
     description: '',
     unlockAfter: 'piping-redireccion'
+  },
+  {
+    id: 'curl-pipes',
+    title: '5. APIs con curl',
+    description: '',
+    unlockAfter: 'bash-scripts'
   }
 ]
 

package/lib/executors/sintaxis-executor.js

@@ -5,6 +5,7 @@ import { TERMINAL_BASICO } from '../data/lessons/sintaxis/terminal-basico.js'
 import { GIT_BASICO } from '../data/lessons/sintaxis/git-basico.js'
 import { BASH_SCRIPTS } from '../data/lessons/sintaxis/bash-scripts.js'
 import { PIPING_REDIRECCION } from '../data/lessons/sintaxis/piping-redireccion.js'
+import { CURL_PIPES } from '../data/lessons/sintaxis/curl-pipes.js'
 import { clearConsole } from '../utils/output.js'
 import { createPromptInterface } from '../utils/input.js'
 import { UserState } from '../utils/user-state.js'
@@ -14,7 +15,8 @@ const LESSONS_BY_ID = new Map([
   ['terminal-basico', TERMINAL_BASICO],
   ['git-basico', GIT_BASICO],
   ['bash-scripts', BASH_SCRIPTS],
-  ['piping-redireccion', PIPING_REDIRECCION]
+  ['piping-redireccion', PIPING_REDIRECCION],
+  ['curl-pipes', CURL_PIPES]
 ])
 
 function waitForEnter(message = '\nPresiona Enter para continuar...') {

package/lib/exercises/curl-and-pipes.md

@@ -0,0 +1,844 @@
+# curl + Pipes - Processing APIs in Real Time
+
+<!-- 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.
+
+}}}
+
+## 🚨 Problem: Need Quick API Insights Without Postman {{{
+
+You're debugging an API and need to:
+- Check if an endpoint is responding
+- Count how many records are returned
+- Filter JSON for specific fields
+- Monitor for errors in real time
+
+**Current workflow:**
+1. Open Postman or browser
+2. Make request
+3. Copy response
+4. Open text editor
+5. Manually search/count
+
+**Time wasted:** 2-5 minutes per query
+
+There's a **better way** → `curl + pipes`
+
+}}}
+
+## ✅ Solution: curl + grep/wc/sed for Instant Insights {{{
+
+Combine curl with pipe commands to process API responses **instantly** in your terminal.
+
+**Core pattern:**
+```bash
+curl [API] | [filter] | [process] | [output]
+```
+
+**Real example:**
+```bash
+# Count active users in one line
+curl -s https://api.example.com/users | grep "active" | wc -l
+```
+
+**Benefits:**
+- ⚡ **Instant feedback** - no UI switching
+- 🔁 **Scriptable** - automate repetitive checks
+- 🎯 **Precise** - extract exactly what you need
+- 📊 **Pipeline-ready** - chain multiple operations
+
+}}}
+
+## 🎯 Essential Curl Flags {{{
+
+### -s (Silent) {{{
+
+**Problem:** Default curl shows progress bar, pollutes pipe output
+
+```bash
+# Without -s (messy)
+curl https://api.github.com/users/github | grep "login"
+# % Total    % Received...  (progress bar appears)
+
+# With -s (clean)
+curl -s https://api.github.com/users/github | grep "login"
+# "login": "github"  (just the data)
+```
+
+**Rule:** Always use `-s` when piping curl output.
+
+}}}
+
+### -i (Include Headers) {{{
+
+**Use case:** See HTTP status codes and headers
+
+```bash
+curl -si https://api.github.com/users/github | head -n 1
+# HTTP/2 200  (status code visible)
+
+curl -si https://api.github.com/users/fake123 | head -n 1
+# HTTP/2 404  (error detected)
+```
+
+**Pro tip:** Use `head -n 1` to extract just the status line.
+
+}}}
+
+### -L (Follow Redirects) {{{
+
+**Problem:** Short URLs redirect, curl doesn't follow by default
+
+```bash
+# Without -L (stops at redirect)
+curl -s https://bit.ly/example
+# <redirect HTML>
+
+# With -L (follows to final destination)
+curl -sL https://bit.ly/example
+# <actual content>
+```
+
+**Use:** Essential for shortened URLs, CDN redirects, HTTPS upgrades.
+
+}}}
+
+### -H (Add Headers) {{{
+
+**Use case:** Authentication, content type specification
+
+```bash
+# Add authorization header
+curl -s -H "Authorization: Bearer $TOKEN" https://api.example.com/protected
+
+# Specify JSON content type
+curl -s -H "Content-Type: application/json" https://api.example.com/data
+
+# Multiple headers
+curl -s \
+  -H "Authorization: Bearer $TOKEN" \
+  -H "Accept: application/json" \
+  https://api.example.com/users
+```
+
+}}}
+
+### -w (Custom Output Format) {{{
+
+**Use case:** Extract specific HTTP metadata
+
+```bash
+# Get only HTTP status code
+curl -s -w "%{http_code}" -o /dev/null https://api.github.com/users/github
+# 200
+
+# Get response time
+curl -s -w "%{time_total}s" -o /dev/null https://api.github.com
+# 0.452s
+
+# Get status + time
+curl -s -w "Status: %{http_code} | Time: %{time_total}s\n" -o /dev/null https://api.github.com
+# Status: 200 | Time: 0.234s
+```
+
+**Flags:**
+- `-w "%{format}"`: Write custom output format
+- `-o /dev/null`: Discard response body (only show -w output)
+
+}}}
+
+}}}
+
+## 🔗 Pipe Combinations {{{
+
+### curl + grep: Filter JSON Fields {{{
+
+**Use case:** Extract specific fields from JSON response
+
+```bash
+# Find email in user object
+curl -s https://jsonplaceholder.typicode.com/users/1 | grep "email"
+# "email": "Sincere@april.biz",
+
+# Find all names in user list
+curl -s https://jsonplaceholder.typicode.com/users | grep "name"
+# "name": "Leanne Graham",
+# "name": "Ervin Howell",
+# ...
+
+# Case-insensitive search
+curl -s https://api.github.com/users/github | grep -i "LOGIN"
+# "login": "github",
+```
+
+**Pro tip:** Use `grep -i` for case-insensitive matching.
+
+}}}
+
+### curl + wc: Count Records/Lines {{{
+
+**Use case:** Quick statistics on API responses
+
+```bash
+# Count lines in response (approx. size)
+curl -s https://jsonplaceholder.typicode.com/users | wc -l
+# 542
+
+# Count words (tokens)
+curl -s https://jsonplaceholder.typicode.com/users | wc -w
+# 1849
+
+# Count bytes (response size)
+curl -s https://jsonplaceholder.typicode.com/users | wc -c
+# 5645
+```
+
+**Interpretation:**
+- `wc -l`: Lines (rough measure of JSON structure)
+- `wc -w`: Words (data density)
+- `wc -c`: Bytes (actual response size)
+
+}}}
+
+### curl + grep + wc: Count Matches {{{
+
+**Use case:** Answer questions like "How many users have X?"
+
+```bash
+# How many users?
+curl -s https://jsonplaceholder.typicode.com/users | grep "\"id\":" | wc -l
+# 10
+
+# How many posts mention "dolor"?
+curl -s https://jsonplaceholder.typicode.com/posts | grep "dolor" | wc -l
+# 23
+
+# How many email addresses end in ".biz"?
+curl -s https://jsonplaceholder.typicode.com/users | grep ".biz" | wc -l
+# 2
+```
+
+**Pattern:** `curl → filter → count`
+
+}}}
+
+### curl + head/tail: Limit Output {{{
+
+**Use case:** See first/last N lines of response
+
+```bash
+# First 10 lines
+curl -s https://jsonplaceholder.typicode.com/posts | head -n 10
+
+# Last 5 lines
+curl -s https://jsonplaceholder.typicode.com/posts | tail -n 5
+
+# Lines 20-30 (skip first 19, show next 10)
+curl -s https://jsonplaceholder.typicode.com/posts | tail -n +20 | head -n 10
+```
+
+**Use cases:**
+- Preview large responses
+- Sample data without downloading everything
+- Extract specific ranges
+
+}}}
+
+### curl + sed: Transform Output {{{
+
+**Use case:** Clean up or reformat JSON fields
+
+```bash
+# Extract email addresses (remove JSON quotes)
+curl -s https://jsonplaceholder.typicode.com/users | grep "email" | sed 's/.*"email": "\(.*\)".*/\1/'
+
+# Remove all commas from JSON
+curl -s https://jsonplaceholder.typicode.com/users/1 | sed 's/,//g'
+
+# Replace text in response
+curl -s https://jsonplaceholder.typicode.com/posts/1 | sed 's/sunt/REDACTED/g'
+```
+
+**Advanced:** Combine with pipes for complex transformations.
+
+}}}
+
+### curl + sort + uniq: Deduplicate {{{
+
+**Use case:** Find unique values in API responses
+
+```bash
+# Get unique user IDs from posts
+curl -s https://jsonplaceholder.typicode.com/posts | grep "userId" | sort | uniq
+
+# Count occurrences of each user
+curl -s https://jsonplaceholder.typicode.com/posts | grep "userId" | sort | uniq -c
+```
+
+**Pattern:** `curl → extract → sort → unique`
+
+}}}
+
+}}}
+
+## 🌍 Real-World Scenarios {{{
+
+### Scenario 1: Health Check Monitoring {{{
+
+**Problem:** Need to check if API is responding with 200 OK
+
+```bash
+# Check status code
+curl -s -w "%{http_code}" -o /dev/null https://api.myapp.com/health
+
+# One-liner health check
+if [ $(curl -s -w "%{http_code}" -o /dev/null https://api.myapp.com/health) -eq 200 ]; then
+  echo "✅ API is healthy"
+else
+  echo "❌ API is down"
+fi
+```
+
+**Use case:** Cron jobs, deployment scripts, CI/CD health checks.
+
+}}}
+
+### Scenario 2: Error Log Analysis {{{
+
+**Problem:** Count how many errors occurred in last hour
+
+```bash
+# Count ERROR lines in logs API
+curl -s https://logs.myapp.com/last-hour | grep "ERROR" | wc -l
+
+# Find critical errors only
+curl -s https://logs.myapp.com/last-hour | grep "CRITICAL" | wc -l
+
+# Group by error type
+curl -s https://logs.myapp.com/last-hour | grep "ERROR" | cut -d':' -f2 | sort | uniq -c
+```
+
+**Use case:** Incident response, debugging production issues.
+
+}}}
+
+### Scenario 3: API Testing in CI/CD {{{
+
+**Problem:** Verify API returns expected data after deployment
+
+```bash
+# Test: Does response contain expected field?
+curl -s https://api.myapp.com/config | grep -q "version" && echo "✅ Pass" || echo "❌ Fail"
+
+# Test: Is there at least one user?
+USER_COUNT=$(curl -s https://api.myapp.com/users | grep "\"id\":" | wc -l)
+if [ $USER_COUNT -gt 0 ]; then
+  echo "✅ Users endpoint working"
+else
+  echo "❌ No users returned"
+fi
+```
+
+**Use case:** Smoke tests after deployment, integration testing.
+
+}}}
+
+### Scenario 4: Data Pipeline Extraction {{{
+
+**Problem:** Download API data, filter active records, save to file
+
+```bash
+# Extract active users to file
+curl -s https://api.myapp.com/users | grep "\"status\": \"active\"" > active-users.json
+
+# Extract and count
+curl -s https://api.myapp.com/orders | grep "\"status\": \"pending\"" | wc -l > pending-orders.txt
+
+# Multi-step pipeline
+curl -s https://api.github.com/users/github/repos \
+  | grep "\"name\":" \
+  | sed 's/.*"name": "\(.*\)".*/\1/' \
+  | sort \
+  > repo-names.txt
+```
+
+**Use case:** ETL jobs, data exports, scheduled reports.
+
+}}}
+
+### Scenario 5: Rate Limit Checking {{{
+
+**Problem:** Check how many API calls you have left
+
+```bash
+# GitHub rate limit (headers contain rate info)
+curl -si https://api.github.com/users/github | grep -i "x-ratelimit"
+# x-ratelimit-limit: 60
+# x-ratelimit-remaining: 59
+
+# Extract just the remaining count
+curl -si https://api.github.com/users/github \
+  | grep -i "x-ratelimit-remaining" \
+  | awk '{print $2}'
+# 59
+```
+
+**Use case:** API quota monitoring, avoiding rate limit errors.
+
+}}}
+
+### Scenario 6: Comparing API Versions {{{
+
+**Problem:** Did the API response change between versions?
+
+```bash
+# Get response from v1
+curl -s https://api.myapp.com/v1/users > v1-response.json
+
+# Get response from v2
+curl -s https://api.myapp.com/v2/users > v2-response.json
+
+# Compare
+diff v1-response.json v2-response.json
+
+# Or count differences
+diff v1-response.json v2-response.json | wc -l
+```
+
+**Use case:** API migration validation, regression testing.
+
+}}}
+
+}}}
+
+## 🧪 Practice Exercises {{{
+
+### Exercise 1: Basic Filtering {{{
+
+**Goal:** Extract the "title" field from a post
+
+```bash
+# API endpoint
+https://jsonplaceholder.typicode.com/posts/1
+
+# Your command:
+curl -s https://jsonplaceholder.typicode.com/posts/1 | grep "title"
+
+# Expected output:
+# "title": "sunt aut facere repellat provident...",
+```
+
+}}}
+
+### Exercise 2: Counting Records {{{
+
+**Goal:** How many comments exist in total?
+
+```bash
+# API endpoint
+https://jsonplaceholder.typicode.com/comments
+
+# Your command:
+curl -s https://jsonplaceholder.typicode.com/comments | grep "\"id\":" | wc -l
+
+# Expected output:
+# 500
+```
+
+}}}
+
+### Exercise 3: Multi-Pipe Chain {{{
+
+**Goal:** Count how many posts contain the word "qui"
+
+```bash
+# API endpoint
+https://jsonplaceholder.typicode.com/posts
+
+# Your command:
+curl -s https://jsonplaceholder.typicode.com/posts | grep "qui" | wc -l
+
+# Expected output:
+# ~30-40 (number of lines containing "qui")
+```
+
+}}}
+
+### Exercise 4: Status Code Check {{{
+
+**Goal:** Verify GitHub API returns 200 for valid user
+
+```bash
+# API endpoint
+https://api.github.com/users/github
+
+# Your command:
+curl -s -w "%{http_code}" -o /dev/null https://api.github.com/users/github
+
+# Expected output:
+# 200
+```
+
+}}}
+
+### Exercise 5: Extract and Transform {{{
+
+**Goal:** Get all email addresses from users, one per line (clean format)
+
+```bash
+# API endpoint
+https://jsonplaceholder.typicode.com/users
+
+# Your command:
+curl -s https://jsonplaceholder.typicode.com/users \
+  | grep "email" \
+  | sed 's/.*"email": "\(.*\)".*/\1/' \
+  | sed 's/,$//'
+
+# Expected output:
+# Sincere@april.biz
+# Shanna@melissa.tv
+# Nathan@yesenia.net
+# (etc...)
+```
+
+}}}
+
+}}}
+
+## 🛡️ Best Practices {{{
+
+### Always Use -s Flag {{{
+
+**Why:** Default progress bar pollutes pipe output
+
+```bash
+# ❌ Bad: progress bar interferes with grep
+curl https://api.example.com | grep "name"
+
+# ✅ Good: clean output
+curl -s https://api.example.com | grep "name"
+```
+
+}}}
+
+### Check Status Codes Before Processing {{{
+
+**Why:** Don't process error responses
+
+```bash
+# ❌ Bad: processes error HTML as JSON
+curl -s https://api.example.com/fake | grep "name"
+
+# ✅ Good: check status first
+RESPONSE=$(curl -s -w "\n%{http_code}" https://api.example.com/users)
+STATUS=$(echo "$RESPONSE" | tail -n 1)
+BODY=$(echo "$RESPONSE" | head -n -1)
+
+if [ $STATUS -eq 200 ]; then
+  echo "$BODY" | grep "name"
+else
+  echo "Error: API returned $STATUS"
+fi
+```
+
+}}}
+
+### Use jq for Complex JSON Parsing {{{
+
+**When to use pipes:** Simple filtering, counting, text search
+**When to use jq:** Proper JSON parsing, nested fields, arrays
+
+```bash
+# Pipes: Quick field search
+curl -s https://api.example.com/users | grep "email"
+
+# jq: Proper JSON parsing
+curl -s https://api.example.com/users | jq '.[].email'
+
+# jq: Complex queries
+curl -s https://api.example.com/users | jq '.[] | select(.id > 5) | .name'
+```
+
+**Rule of thumb:** If you need more than 2-3 greps/seds, switch to jq.
+
+}}}
+
+### Save Responses for Testing {{{
+
+**Why:** Don't hammer APIs during development
+
+```bash
+# ❌ Bad: hits API every time you test
+curl -s https://api.example.com/users | grep "name"
+curl -s https://api.example.com/users | grep "email"
+curl -s https://api.example.com/users | grep "phone"
+
+# ✅ Good: save once, test multiple times
+curl -s https://api.example.com/users > users.json
+cat users.json | grep "name"
+cat users.json | grep "email"
+cat users.json | grep "phone"
+```
+
+}}}
+
+### Handle Errors Gracefully {{{
+
+**Check for empty responses:**
+
+```bash
+# Store response
+RESPONSE=$(curl -s https://api.example.com/users)
+
+# Check if empty
+if [ -z "$RESPONSE" ]; then
+  echo "Error: Empty response"
+  exit 1
+fi
+
+# Process
+echo "$RESPONSE" | grep "name"
+```
+
+}}}
+
+### Timeout Long Requests {{{
+
+**Prevent hanging scripts:**
+
+```bash
+# Default: waits forever
+curl -s https://slow-api.example.com
+
+# With timeout: fails after 10 seconds
+curl -s --max-time 10 https://slow-api.example.com
+```
+
+}}}
+
+}}}
+
+## 📚 Quick Reference {{{
+
+### Essential curl Flags {{{
+
+```bash
+-s                    # Silent (no progress bar)
+-i                    # Include headers in output
+-I                    # Headers only (no body)
+-L                    # Follow redirects
+-w "%{http_code}"     # Print HTTP status code
+-o /dev/null          # Discard response body
+-H "Key: Value"       # Add custom header
+--max-time 10         # Timeout after 10 seconds
+-X POST               # HTTP method (POST, PUT, DELETE, etc.)
+-d "key=value"        # Send data (POST body)
+```
+
+}}}
+
+### Common Pipe Patterns {{{
+
+```bash
+# Filter
+curl -s URL | grep "pattern"
+
+# Count
+curl -s URL | wc -l
+
+# Count matches
+curl -s URL | grep "pattern" | wc -l
+
+# First N lines
+curl -s URL | head -n 10
+
+# Last N lines
+curl -s URL | tail -n 10
+
+# Transform
+curl -s URL | sed 's/old/new/g'
+
+# Deduplicate
+curl -s URL | grep "field" | sort | uniq
+
+# Save filtered results
+curl -s URL | grep "active" > output.txt
+```
+
+}}}
+
+### One-Liner Templates {{{
+
+```bash
+# Health check
+curl -s -w "%{http_code}" -o /dev/null https://api.example.com/health
+
+# Count records
+curl -s https://api.example.com/users | grep "\"id\":" | wc -l
+
+# Extract field
+curl -s https://api.example.com/config | grep "version" | sed 's/.*"version": "\(.*\)".*/\1/'
+
+# Monitor errors
+curl -s https://logs.example.com/today | grep "ERROR" | wc -l
+
+# Test endpoint
+curl -s https://api.example.com/users | grep -q "data" && echo "OK" || echo "FAIL"
+```
+
+}}}
+
+}}}
+
+## 🎓 Advanced Topics {{{
+
+### Parallel Requests with xargs {{{
+
+**Use case:** Check multiple endpoints simultaneously
+
+```bash
+# Check health of multiple services
+echo -e "api.service1.com\napi.service2.com\napi.service3.com" \
+  | xargs -I {} -P 3 curl -s -w "{} → %{http_code}\n" -o /dev/null https://{}
+```
+
+**Explanation:**
+- `-I {}`: Replace `{}` with each line
+- `-P 3`: Run 3 parallel processes
+- `-w "... %{http_code}"`: Print status code
+
+}}}
+
+### JSON Stream Processing {{{
+
+**Use case:** Process large API responses line-by-line
+
+```bash
+# Stream large response
+curl -s https://api.example.com/large-dataset \
+  | while IFS= read -r line; do
+      echo "$line" | grep "active" >> active-records.txt
+    done
+```
+
+**Use when:** API returns huge responses, need to filter during download.
+
+}}}
+
+### Authenticated API Requests {{{
+
+**JWT token example:**
+
+```bash
+# Store token
+TOKEN="your-jwt-token-here"
+
+# Authenticated request
+curl -s -H "Authorization: Bearer $TOKEN" \
+  https://api.example.com/protected \
+  | grep "data"
+```
+
+**Environment variable:**
+
+```bash
+# In .env or .bashrc
+export API_TOKEN="your-token"
+
+# In script
+curl -s -H "Authorization: Bearer $API_TOKEN" https://api.example.com/protected
+```
+
+}}}
+
+### POST Requests with Data {{{
+
+**Send JSON data:**
+
+```bash
+# POST JSON
+curl -s -X POST \
+  -H "Content-Type: application/json" \
+  -d '{"name": "John", "email": "john@example.com"}' \
+  https://jsonplaceholder.typicode.com/users \
+  | grep "id"
+```
+
+**POST form data:**
+
+```bash
+curl -s -X POST \
+  -d "name=John" \
+  -d "email=john@example.com" \
+  https://httpbin.org/post \
+  | grep "form"
+```
+
+}}}
+
+}}}
+
+## 💡 Pro Tips {{{
+
+1. **Combine with watch for live monitoring:**
+   ```bash
+   watch -n 5 'curl -s https://api.example.com/metrics | grep "active" | wc -l'
+   ```
+
+2. **Save complex one-liners as shell functions:**
+   ```bash
+   # In .bashrc or .zshrc
+   api_health() {
+     curl -s -w "%{http_code}" -o /dev/null "https://api.example.com/$1"
+   }
+
+   # Usage
+   api_health users  # Check /users endpoint
+   ```
+
+3. **Use aliases for frequent API checks:**
+   ```bash
+   alias check-api='curl -s https://api.myapp.com/health | grep "ok"'
+   ```
+
+4. **Pipe to pbcopy (Mac) or xclip (Linux) to copy output:**
+   ```bash
+   curl -s https://api.example.com/users | grep "email" | pbcopy
+   ```
+
+5. **Chain with git for API version tracking:**
+   ```bash
+   curl -s https://api.example.com/schema > schema.json
+   git diff schema.json  # See what changed
+   ```
+
+}}}
+
+## 🚀 Next Steps {{{
+
+**Master these progressively:**
+
+1. ✅ **Level 1:** `curl + grep` (filtering)
+2. ✅ **Level 2:** `curl + grep + wc` (counting)
+3. ✅ **Level 3:** `curl + sed` (transforming)
+4. 🎯 **Level 4:** `curl + jq` (proper JSON parsing)
+5. 🎯 **Level 5:** Write shell scripts with error handling
+6. 🎯 **Level 6:** Automate with cron jobs
+
+**Related skills:**
+- Learn `jq` for advanced JSON manipulation
+- Study bash scripting for automation
+- Explore `watch` for continuous monitoring
+- Master `awk` for columnar data processing
+
+}}}
+
+---
+
+**Remember:** curl + pipes turns your terminal into a powerful API client. No GUI needed! 🚀

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@icarusmx/creta",
-  "version": "1.5.10",
+  "version": "1.5.11",
   "description": "Salgamos de este laberinto.",
   "type": "module",
   "bin": {