@saulwade/swl-ses 1.5.1 → 1.6.0

package/scripts/run-eval.js

@@ -1,141 +1,141 @@
-#!/usr/bin/env node
-'use strict';
-
-/**
- * run-eval.js — CLI para ejecutar evaluaciones del eval framework.
- *
- * Uso:
- *   node scripts/run-eval.js <ruta-eval.json>
- *
- * Formato del archivo JSON de eval:
- * {
- *   "functionId": "memoria-busqueda::search",
- *   "schemaName": "MEMORY_SEARCH_RESULT_SCHEMA",   // opcional, valida output
- *   "qualityScorer": "scoreObservacion",           // opcional, calcula calidad
- *   "input":  { ... },                              // datos de entrada
- *   "expectedKeys": ["id", "tipo", "titulo"],       // opcional, valida presencia
- *   "output": { ... }                               // output a evaluar
- * }
- *
- * Exit codes:
- *   0 - eval pasa (valid: true)
- *   1 - eval falla (valid: false) o error de I/O
- *   2 - error de uso (argumentos inválidos)
- */
-
-const fs   = require('fs');
-const path = require('path');
-
-const schemas         = require('./lib/eval-schemas');
-const validator       = require('./lib/eval-validator');
-const quality         = require('./lib/eval-quality');
-const metricsStore    = require('./lib/eval-metrics-store');
-
-function uso() {
-  console.error('Uso: node scripts/run-eval.js <ruta-eval.json>');
-  console.error('     node scripts/run-eval.js --rebuild-aggregate');
-  process.exit(2);
-}
-
-function ejecutarEval(ruta) {
-  if (!fs.existsSync(ruta)) {
-    console.error(`Archivo no existe: ${ruta}`);
-    return 1;
-  }
-
-  let definicion;
-  try {
-    definicion = JSON.parse(fs.readFileSync(ruta, 'utf8'));
-  } catch (err) {
-    console.error(`Error parseando ${ruta}: ${err.message}`);
-    return 1;
-  }
-
-  const { functionId, schemaName, qualityScorer, output } = definicion;
-  if (!functionId || typeof functionId !== 'string') {
-    console.error('functionId requerido en el archivo de eval');
-    return 1;
-  }
-
-  const inicio = Date.now();
-  let valid = true;
-  let errors = [];
-  let qualityScore = null;
-
-  // Validar contra schema si se especifica
-  if (schemaName) {
-    const schema = schemas[schemaName];
-    if (!schema) {
-      console.error(`Schema desconocido: ${schemaName}. Disponibles: ${Object.keys(schemas).filter(k => k.endsWith('_SCHEMA')).join(', ')}`);
-      return 1;
-    }
-    const r = validator.validar(output, schema);
-    valid = valid && r.valid;
-    if (!r.valid) errors.push(...r.errors);
-  }
-
-  // Validar campos esperados si se especifican
-  if (Array.isArray(definicion.expectedKeys)) {
-    for (const key of definicion.expectedKeys) {
-      if (!output || !(key in output)) {
-        valid = false;
-        errors.push(`expectedKey faltante: ${key}`);
-      }
-    }
-  }
-
-  // Calcular quality score si se especifica
-  if (qualityScorer) {
-    const scorer = quality[qualityScorer];
-    if (typeof scorer !== 'function') {
-      console.error(`Quality scorer desconocido: ${qualityScorer}. Disponibles: ${Object.keys(quality).join(', ')}`);
-      return 1;
-    }
-    qualityScore = scorer(output);
-  }
-
-  const latencyMs = Date.now() - inicio;
-  const exito = valid;
-
-  // Persistir resultado
-  const baseDir = process.cwd();
-  metricsStore.registrar(baseDir, {
-    functionId,
-    latencyMs,
-    success: exito,
-    qualityScore,
-    metadata: { schemaName, qualityScorer, evalFile: path.basename(ruta) },
-  });
-
-  // Reportar
-  console.log(JSON.stringify({
-    functionId,
-    valid,
-    errors: errors.length > 0 ? errors : undefined,
-    qualityScore,
-    latencyMs,
-  }, null, 2));
-
-  return valid ? 0 : 1;
-}
-
-function main() {
-  const args = process.argv.slice(2);
-  if (args.length === 0) uso();
-
-  if (args[0] === '--rebuild-aggregate') {
-    const r = metricsStore.reconstruirAgregado(process.cwd());
-    console.log(`Agregado reconstruido: ${r.rebuilt} eventos, ${r.functions} funciones únicas.`);
-    process.exit(0);
-  }
-
-  process.exit(ejecutarEval(args[0]));
-}
-
-if (require.main === module) {
-  main();
-}
-
-module.exports = {
-  ejecutarEval,
-};
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * run-eval.js — CLI para ejecutar evaluaciones del eval framework.
+ *
+ * Uso:
+ *   node scripts/run-eval.js <ruta-eval.json>
+ *
+ * Formato del archivo JSON de eval:
+ * {
+ *   "functionId": "memoria-busqueda::search",
+ *   "schemaName": "MEMORY_SEARCH_RESULT_SCHEMA",   // opcional, valida output
+ *   "qualityScorer": "scoreObservacion",           // opcional, calcula calidad
+ *   "input":  { ... },                              // datos de entrada
+ *   "expectedKeys": ["id", "tipo", "titulo"],       // opcional, valida presencia
+ *   "output": { ... }                               // output a evaluar
+ * }
+ *
+ * Exit codes:
+ *   0 - eval pasa (valid: true)
+ *   1 - eval falla (valid: false) o error de I/O
+ *   2 - error de uso (argumentos inválidos)
+ */
+
+const fs   = require('fs');
+const path = require('path');
+
+const schemas         = require('./lib/eval-schemas');
+const validator       = require('./lib/eval-validator');
+const quality         = require('./lib/eval-quality');
+const metricsStore    = require('./lib/eval-metrics-store');
+
+function uso() {
+  console.error('Uso: node scripts/run-eval.js <ruta-eval.json>');
+  console.error('     node scripts/run-eval.js --rebuild-aggregate');
+  process.exit(2);
+}
+
+function ejecutarEval(ruta) {
+  if (!fs.existsSync(ruta)) {
+    console.error(`Archivo no existe: ${ruta}`);
+    return 1;
+  }
+
+  let definicion;
+  try {
+    definicion = JSON.parse(fs.readFileSync(ruta, 'utf8'));
+  } catch (err) {
+    console.error(`Error parseando ${ruta}: ${err.message}`);
+    return 1;
+  }
+
+  const { functionId, schemaName, qualityScorer, output } = definicion;
+  if (!functionId || typeof functionId !== 'string') {
+    console.error('functionId requerido en el archivo de eval');
+    return 1;
+  }
+
+  const inicio = Date.now();
+  let valid = true;
+  let errors = [];
+  let qualityScore = null;
+
+  // Validar contra schema si se especifica
+  if (schemaName) {
+    const schema = schemas[schemaName];
+    if (!schema) {
+      console.error(`Schema desconocido: ${schemaName}. Disponibles: ${Object.keys(schemas).filter(k => k.endsWith('_SCHEMA')).join(', ')}`);
+      return 1;
+    }
+    const r = validator.validar(output, schema);
+    valid = valid && r.valid;
+    if (!r.valid) errors.push(...r.errors);
+  }
+
+  // Validar campos esperados si se especifican
+  if (Array.isArray(definicion.expectedKeys)) {
+    for (const key of definicion.expectedKeys) {
+      if (!output || !(key in output)) {
+        valid = false;
+        errors.push(`expectedKey faltante: ${key}`);
+      }
+    }
+  }
+
+  // Calcular quality score si se especifica
+  if (qualityScorer) {
+    const scorer = quality[qualityScorer];
+    if (typeof scorer !== 'function') {
+      console.error(`Quality scorer desconocido: ${qualityScorer}. Disponibles: ${Object.keys(quality).join(', ')}`);
+      return 1;
+    }
+    qualityScore = scorer(output);
+  }
+
+  const latencyMs = Date.now() - inicio;
+  const exito = valid;
+
+  // Persistir resultado
+  const baseDir = process.cwd();
+  metricsStore.registrar(baseDir, {
+    functionId,
+    latencyMs,
+    success: exito,
+    qualityScore,
+    metadata: { schemaName, qualityScorer, evalFile: path.basename(ruta) },
+  });
+
+  // Reportar
+  console.log(JSON.stringify({
+    functionId,
+    valid,
+    errors: errors.length > 0 ? errors : undefined,
+    qualityScore,
+    latencyMs,
+  }, null, 2));
+
+  return valid ? 0 : 1;
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  if (args.length === 0) uso();
+
+  if (args[0] === '--rebuild-aggregate') {
+    const r = metricsStore.reconstruirAgregado(process.cwd());
+    console.log(`Agregado reconstruido: ${r.rebuilt} eventos, ${r.functions} funciones únicas.`);
+    process.exit(0);
+  }
+
+  process.exit(ejecutarEval(args[0]));
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  ejecutarEval,
+};

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 };

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

@@ -0,0 +1,158 @@
+'use strict';
+
+/**
+ * Selector único (single-select) para la TUI.
+ * Más rico que `preguntarOpcion` de scripts/lib/ui.js: navegación con flechas,
+ * descripciones largas con wrap, soporte para items con etiquetas (badges),
+ * pie de página con atajos, indicador de cursor visible.
+ *
+ * Diseño:
+ *   - Cada item: { valor, etiqueta, descripcion?, badge?, deshabilitado? }
+ *   - El cursor se mueve solo entre items habilitados.
+ *   - Enter resuelve con `items[cursor].valor`.
+ *   - Escape resuelve con `null` (señal de "cancelado").
+ *
+ * No-TTY: resuelve inmediatamente con el item por defecto sin esperar input.
+ */
+
+const render = require('../lib/render');
+const teclas = require('../lib/teclas');
+const { colores, semantico, iconos } = require('../lib/colores');
+
+/**
+ * @param {object} opciones
+ * @param {string} opciones.titulo - Título mostrado arriba de la lista.
+ * @param {Array<{valor:string,etiqueta:string,descripcion?:string,badge?:string,deshabilitado?:boolean}>} opciones.items
+ * @param {number} [opciones.indiceDefault=0]
+ * @param {string} [opciones.hintAtajos] - Hint adicional en el pie (opcional).
+ * @returns {Promise<string|null>} - Valor seleccionado o null si se canceló.
+ */
+function selectorUnico(opciones) {
+  const items = opciones.items || [];
+  const titulo = opciones.titulo || 'Selecciona una opción:';
+  let cursor = opciones.indiceDefault || 0;
+
+  // Asegurar que el cursor inicial caiga en un item habilitado
+  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) {
+      // No-TTY: devolver el item por defecto sin renderizar
+      const valor = items[cursor]?.valor ?? items[0]?.valor ?? null;
+      resolve(valor);
+      return;
+    }
+
+    function _renderizar() {
+      render.limpiarPantalla();
+      const { cols, rows } = render.obtenerDimensiones();
+
+      // Título
+      render.escribirEn(2, 3, semantico.titulo(titulo));
+
+      // Items
+      const filaInicio = 4;
+      const maxVisible = Math.min(items.length, rows - 6);
+      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 filaItem = filaInicio + (i - scrollOffset);
+
+        let prefijo;
+        if (item.deshabilitado) {
+          prefijo = colores.dim('  ');
+        } else if (esCursor) {
+          prefijo = semantico.cursor(iconos.cursor + ' ');
+        } else {
+          prefijo = '  ';
+        }
+
+        // Etiqueta principal
+        let etiqueta = item.etiqueta;
+        if (item.deshabilitado) {
+          etiqueta = colores.dim(etiqueta);
+        } else if (esCursor) {
+          etiqueta = colores.negrita(etiqueta);
+        }
+
+        // Badge opcional
+        const badge = item.badge ? '  ' + semantico.badge(item.badge) : '';
+
+        render.escribirEn(filaItem, 3, prefijo + etiqueta + badge);
+
+        // Descripción solo del item bajo cursor (panel inferior)
+        if (esCursor && item.descripcion && !item.deshabilitado) {
+          const filaDesc = filaInicio + maxVisible + 1;
+          const maxAnchoDesc = cols - 6;
+          const desc = render.recortar(colores.dim(item.descripcion), maxAnchoDesc);
+          render.escribirEn(filaDesc, 3, desc);
+        }
+      }
+
+      // Indicador de scroll si hay más items abajo
+      if (scrollOffset + maxVisible < items.length) {
+        render.escribirEn(filaInicio + maxVisible, 3,
+          colores.dim(`${iconos.flechaAbajo} ${items.length - scrollOffset - maxVisible} más`));
+      }
+
+      // Pie con atajos
+      const atajos = [
+        ['↑↓', 'navegar'],
+        ['Enter', 'elegir'],
+        ['Esc', 'cancelar'],
+      ];
+      if (opciones.hintAtajos) atajos.push([opciones.hintAtajos, '']);
+      render.dibujarPiePagina(atajos);
+    }
+
+    render.iniciarModoTui();
+    _renderizar();
+
+    const onResize = () => _renderizar();
+    process.stdout.on('resize', onResize);
+
+    const teclado = teclas.crearTeclado();
+
+    function _moverArriba() {
+      // Saltar items deshabilitados
+      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 _finalizar(valor) {
+      teclado.desactivar();
+      process.stdout.removeListener('resize', onResize);
+      render.salirModoTui();
+      resolve(valor);
+    }
+
+    teclado.on('up', _moverArriba);
+    teclado.on('down', _moverAbajo);
+    teclado.on('return', () => {
+      const item = items[cursor];
+      if (item && !item.deshabilitado) _finalizar(item.valor);
+    });
+    teclado.on('escape', () => _finalizar(null));
+    teclado.activar();
+  });
+}
+
+module.exports = { selectorUnico };