@icarusmx/creta 1.4.9 → 1.4.11

package/lib/data/lessons/sintaxis/piping-redireccion.js

@@ -9,11 +9,89 @@ export const PIPING_REDIRECCION = {
   },
 
   steps: [
+    {
+      type: 'text',
+      content: 'Primero, entendamos los 3 canales de comunicación que tiene cada programa.'
+    },
+    {
+      type: 'pause'
+    },
+    {
+      type: 'text',
+      content: 'Cada comando que ejecutas tiene 3 "streams" (flujos) estándar:'
+    },
+    {
+      type: 'text',
+      content: '• stdin (standard input) - Canal 0: Por donde entra información'
+    },
+    {
+      type: 'text',
+      content: '• stdout (standard output) - Canal 1: Por donde sale información normal'
+    },
+    {
+      type: 'text',
+      content: '• stderr (standard error) - Canal 2: Por donde salen mensajes de error'
+    },
+    {
+      type: 'pause'
+    },
+    {
+      type: 'text',
+      content: 'Por defecto:'
+    },
+    {
+      type: 'text',
+      content: '• stdin lee del teclado'
+    },
+    {
+      type: 'text',
+      content: '• stdout y stderr escriben a la pantalla'
+    },
+    {
+      type: 'pause'
+    },
+    {
+      type: 'text',
+      content: 'Pero con piping y redirección puedes cambiar estos destinos.'
+    },
+    {
+      type: 'pause'
+    },
+    {
+      type: 'code',
+      title: 'Los 3 streams en acción',
+      code: `# ls produce salida normal (stdout)
+ls archivo.txt
+# → archivo.txt (aparece en pantalla)
+
+# ls con archivo inexistente produce error (stderr)
+ls archivo-que-no-existe
+# → ls: archivo-que-no-existe: No such file or directory (aparece en pantalla)
+
+# read espera entrada (stdin)
+read NOMBRE
+# → [cursor esperando que escribas]`,
+      after: [
+        '',
+        'Aunque ambos aparecen en pantalla, stdout y stderr son canales separados.',
+        'Esto te permite tratarlos diferente con redirección.'
+      ]
+    },
+    {
+      type: 'pause'
+    },
+    {
+      type: 'text',
+      content: 'Ahora veamos cómo manipular estos streams.'
+    },
+    {
+      type: 'pause'
+    },
     {
       type: 'command-intro',
       command: '|',
       description: 'El pipe (tubería)',
-      explanation: 'El símbolo | toma la salida de un comando y la envía como entrada a otro.',
+      explanation: 'El símbolo | conecta el stdout de un comando al stdin de otro.',
       example: 'ls | grep ".js"\ncat archivo.txt | wc -l',
       instruction: 'Úsalo para encadenar comandos. La salida del izquierdo entra al derecho.'
     },
@@ -68,19 +146,56 @@ export const PIPING_REDIRECCION = {
     {
       type: 'command-intro',
       command: '2>',
-      description: 'Redirección de errores',
-      explanation: '2> redirige los mensajes de error (stderr) a un archivo.',
+      description: 'Redirección de errores (stderr)',
+      explanation: 'El 2 se refiere al file descriptor de stderr. 2> redirige solo los errores a un archivo.',
       example: 'npm install 2> errores.log\nls archivo-que-no-existe 2> /dev/null',
       instruction: '/dev/null es como un "agujero negro" - descarta todo lo que le envíes.'
     },
+    {
+      type: 'text',
+      content: 'También puedes redirigir stdout explícitamente con 1> (aunque > solo es equivalente).'
+    },
+    {
+      type: 'pause'
+    },
     {
       type: 'command-intro',
       command: '&>',
-      description: 'Redirección de salida Y errores',
-      explanation: '&> redirige tanto la salida normal como los errores al mismo destino.',
+      description: 'Redirección de stdout Y stderr',
+      explanation: '&> redirige ambos canales (1 y 2) al mismo destino. Es como hacer 1> archivo 2>&1',
       example: 'npm install &> install-log.txt\ngit pull &> pull.log',
       instruction: 'Útil cuando quieres capturar todo lo que un comando produce.'
     },
+    {
+      type: 'pause'
+    },
+    {
+      type: 'code',
+      title: 'Standard streams en acción',
+      code: `# Separar stdout y stderr en diferentes archivos
+ls archivo.txt archivo-inexistente 1> salidas.txt 2> errores.txt
+# → archivo.txt va a salidas.txt
+# → el error va a errores.txt
+
+# Guardar salida, descartar errores
+npm install 1> install.log 2> /dev/null
+
+# Redirigir stderr a stdout, luego todo a un archivo
+ls archivo-inexistente 2>&1 | grep "No such"
+# → El error se convierte en stdout y puede ser procesado por grep
+
+# Capturar todo en un solo archivo (equivalentes)
+comando &> todo.log
+comando > todo.log 2>&1`,
+      after: [
+        '',
+        'Entender los file descriptors (0, 1, 2) te da control total del flujo de datos.',
+        'Puedes separar, combinar, o descartar cualquier stream según necesites.'
+      ]
+    },
+    {
+      type: 'pause'
+    },
     {
       type: 'code',
       title: 'Ejemplo real: Procesando una versión',

package/lib/data/menus.js

@@ -2,15 +2,43 @@ import { ENUNCIADOS } from './enunciados.js'
 import { UNLOCK_CONFIG, isUnlocked, hasCompletedLesson } from './progression.js'
 import { UserState } from '../utils/user-state.js'
 
-export const SINTAXIS_MENU_CONFIG = {
-  title: 'Elige qué lección de sintaxis te gustaría explorar:',
-  description: 'Aprende los comandos fundamentales de terminal y git.',
-  options: [
-    { id: 'terminal-basico', title: '1. Terminal básico', description: 'ls, cd, mkdir' },
-    { id: 'git-basico', title: '2. Git básico', description: 'init, status, add, commit' },
-    { id: 'bash-scripts', title: '3. Bash Scripts', description: 'variables, sed, condicionales' },
-    { id: 'piping-redireccion', title: '4. Piping y Redirección', description: '|, >, <, <<<' }
-  ]
+export const SINTAXIS_LESSONS = [
+  {
+    id: 'terminal-basico',
+    title: '1. Terminal básico',
+    description: '',
+    unlockAfter: null
+  },
+  {
+    id: 'git-basico',
+    title: '2. Git básico',
+    description: '',
+    unlockAfter: 'terminal-basico'
+  },
+  {
+    id: 'piping-redireccion',
+    title: '3. Piping y Redirección',
+    description: '',
+    unlockAfter: 'git-basico'
+  },
+  {
+    id: 'bash-scripts',
+    title: '4. Bash Scripts',
+    description: '',
+    unlockAfter: 'piping-redireccion'
+  }
+]
+
+export function getSintaxisMenuConfig(state = UserState.get()) {
+  const options = SINTAXIS_LESSONS
+    .filter((lesson) => !lesson.unlockAfter || hasCompletedLesson(lesson.unlockAfter, state))
+    .map(({ id, title, description }) => ({ id, title, description }))
+
+  return {
+    title: 'Elige qué lección de sintaxis te gustaría explorar:',
+    description: 'Aprende los comandos fundamentales de terminal y git.',
+    options
+  }
 }
 
 const MENU_ITEMS = {
@@ -19,14 +47,13 @@ const MENU_ITEMS = {
   proyectos: { baseTitle: 'Construir proyectos' }
 }
 
-export function getMainMenuConfig() {
-  const state = UserState.get()
+export function getMainMenuConfig(state = UserState.get()) {
   const options = []
 
   for (const [id, itemConfig] of Object.entries(MENU_ITEMS)) {
     const unlockConfig = UNLOCK_CONFIG.mainMenu[id]
 
-    if (!isUnlocked(id, unlockConfig)) continue
+    if (!isUnlocked(id, unlockConfig, state)) continue
 
     const showNew = typeof unlockConfig.showNewIndicator === 'function'
       ? unlockConfig.showNewIndicator(state)
@@ -45,7 +72,9 @@ export function getMainMenuConfig() {
 
   return {
     clearConsole: false,
-    title: 'Te ofrecemos las siguientes opciones:',
+    title: options.length === 1
+      ? 'Empecemos por aquí:'
+      : 'Te ofrecemos las siguientes opciones:',
     options
   }
 }

package/lib/data/progression.js

@@ -1,9 +1,9 @@
 // Centralized progression and unlock logic
 import { UserState } from '../utils/user-state.js'
 
-export function hasCompletedLesson(lessonId) {
-  const state = UserState.get()
-  return state.lessonsCompleted.some(
+export function hasCompletedLesson(lessonId, state = UserState.get()) {
+  const lessonsCompleted = state?.lessonsCompleted || []
+  return lessonsCompleted.some(
     lesson => typeof lesson === 'object' ? lesson.id === lessonId : lesson === lessonId
   )
 }
@@ -14,9 +14,9 @@ export const UNLOCK_CONFIG = {
     sintaxis: {
       alwaysVisible: true,
       showNewIndicator: (state) =>
-        hasCompletedLesson('terminal-basico') && !hasCompletedLesson('git-basico'),
+        hasCompletedLesson('terminal-basico', state) && !hasCompletedLesson('git-basico', state),
       description: (state) =>
-        hasCompletedLesson('terminal-basico') && !hasCompletedLesson('git-basico')
+        hasCompletedLesson('terminal-basico', state) && !hasCompletedLesson('git-basico', state)
           ? 'Git básico desbloqueado'
           : undefined
     },
@@ -33,12 +33,12 @@ export const UNLOCK_CONFIG = {
   },
   sintaxis: {
     directToLesson: (state) =>
-      !hasCompletedLesson('terminal-basico') ? 'terminal-basico' : null
+      !hasCompletedLesson('terminal-basico', state) ? 'terminal-basico' : null
   }
 }
 
-export function isUnlocked(itemKey, config) {
+export function isUnlocked(itemKey, config, state = UserState.get()) {
   if (config.alwaysVisible) return true
   if (!config.unlockAfter) return true
-  return hasCompletedLesson(config.unlockAfter)
+  return hasCompletedLesson(config.unlockAfter, state)
 }

package/lib/executors/sintaxis-executor.js

@@ -1,5 +1,5 @@
 import { MenuBuilder } from '../builders/MenuBuilder.js'
-import { SINTAXIS_MENU_CONFIG } from '../data/menus.js'
+import { getSintaxisMenuConfig, SINTAXIS_LESSONS } from '../data/menus.js'
 import { LessonBuilder } from '../builders/LessonBuilder.js'
 import { TERMINAL_BASICO } from '../data/lessons/sintaxis/terminal-basico.js'
 import { GIT_BASICO } from '../data/lessons/sintaxis/git-basico.js'
@@ -53,18 +53,30 @@ export async function executeSintaxis() {
   const directLesson = UNLOCK_CONFIG.sintaxis.directToLesson(state)
 
   if (directLesson) {
-    await runLesson(directLesson, 'Terminal básico')
+    const lessonMeta = SINTAXIS_LESSONS.find((lesson) => lesson.id === directLesson)
+    const lessonTitle = lessonMeta?.title || 'Lección de sintaxis'
+
+    await runLesson(directLesson, lessonTitle)
+
+    const nextLesson = SINTAXIS_LESSONS.find((lesson) => lesson.unlockAfter === directLesson)
+    if (nextLesson) {
+      console.log(`\n✨ ${nextLesson.title} desbloqueado.`)
+      console.log('   Vuelve al menú de sintaxis para explorarlo.')
+    }
 
-    // After completing, show what was unlocked
-    console.log('\n✨ Ahora puedes acceder al menú de sintaxis para aprender Git básico')
     await waitForEnter()
     return
   }
 
-  // Show menu
-  const menu = new MenuBuilder(SINTAXIS_MENU_CONFIG)
-
   while (true) {
+    const menuConfig = getSintaxisMenuConfig()
+
+    if (menuConfig.options.length === 0) {
+      console.log('\nPor ahora no hay lecciones disponibles en este camino.')
+      return
+    }
+
+    const menu = new MenuBuilder(menuConfig)
     const choice = await menu.show()
     if (!choice) {
       return

package/package.json

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

package/test/sintaxis-menu.test.js

@@ -0,0 +1,45 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+
+import { getSintaxisMenuConfig, getMainMenuConfig } from '../lib/data/menus.js'
+
+const baseState = {
+  lessonsCompleted: []
+}
+
+test('sintaxis menu shows only terminal básico for new users', () => {
+  const menu = getSintaxisMenuConfig(baseState)
+  assert.equal(menu.options.length, 1)
+  assert.equal(menu.options[0].id, 'terminal-basico')
+})
+
+test('sintaxis menu unlocks git básico after completing terminal básico', () => {
+  const state = {
+    lessonsCompleted: [{ id: 'terminal-basico' }]
+  }
+  const menu = getSintaxisMenuConfig(state)
+  assert.equal(menu.options.length, 2)
+  assert.deepEqual(menu.options.map(option => option.id), ['terminal-basico', 'git-basico'])
+})
+
+test('sintaxis menu unlocks bash scripts after completing git básico', () => {
+  const state = {
+    lessonsCompleted: [
+      { id: 'terminal-basico' },
+      { id: 'git-basico' }
+    ]
+  }
+  const menu = getSintaxisMenuConfig(state)
+  assert.equal(menu.options.length, 3)
+  assert.deepEqual(menu.options.map(option => option.id), ['terminal-basico', 'git-basico', 'bash-scripts'])
+})
+
+test('main menu title changes when only one option is available', () => {
+  const config = getMainMenuConfig({ lessonsCompleted: [] })
+  assert.equal(config.title, 'Empecemos por aquí:')
+})
+
+test('main menu title defaults once multiple options unlock', () => {
+  const config = getMainMenuConfig({ lessonsCompleted: [{ id: 'terminal-basico' }] })
+  assert.equal(config.title, 'Te ofrecemos las siguientes opciones:')
+})

package/.claude/settings.local.json

@@ -1,16 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Read(//private/tmp/**)",
-      "Bash(node:*)",
-      "WebFetch(domain:github.com)",
-      "Bash(npm install)",
-      "Bash(npm run dev:*)",
-      "Bash(rm:*)",
-      "Bash(npm publish:*)",
-      "Bash(npm view:*)"
-    ],
-    "deny": [],
-    "ask": []
-  }
-}

package/deploy-patch.sh

@@ -1,30 +0,0 @@
-#!/bin/bash
-
-# Get current version from package.json
-CURRENT_VERSION=$(node -p "require('./package.json').version")
-
-# Split version into parts
-IFS='.' read -r -a VERSION_PARTS <<< "$CURRENT_VERSION"
-MAJOR="${VERSION_PARTS[0]}"
-MINOR="${VERSION_PARTS[1]}"
-PATCH="${VERSION_PARTS[2]}"
-
-# Increment patch
-NEW_PATCH=$((PATCH + 1))
-NEW_VERSION="$MAJOR.$MINOR.$NEW_PATCH"
-
-echo "📦 Bumping version: $CURRENT_VERSION → $NEW_VERSION"
-
-# Update package.json
-sed -i '' "s/\"version\": \"$CURRENT_VERSION\"/\"version\": \"$NEW_VERSION\"/" package.json
-
-echo "🚀 Publishing to npm..."
-npm publish
-
-if [ $? -eq 0 ]; then
-    echo "✅ Successfully published @icarusmx/creta@$NEW_VERSION"
-else
-    echo "❌ Publish failed, reverting version..."
-    sed -i '' "s/\"version\": \"$NEW_VERSION\"/\"version\": \"$CURRENT_VERSION\"/" package.json
-    exit 1
-fi