@saulwade/swl-ses 1.5.1 → 1.6.0

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

@@ -0,0 +1,334 @@
+'use strict';
+
+/**
+ * Wizard de instalación TUI.
+ * Reemplaza la versión simple basada en preguntarOpcion del install-asistido.js
+ * con un flujo multi-step visual usando los componentes selector-unico y
+ * selector-multi.
+ *
+ * Pasos:
+ *   1. Runtime destino (Claude/Codex/OpenCode/etc.)
+ *   2. Perfil (core / backend-python / fullstack-* / completo / ...)
+ *   3. Scope (proyecto / global)
+ *   4. Flags adicionales (with-mcp, dry-run)
+ *   5. Stacks de lenguajes (solo si perfil = completo)
+ *   6. Preview del plan
+ *   7. Confirmación final
+ *
+ * Devuelve el objeto de opciones para `scripts/instalador.js` o null si el
+ * usuario canceló en cualquier paso.
+ */
+
+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 RAIZ = path.resolve(__dirname, '..', '..', '..');
+const PERFILES_PATH = path.join(RAIZ, 'manifiestos', 'perfiles.json');
+
+// ---------------------------------------------------------------------------
+// Datos estáticos
+// ---------------------------------------------------------------------------
+
+const RUNTIMES = [
+  {
+    valor: 'claude',
+    etiqueta: 'Claude Code',
+    descripcion: 'Runtime principal de Anthropic. Soporte completo de hooks, agentes, skills y comandos.',
+    badge: 'recomendado',
+  },
+  {
+    valor: 'openclaude',
+    etiqueta: 'OpenClaude',
+    descripcion: 'Fork open source compatible con Claude Code. Soporte completo.',
+  },
+  {
+    valor: 'opencode',
+    etiqueta: 'OpenCode',
+    descripcion: 'CLI de código abierto multi-modelo. Soporte completo.',
+  },
+  {
+    valor: 'codex',
+    etiqueta: 'Codex CLI (OpenAI)',
+    descripcion: 'CLI oficial de OpenAI. Soporte parcial: agentes en TOML, hooks limitados.',
+  },
+  {
+    valor: 'gemini',
+    etiqueta: 'Gemini CLI (Google)',
+    descripcion: 'CLI oficial de Google Gemini. Soporte completo.',
+  },
+  {
+    valor: 'copilot',
+    etiqueta: 'GitHub Copilot',
+    descripcion: 'Copilot Chat / CLI. Soporte parcial — no soporta todos los hooks SWL.',
+  },
+  {
+    valor: 'cursor',
+    etiqueta: 'Cursor',
+    descripcion: 'IDE basado en VS Code con Cursor Agents. Soporte completo de hooks (17 eventos).',
+  },
+];
+
+const SCOPES = [
+  {
+    valor: 'proyecto',
+    etiqueta: 'Proyecto (./.claude/)',
+    descripcion: 'Solo este proyecto. Recomendado para uso por proyecto y CI/CD.',
+    badge: 'recomendado',
+  },
+  {
+    valor: 'global',
+    etiqueta: 'Global (~/.claude/)',
+    descripcion: 'Disponible en todos los proyectos del usuario. Útil para herramientas comunes.',
+  },
+];
+
+const STACKS_ADICIONALES = [
+  { valor: 'java',    etiqueta: 'Java + Spring Boot' },
+  { valor: 'go',      etiqueta: 'Go' },
+  { valor: 'rust',    etiqueta: 'Rust' },
+  { valor: 'csharp',  etiqueta: 'C# / .NET' },
+  { valor: 'kotlin',  etiqueta: 'Kotlin + Android' },
+  { valor: 'swift',   etiqueta: 'Swift + iOS' },
+  { valor: 'php',     etiqueta: 'PHP + Laravel' },
+  { valor: 'nextjs',  etiqueta: 'Next.js' },
+];
+
+const FLAGS = [
+  {
+    valor: 'with-mcp',
+    etiqueta: 'Configurar MCP server swl-memory',
+    descripcion: 'Habilita búsqueda híbrida BM25+vector en sesiones pasadas. Recomendado.',
+    preseleccionado: false,
+  },
+  {
+    valor: 'dry-run',
+    etiqueta: 'Dry-run (solo mostrar plan, no copiar archivos)',
+    descripcion: 'Útil para inspeccionar qué se haría sin tocar el filesystem.',
+    preseleccionado: false,
+  },
+];
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function cargarPerfiles() {
+  try {
+    const data = JSON.parse(fs.readFileSync(PERFILES_PATH, 'utf8'));
+    return data.perfiles || {};
+  } catch (_) {
+    return {};
+  }
+}
+
+function construirItemsPerfil(perfiles) {
+  // Orden: core primero, completo al final, el resto alfabético
+  const keys = Object.keys(perfiles);
+  const ordenados = [];
+  if (keys.includes('core')) ordenados.push('core');
+  const intermedios = keys.filter(k => k !== 'core' && k !== 'completo').sort();
+  ordenados.push(...intermedios);
+  if (keys.includes('completo')) ordenados.push('completo');
+
+  return ordenados.map(k => {
+    const p = perfiles[k];
+    return {
+      valor: k,
+      etiqueta: k,
+      descripcion: p.descripcion || `Perfil ${k} con ${p.modulos?.length || 0} módulos`,
+      badge: k === 'core' ? 'mínimo' : k === 'completo' ? 'todo' : undefined,
+    };
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Pantalla de preview
+// ---------------------------------------------------------------------------
+
+/**
+ * Renderiza una pantalla de preview con el resumen del plan y espera Enter
+ * (continuar a confirmación) o Esc (cancelar). Devuelve true/false.
+ */
+function pantallaPreview(opciones, perfiles) {
+  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 del plan'));
+      render.escribirEn(3, 3, colores.dim('Revisa antes de confirmar:'));
+
+      const filas = [
+        ['Runtime',     opciones.target],
+        ['Perfil',      opciones.profile],
+        ['Scope',       opciones.global ? 'global (~/.claude)' : 'proyecto (./.claude)'],
+        ['With MCP',    opciones.with_mcp ? 'sí' : 'no'],
+        ['Dry-run',     opciones.dry_run ? 'sí (no copia archivos)' : 'no'],
+      ];
+
+      if (opciones.profile === 'completo' && opciones.stacks?.length > 0) {
+        filas.push(['Stacks extra', opciones.stacks.join(', ')]);
+      }
+
+      const perfilInfo = perfiles[opciones.profile];
+      if (perfilInfo?.modulos) {
+        filas.push(['Módulos', String(perfilInfo.modulos.length)]);
+      }
+
+      filas.forEach((fila, i) => {
+        const [k, v] = fila;
+        render.escribirEn(5 + i, 5,
+          render.rellenarDer(colores.dim(k + ':'), 16) + semantico.enfasis(v));
+      });
+
+      // Si hay perfil con módulos, listar los primeros 8
+      if (perfilInfo?.modulos) {
+        const filaMod = 7 + filas.length;
+        render.escribirEn(filaMod, 5, colores.dim('Módulos incluidos:'));
+        const mostrar = perfilInfo.modulos.slice(0, 8);
+        mostrar.forEach((m, i) => {
+          render.escribirEn(filaMod + 1 + i, 7, colores.cyan(iconos.punto) + ' ' + m);
+        });
+        if (perfilInfo.modulos.length > 8) {
+          render.escribirEn(filaMod + 1 + mostrar.length, 7,
+            colores.dim(`... y ${perfilInfo.modulos.length - 8} más`));
+        }
+      }
+
+      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(continuar) {
+      teclado.desactivar();
+      process.stdout.removeListener('resize', onResize);
+      render.salirModoTui();
+      resolve(continuar);
+    }
+
+    teclado.on('return', () => _finalizar(true));
+    teclado.on('escape', () => _finalizar(false));
+    teclado.activar();
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Wizard principal
+// ---------------------------------------------------------------------------
+
+async function ejecutarWizardInstall() {
+  const perfiles = cargarPerfiles();
+  if (Object.keys(perfiles).length === 0) {
+    return { exito: false, error: 'No se pudo cargar manifiestos/perfiles.json' };
+  }
+
+  // 1. Runtime
+  const target = await selectorUnico({
+    titulo: 'Paso 1/6 — ¿En qué runtime instalas SWL?',
+    items: RUNTIMES,
+    indiceDefault: 0,
+  });
+  if (!target) return { exito: false, cancelado: true };
+
+  // 2. Perfil
+  const profile = await selectorUnico({
+    titulo: 'Paso 2/6 — ¿Qué perfil instalas?',
+    items: construirItemsPerfil(perfiles),
+    indiceDefault: 0,
+  });
+  if (!profile) return { exito: false, cancelado: true };
+
+  // 3. Scope
+  const scope = await selectorUnico({
+    titulo: 'Paso 3/6 — ¿Dónde se instala?',
+    items: SCOPES,
+    indiceDefault: 0,
+  });
+  if (!scope) return { exito: false, cancelado: true };
+
+  // 4. Flags
+  const flagsSeleccionados = await selectorMulti({
+    titulo: 'Paso 4/6 — Flags adicionales (espacio para toggle):',
+    items: FLAGS,
+  });
+  if (flagsSeleccionados === null) return { exito: false, cancelado: true };
+
+  // 5. Stacks (solo si perfil = completo)
+  let stacks = [];
+  if (profile === 'completo') {
+    const elegidos = await selectorMulti({
+      titulo: 'Paso 5/6 — Stacks de lenguajes adicionales (perfil completo):',
+      items: STACKS_ADICIONALES,
+    });
+    if (elegidos === null) return { exito: false, cancelado: true };
+    stacks = elegidos;
+  }
+
+  const opciones = {
+    target,
+    profile,
+    global: scope === 'global',
+    with_mcp: flagsSeleccionados.includes('with-mcp'),
+    dry_run: flagsSeleccionados.includes('dry-run'),
+    all_langs: stacks.length > 0,
+    stacks,
+  };
+
+  // 6. Preview
+  const procederPreview = await pantallaPreview(opciones, perfiles);
+  if (!procederPreview) return { exito: false, cancelado: true };
+
+  // 7. Confirmación final (selector único con 2 opciones para claridad visual)
+  const confirmacion = await selectorUnico({
+    titulo: 'Paso 6/6 — Confirmar e iniciar instalación',
+    items: [
+      {
+        valor: 'si',
+        etiqueta: 'Sí, instalar ahora',
+        descripcion: 'Ejecuta el plan y muestra progreso. Puedes usar dry-run en el paso 4 si solo quieres ver qué pasaría.',
+      },
+      {
+        valor: 'no',
+        etiqueta: 'No, cancelar',
+        descripcion: 'Vuelve al menú principal sin tocar nada.',
+      },
+    ],
+    indiceDefault: 0,
+  });
+
+  if (confirmacion !== 'si') return { exito: false, cancelado: true };
+
+  return { exito: true, opciones };
+}
+
+module.exports = {
+  ejecutarWizardInstall,
+  // exports auxiliares para tests
+  RUNTIMES,
+  SCOPES,
+  STACKS_ADICIONALES,
+  FLAGS,
+  cargarPerfiles,
+  construirItemsPerfil,
+};

package/scripts/tui/pantallas/menu-principal.js

@@ -0,0 +1,52 @@
+'use strict';
+
+/**
+ * Menú principal de la TUI de swl-ses.
+ * 4 operaciones disponibles: Install / Update / Inspect / Uninstall.
+ *
+ * Devuelve uno de: 'install' | 'update' | 'inspect' | 'uninstall' | null
+ *   (null = el usuario canceló con Escape)
+ */
+
+const { selectorUnico } = require('../componentes/selector-unico');
+
+const OPCIONES = [
+  {
+    valor: 'install',
+    etiqueta: 'Install — Instalar SWL en un runtime nuevo',
+    descripcion:
+      'Asistente paso a paso: runtime + perfil + scope + flags. ' +
+      'Detecta instalaciones existentes y avisa si hay conflictos de scope.',
+  },
+  {
+    valor: 'update',
+    etiqueta: 'Update — Actualizar instalaciones existentes',
+    descripcion:
+      'Multi-select de runtimes a actualizar + componentes a refrescar ' +
+      '(skills, hooks, agentes, reglas, comandos). Muestra diff antes de aplicar.',
+  },
+  {
+    valor: 'inspect',
+    etiqueta: 'Inspect — Explorar componentes instalados',
+    descripcion:
+      'Navega por runtime → perfil → componentes sin modificar nada. ' +
+      'Lee de los manifiestos y archivos de estado.',
+  },
+  {
+    valor: 'uninstall',
+    etiqueta: 'Uninstall — Desinstalar SWL de un runtime',
+    descripcion:
+      'Elige runtime y scope a desinstalar. Preserva _userland/ y APRENDIZAJES.md ' +
+      'por default. Pide confirmación explícita antes de borrar.',
+  },
+];
+
+function mostrarMenuPrincipal() {
+  return selectorUnico({
+    titulo: '¿Qué operación quieres realizar?',
+    items: OPCIONES,
+    indiceDefault: 0,
+  });
+}
+
+module.exports = { mostrarMenuPrincipal, OPCIONES };

package/scripts/tui/pantallas/progreso.js

@@ -0,0 +1,274 @@
+'use strict';
+
+/**
+ * Pantalla de progreso de la TUI.
+ * Diseño:
+ *   - Cabecera con título de la operación (Install / Update)
+ *   - Barra global de progreso con porcentaje
+ *   - Tabla de contadores por categoría (skills, hooks, agentes, reglas, etc.)
+ *   - Panel inferior con log rotativo (últimas N líneas)
+ *
+ * Modelo de uso:
+ *
+ *   const ctrl = crearProgreso({ titulo, categorias });
+ *   ctrl.iniciar();
+ *
+ *   // El instalador emite eventos:
+ *   ctrl.onEvento({ tipo: 'archivo-copiado', componente: 'skills', archivo: '...' });
+ *   ctrl.onEvento({ tipo: 'componente-completado', componente: 'skills' });
+ *   ctrl.onEvento({ tipo: 'log', linea: 'Backup creado: ...' });
+ *
+ *   // Al terminar:
+ *   ctrl.finalizar({ ok: true, mensaje: 'Instalación completa' });
+ *
+ * En no-TTY: imprime líneas simples a stdout sin esperar.
+ */
+
+const render = require('../lib/render');
+const teclas = require('../lib/teclas');
+const { colores, semantico, iconos } = require('../lib/colores');
+
+const MAX_LOG_LINEAS_DEFAULT = 8;
+const MAX_LOG_LINEAS_VERBOSE = 24;
+
+// Compat: el contador histórico exportado seguía siendo MAX_LOG_LINEAS.
+// Lo mantenemos para no romper consumidores externos.
+const MAX_LOG_LINEAS = MAX_LOG_LINEAS_DEFAULT;
+
+/**
+ * @param {object} opciones
+ * @param {string} opciones.titulo - Encabezado (ej: "Instalando SWL en Claude Code...")
+ * @param {Array<{nombre:string, etiqueta:string, total:number}>} opciones.categorias
+ *        Categorías a contar. Ej: [{ nombre:'skills', etiqueta:'Skills', total:162 }, ...]
+ * @param {boolean} [opciones.verbose=false] - Expande el panel de log para mostrar
+ *        más líneas (24 vs 8) y deshabilita el truncado del log por archivo.
+ *        Util cuando se quiere depurar qué hace exactamente el instalador.
+ */
+function crearProgreso(opciones) {
+  const titulo = opciones.titulo || 'Procesando...';
+  const categorias = opciones.categorias || [];
+  const verbose = !!opciones.verbose;
+  const maxLogLineas = verbose ? MAX_LOG_LINEAS_VERBOSE : MAX_LOG_LINEAS_DEFAULT;
+
+  // Estado interno
+  const conteos = new Map(); // nombre → contador actual
+  for (const c of categorias) conteos.set(c.nombre, 0);
+  const logBuffer = []; // últimas N líneas
+  let finalizado = false;
+  let mensajeFinal = '';
+  let okFinal = true;
+  let onResize = null;
+  let teclado = null;
+  let resolverEspera = null;
+
+  function _porcentajeGlobal() {
+    let hecho = 0, total = 0;
+    for (const c of categorias) {
+      hecho += Math.min(conteos.get(c.nombre) || 0, c.total);
+      total += c.total;
+    }
+    return total > 0 ? hecho / total : 0;
+  }
+
+  function _renderizar() {
+    if (!render.ES_TTY) return;
+    render.limpiarPantalla();
+    const { cols, rows } = render.obtenerDimensiones();
+
+    // Cabecera
+    render.escribirEn(2, 3, semantico.titulo(titulo));
+
+    // Barra global
+    const filaBarra = 4;
+    render.escribirEn(filaBarra, 3, colores.dim('Progreso global'));
+    render.dibujarBarra(filaBarra + 1, 3, Math.min(cols - 6, 60), _porcentajeGlobal());
+
+    // Contadores por categoría
+    const filaCat = filaBarra + 4;
+    render.escribirEn(filaCat - 1, 3, colores.dim('Por categoría:'));
+    categorias.forEach((c, i) => {
+      const actual = conteos.get(c.nombre) || 0;
+      const pct = c.total > 0 ? actual / c.total : 0;
+      const completo = actual >= c.total && c.total > 0;
+      const icono = completo ? semantico.exito(iconos.check) : (actual > 0 ? semantico.info(iconos.arrow) : colores.dim(iconos.punto));
+      const linea =
+        `${icono} ` +
+        render.rellenarDer(colores.negrita(c.etiqueta), 14) +
+        render.rellenarDer(`${actual}/${c.total}`, 12);
+      render.escribirEn(filaCat + i, 5, linea);
+      // Mini-barra al lado
+      const anchoMini = Math.min(20, cols - 50);
+      if (anchoMini > 8) {
+        render.dibujarBarra(filaCat + i, 32, anchoMini, pct, {
+          colorLleno: completo ? colores.verde : colores.cyan,
+        });
+      }
+    });
+
+    // Panel inferior con log rotativo
+    const filaLog = filaCat + categorias.length + 2;
+    const altoLog = Math.min(maxLogLineas + 2, rows - filaLog - 2);
+    if (altoLog >= 3) {
+      const tituloLog = verbose
+        ? `Log detallado (verbose, ${maxLogLineas} líneas)`
+        : 'Log (últimas líneas)';
+      render.dibujarCaja(filaLog, 3, cols - 5, altoLog, {
+        titulo: tituloLog,
+        color: colores.dim,
+      });
+      const lineasMostradas = logBuffer.slice(-Math.max(1, altoLog - 2));
+      lineasMostradas.forEach((l, i) => {
+        render.escribirEn(filaLog + 1 + i, 5,
+          render.recortar(colores.dim(l), cols - 9));
+      });
+    }
+
+    // Pie
+    if (finalizado) {
+      const colorPie = okFinal ? semantico.exito : semantico.error;
+      const ico = okFinal ? iconos.check : iconos.cross;
+      render.escribirEn(rows - 2, 3,
+        colorPie(`${ico} ${mensajeFinal}  ${colores.dim('— Enter para continuar')}`));
+    } else {
+      render.dibujarPiePagina([
+        ['Esc', 'cancelar'],
+      ]);
+    }
+  }
+
+  // ── API pública ───────────────────────────────────────────────────────────
+
+  function iniciar() {
+    if (!render.ES_TTY) {
+      console.log('');
+      console.log(`  ${titulo}`);
+      return;
+    }
+    render.iniciarModoTui();
+    _renderizar();
+    onResize = () => _renderizar();
+    process.stdout.on('resize', onResize);
+    teclado = teclas.crearTeclado();
+    teclado.on('escape', () => {
+      // No interrumpimos directamente: el caller decide cómo manejar.
+      // Aquí solo registramos en el log.
+      onEvento({ tipo: 'log', linea: '[usuario presionó Esc — ignorado durante ejecución]' });
+    });
+    teclado.activar();
+  }
+
+  /**
+   * Recibe eventos del instalador.
+   * tipos soportados:
+   *   - 'archivo-copiado'      { componente, archivo? }
+   *   - 'componente-completado' { componente }
+   *   - 'log'                  { linea }
+   *   - 'set-total'            { componente, total }  — actualizar total dinámico
+   */
+  function onEvento(evento) {
+    if (!evento || !evento.tipo) return;
+
+    switch (evento.tipo) {
+      case 'archivo-copiado':
+        if (evento.componente) {
+          const actual = conteos.get(evento.componente) || 0;
+          conteos.set(evento.componente, actual + 1);
+        }
+        if (evento.archivo) {
+          logBuffer.push(`${semantico.exito('+')} ${evento.componente}: ${evento.archivo}`);
+          if (logBuffer.length > maxLogLineas * 2) logBuffer.splice(0, logBuffer.length - maxLogLineas * 2);
+        }
+        break;
+      case 'componente-completado':
+        if (evento.componente) {
+          const cat = categorias.find(c => c.nombre === evento.componente);
+          if (cat) conteos.set(evento.componente, cat.total);
+        }
+        break;
+      case 'log':
+        if (evento.linea) {
+          logBuffer.push(evento.linea);
+          if (logBuffer.length > maxLogLineas * 2) logBuffer.splice(0, logBuffer.length - maxLogLineas * 2);
+        }
+        break;
+      case 'set-total':
+        if (evento.componente && typeof evento.total === 'number') {
+          const cat = categorias.find(c => c.nombre === evento.componente);
+          if (cat) cat.total = evento.total;
+        }
+        break;
+    }
+
+    _renderizar();
+    if (!render.ES_TTY && evento.linea) {
+      // Modo no-TTY: imprimir log lineal
+      console.log(`  ${evento.linea}`);
+    }
+  }
+
+  /**
+   * Marca la pantalla como finalizada. El usuario debe presionar Enter para
+   * cerrar. Resuelve la promise devuelta por esperarSalida().
+   */
+  function finalizar(opts = {}) {
+    finalizado = true;
+    okFinal = opts.ok !== false;
+    mensajeFinal = opts.mensaje || (okFinal ? 'Completado' : 'Falló');
+    if (!render.ES_TTY) {
+      console.log('');
+      console.log(`  ${okFinal ? '[OK]' : '[ERROR]'} ${mensajeFinal}`);
+      if (resolverEspera) resolverEspera();
+      return;
+    }
+    _renderizar();
+
+    if (teclado) {
+      teclado.on('return', () => {
+        cerrar();
+        if (resolverEspera) {
+          const r = resolverEspera;
+          resolverEspera = null;
+          r();
+        }
+      });
+    }
+  }
+
+  function cerrar() {
+    if (teclado) teclado.desactivar();
+    if (onResize) process.stdout.removeListener('resize', onResize);
+    render.salirModoTui();
+  }
+
+  /**
+   * Devuelve una promise que se resuelve cuando el usuario presiona Enter
+   * después de finalizar(). En no-TTY se resuelve inmediatamente al finalizar.
+   */
+  function esperarSalida() {
+    return new Promise((resolve) => {
+      if (finalizado && !render.ES_TTY) {
+        resolve();
+        return;
+      }
+      resolverEspera = resolve;
+    });
+  }
+
+  return {
+    iniciar,
+    onEvento,
+    finalizar,
+    cerrar,
+    esperarSalida,
+    // exports auxiliares para tests
+    _getEstado: () => ({
+      conteos: Object.fromEntries(conteos),
+      logBuffer: [...logBuffer],
+      finalizado,
+      mensajeFinal,
+      okFinal,
+    }),
+  };
+}
+
+module.exports = { crearProgreso, MAX_LOG_LINEAS, MAX_LOG_LINEAS_DEFAULT, MAX_LOG_LINEAS_VERBOSE };