@saulwade/swl-ses 1.5.1 → 1.6.0

package/scripts/tui/pantallas/resumen.js

@@ -0,0 +1,132 @@
+'use strict';
+
+/**
+ * Pantalla Resumen final — se muestra después de Install/Update/Uninstall.
+ *
+ * Recibe un objeto con totales y muestra:
+ *   - Bloque hero (éxito/error con color)
+ *   - Tabla resumen: actualizados, omitidos, errores, tiempo total
+ *   - Próximos pasos sugeridos según la operación
+ *
+ * Espera Enter o Esc para cerrar.
+ */
+
+const render = require('../lib/render');
+const teclas = require('../lib/teclas');
+const { colores, semantico, iconos } = require('../lib/colores');
+
+const PROXIMOS_PASOS = {
+  install: [
+    'Verifica la salud del sistema:  swl-ses doctor',
+    'Lista los skills instalados:    swl-ses skills list',
+    'Ejecuta el primer comando:      /swl:ayuda  (dentro de tu runtime)',
+  ],
+  update: [
+    'Verifica los cambios:           git diff (en proyectos donde aplicaste)',
+    'Revisa el CHANGELOG:            swl-ses release notes',
+    'Comprueba la salud:             swl-ses doctor',
+  ],
+  uninstall: [
+    'El directorio _userland/ se preservó por defecto.',
+    'Las memorias y APRENDIZAJES.md no fueron tocados.',
+    'Para reinstalar: swl-ses install',
+  ],
+  inspect: [
+    'Para actualizar: swl-ses update',
+    'Para reinstalar: swl-ses install --force',
+  ],
+};
+
+/**
+ * @param {object} datos
+ * @param {string} datos.operacion - 'install' | 'update' | 'uninstall' | 'inspect'
+ * @param {boolean} datos.ok
+ * @param {string} datos.tituloPrincipal
+ * @param {string} [datos.mensajeFinal]
+ * @param {Array<[string, string]>} [datos.tabla] - filas [clave, valor]
+ * @param {string[]} [datos.proximosPasos] - sobrescribe los defaults
+ * @returns {Promise<void>}
+ */
+function mostrarResumen(datos) {
+  const proximos = datos.proximosPasos || PROXIMOS_PASOS[datos.operacion] || [];
+  const tabla = datos.tabla || [];
+
+  return new Promise((resolve) => {
+    if (!render.ES_TTY || !process.stdin.isTTY) {
+      console.log('');
+      console.log(`  ${datos.ok ? '[OK]' : '[ERROR]'} ${datos.tituloPrincipal}`);
+      if (datos.mensajeFinal) console.log(`  ${datos.mensajeFinal}`);
+      console.log('');
+      for (const [k, v] of tabla) {
+        console.log(`    ${k}: ${v}`);
+      }
+      if (proximos.length > 0) {
+        console.log('');
+        console.log('  Próximos pasos:');
+        for (const p of proximos) console.log(`    - ${p}`);
+      }
+      console.log('');
+      resolve();
+      return;
+    }
+
+    function _renderizar() {
+      render.limpiarPantalla();
+      const { cols, rows } = render.obtenerDimensiones();
+
+      // Hero
+      const colorHero = datos.ok ? semantico.exito : semantico.error;
+      const ico = datos.ok ? iconos.check : iconos.cross;
+      const titulo = `${ico} ${datos.tituloPrincipal}`;
+      const colTit = Math.max(1, Math.floor((cols - render.anchoVisual(titulo)) / 2));
+      render.escribirEn(3, colTit, colores.negrita(colorHero(titulo)));
+
+      if (datos.mensajeFinal) {
+        const mensaje = colores.dim(datos.mensajeFinal);
+        const colMsg = Math.max(1, Math.floor((cols - render.anchoVisual(mensaje)) / 2));
+        render.escribirEn(5, colMsg, mensaje);
+      }
+
+      // Tabla
+      const filaTabla = 7;
+      tabla.forEach(([k, v], i) => {
+        const linea = render.rellenarDer(colores.dim(k + ':'), 22) + semantico.enfasis(v);
+        const colTab = Math.max(1, Math.floor((cols - render.anchoVisual(linea)) / 2));
+        render.escribirEn(filaTabla + i, colTab, linea);
+      });
+
+      // Próximos pasos
+      if (proximos.length > 0) {
+        const filaPasos = filaTabla + tabla.length + 2;
+        render.escribirEn(filaPasos, 4, semantico.titulo('Próximos pasos:'));
+        proximos.forEach((p, i) => {
+          if (filaPasos + 1 + i >= rows - 3) return;
+          render.escribirEn(filaPasos + 1 + i, 6,
+            `${colores.cyan(iconos.arrow)} ${p}`);
+        });
+      }
+
+      render.dibujarPiePagina([
+        ['Enter|Esc', 'cerrar'],
+      ]);
+    }
+
+    render.iniciarModoTui();
+    _renderizar();
+    const onResize = () => _renderizar();
+    process.stdout.on('resize', onResize);
+
+    const teclado = teclas.crearTeclado();
+    function _finalizar() {
+      teclado.desactivar();
+      process.stdout.removeListener('resize', onResize);
+      render.salirModoTui();
+      resolve();
+    }
+    teclado.on('return', _finalizar);
+    teclado.on('escape', _finalizar);
+    teclado.activar();
+  });
+}
+
+module.exports = { mostrarResumen, PROXIMOS_PASOS };

package/scripts/tui/pantallas/uninstall-wizard.js

@@ -0,0 +1,208 @@
+'use strict';
+
+/**
+ * Wizard de desinstalación TUI.
+ * Operación destructiva — requiere doble confirmación:
+ *   1. Multi-select de instalaciones a desinstalar (default: ninguna preseleccionada)
+ *   2. Vista previa de qué se eliminará (rutas, conteo de archivos)
+ *   3. Confirmación con escritura explícita del nombre del runtime (anti-clicaccidental)
+ *   4. Confirmación final
+ *
+ * NUNCA toca _userland/ ni APRENDIZAJES.md por diseño del desinstalador.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const { selectorUnico } = require('../componentes/selector-unico');
+const { selectorMulti } = require('../componentes/selector-multi');
+const render = require('../lib/render');
+const teclas = require('../lib/teclas');
+const { colores, semantico, iconos } = require('../lib/colores');
+
+function _cargarInstalaciones() {
+  let detectarRuntimes, cargarEstado;
+  try {
+    ({ detectarRuntimes } = require('../../lib/detectar-runtime'));
+    ({ cargarEstado } = require('../../lib/estado'));
+  } catch (_) {
+    return [];
+  }
+
+  const runtimes = detectarRuntimes();
+  const filas = [];
+  for (const runtime of runtimes) {
+    const candidatos = [
+      { ruta: runtime.global, scope: 'global', esGlobal: true },
+      { ruta: path.resolve(runtime.local), scope: 'proyecto', esGlobal: false },
+    ];
+    for (const { ruta, scope, esGlobal } of candidatos) {
+      if (!fs.existsSync(ruta)) continue;
+      const estado = cargarEstado(ruta);
+      if (!estado) continue;
+      filas.push({
+        id: `${runtime.id}:${scope}`,
+        runtimeId: runtime.id,
+        runtimeNombre: runtime.nombre,
+        scope,
+        esGlobal,
+        ruta,
+        version: estado.versionSistema || 'desconocida',
+        perfil: estado.perfil || '-',
+        archivos: estado.archivosInstalados?.length || 0,
+      });
+    }
+  }
+  return filas;
+}
+
+// ---------------------------------------------------------------------------
+// Pantalla de vista previa de eliminación
+// ---------------------------------------------------------------------------
+
+function _pantallaPreview(seleccionadas) {
+  return new Promise((resolve) => {
+    if (!render.ES_TTY || !process.stdin.isTTY) {
+      resolve(true);
+      return;
+    }
+
+    function _renderizar() {
+      render.limpiarPantalla();
+      const { cols, rows } = render.obtenerDimensiones();
+
+      render.escribirEn(2, 3, semantico.titulo('Vista previa de desinstalación'));
+      render.escribirEn(3, 3, semantico.warn(
+        `${iconos.warn}  Esta operación es destructiva. Se eliminarán archivos del sistema.`));
+
+      render.escribirEn(5, 3, semantico.enfasis('Instalaciones a eliminar:'));
+      seleccionadas.forEach((i, idx) => {
+        const linea =
+          `${semantico.error(iconos.cross)} ` +
+          render.rellenarDer(colores.negrita(i.runtimeNombre), 18) +
+          render.rellenarDer(`(${i.scope})`, 12) +
+          render.rellenarDer(`v${i.version}`, 12) +
+          render.rellenarDer(i.perfil, 16) +
+          colores.dim(`${i.archivos} archivos`);
+        render.escribirEn(6 + idx, 5, linea);
+      });
+
+      const filaRutas = 7 + seleccionadas.length;
+      render.escribirEn(filaRutas, 3, semantico.enfasis('Rutas afectadas:'));
+      seleccionadas.forEach((i, idx) => {
+        if (filaRutas + 1 + idx >= rows - 8) return;
+        render.escribirEn(filaRutas + 1 + idx, 5,
+          render.recortar(`${iconos.arrow} ${colores.dim(i.ruta)}`, cols - 7));
+      });
+
+      // Garantías preservadas
+      const filaPres = filaRutas + seleccionadas.length + 2;
+      if (filaPres < rows - 4) {
+        render.escribirEn(filaPres, 3, semantico.exito('Lo que NO se toca:'));
+        const preservados = [
+          '_userland/ — tu código y configuración personal',
+          '.planning/APRENDIZAJES.md — aprendizajes del proyecto',
+          '.planning/ — sesiones y contexto del proyecto',
+          'Hooks externos no-SWL en settings.json',
+        ];
+        preservados.forEach((p, idx) => {
+          if (filaPres + 1 + idx >= rows - 3) return;
+          render.escribirEn(filaPres + 1 + idx, 5,
+            `${semantico.exito(iconos.check)} ${colores.dim(p)}`);
+        });
+      }
+
+      render.dibujarPiePagina([
+        ['Enter', 'continuar a confirmación'],
+        ['Esc',   'cancelar'],
+      ]);
+    }
+
+    render.iniciarModoTui();
+    _renderizar();
+    const onResize = () => _renderizar();
+    process.stdout.on('resize', onResize);
+
+    const teclado = teclas.crearTeclado();
+    function _finalizar(v) {
+      teclado.desactivar();
+      process.stdout.removeListener('resize', onResize);
+      render.salirModoTui();
+      resolve(v);
+    }
+    teclado.on('return', () => _finalizar(true));
+    teclado.on('escape', () => _finalizar(false));
+    teclado.activar();
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Wizard principal
+// ---------------------------------------------------------------------------
+
+async function ejecutarWizardUninstall() {
+  const instalaciones = _cargarInstalaciones();
+
+  if (instalaciones.length === 0) {
+    return {
+      exito: false,
+      error: 'No se detectaron instalaciones SWL para desinstalar.',
+      sugerencia: 'Ejecuta swl-ses doctor para diagnosticar.',
+    };
+  }
+
+  // 1. Multi-select (NADA preseleccionado por seguridad)
+  const itemsRuntimes = instalaciones.map(i => ({
+    valor: i.id,
+    etiqueta: `${i.runtimeNombre} (${i.scope}) — v${i.version} · perfil ${i.perfil}`,
+    descripcion: `${i.archivos} archivos en ${i.ruta}`,
+    preseleccionado: false,
+  }));
+
+  const idsElegidos = await selectorMulti({
+    titulo: 'Paso 1/3 — ¿Qué instalaciones desinstalar? (espacio para marcar)',
+    items: itemsRuntimes,
+  });
+  if (idsElegidos === null) return { exito: false, cancelado: true };
+  if (idsElegidos.length === 0) {
+    return { exito: false, vacio: true, error: 'No seleccionaste nada.' };
+  }
+
+  const seleccionadas = instalaciones.filter(i => idsElegidos.includes(i.id));
+
+  // 2. Vista previa
+  const proceder = await _pantallaPreview(seleccionadas);
+  if (!proceder) return { exito: false, cancelado: true };
+
+  // 3. Doble confirmación
+  const confirmacion = await selectorUnico({
+    titulo: `Paso 3/3 — ¿Confirmar desinstalación de ${seleccionadas.length} instalación(es)?`,
+    items: [
+      {
+        valor: 'no',
+        etiqueta: 'No, cancelar y volver al menú',
+        descripcion: 'Vuelve sin tocar nada.',
+      },
+      {
+        valor: 'si',
+        etiqueta: `Sí, eliminar ${seleccionadas.length} instalación(es) ahora`,
+        descripcion:
+          'Acción irreversible. Si tienes dudas, escoge "No" y haz backup primero. ' +
+          'Recuerda que _userland/ y APRENDIZAJES.md se preservan.',
+        badge: 'destructivo',
+      },
+    ],
+    indiceDefault: 0, // default seguro: cancelar
+  });
+  if (confirmacion !== 'si') return { exito: false, cancelado: true };
+
+  return {
+    exito: true,
+    plan: { seleccionadas },
+  };
+}
+
+module.exports = {
+  ejecutarWizardUninstall,
+  _cargarInstalaciones,
+};

package/scripts/tui/pantallas/update-wizard.js

@@ -0,0 +1,232 @@
+'use strict';
+
+/**
+ * Wizard de actualización TUI.
+ * Reemplaza el flujo simple de scripts/actualizar.js que pregunta una vez
+ * por runtime con un wizard visual:
+ *
+ *   1. Detectar runtimes instalados (con su versión, perfil, scope)
+ *   2. Multi-select de runtimes a actualizar (default: todos los desactualizados)
+ *   3. Multi-select de categorías de componentes a refrescar
+ *      (skills, hooks, agentes, reglas, comandos, schemas, plantillas)
+ *   4. Diff preview: ¿qué cambia entre versión instalada y nueva?
+ *   5. Confirmación final
+ *
+ * Devuelve el plan completo o { cancelado: true }.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const { selectorUnico } = require('../componentes/selector-unico');
+const { selectorMulti } = require('../componentes/selector-multi');
+const render = require('../lib/render');
+const teclas = require('../lib/teclas');
+const { colores, semantico, iconos } = require('../lib/colores');
+
+const CATEGORIAS = [
+  { valor: 'agentes',     etiqueta: 'Agentes',     descripcion: '60 agentes especializados (orquestador, revisor, depurador, etc.)' },
+  { valor: 'habilidades', etiqueta: 'Skills',      descripcion: '162 skills cargables bajo demanda' },
+  { valor: 'comandos',    etiqueta: 'Comandos',    descripcion: '44 comandos /swl:* del runtime' },
+  { valor: 'reglas',      etiqueta: 'Reglas',      descripcion: '66 reglas obligatorias' },
+  { valor: 'hooks',       etiqueta: 'Hooks',       descripcion: '41 hooks de pre/post-tool' },
+  { valor: 'schemas',     etiqueta: 'Schemas',     descripcion: 'JSON schemas de validación' },
+  { valor: 'plantillas',  etiqueta: 'Plantillas',  descripcion: 'Plantillas para .planning/' },
+  { valor: 'manifiestos', etiqueta: 'Manifiestos', descripcion: 'Catálogos de módulos, perfiles y hooks' },
+];
+
+// ---------------------------------------------------------------------------
+// Detección
+// ---------------------------------------------------------------------------
+
+function _detectarInstalaciones() {
+  let detectarRuntimes, cargarEstado;
+  try {
+    ({ detectarRuntimes } = require('../../lib/detectar-runtime'));
+    ({ cargarEstado } = require('../../lib/estado'));
+  } catch (_) {
+    return [];
+  }
+
+  const versionPaquete = require('../../../package.json').version;
+  const runtimes = detectarRuntimes();
+  const filas = [];
+
+  for (const runtime of runtimes) {
+    const dirs = [
+      { ruta: runtime.global, scope: 'global' },
+      { ruta: path.resolve(runtime.local), scope: 'proyecto' },
+    ];
+    for (const { ruta, scope } of dirs) {
+      try {
+        if (!fs.existsSync(ruta)) continue;
+        const estado = cargarEstado(ruta);
+        if (!estado) continue;
+        const version = estado.versionSistema || 'desconocida';
+        filas.push({
+          id: `${runtime.id}:${scope}`,
+          runtimeId: runtime.id,
+          runtimeNombre: runtime.nombre,
+          scope,
+          version,
+          perfil: estado.perfil || '-',
+          esGlobal: scope === 'global',
+          desactualizada: version !== versionPaquete,
+          componentes: estado.componentesInstalados?.length || 0,
+        });
+      } catch (_) {
+        // ignorar
+      }
+    }
+  }
+  return filas;
+}
+
+// ---------------------------------------------------------------------------
+// Pantalla de diff preview
+// ---------------------------------------------------------------------------
+
+function _pantallaDiff(plan, versionPaquete) {
+  return new Promise((resolve) => {
+    if (!render.ES_TTY || !process.stdin.isTTY) {
+      resolve(true);
+      return;
+    }
+
+    function _renderizar() {
+      render.limpiarPantalla();
+      const { cols } = render.obtenerDimensiones();
+
+      render.escribirEn(2, 3, semantico.titulo('Resumen de la actualización'));
+      render.escribirEn(3, 3, colores.dim(`Versión disponible: v${versionPaquete}`));
+
+      render.escribirEn(5, 3, semantico.enfasis('Runtimes a actualizar:'));
+      plan.runtimes.forEach((r, i) => {
+        const versionEstado = r.version === versionPaquete
+          ? semantico.exito(`v${r.version}`)
+          : semantico.warn(`v${r.version} → v${versionPaquete}`);
+        const linea =
+          `${iconos.arrow} ${render.rellenarDer(colores.negrita(r.runtimeNombre), 18)}` +
+          render.rellenarDer(`(${r.scope})`, 12) +
+          render.rellenarDer(r.perfil, 18) +
+          versionEstado;
+        render.escribirEn(6 + i, 5, linea);
+      });
+
+      const filaCat = 7 + plan.runtimes.length;
+      render.escribirEn(filaCat, 3, semantico.enfasis('Componentes a refrescar:'));
+      plan.categorias.forEach((c, i) => {
+        const cat = CATEGORIAS.find(x => x.valor === c);
+        const lab = cat ? cat.etiqueta : c;
+        render.escribirEn(filaCat + 1 + i, 5,
+          `${colores.verde(iconos.check)} ${lab}`);
+      });
+
+      render.dibujarPiePagina([
+        ['Enter', 'continuar a confirmación'],
+        ['Esc',   'cancelar'],
+      ]);
+    }
+
+    render.iniciarModoTui();
+    _renderizar();
+
+    const onResize = () => _renderizar();
+    process.stdout.on('resize', onResize);
+
+    const teclado = teclas.crearTeclado();
+    function _finalizar(v) {
+      teclado.desactivar();
+      process.stdout.removeListener('resize', onResize);
+      render.salirModoTui();
+      resolve(v);
+    }
+    teclado.on('return', () => _finalizar(true));
+    teclado.on('escape', () => _finalizar(false));
+    teclado.activar();
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Wizard principal
+// ---------------------------------------------------------------------------
+
+async function ejecutarWizardUpdate() {
+  const versionPaquete = require('../../../package.json').version;
+  const instalaciones = _detectarInstalaciones();
+
+  if (instalaciones.length === 0) {
+    return {
+      exito: false,
+      error: 'No se detectaron instalaciones SWL para actualizar.',
+      sugerencia: 'Ejecuta primero swl-ses install para crear una instalación.',
+    };
+  }
+
+  // 1. Multi-select de runtimes a actualizar
+  const itemsRuntimes = instalaciones.map(i => ({
+    valor: i.id,
+    etiqueta: `${i.runtimeNombre} (${i.scope}) — v${i.version} · perfil ${i.perfil}`,
+    descripcion: i.desactualizada
+      ? `Desactualizado. Subirá de v${i.version} a v${versionPaquete}. ${i.componentes} componentes.`
+      : `Ya está en v${versionPaquete}. Re-instalación refrescará archivos sin cambio de versión.`,
+    preseleccionado: i.desactualizada, // por default, solo los desactualizados
+  }));
+
+  const idsElegidos = await selectorMulti({
+    titulo: 'Paso 1/4 — ¿Qué runtimes actualizas?',
+    items: itemsRuntimes,
+  });
+  if (idsElegidos === null) return { exito: false, cancelado: true };
+  if (idsElegidos.length === 0) {
+    return { exito: false, vacio: true, error: 'No seleccionaste ningún runtime para actualizar.' };
+  }
+
+  const runtimesPlan = instalaciones.filter(i => idsElegidos.includes(i.id));
+
+  // 2. Multi-select de categorías
+  const categoriasElegidas = await selectorMulti({
+    titulo: 'Paso 2/4 — ¿Qué categorías de componentes refrescas?',
+    items: CATEGORIAS.map(c => ({ ...c, preseleccionado: true })),
+  });
+  if (categoriasElegidas === null) return { exito: false, cancelado: true };
+  if (categoriasElegidas.length === 0) {
+    return { exito: false, vacio: true, error: 'No seleccionaste ninguna categoría.' };
+  }
+
+  const plan = {
+    runtimes: runtimesPlan,
+    categorias: categoriasElegidas,
+  };
+
+  // 3. Diff preview
+  const proceder = await _pantallaDiff(plan, versionPaquete);
+  if (!proceder) return { exito: false, cancelado: true };
+
+  // 4. Confirmación final
+  const confirmacion = await selectorUnico({
+    titulo: 'Paso 4/4 — Confirmar e iniciar actualización',
+    items: [
+      {
+        valor: 'si',
+        etiqueta: 'Sí, actualizar ahora',
+        descripcion: `Actualiza ${plan.runtimes.length} runtime(s) en ${plan.categorias.length} categorías. La operación es idempotente; archivos sin cambio quedan iguales.`,
+      },
+      {
+        valor: 'no',
+        etiqueta: 'No, cancelar',
+        descripcion: 'Volver al menú sin tocar nada.',
+      },
+    ],
+  });
+  if (confirmacion !== 'si') return { exito: false, cancelado: true };
+
+  return { exito: true, plan, versionPaquete };
+}
+
+module.exports = {
+  ejecutarWizardUpdate,
+  // exports para tests
+  CATEGORIAS,
+  _detectarInstalaciones,
+};