@saulwade/swl-ses 1.5.2 → 1.6.0

package/scripts/tui/ejecutores.js

@@ -0,0 +1,375 @@
+'use strict';
+
+/**
+ * Ejecutores TUI — conectan los wizards con scripts/instalador.js y
+ * scripts/actualizar.js a través del callback `onProgress`.
+ *
+ * Diseño:
+ *   - El wizard devuelve un plan (opciones del instalador).
+ *   - Se crea la pantalla Progreso con las categorías esperadas.
+ *   - Se invoca al instalador con onProgress conectado a la pantalla.
+ *   - Al terminar, se cierra Progreso y se muestra Resumen.
+ *
+ * Las funciones son async y devuelven el resultado de la operación
+ * (sin tirar excepciones — los errores quedan en el objeto resultado).
+ */
+
+const path = require('path');
+
+const { crearProgreso } = require('./pantallas/progreso');
+const { mostrarResumen } = require('./pantallas/resumen');
+
+const RAIZ_PKG = path.resolve(__dirname, '..', '..');
+
+// ---------------------------------------------------------------------------
+// Categorías que tracker el progreso. Total es estimación inicial — el
+// instalador puede emitir set-total para corregirlo si la cifra exacta
+// se conoce solo en runtime (depende del perfil).
+// ---------------------------------------------------------------------------
+
+function _categoriasDesdeOpciones(opciones) {
+  // Para los totales reales se podrían leer manifiestos. Por simplicidad,
+  // empezamos con totales nominales del proyecto y se ajustan con set-total
+  // si el instalador los provee.
+  return [
+    { nombre: 'agentes',     etiqueta: 'Agentes',     total: 0 },
+    { nombre: 'habilidades', etiqueta: 'Skills',      total: 0 },
+    { nombre: 'comandos',    etiqueta: 'Comandos',    total: 0 },
+    { nombre: 'reglas',      etiqueta: 'Reglas',      total: 0 },
+    { nombre: 'hooks',       etiqueta: 'Hooks',       total: 0 },
+    { nombre: 'schemas',     etiqueta: 'Schemas',     total: 0 },
+    { nombre: 'plantillas',  etiqueta: 'Plantillas',  total: 0 },
+  ];
+}
+
+function _calcularTotalesDelPlan(opciones) {
+  // Calcula el total estimado leyendo manifiestos/perfiles.json + modulos.json
+  // mediante resolverPerfil, que devuelve { perfil, modulos, archivos, warnings }.
+  try {
+    const { resolverPerfil } = require('../lib/manifiestos');
+    const resolucion = resolverPerfil(opciones.profile || 'core', {});
+    if (!resolucion || !Array.isArray(resolucion.archivos)) return {};
+    const totales = {};
+    for (const archivo of resolucion.archivos) {
+      const tipo = archivo.tipo || 'otros';
+      totales[tipo] = (totales[tipo] || 0) + 1;
+    }
+    return totales;
+  } catch (_) {
+    return {};
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Ejecutar Install
+// ---------------------------------------------------------------------------
+
+/**
+ * Ejecuta el install con UI de progreso conectada.
+ *
+ * @param {object} opciones - resultado del wizard Install (target, profile, global, etc.)
+ * @returns {Promise<{ ok, totales, error? }>}
+ */
+async function ejecutarInstall(opciones) {
+  const categorias = _categoriasDesdeOpciones(opciones);
+  const totalesEstimados = _calcularTotalesDelPlan(opciones);
+  for (const cat of categorias) {
+    if (totalesEstimados[cat.nombre]) cat.total = totalesEstimados[cat.nombre];
+  }
+
+  const ctrl = crearProgreso({
+    titulo: `Instalando perfil "${opciones.profile}" en ${opciones.target} (${opciones.global ? 'global' : 'proyecto'})`,
+    categorias,
+    verbose: !!opciones.verbose,
+  });
+  ctrl.iniciar();
+
+  let resultadoInstalador = null;
+  let error = null;
+
+  try {
+    const install = require('../instalador');
+    const fn = typeof install === 'function' ? install : install.install;
+    resultadoInstalador = await fn({
+      ...opciones,
+      onProgress: (evento) => ctrl.onEvento(evento),
+    });
+    ctrl.finalizar({
+      ok: true,
+      mensaje: opciones.dry_run
+        ? 'Dry-run completado (no se modificaron archivos)'
+        : 'Instalación completada con éxito',
+    });
+  } catch (e) {
+    error = e;
+    ctrl.finalizar({
+      ok: false,
+      mensaje: `Error: ${e.message}`,
+    });
+  }
+
+  await ctrl.esperarSalida();
+
+  // Resumen
+  const tabla = [
+    ['Runtime', opciones.target],
+    ['Perfil',  opciones.profile],
+    ['Scope',   opciones.global ? 'global' : 'proyecto'],
+  ];
+  if (opciones.with_mcp) tabla.push(['MCP', 'configurado']);
+  if (opciones.dry_run)  tabla.push(['Modo', 'dry-run (sin escribir)']);
+  if (opciones.stacks?.length > 0) tabla.push(['Stacks', opciones.stacks.join(', ')]);
+
+  await mostrarResumen({
+    operacion: 'install',
+    ok: !error,
+    tituloPrincipal: error ? 'Falló la instalación' : 'Instalación completada',
+    mensajeFinal: error ? error.message : undefined,
+    tabla,
+  });
+
+  return {
+    ok: !error,
+    error: error ? error.message : null,
+    resultado: resultadoInstalador,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Ejecutar Update
+// ---------------------------------------------------------------------------
+
+/**
+ * Ejecuta el update con UI de progreso. Itera por cada runtime+scope del
+ * plan, llamando al instalador con force=true y onProgress conectado.
+ *
+ * @param {object} planUpdate - resultado del wizard Update
+ * @returns {Promise<{ ok, actualizados, errores }>}
+ */
+async function ejecutarUpdate(planUpdate) {
+  const { plan, versionPaquete, verbose } = planUpdate;
+  const categorias = _categoriasDesdeOpciones({});
+
+  const ctrl = crearProgreso({
+    titulo: `Actualizando ${plan.runtimes.length} runtime(s) a v${versionPaquete}`,
+    categorias,
+    verbose: !!verbose,
+  });
+  ctrl.iniciar();
+
+  let actualizados = 0;
+  const errores = [];
+
+  const install = require('../instalador');
+  const fn = typeof install === 'function' ? install : install.install;
+
+  for (const runtime of plan.runtimes) {
+    ctrl.onEvento({
+      tipo: 'log',
+      linea: `→ Actualizando ${runtime.runtimeNombre} (${runtime.scope})...`,
+    });
+
+    try {
+      await fn({
+        target: runtime.runtimeId,
+        profile: runtime.perfil,
+        global: runtime.esGlobal,
+        force: true,
+        versionAnterior: runtime.version,
+        versionActual: versionPaquete,
+        onProgress: (evento) => ctrl.onEvento(evento),
+      });
+      actualizados++;
+      ctrl.onEvento({
+        tipo: 'log',
+        linea: `  ✓ ${runtime.runtimeNombre} (${runtime.scope}) actualizado`,
+      });
+    } catch (e) {
+      errores.push({ runtime: runtime.id, error: e.message });
+      ctrl.onEvento({
+        tipo: 'log',
+        linea: `  ✗ ${runtime.runtimeNombre}: ${e.message}`,
+      });
+    }
+  }
+
+  const ok = errores.length === 0;
+  ctrl.finalizar({
+    ok,
+    mensaje: ok
+      ? `${actualizados} runtime(s) actualizado(s)`
+      : `${actualizados} ok, ${errores.length} con error`,
+  });
+  await ctrl.esperarSalida();
+
+  const tabla = [
+    ['Versión objetivo', `v${versionPaquete}`],
+    ['Runtimes en plan', String(plan.runtimes.length)],
+    ['Actualizados',     String(actualizados)],
+    ['Errores',          String(errores.length)],
+    ['Categorías',       plan.categorias.join(', ')],
+  ];
+
+  await mostrarResumen({
+    operacion: 'update',
+    ok,
+    tituloPrincipal: ok ? 'Actualización completada' : 'Actualización con errores',
+    mensajeFinal: errores.length > 0
+      ? `${errores.length} runtime(s) fallaron — revisa los logs`
+      : undefined,
+    tabla,
+  });
+
+  return { ok, actualizados, errores };
+}
+
+// ---------------------------------------------------------------------------
+// Ejecutar Uninstall (TUI completo, Fase 5)
+// ---------------------------------------------------------------------------
+
+/**
+ * Ejecuta el uninstall con UI de progreso. Itera por cada instalación del
+ * plan invocando scripts/desinstalar.js con onProgress conectado.
+ *
+ * @param {object} planUninstall - resultado del wizard Uninstall
+ * @returns {Promise<{ ok, totalEliminados, totalBloques, errores }>}
+ */
+async function ejecutarUninstall(planUninstall) {
+  if (!planUninstall || !planUninstall.plan) {
+    // Sin plan (caller no pasó datos del wizard) — devolver pendiente
+    await mostrarResumen({
+      operacion: 'uninstall',
+      ok: false,
+      tituloPrincipal: 'Uninstall sin plan',
+      mensajeFinal: 'Falta el resultado del wizard. Llama ejecutarUninstall(planUninstall) con el plan completo.',
+      tabla: [],
+    });
+    return { ok: false, pendiente: true };
+  }
+
+  const { seleccionadas } = planUninstall.plan;
+
+  const { crearProgreso: crear } = require('./pantallas/progreso');
+  const ctrl = crear({
+    titulo: `Desinstalando ${seleccionadas.length} instalación(es) SWL`,
+    categorias: [
+      { nombre: 'archivos-eliminados', etiqueta: 'Archivos',  total: 0 },
+      { nombre: 'bloques-limpiados',   etiqueta: 'Bloques',   total: 0 },
+      { nombre: 'hooks-quitados',      etiqueta: 'Hooks',     total: 0 },
+    ],
+    verbose: !!planUninstall.verbose,
+  });
+  ctrl.iniciar();
+
+  let totalEliminados = 0;
+  let totalBloques = 0;
+  let totalHooks = 0;
+  const errores = [];
+
+  const uninstall = require('../desinstalar');
+
+  for (const inst of seleccionadas) {
+    ctrl.onEvento({
+      tipo: 'log',
+      linea: `→ Desinstalando ${inst.runtimeNombre} (${inst.scope})...`,
+    });
+
+    try {
+      const resultado = uninstall({
+        target: inst.runtimeId,
+        global: inst.esGlobal,
+        onProgress: (evento) => {
+          // Mapear eventos del desinstalador a categorías de la pantalla
+          if (evento.tipo === 'archivo-eliminado') {
+            ctrl.onEvento({
+              tipo: 'archivo-copiado', // re-usa el contador de progreso
+              componente: 'archivos-eliminados',
+              archivo: evento.archivo,
+            });
+          } else if (evento.tipo === 'bloque-eliminado') {
+            ctrl.onEvento({
+              tipo: 'archivo-copiado',
+              componente: 'bloques-limpiados',
+              archivo: evento.archivo,
+            });
+          } else if (evento.tipo === 'hooks-desregistrados') {
+            for (let i = 0; i < evento.cuenta; i++) {
+              ctrl.onEvento({
+                tipo: 'archivo-copiado',
+                componente: 'hooks-quitados',
+              });
+            }
+          } else if (evento.tipo === 'log') {
+            ctrl.onEvento(evento);
+          } else if (evento.tipo === 'error') {
+            ctrl.onEvento({
+              tipo: 'log',
+              linea: `  ✗ ${evento.archivo || ''}: ${evento.mensaje}`,
+            });
+          }
+        },
+      });
+
+      totalEliminados += resultado.eliminados || 0;
+      totalBloques += resultado.bloquesEliminados || 0;
+      totalHooks += resultado.hooksDesregistrados || 0;
+
+      ctrl.onEvento({
+        tipo: 'log',
+        linea: `  ✓ ${inst.runtimeNombre} (${inst.scope}) limpiado`,
+      });
+    } catch (e) {
+      errores.push({ instalacion: inst.id, error: e.message });
+      ctrl.onEvento({
+        tipo: 'log',
+        linea: `  ✗ ${inst.runtimeNombre}: ${e.message}`,
+      });
+    }
+  }
+
+  const ok = errores.length === 0;
+  ctrl.finalizar({
+    ok,
+    mensaje: ok
+      ? `${totalEliminados} archivos eliminados, ${totalBloques} bloques limpiados`
+      : `${errores.length} instalación(es) con error`,
+  });
+  await ctrl.esperarSalida();
+
+  const tabla = [
+    ['Instalaciones procesadas', String(seleccionadas.length)],
+    ['Archivos eliminados',      String(totalEliminados)],
+    ['Bloques CLAUDE.md limpiados', String(totalBloques)],
+    ['Hooks desregistrados',     String(totalHooks)],
+  ];
+  if (errores.length > 0) {
+    tabla.push(['Errores', String(errores.length)]);
+  }
+
+  await mostrarResumen({
+    operacion: 'uninstall',
+    ok,
+    tituloPrincipal: ok ? 'Desinstalación completada' : 'Desinstalación con errores',
+    mensajeFinal: ok
+      ? '_userland/ y APRENDIZAJES.md fueron preservados.'
+      : 'Algunas instalaciones fallaron — revisa el log.',
+    tabla,
+  });
+
+  return {
+    ok,
+    totalEliminados,
+    totalBloques,
+    totalHooks,
+    errores,
+  };
+}
+
+module.exports = {
+  ejecutarInstall,
+  ejecutarUpdate,
+  ejecutarUninstall,
+  // exports para tests
+  _calcularTotalesDelPlan,
+  _categoriasDesdeOpciones,
+};

package/scripts/tui/index.js

@@ -0,0 +1,162 @@
+'use strict';
+
+/**
+ * Entry point del TUI de swl-ses.
+ *
+ * Flujo:
+ *   1. Welcome (pantalla de bienvenida + detección de instalaciones)
+ *   2. Menú principal (Install / Update / Inspect / Uninstall)
+ *   3. Wizard correspondiente
+ *   4. Ejecución con UI de progreso
+ *   5. Resumen final
+ *   6. Vuelve al menú principal (a menos que el usuario haya hecho Esc en el menú)
+ *
+ * En no-TTY, el TUI se desactiva automáticamente — cada pantalla devuelve
+ * un valor por defecto sin esperar input. Los caller deben detectar esa
+ * salida y caer al CLI clásico si quieren UX interactivo.
+ */
+
+const { mostrarWelcome } = require('./pantallas/welcome');
+const { mostrarMenuPrincipal } = require('./pantallas/menu-principal');
+const { ejecutarWizardInstall } = require('./pantallas/install-wizard');
+const { ejecutarWizardUpdate } = require('./pantallas/update-wizard');
+const { ejecutarWizardUninstall } = require('./pantallas/uninstall-wizard');
+const { ejecutarInspect } = require('./pantallas/inspect');
+const { ejecutarInstall, ejecutarUpdate, ejecutarUninstall } = require('./ejecutores');
+const { mostrarResumen } = require('./pantallas/resumen');
+const render = require('./lib/render');
+
+/**
+ * Lanza el flujo TUI completo. Devuelve cuando el usuario sale del menú
+ * principal con Esc.
+ *
+ * @param {object} [opciones]
+ * @param {string} [opciones.operacionInicial] - si está dado, salta el menú
+ *        e inicia directamente en esa operación ('install' | 'update' | etc.)
+ * @returns {Promise<{ ok, motivo?, ultimaOperacion? }>}
+ */
+async function iniciarTui(opciones = {}) {
+  // Detección defensiva: si no hay TTY, no entrar al flujo interactivo
+  if (!render.ES_TTY || !process.stdin.isTTY) {
+    return { ok: false, motivo: 'no-tty', mensaje: 'TUI requiere terminal interactiva' };
+  }
+
+  // 1. Welcome (a menos que se haya pedido saltar)
+  if (!opciones.saltarWelcome) {
+    const w = await mostrarWelcome();
+    if (!w.continuar) {
+      return { ok: true, motivo: 'usuario-salio-welcome' };
+    }
+  }
+
+  // 2. Loop principal: menú → operación → vuelve al menú
+  let ultimaOperacion = null;
+  while (true) {
+    let operacion = opciones.operacionInicial;
+    opciones.operacionInicial = null; // solo aplica la primera vez
+
+    if (!operacion) {
+      operacion = await mostrarMenuPrincipal();
+      if (!operacion) {
+        return { ok: true, motivo: 'usuario-salio-menu', ultimaOperacion };
+      }
+    }
+
+    ultimaOperacion = operacion;
+
+    try {
+      await _ejecutarOperacion(operacion);
+    } catch (e) {
+      // Mostrar error como pantalla de resumen y continuar
+      await mostrarResumen({
+        operacion,
+        ok: false,
+        tituloPrincipal: `Error en operación "${operacion}"`,
+        mensajeFinal: e.message,
+        tabla: [['Tipo de error', e.name || 'Error']],
+        proximosPasos: [
+          'Revisa los logs anteriores',
+          'Intenta de nuevo desde el menú',
+          'Si el error persiste: swl-ses doctor',
+        ],
+      });
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Despacho de operaciones
+// ---------------------------------------------------------------------------
+
+async function _ejecutarOperacion(operacion) {
+  switch (operacion) {
+    case 'install':
+      return _flujoInstall();
+    case 'update':
+      return _flujoUpdate();
+    case 'inspect':
+      return ejecutarInspect();
+    case 'uninstall':
+      return _flujoUninstall();
+    default:
+      throw new Error(`Operación no soportada: ${operacion}`);
+  }
+}
+
+async function _flujoInstall() {
+  const w = await ejecutarWizardInstall();
+  if (!w.exito) {
+    if (w.cancelado) return { ok: true, cancelado: true };
+    if (w.error) {
+      await mostrarResumen({
+        operacion: 'install',
+        ok: false,
+        tituloPrincipal: 'No se pudo iniciar la instalación',
+        mensajeFinal: w.error,
+        tabla: [],
+      });
+    }
+    return { ok: false };
+  }
+  return ejecutarInstall(w.opciones);
+}
+
+async function _flujoUpdate() {
+  const w = await ejecutarWizardUpdate();
+  if (!w.exito) {
+    if (w.cancelado) return { ok: true, cancelado: true };
+    if (w.error || w.vacio) {
+      await mostrarResumen({
+        operacion: 'update',
+        ok: false,
+        tituloPrincipal: w.vacio ? 'Nada que actualizar' : 'No se pudo iniciar la actualización',
+        mensajeFinal: w.error || 'Selección vacía',
+        tabla: [],
+        proximosPasos: w.sugerencia ? [w.sugerencia] : [],
+      });
+    }
+    return { ok: false };
+  }
+  return ejecutarUpdate(w);
+}
+
+async function _flujoUninstall() {
+  const w = await ejecutarWizardUninstall();
+  if (!w.exito) {
+    if (w.cancelado) return { ok: true, cancelado: true };
+    if (w.error || w.vacio) {
+      await mostrarResumen({
+        operacion: 'uninstall',
+        ok: false,
+        tituloPrincipal: w.vacio ? 'Nada seleccionado para desinstalar' : 'No se pudo iniciar la desinstalación',
+        mensajeFinal: w.error,
+        tabla: [],
+        proximosPasos: w.sugerencia ? [w.sugerencia] : [],
+      });
+    }
+    return { ok: false };
+  }
+  return ejecutarUninstall(w);
+}
+
+module.exports = { iniciarTui };

package/scripts/tui/lib/colores.js

@@ -0,0 +1,129 @@
+'use strict';
+
+/**
+ * Paleta de colores ANSI para la TUI de swl-ses.
+ * Zero-deps. Respeta NO_COLOR. Detecta TTY.
+ *
+ * Diseño: las funciones siempre devuelven string. Si no hay color, devuelven
+ * el texto sin modificar — para que el caller pueda concatenar sin checks.
+ */
+
+const SOPORTA_COLOR = !process.env.NO_COLOR && process.stdout.isTTY;
+
+function _wrap(codigo, texto) {
+  return SOPORTA_COLOR ? `\x1b[${codigo}m${texto}\x1b[0m` : String(texto);
+}
+
+const colores = {
+  // Texto
+  negro:     (t) => _wrap('30', t),
+  rojo:      (t) => _wrap('31', t),
+  verde:     (t) => _wrap('32', t),
+  amarillo:  (t) => _wrap('33', t),
+  azul:      (t) => _wrap('34', t),
+  magenta:   (t) => _wrap('35', t),
+  cyan:      (t) => _wrap('36', t),
+  blanco:    (t) => _wrap('37', t),
+  gris:      (t) => _wrap('90', t),
+
+  // Brillantes
+  rojoBr:     (t) => _wrap('91', t),
+  verdeBr:    (t) => _wrap('92', t),
+  amarilloBr: (t) => _wrap('93', t),
+  azulBr:     (t) => _wrap('94', t),
+  cyanBr:     (t) => _wrap('96', t),
+
+  // Estilos
+  negrita:    (t) => _wrap('1', t),
+  dim:        (t) => _wrap('2', t),
+  italica:    (t) => _wrap('3', t),
+  subrayado:  (t) => _wrap('4', t),
+  invertido:  (t) => _wrap('7', t),
+
+  // Fondos
+  fondoAzul:    (t) => _wrap('44', t),
+  fondoCyan:    (t) => _wrap('46', t),
+  fondoGris:    (t) => _wrap('100', t),
+};
+
+// Semánticos (para usar en lugar de colores directos)
+const semantico = {
+  exito:    colores.verde,
+  error:    colores.rojo,
+  warn:     colores.amarillo,
+  info:     colores.cyan,
+  hint:     colores.dim,
+  enfasis:  colores.negrita,
+  titulo:   (t) => colores.negrita(colores.cyan(t)),
+  cursor:   colores.cyanBr,
+  badge:    (t) => colores.invertido(` ${t} `),
+};
+
+// Iconos con fallback ASCII
+const iconos = SOPORTA_COLOR ? {
+  check:   '✓',
+  cross:   '✗',
+  warn:    '⚠',
+  arrow:   '→',
+  star:    '★',
+  info:    'ℹ',
+  punto:   '•',
+  cursor:  '❯',
+  cajaVacia: '○',
+  cajaLlena: '◉',
+  flechaArriba: '↑',
+  flechaAbajo: '↓',
+} : {
+  check:   '[OK]',
+  cross:   '[X]',
+  warn:    '[!]',
+  arrow:   '->',
+  star:    '*',
+  info:    '[i]',
+  punto:   '-',
+  cursor:  '>',
+  cajaVacia: '[ ]',
+  cajaLlena: '[x]',
+  flechaArriba: '^',
+  flechaAbajo: 'v',
+};
+
+// Caracteres de borde de caja (Unicode rounded fallback ASCII)
+const borde = SOPORTA_COLOR ? {
+  // Borde rounded
+  esquinaSupIzq:  '╭',
+  esquinaSupDer:  '╮',
+  esquinaInfIzq:  '╰',
+  esquinaInfDer:  '╯',
+  horizontal:     '─',
+  vertical:       '│',
+  cruz:           '┼',
+  tSup:           '┬',
+  tInf:           '┴',
+  tIzq:           '├',
+  tDer:           '┤',
+
+  // Borde doble (para énfasis)
+  dbHorizontal:   '═',
+  dbVertical:     '║',
+  dbEsqSupIzq:    '╔',
+  dbEsqSupDer:    '╗',
+  dbEsqInfIzq:    '╚',
+  dbEsqInfDer:    '╝',
+} : {
+  esquinaSupIzq: '+',  esquinaSupDer: '+',
+  esquinaInfIzq: '+',  esquinaInfDer: '+',
+  horizontal: '-',     vertical: '|',
+  cruz: '+',           tSup: '+', tInf: '+', tIzq: '+', tDer: '+',
+  dbHorizontal: '=',   dbVertical: '|',
+  dbEsqSupIzq: '+',    dbEsqSupDer: '+',
+  dbEsqInfIzq: '+',    dbEsqInfDer: '+',
+};
+
+module.exports = {
+  SOPORTA_COLOR,
+  colores,
+  semantico,
+  iconos,
+  borde,
+};