@saulwade/swl-ses 1.5.2 → 1.6.1

package/scripts/instalador.js

@@ -42,6 +42,24 @@ const { actualizarGitignore, entradasParaRuntime, limpiarTracked, leerManifest,
 const RAIZ_PKG = path.resolve(__dirname, '..');
 const VERSION = require('../package.json').version;
 
+/**
+ * Contrato adicional: `opciones.onProgress(evento)`
+ *
+ * Si se pasa una función `opciones.onProgress`, el instalador deja de imprimir
+ * cada archivo copiado/backup/symlink a stdout y en su lugar emite eventos
+ * estructurados que el caller (típicamente la TUI) puede consumir para mostrar
+ * barra de progreso + contadores por categoría.
+ *
+ * Eventos emitidos:
+ *   { tipo: 'archivo-copiado', componente: 'agentes'|'habilidades'|... , archivo: 'nombre.md' }
+ *   { tipo: 'backup',          componente: <tipo>, archivo, rutaBackup }
+ *   { tipo: 'symlink',         componente: <tipo>, archivo }
+ *   { tipo: 'colision',        componente: <tipo>, archivo }
+ *   { tipo: 'log',             linea: 'mensaje libre' }   — para mensajes informativos
+ *
+ * Backward compat: si onProgress NO se pasa, los console.log siguen iguales.
+ * El comportamiento sin TUI no cambia.
+ */
 async function install(opciones) {
   // Leer manifest .swl-ses si existe — sus valores son defaults que el CLI puede sobreescribir
   const manifest = leerManifest(process.cwd());
@@ -990,7 +1008,15 @@ function instalarArchivo(archivo, rutas, runtime, opciones = {}) {
 
   // Verificar colisión
   if (fs.existsSync(destino) && !opciones.force) {
-    console.log(`  - Colisión: ${nombreArchivo} (usa --force para sobreescribir)`);
+    if (typeof opciones.onProgress === 'function') {
+      opciones.onProgress({
+        tipo: 'colision',
+        componente: archivo.tipo,
+        archivo: nombreArchivo,
+      });
+    } else {
+      console.log(`  - Colisión: ${nombreArchivo} (usa --force para sobreescribir)`);
+    }
     return { instalado: false, colision: true };
   }
 
@@ -998,7 +1024,16 @@ function instalarArchivo(archivo, rutas, runtime, opciones = {}) {
   if (fs.existsSync(destino) && opciones.force && opciones.versionAnterior) {
     const backup = crearBackup(process.cwd(), destino, opciones.versionAnterior);
     if (backup.respaldado) {
-      console.log(`  ↩ Backup: ${nombreArchivo} → ${path.relative(process.cwd(), backup.rutaBackup)}`);
+      if (typeof opciones.onProgress === 'function') {
+        opciones.onProgress({
+          tipo: 'backup',
+          componente: archivo.tipo,
+          archivo: nombreArchivo,
+          rutaBackup: backup.rutaBackup,
+        });
+      } else {
+        console.log(`  ↩ Backup: ${nombreArchivo} → ${path.relative(process.cwd(), backup.rutaBackup)}`);
+      }
       if (opciones.estado) {
         registrarBackup(opciones.estado, {
           rutaOriginal: destino,
@@ -1027,7 +1062,15 @@ function instalarArchivo(archivo, rutas, runtime, opciones = {}) {
         }
         const origenAbsoluto = path.resolve(archivo.origen);
         fs.symlinkSync(origenAbsoluto, destino, stat.isDirectory() ? 'junction' : 'file');
-        console.log(`  ~ ${path.relative(rutas.base, destino)} (symlink)`);
+        if (typeof opciones.onProgress === 'function') {
+          opciones.onProgress({
+            tipo: 'symlink',
+            componente: archivo.tipo,
+            archivo: nombreArchivo,
+          });
+        } else {
+          console.log(`  ~ ${path.relative(rutas.base, destino)} (symlink)`);
+        }
         return { instalado: true, destino };
       } catch (symlinkErr) {
         // Fallback a copy si symlink falla (permisos, filesystem)
@@ -1045,7 +1088,15 @@ function instalarArchivo(archivo, rutas, runtime, opciones = {}) {
     } else {
       fs.copyFileSync(archivo.origen, destino);
     }
-    console.log(`  + ${path.relative(rutas.base, destino)}`);
+    if (typeof opciones.onProgress === 'function') {
+      opciones.onProgress({
+        tipo: 'archivo-copiado',
+        componente: archivo.tipo,
+        archivo: nombreArchivo,
+      });
+    } else {
+      console.log(`  + ${path.relative(rutas.base, destino)}`);
+    }
     return { instalado: true, destino };
   } else {
     return { instalado: false, razon: 'origen no existe' };

package/scripts/lib/parsear-opciones.js

@@ -45,6 +45,9 @@ const BOOLEANAS = [
   // ADR-0019 — Codex/Cursor + MCP autoconfig opt-in
   'with-mcp', 'no-mcp',
   'all-runtimes',
+  // TUI opt-out (Fase 4 instalador visual). Default: si stdin es TTY y no
+  // hay flags, lanza el TUI. Con --no-tui cae al install-asistido clásico.
+  'no-tui', 'tui',
 ];
 
 /**

package/scripts/lib/ui.js

@@ -82,6 +82,25 @@ function encabezado(titulo, version) {
 // Spinner
 // ---------------------------------------------------------------------------
 
+// Registro global de spinners activos. Permite que las funciones interactivas
+// (preguntarSiNo, preguntarOpcion, preguntarTexto) pausen cualquier spinner en
+// curso antes de crear un readline, evitando que el setInterval del spinner
+// sobreescriba el prompt con `\r`. Origen: bug observado en `swl-ses update`
+// cuando el instalador hace preguntarSiNo dentro del spinner del actualizador.
+const _spinnersActivos = new Set();
+
+function _pausarSpinnersActivos() {
+  for (const sp of _spinnersActivos) {
+    sp._pausar();
+  }
+}
+
+function _reanudarSpinnersActivos() {
+  for (const sp of _spinnersActivos) {
+    sp._reanudar();
+  }
+}
+
 function spinner(mensaje) {
   if (!SOPORTA_COLOR) {
     // Sin TTY: solo mostrar mensaje estático
@@ -91,49 +110,96 @@ function spinner(mensaje) {
       exito: (msg) => { console.log(`  [OK] ${msg}`); },
       fallo: (msg) => { console.log(`  [ERROR] ${msg}`); },
       detener: () => {},
+      _pausar: () => {},
+      _reanudar: () => {},
     };
   }
 
   let frameIdx = 0;
   let textoActual = mensaje;
   let activo = true;
+  let pausado = false;
+  let intervalo = null;
 
-  const intervalo = setInterval(() => {
-    if (!activo) return;
+  function _tick() {
+    if (!activo || pausado) return;
     const frame = SPINNER_FRAMES[frameIdx % SPINNER_FRAMES.length];
     process.stdout.write(`\r  ${color.cyan(frame)} ${textoActual}   `);
     frameIdx++;
-  }, 80);
+  }
+
+  function _arrancarIntervalo() {
+    if (intervalo) return;
+    intervalo = setInterval(_tick, 80);
+  }
+
+  function _detenerIntervalo() {
+    if (intervalo) {
+      clearInterval(intervalo);
+      intervalo = null;
+    }
+  }
 
   function limpiarLinea() {
     process.stdout.write('\r\x1b[2K');
   }
 
+  _arrancarIntervalo();
+
+  // Declarado antes del handle para que las funciones de terminación puedan
+  // removerlo. Origen: F-1 nemesis iter-1 — sin remove, cada spinner deja un
+  // listener muerto en `process` y un loop con N runtimes acumula warnings
+  // de MaxListenersExceeded.
+  const exitHandler = () => { handle.detener(); };
+
   const handle = {
     actualizar(msg) {
       textoActual = msg;
     },
     exito(msg) {
       activo = false;
-      clearInterval(intervalo);
+      _detenerIntervalo();
+      _spinnersActivos.delete(handle);
+      process.removeListener('exit', exitHandler);
       limpiarLinea();
       console.log(`  ${color.verde(icono.check)} ${msg}`);
     },
     fallo(msg) {
       activo = false;
-      clearInterval(intervalo);
+      _detenerIntervalo();
+      _spinnersActivos.delete(handle);
+      process.removeListener('exit', exitHandler);
       limpiarLinea();
       console.log(`  ${color.rojo(icono.cross)} ${msg}`);
     },
     detener() {
       activo = false;
-      clearInterval(intervalo);
+      _detenerIntervalo();
+      _spinnersActivos.delete(handle);
+      process.removeListener('exit', exitHandler);
+      limpiarLinea();
+    },
+    _pausar() {
+      // Pausa el tick para que un readline pueda renderizar el prompt sin
+      // que el spinner lo sobreescriba con `\r`. Limpia la línea para que
+      // el prompt empiece en una columna libre.
+      if (pausado) return;
+      pausado = true;
+      _detenerIntervalo();
       limpiarLinea();
     },
+    _reanudar() {
+      // Reanuda el tick tras el cierre del readline. Solo si el spinner sigue
+      // lógicamente activo (no fue detenido durante la pausa).
+      if (!pausado || !activo) return;
+      pausado = false;
+      _arrancarIntervalo();
+    },
   };
 
-  // Limpieza en caso de que el proceso muera
-  const exitHandler = () => { handle.detener(); };
+  _spinnersActivos.add(handle);
+
+  // Limpieza si el proceso muere antes de exito/fallo/detener
   process.once('exit', exitHandler);
 
   return handle;
@@ -151,19 +217,36 @@ function preguntarSiNo(mensaje, valorDefault = true) {
     }
 
     const hint = valorDefault ? 'S/n' : 's/N';
+    _pausarSpinnersActivos();
     const rl = readline.createInterface({
       input: process.stdin,
       output: process.stdout,
     });
 
+    // El evento 'close' es la única ruta de finalización. Se garantiza que
+    // se dispare incluso si el callback de question no se ejecuta (Ctrl+C,
+    // EOF, error en stdin). Esto evita el bug donde los spinners quedaban
+    // permanentemente pausados tras un cierre prematuro del readline.
+    let valorFinal = valorDefault;
+    let resuelto = false;
+
+    function finalizar() {
+      if (resuelto) return;
+      resuelto = true;
+      _reanudarSpinnersActivos();
+      resolve(valorFinal);
+    }
+
+    rl.on('close', finalizar);
+
     rl.question(`  ${mensaje} [${hint}] `, (respuesta) => {
-      rl.close();
       const r = respuesta.trim().toLowerCase();
       if (r === '') {
-        resolve(valorDefault);
+        valorFinal = valorDefault;
       } else {
-        resolve(r === 's' || r === 'si' || r === 'sí' || r === 'y' || r === 'yes');
+        valorFinal = r === 's' || r === 'si' || r === 'sí' || r === 'y' || r === 'yes';
       }
+      rl.close(); // dispara 'close' → finalizar(); idempotente vía `resuelto`
     });
   });
 }
@@ -185,6 +268,11 @@ function preguntarOpcion(titulo, opciones, opts = {}) {
       return;
     }
 
+    // Pausar antes de emitir el menú con console.log — si hay spinner activo,
+    // un tick a 80ms puede sobreescribir la primera línea del menú. Origen:
+    // F-2 nemesis iter-1.
+    _pausarSpinnersActivos();
+
     console.log('');
     console.log(`  ${titulo}`);
     console.log('');
@@ -197,21 +285,36 @@ function preguntarOpcion(titulo, opciones, opts = {}) {
 
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
     const hint = `[1-${opciones.length}, Enter=${opciones[indiceDefault].valor}]`;
+
+    // Ver preguntarSiNo: 'close' garantiza reanudación incluso si el callback
+    // de question no se invoca (Ctrl+C, EOF, error).
+    let valorFinal = opciones[indiceDefault].valor;
+    let resuelto = false;
+
+    function finalizar() {
+      if (resuelto) return;
+      resuelto = true;
+      _reanudarSpinnersActivos();
+      resolve(valorFinal);
+    }
+
+    rl.on('close', finalizar);
+
     rl.question(`  Tu elección ${hint}: `, (respuesta) => {
-      rl.close();
       const r = respuesta.trim();
       if (r === '') {
-        resolve(opciones[indiceDefault].valor);
-        return;
-      }
-      const n = parseInt(r, 10);
-      if (Number.isFinite(n) && n >= 1 && n <= opciones.length) {
-        resolve(opciones[n - 1].valor);
+        valorFinal = opciones[indiceDefault].valor;
       } else {
-        // Permitir también escribir el valor directo si coincide
-        const match = opciones.find(o => o.valor === r);
-        resolve(match ? match.valor : opciones[indiceDefault].valor);
+        const n = parseInt(r, 10);
+        if (Number.isFinite(n) && n >= 1 && n <= opciones.length) {
+          valorFinal = opciones[n - 1].valor;
+        } else {
+          // Permitir también escribir el valor directo si coincide
+          const match = opciones.find(o => o.valor === r);
+          valorFinal = match ? match.valor : opciones[indiceDefault].valor;
+        }
       }
+      rl.close();
     });
   });
 }
@@ -230,10 +333,26 @@ function preguntarTexto(mensaje, valorDefault = '') {
       return;
     }
     const hint = valorDefault ? ` [${valorDefault}]` : '';
+    _pausarSpinnersActivos();
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+    // Ver preguntarSiNo: 'close' garantiza reanudación incluso si el callback
+    // de question no se invoca (Ctrl+C, EOF, error).
+    let valorFinal = valorDefault;
+    let resuelto = false;
+
+    function finalizar() {
+      if (resuelto) return;
+      resuelto = true;
+      _reanudarSpinnersActivos();
+      resolve(valorFinal);
+    }
+
+    rl.on('close', finalizar);
+
     rl.question(`  ${mensaje}${hint}: `, (respuesta) => {
+      valorFinal = respuesta.trim() || valorDefault;
       rl.close();
-      resolve(respuesta.trim() || valorDefault);
     });
   });
 }
@@ -245,6 +364,13 @@ function preguntarTexto(mensaje, valorDefault = '') {
 module.exports = {
   SOPORTA_COLOR,
   ES_TTY,
+  // Exports internos para tests del fix de race spinner/prompt. NO usar en
+  // código de producción — la API estable es spinner() + preguntar*.
+  __internalForTesting: {
+    spinnersActivos: _spinnersActivos,
+    pausarSpinnersActivos: _pausarSpinnersActivos,
+    reanudarSpinnersActivos: _reanudarSpinnersActivos,
+  },
   color,
   icono,
   formatearPaso,

package/scripts/tui/componentes/selector-multi.js

@@ -0,0 +1,189 @@
+'use strict';
+
+/**
+ * Selector múltiple (multi-select / checkbox) para la TUI.
+ * Extensión del selectorCheckbox de scripts/lib/selector-interactivo.js con:
+ *   - Descripciones por item (panel inferior bajo el cursor)
+ *   - Atajos: ↑↓ navegar, espacio toggle, 'a' todos, 'n' ninguno
+ *   - Hint configurable
+ *   - Items deshabilitados respetados
+ *
+ * Diseño:
+ *   - Cada item: { valor, etiqueta, descripcion?, deshabilitado?, preseleccionado? }
+ *   - Resuelve con array de valores seleccionados (en orden de items).
+ *   - Esc resuelve con `null` (señal de cancelación).
+ *
+ * No-TTY: resuelve con los items preseleccionados o con todos si
+ *   `opciones.todosSeleccionadosSiNoTty` está en true.
+ */
+
+const render = require('../lib/render');
+const teclas = require('../lib/teclas');
+const { colores, semantico, iconos } = require('../lib/colores');
+
+/**
+ * @param {object} opciones
+ * @param {string} opciones.titulo
+ * @param {Array<{valor:string,etiqueta:string,descripcion?:string,deshabilitado?:boolean,preseleccionado?:boolean}>} opciones.items
+ * @param {boolean} [opciones.todosSeleccionadosSiNoTty=false]
+ * @returns {Promise<string[]|null>}
+ */
+function selectorMulti(opciones) {
+  const items = opciones.items || [];
+  const titulo = opciones.titulo || 'Selecciona las opciones:';
+
+  // Construir set inicial respetando preseleccionados y deshabilitados
+  const seleccionados = new Set();
+  for (const it of items) {
+    if (it.preseleccionado && !it.deshabilitado) seleccionados.add(it.valor);
+  }
+
+  let cursor = 0;
+  while (cursor < items.length && items[cursor]?.deshabilitado) cursor++;
+  if (cursor >= items.length) cursor = 0;
+
+  return new Promise((resolve) => {
+    if (!render.ES_TTY || !process.stdin.isTTY) {
+      if (opciones.todosSeleccionadosSiNoTty) {
+        resolve(items.filter(i => !i.deshabilitado).map(i => i.valor));
+      } else {
+        resolve(Array.from(seleccionados));
+      }
+      return;
+    }
+
+    function _renderizar() {
+      render.limpiarPantalla();
+      const { cols, rows } = render.obtenerDimensiones();
+
+      render.escribirEn(2, 3, semantico.titulo(titulo));
+      render.escribirEn(3, 3, colores.dim(
+        `${seleccionados.size}/${items.filter(i => !i.deshabilitado).length} seleccionados`
+      ));
+
+      const filaInicio = 5;
+      const maxVisible = Math.min(items.length, rows - 8);
+      let scrollOffset = 0;
+      if (cursor < scrollOffset) scrollOffset = cursor;
+      if (cursor >= scrollOffset + maxVisible) scrollOffset = cursor - maxVisible + 1;
+
+      for (let i = scrollOffset; i < Math.min(items.length, scrollOffset + maxVisible); i++) {
+        const item = items[i];
+        const esCursor = i === cursor;
+        const marcado = seleccionados.has(item.valor);
+        const filaItem = filaInicio + (i - scrollOffset);
+
+        let prefijo;
+        if (item.deshabilitado) {
+          prefijo = colores.dim('  ');
+        } else if (esCursor) {
+          prefijo = semantico.cursor(iconos.cursor + ' ');
+        } else {
+          prefijo = '  ';
+        }
+
+        const checkbox = item.deshabilitado
+          ? colores.dim(iconos.cajaVacia)
+          : (marcado ? semantico.exito(iconos.cajaLlena) : iconos.cajaVacia);
+
+        let etiqueta = item.etiqueta;
+        if (item.deshabilitado) etiqueta = colores.dim(etiqueta);
+        else if (esCursor) etiqueta = colores.negrita(etiqueta);
+
+        render.escribirEn(filaItem, 3, `${prefijo}${checkbox} ${etiqueta}`);
+
+        // Descripción del item bajo cursor
+        if (esCursor && item.descripcion && !item.deshabilitado) {
+          const filaDesc = filaInicio + maxVisible + 1;
+          const desc = render.recortar(colores.dim(item.descripcion), cols - 6);
+          render.escribirEn(filaDesc, 3, desc);
+        }
+      }
+
+      // Indicador de scroll
+      if (scrollOffset + maxVisible < items.length) {
+        render.escribirEn(filaInicio + maxVisible, 3,
+          colores.dim(`${iconos.flechaAbajo} ${items.length - scrollOffset - maxVisible} más`));
+      }
+
+      render.dibujarPiePagina([
+        ['↑↓', 'navegar'],
+        ['Space', 'toggle'],
+        ['a', 'todos'],
+        ['n', 'ninguno'],
+        ['Enter', 'confirmar'],
+        ['Esc', 'cancelar'],
+      ]);
+    }
+
+    render.iniciarModoTui();
+    _renderizar();
+
+    const onResize = () => _renderizar();
+    process.stdout.on('resize', onResize);
+
+    const teclado = teclas.crearTeclado();
+
+    function _moverArriba() {
+      let nuevo = cursor;
+      do {
+        nuevo = nuevo > 0 ? nuevo - 1 : items.length - 1;
+      } while (nuevo !== cursor && items[nuevo]?.deshabilitado);
+      cursor = nuevo;
+      _renderizar();
+    }
+
+    function _moverAbajo() {
+      let nuevo = cursor;
+      do {
+        nuevo = nuevo < items.length - 1 ? nuevo + 1 : 0;
+      } while (nuevo !== cursor && items[nuevo]?.deshabilitado);
+      cursor = nuevo;
+      _renderizar();
+    }
+
+    function _toggle() {
+      const item = items[cursor];
+      if (!item || item.deshabilitado) return;
+      if (seleccionados.has(item.valor)) seleccionados.delete(item.valor);
+      else seleccionados.add(item.valor);
+      _renderizar();
+    }
+
+    function _todos() {
+      for (const it of items) {
+        if (!it.deshabilitado) seleccionados.add(it.valor);
+      }
+      _renderizar();
+    }
+
+    function _ninguno() {
+      seleccionados.clear();
+      _renderizar();
+    }
+
+    function _finalizar(valor) {
+      teclado.desactivar();
+      process.stdout.removeListener('resize', onResize);
+      render.salirModoTui();
+      resolve(valor);
+    }
+
+    teclado.on('up', _moverArriba);
+    teclado.on('down', _moverAbajo);
+    teclado.on('space', _toggle);
+    teclado.on('a', _todos);
+    teclado.on('n', _ninguno);
+    teclado.on('return', () => {
+      // Preservar el orden de los items, no el de inserción al set
+      const resultado = items
+        .filter(it => seleccionados.has(it.valor))
+        .map(it => it.valor);
+      _finalizar(resultado);
+    });
+    teclado.on('escape', () => _finalizar(null));
+    teclado.activar();
+  });
+}
+
+module.exports = { selectorMulti };