@icarusmx/creta 1.3.3 → 1.3.5

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,228 @@
+import { createPromptInterface, askQuestion } from '../utils/input.js'
+import { clearConsole } from '../utils/output.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)
+    } 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 '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 comenzar...')
+
+    // Show explanation and detail
+    if (action.explanation) {
+      console.log(`\n${action.explanation}`)
+    }
+
+    if (action.detail) {
+      console.log('')
+      console.log(action.detail)
+    }
+  }
+
+  async handleCommandIntro(action) {
+    console.log('')
+    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, DEFAULT_WAIT_MESSAGE)
+    }
+  }
+}

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,81 @@
+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'
+
+async function executeMainMenu() {
+  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)
+}

package/lib/constants/paths.js

@@ -0,0 +1,9 @@
+import path from 'path'
+import { fileURLToPath } from 'url'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+export const CLI_ROOT = path.resolve(__dirname, '../..')
+export const TEMPLATES_ROOT = path.join(CLI_ROOT, 'templates')
+export const SVELTEKIT_PORTFOLIO_TEMPLATE_PATH = path.join(TEMPLATES_ROOT, 'sveltekit-portfolio')

package/lib/data/enunciados.js

@@ -0,0 +1,44 @@
+export const ENUNCIADOS = [
+  {
+    id: 1,
+    texto: "La parte difícil del diseño orientado a objetos es descomponer un sistema como un conjunto de objetos que interactúan entre sí.",
+    nivel: "Fundacional",
+    enfoque: "Descomposición de sistemas"
+  },
+  {
+    id: 2,
+    texto: "Los objetos interactúan entre sí a través de solicitudes.",
+    nivel: "Interacción",
+    enfoque: "Comunicación entre objetos"
+  },
+  {
+    id: 3,
+    texto: "Las solicitudes son la única forma de conseguir que un objeto lleve a cabo una operación.",
+    nivel: "Operaciones",
+    enfoque: "Mecanismo de ejecución"
+  },
+  {
+    id: 4,
+    texto: "Cada operación declarada por un objeto debe incluir:\na) nombre de la operación\nb) insumos necesarios para realizar la operación\nc) el valor que regresa tras ejecutar la operación\n\nEstos tres elementos constituyen la firma de operación.",
+    nivel: "Firmas",
+    enfoque: "Contratos de operación"
+  },
+  {
+    id: 5,
+    texto: "La interfaz de un objeto es el conjunto de todas sus firmas de operación.",
+    nivel: "Interfaces",
+    enfoque: "Definición de contratos"
+  },
+  {
+    id: 6,
+    texto: "El énfasis al diseñar los objetos debe estar en la definición de sus solicitudes e interfaces.",
+    nivel: "Diseño",
+    enfoque: "Metodología de desarrollo"
+  },
+  {
+    id: 7,
+    texto: "Un objeto es un conjunto de datos y procedimientos que operan sobre esos datos.",
+    nivel: "Definición",
+    enfoque: "Naturaleza del objeto"
+  }
+]

package/lib/data/lessons/index.js

@@ -0,0 +1,25 @@
+export { LESSON_1_SYSTEM_DECOMPOSITION } from './lesson1-system-decomposition.js'
+export { LESSON_2_OBJECT_REQUESTS } from './lesson2-object-requests.js'
+export { LESSON_3_ONLY_WAY } from './lesson3-only-way.js'
+export { LESSON_4_OPERATION_SIGNATURES } from './lesson4-operation-signatures.js'
+export { LESSON_5_INTERFACE_SET } from './lesson5-interface-set.js'
+export { LESSON_6_INTERFACE_DESIGN } from './lesson6-interface-design.js'
+export { LESSON_7_OBJECT_DEFINITION } from './lesson7-object-definition.js'
+
+import { LESSON_1_SYSTEM_DECOMPOSITION } from './lesson1-system-decomposition.js'
+import { LESSON_2_OBJECT_REQUESTS } from './lesson2-object-requests.js'
+import { LESSON_3_ONLY_WAY } from './lesson3-only-way.js'
+import { LESSON_4_OPERATION_SIGNATURES } from './lesson4-operation-signatures.js'
+import { LESSON_5_INTERFACE_SET } from './lesson5-interface-set.js'
+import { LESSON_6_INTERFACE_DESIGN } from './lesson6-interface-design.js'
+import { LESSON_7_OBJECT_DEFINITION } from './lesson7-object-definition.js'
+
+export const LESSONS_BY_ID = new Map([
+  [1, LESSON_1_SYSTEM_DECOMPOSITION],
+  [2, LESSON_2_OBJECT_REQUESTS],
+  [3, LESSON_3_ONLY_WAY],
+  [4, LESSON_4_OPERATION_SIGNATURES],
+  [5, LESSON_5_INTERFACE_SET],
+  [6, LESSON_6_INTERFACE_DESIGN],
+  [7, LESSON_7_OBJECT_DEFINITION]
+])