@icarusmx/creta 1.3.4 → 1.4.0

package/codex-refactor.txt

@@ -0,0 +1,13 @@
+# creta cli refactor - progress log
+
+## 2025-02-14
+- restored `bin/creta.js` to the original working version so the CLI behaved correctly again.
+- extracted reusable data for the welcome banner, help text, and enunciados into `lib/data/messages.js` and `lib/data/enunciados.js`.
+- added initial utilities (`lib/utils/input.js`, `lib/utils/output.js`, `lib/utils/file-utils.js`) plus `lib/templates/LevelModifier.js` to reuse template logic.
+
+## 2025-02-15
+- introduced Discord-style builders (`lib/builders/MenuBuilder.js`, `lib/builders/ProjectBuilder.js`).
+- defined menu configurations in `lib/data/menus.js` and template paths in `lib/constants/paths.js`.
+- created executors for enunciados, sintaxis, proyectos, and portafolio to encapsulate orchestration logic.
+- added `lib/cli/index.js` as the central command router and reduced `bin/creta.js` to a minimal entry point (<20 lines).
+- verified primary commands (`help`, `portafolio-*`, invalid command handling) after restructuring.

package/lib/builders/LessonBuilder.js

@@ -0,0 +1,388 @@
+import { createPromptInterface, askQuestion } from '../utils/input.js'
+import { clearConsole } from '../utils/output.js'
+import { UserState } from '../utils/user-state.js'
+
+const DEFAULT_WAIT_MESSAGE = '\nPresiona Enter para continuar...'
+
+export class LessonBuilder {
+  constructor(lessonData) {
+    this.lesson = lessonData
+    this.rl = null
+  }
+
+  async start() {
+    if (!this.lesson) {
+      throw new Error('Se requiere un objeto de lección para ejecutar el LessonBuilder')
+    }
+
+    this.rl = createPromptInterface()
+
+    try {
+      const flow = this.collectActions()
+      await this.executeActions(flow)
+
+      // Track lesson completion if lesson has an ID
+      if (this.lesson.id) {
+        UserState.completLesson(this.lesson.id)
+      }
+    } finally {
+      this.rl.close()
+      this.rl = null
+    }
+  }
+
+  collectActions() {
+    const actions = []
+
+    const parts = [
+      this.lesson.title && { type: 'text', text: this.lesson.title },
+      this.lesson.subtitle && { type: 'text', text: this.lesson.subtitle },
+      this.lesson.intro && { type: 'intro', ...this.lesson.intro },
+      this.lesson.flow,
+      this.lesson.actions,
+      this.lesson.sections,
+      this.lesson.steps,
+      this.lesson.body,
+      this.lesson.conclusion
+    ]
+
+    for (const part of parts) {
+      if (!part) continue
+
+      if (Array.isArray(part)) {
+        actions.push(...part)
+      } else if (Array.isArray(part.actions)) {
+        actions.push(...part.actions)
+      } else {
+        actions.push(part)
+      }
+    }
+
+    return actions
+  }
+
+  async executeActions(actions = []) {
+    for (const action of actions) {
+      if (!action) continue
+      await this.executeAction(action)
+    }
+  }
+
+  async executeAction(action) {
+    const type = action.type || 'text'
+
+    switch (type) {
+      case 'clear':
+        this.handleClear(action)
+        break
+      case 'intro':
+        await this.handleIntro(action)
+        break
+      case 'pause':
+      case 'wait':
+        await this.handlePause(action)
+        break
+      case 'code':
+        this.handleCode(action)
+        break
+      case 'sleep':
+        await this.handleSleep(action)
+        break
+      case 'command-intro':
+        await this.handleCommandIntro(action)
+        break
+      case 'maze-completion':
+        await this.handleMazeCompletion(action)
+        break
+      case 'text':
+      default:
+        this.handleText(action)
+        break
+    }
+  }
+
+  handleClear(action) {
+    if (action.message) {
+      console.log(action.message)
+    }
+
+    if (typeof action.useConsoleClear === 'boolean' && action.useConsoleClear) {
+      console.clear()
+      return
+    }
+
+    clearConsole()
+  }
+
+  handleText(action) {
+    const lines = this.normalizeLines(action)
+    lines.forEach(line => console.log(line))
+    if (action.extraNewLine) {
+      console.log('')
+    }
+  }
+
+  handleCode(action) {
+    if (action.title) {
+      console.log(`\n${action.title}`)
+      console.log('━'.repeat(action.width || 50))
+    }
+
+    const lines = typeof action.code === 'string' ? action.code.split('\n') : []
+    lines.forEach(line => console.log(this.formatCode(line)))
+
+    if (action.title) {
+      console.log('━'.repeat(action.width || 50))
+    }
+
+    if (action.after) {
+      const afterLines = Array.isArray(action.after) ? action.after : [action.after]
+      afterLines.forEach(line => console.log(line))
+    }
+  }
+
+  async handlePause(action) {
+    const message = action.message || DEFAULT_WAIT_MESSAGE
+    await askQuestion(this.rl, message)
+    if (action.appendNewLines !== false) {
+      console.log('\n')
+    }
+  }
+
+  async handleSleep(action) {
+    const duration = typeof action.duration === 'number' ? action.duration : 800
+    await new Promise(resolve => setTimeout(resolve, duration))
+  }
+
+  normalizeLines(action) {
+    if (Array.isArray(action.lines)) {
+      return action.lines.map(item => (item === null || item === undefined ? '' : String(item)))
+    }
+
+    if (typeof action.lines === 'string') {
+      return action.lines.split('\n')
+    }
+
+    if (Array.isArray(action.text)) {
+      return action.text.map(item => (item === null || item === undefined ? '' : String(item)))
+    }
+
+    if (typeof action.text === 'string') {
+      return action.text.split('\n')
+    }
+
+    if (typeof action.text !== 'undefined') {
+      return [String(action.text)]
+    }
+
+    return []
+  }
+
+  formatCode(line = '') {
+    const colors = {
+      keyword: '\u001b[35m',
+      property: '\u001b[32m',
+      string: '\u001b[33m',
+      comment: '\u001b[90m',
+      reset: '\u001b[0m'
+    }
+
+    return line
+      .replace(/\b(class|constructor|return|if|const|let|new|async|await|throw|try|catch)\b/g, `${colors.keyword}$1${colors.reset}`)
+      .replace(/\bthis\./g, `${colors.property}this.${colors.reset}`)
+      .replace(/'([^']*)'/g, (_, inner) => `${colors.string}'${inner}'${colors.reset}`)
+      .replace(/"([^\"]*)"/g, (_, inner) => `${colors.string}"${inner}"${colors.reset}`)
+      .replace(/`([^`]*)`/g, (_, inner) => `${colors.string}\`${inner}\`${colors.reset}`)
+      .replace(/\/\/.*$/g, match => `${colors.comment}${match}${colors.reset}`)
+  }
+
+  async handleIntro(action) {
+    // Show definition first
+    if (action.definition) {
+      console.log(action.definition)
+    }
+
+    // Wait for Enter
+    await askQuestion(this.rl, '\nPresiona Enter para continuar...')
+
+    // Clear screen and show explanation
+    if (action.explanation) {
+      clearConsole()
+      console.log(action.explanation)
+      await askQuestion(this.rl, '\nPresiona Enter para continuar...')
+    }
+
+    // Clear screen and show detail
+    if (action.detail) {
+      clearConsole()
+      console.log(action.detail)
+      await askQuestion(this.rl, '\nPresiona Enter para continuar...')
+    }
+  }
+
+  async handleCommandIntro(action) {
+    // Clear screen before showing command
+    clearConsole()
+
+    console.log(action.description)
+    console.log('')
+    console.log(action.explanation)
+
+    if (action.example) {
+      console.log('')
+      console.log(`Ejemplo: ${action.example}`)
+    }
+
+    console.log('')
+    console.log(action.instruction)
+
+    if (!action.exitOnComplete) {
+      await askQuestion(this.rl, '\nPresiona Enter para continuar...')
+    }
+  }
+
+  async handleMazeCompletion(action) {
+    const frames = [
+      // Frame 1: Cow enters maze
+      [
+        '███████████████',
+        '█🐄░░░███░░░░░█',
+        '█░███░███░███░█',
+        '█░███░░░░░███░█',
+        '█░░░░░███░░░░░█',
+        '███████████████'
+      ],
+      // Frame 2: Cow moves forward
+      [
+        '███████████████',
+        '█░🐄░░███░░░░░█',
+        '█░███░███░███░█',
+        '█░███░░░░░███░█',
+        '█░░░░░███░░░░░█',
+        '███████████████'
+      ],
+      // Frame 3: Cow continues
+      [
+        '███████████████',
+        '█░░🐄░███░░░░░█',
+        '█░███░███░███░█',
+        '█░███░░░░░███░█',
+        '█░░░░░███░░░░░█',
+        '███████████████'
+      ],
+      // Frame 4: Cow turns down
+      [
+        '███████████████',
+        '█░░░🐄███░░░░░█',
+        '█░███░███░███░█',
+        '█░███░░░░░███░█',
+        '█░░░░░███░░░░░█',
+        '███████████████'
+      ],
+      // Frame 5: Cow goes down
+      [
+        '███████████████',
+        '█░░░░░███░░░░░█',
+        '█░███🐄███░███░█',
+        '█░███░░░░░███░█',
+        '█░░░░░███░░░░░█',
+        '███████████████'
+      ],
+      // Frame 6: Cow continues down
+      [
+        '███████████████',
+        '█░░░░░███░░░░░█',
+        '█░███░███░███░█',
+        '█░███🐄░░░███░█',
+        '█░░░░░███░░░░░█',
+        '███████████████'
+      ],
+      // Frame 7: Cow moves right
+      [
+        '███████████████',
+        '█░░░░░███░░░░░█',
+        '█░███░███░███░█',
+        '█░███░🐄░░███░█',
+        '█░░░░░███░░░░░█',
+        '███████████████'
+      ],
+      // Frame 8: Cow reaches bottom
+      [
+        '███████████████',
+        '█░░░░░███░░░░░█',
+        '█░███░███░███░█',
+        '█░███░░🐄░███░█',
+        '█░░░░░███░░░░░█',
+        '███████████████'
+      ],
+      // Frame 9: Cow moves down to exit
+      [
+        '███████████████',
+        '█░░░░░███░░░░░█',
+        '█░███░███░███░█',
+        '█░███░░░░░███░█',
+        '█░░░░🐄███░░░░█',
+        '███████████████'
+      ],
+      // Frame 10: Cow approaches exit
+      [
+        '███████████████',
+        '█░░░░░███░░░░░█',
+        '█░███░███░███░█',
+        '█░███░░░░░███░█',
+        '█░░░░░███🐄░░░█',
+        '███████████████'
+      ],
+      // Frame 11: Cow exits!
+      [
+        '███████████████',
+        '█░░░░░███░░░░░█',
+        '█░███░███░███░█',
+        '█░███░░░░░███░█',
+        '█░░░░░███░░🐄░█',
+        '███████████████'
+      ],
+      // Frame 12: Cow is free!
+      [
+        '███████████████',
+        '█░░░░░███░░░░░█',
+        '█░███░███░███░█',
+        '█░███░░░░░███░█',
+        '█░░░░░███░░░🐄█',
+        '███████████████'
+      ],
+      // Frame 13: Cow outside the maze
+      [
+        '███████████████',
+        '█░░░░░███░░░░░█',
+        '█░███░███░███░█',
+        '█░███░░░░░███░█',
+        '█░░░░░███░░░░░█',
+        '███████████████  🐄'
+      ]
+    ]
+
+    console.log('\n')
+
+    // Animate through frames
+    for (const frame of frames) {
+      clearConsole()
+      console.log('')
+      frame.forEach(line => console.log('  ' + line))
+      await new Promise(resolve => setTimeout(resolve, 300))
+    }
+
+    // Show completion message
+    await new Promise(resolve => setTimeout(resolve, 500))
+    console.log('')
+    console.log(`  ✓ ${action.message}`)
+
+    if (action.unlocked) {
+      await new Promise(resolve => setTimeout(resolve, 300))
+      console.log(`  🔓 Desbloqueaste: ${action.unlocked}`)
+    }
+
+    console.log('')
+    await askQuestion(this.rl, '\nPresiona Enter para continuar...')
+  }
+}

package/lib/builders/MenuBuilder.js

@@ -0,0 +1,154 @@
+import { createPromptInterface, askQuestion } from '../utils/input.js'
+import { clearConsole } from '../utils/output.js'
+
+export class MenuBuilder {
+  constructor(config) {
+    this.config = config
+  }
+
+  async show() {
+    if (this.config?.options?.length === 0) {
+      return null
+    }
+
+    if (!process.stdin.isTTY) {
+      return this.showFallback()
+    }
+
+    try {
+      return await this.showInteractive()
+    } catch (error) {
+      console.log('\nModo interactivo no disponible, usando selección numérica...\n')
+      return await this.showFallback()
+    }
+  }
+
+  renderHeader() {
+    clearConsole()
+
+    if (this.config.banner) {
+      console.log(this.config.banner)
+    }
+
+    if (this.config.description) {
+      const lines = Array.isArray(this.config.description)
+        ? this.config.description
+        : [this.config.description]
+      lines.forEach(line => console.log(line))
+      console.log('')
+    }
+
+    if (this.config.title) {
+      console.log(this.config.title)
+    }
+  }
+
+  renderOption(option, isSelected, index) {
+    const prefix = isSelected ? '▶ ' : '  '
+    const label = option.title || option.label || `Opción ${index + 1}`
+
+    if (isSelected) {
+      console.log(`\x1b[36m${prefix}${label}\x1b[0m`)
+    } else {
+      console.log(`${prefix}${label}`)
+    }
+
+    if (option.description) {
+      console.log(`    ${option.description}`)
+    }
+    console.log('')
+  }
+
+  async showInteractive() {
+    if (typeof process.stdin.setRawMode !== 'function') {
+      throw new Error('setRawMode not available')
+    }
+
+    let selectedIndex = 0
+
+    const render = () => {
+      this.renderHeader()
+      this.config.options.forEach((option, index) => {
+        this.renderOption(option, index === selectedIndex, index)
+      })
+    }
+
+    return new Promise((resolve) => {
+      process.stdin.setRawMode(true)
+      process.stdin.resume()
+      process.stdin.setEncoding('utf8')
+
+      const onKeyPress = (key) => {
+        if (key === 'q' || key === '\u0003') {
+          cleanup()
+          resolve(null)
+          return
+        }
+
+        if (key === '\r' || key === '\n') {
+          const choice = this.config.options[selectedIndex]
+          cleanup()
+          resolve(choice)
+          return
+        }
+
+        if (key === '\u001b[A') {
+          selectedIndex = selectedIndex > 0 ? selectedIndex - 1 : this.config.options.length - 1
+          render()
+        } else if (key === '\u001b[B') {
+          selectedIndex = selectedIndex < this.config.options.length - 1 ? selectedIndex + 1 : 0
+          render()
+        }
+      }
+
+      const cleanup = () => {
+        process.stdin.setRawMode(false)
+        process.stdin.removeListener('data', onKeyPress)
+      }
+
+      process.stdin.on('data', onKeyPress)
+      render()
+    })
+  }
+
+  async showFallback() {
+    const rl = createPromptInterface()
+
+    if (this.config.banner) {
+      console.log(this.config.banner)
+    }
+
+    if (this.config.description) {
+      const lines = Array.isArray(this.config.description)
+        ? this.config.description
+        : [this.config.description]
+      lines.forEach(line => console.log(line))
+      console.log('')
+    }
+
+    if (this.config.title) {
+      console.log(this.config.title)
+    }
+
+    this.config.options.forEach((option, index) => {
+      const label = option.title || option.label || `Opción ${index + 1}`
+      console.log(`${index + 1}. ${label}`)
+      if (option.description) {
+        console.log(`   ${option.description}`)
+      }
+    })
+
+    console.log('')
+    const answer = await askQuestion(rl, `Elige una opción (1-${this.config.options.length}) o 'q' para salir: `)
+
+    if (answer.toLowerCase() === 'q') {
+      rl.close()
+      return null
+    }
+
+    const selectedIndex = parseInt(answer, 10) - 1
+    const choice = this.config.options[selectedIndex]
+    rl.close()
+    return choice || null
+  }
+}

package/lib/builders/ProjectBuilder.js

@@ -0,0 +1,56 @@
+import fs from 'fs'
+import path from 'path'
+import { isBinaryFile } from '../utils/file-utils.js'
+import { LevelModifier } from '../templates/LevelModifier.js'
+
+export class ProjectBuilder {
+  constructor(templatePath) {
+    this.templatePath = templatePath
+  }
+
+  createProject(targetDir, projectName, studentName, level) {
+    if (!fs.existsSync(this.templatePath)) {
+      throw new Error(`Template no encontrado en: ${this.templatePath}`)
+    }
+
+    if (fs.existsSync(targetDir)) {
+      throw new Error(`El directorio ${projectName} ya existe`)
+    }
+
+    fs.mkdirSync(targetDir, { recursive: true })
+    const modifier = new LevelModifier(level)
+    this.copyDirectory(this.templatePath, targetDir, projectName, studentName, modifier)
+  }
+
+  applyPlaceholders(content, projectName, studentName) {
+    return content
+      .replace(/\{\{PROJECT_NAME\}\}/g, projectName)
+      .replace(/\{\{STUDENT_NAME\}\}/g, studentName)
+  }
+
+  copyDirectory(source, target, projectName, studentName, modifier) {
+    const entries = fs.readdirSync(source)
+
+    for (const entry of entries) {
+      const sourcePath = path.join(source, entry)
+      const targetPath = path.join(target, entry)
+      const stats = fs.statSync(sourcePath)
+
+      if (stats.isDirectory()) {
+        fs.mkdirSync(targetPath, { recursive: true })
+        this.copyDirectory(sourcePath, targetPath, projectName, studentName, modifier)
+        continue
+      }
+
+      if (isBinaryFile(sourcePath)) {
+        fs.copyFileSync(sourcePath, targetPath)
+        continue
+      }
+
+      let content = fs.readFileSync(sourcePath, 'utf8')
+      content = modifier.apply(content, entry)
+      content = this.applyPlaceholders(content, projectName, studentName)
+      fs.writeFileSync(targetPath, content)
+    }
+  }
+}

package/lib/cli/index.js

@@ -0,0 +1,85 @@
+import { MenuBuilder } from '../builders/MenuBuilder.js'
+import { MAIN_MENU_CONFIG } from '../data/menus.js'
+import { executeEnunciados } from '../executors/enunciados-executor.js'
+import { executeProyectos } from '../executors/proyectos-executor.js'
+import { executeSintaxis } from '../executors/sintaxis-executor.js'
+import { executePortfolio } from '../executors/portfolio-executor.js'
+import { showHelp } from '../commands/help.js'
+import { CretaCodeSession } from '../session.js'
+import { greetUser } from '../utils/greeting.js'
+
+async function executeMainMenu() {
+  // Greet user (ask name if first time, or show stats if returning)
+  await greetUser()
+
+  const menu = new MenuBuilder(MAIN_MENU_CONFIG)
+
+  while (true) {
+    const choice = await menu.show()
+    if (!choice) {
+      console.log('\nHecho con <3 por icarus.mx')
+      return
+    }
+
+    if (choice.id === 'sintaxis') {
+      await executeSintaxis()
+    } else if (choice.id === 'enunciados') {
+      await executeEnunciados()
+    } else if (choice.id === 'proyectos') {
+      await executeProyectos()
+    }
+  }
+}
+
+async function runCodeSession() {
+  const session = new CretaCodeSession()
+  await session.start()
+}
+
+const COMMANDS = new Map([
+  ['enunciados', () => executeEnunciados()],
+  ['sintaxis', () => executeSintaxis()],
+  ['proyectos', () => executeProyectos()],
+  ['portafolio', () => executePortfolio(0)],
+  ['code', () => runCodeSession()],
+  ['help', () => showHelp()],
+  ['ayuda', () => showHelp()]
+])
+
+export async function handleCommand(command, args = []) {
+  if (!command) {
+    return true
+  }
+
+  const normalized = command.toLowerCase()
+
+  if (normalized.startsWith('portafolio')) {
+    const levelPart = normalized.split('-')[1]
+    const level = levelPart ? parseInt(levelPart, 10) : 0
+    await executePortfolio(Number.isNaN(level) ? 0 : level)
+    return true
+  }
+
+  const handler = COMMANDS.get(normalized)
+
+  if (!handler) {
+    console.log(`Comando no reconocido: ${command}`)
+    console.log("Escribe 'creta help' para ver comandos disponibles")
+    return false
+  }
+
+  await handler(args)
+  return true
+}
+
+export async function runCLI(args = []) {
+  const [command, ...rest] = args
+
+  if (!command) {
+    await executeMainMenu()
+    return 0
+  }
+
+  const handled = await handleCommand(command, rest)
+  return handled ? 0 : 1
+}

package/lib/commands/help.js

@@ -0,0 +1,5 @@
+import { HELP_TEXT } from '../data/messages.js'
+
+export function showHelp() {
+  console.log(HELP_TEXT)
+}