swl-ses 3.3.2

package/scripts/lib/detectar-runtime.js

@@ -0,0 +1,177 @@
+'use strict';
+
+/**
+ * Detecta el runtime de IA disponible en el sistema.
+ * Soporta: Claude Code, Copilot, OpenCode, Codex, Gemini CLI
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const RUNTIMES = {
+  claude: {
+    nombre: 'Claude Code',
+    global: path.join(os.homedir(), '.claude'),
+    local: '.claude',
+    archivosConfig: ['settings.json', 'settings.local.json'],
+    dirAgentes: 'agents',
+    dirHabilidades: 'skills',
+    dirComandos: 'commands',
+    dirReglas: 'rules',
+    formatoAgente: 'markdown-frontmatter',
+    soportaHooks: true,
+    hookConfig: 'settings.json',
+  },
+  copilot: {
+    nombre: 'GitHub Copilot',
+    global: path.join(os.homedir(), '.copilot'),
+    local: '.copilot',
+    archivosConfig: ['config.json'],
+    dirAgentes: 'agents',
+    dirHabilidades: 'skills',
+    dirComandos: 'commands',
+    dirReglas: 'rules',
+    formatoAgente: 'markdown-frontmatter',
+    soportaHooks: false,
+    experimental: true,
+  },
+  opencode: {
+    nombre: 'OpenCode',
+    global: path.join(os.homedir(), '.opencode'),
+    local: '.opencode',
+    archivosConfig: ['config.ts', 'config.json'],
+    dirAgentes: 'agents',
+    dirHabilidades: 'skills',
+    dirComandos: 'commands',
+    dirReglas: 'rules',
+    formatoAgente: 'markdown-frontmatter',
+    soportaHooks: true,
+    hookConfig: 'config.json',
+    experimental: true,
+  },
+  codex: {
+    nombre: 'Codex CLI',
+    global: path.join(os.homedir(), '.codex'),
+    local: '.codex',
+    archivosConfig: ['config.toml'],
+    dirAgentes: 'agents',
+    dirHabilidades: 'skills',
+    dirComandos: null,
+    dirReglas: null,
+    formatoAgente: 'toml',
+    soportaHooks: false,
+    experimental: true,
+  },
+  gemini: {
+    nombre: 'Gemini CLI',
+    global: path.join(os.homedir(), '.gemini'),
+    local: '.gemini',
+    archivosConfig: ['settings.json'],
+    dirAgentes: 'agents',
+    dirHabilidades: 'skills',
+    dirComandos: 'commands',
+    dirReglas: 'rules',
+    formatoAgente: 'markdown-frontmatter',
+    soportaHooks: true,
+    hookConfig: 'settings.json',
+    experimental: true,
+  },
+};
+
+/**
+ * Detecta qué runtimes están instalados en el sistema
+ */
+function detectarRuntimes() {
+  const detectados = [];
+
+  for (const [id, config] of Object.entries(RUNTIMES)) {
+    const globalExiste = fs.existsSync(config.global);
+    const localExiste = fs.existsSync(path.resolve(config.local));
+
+    if (globalExiste || localExiste) {
+      detectados.push({
+        id,
+        ...config,
+        globalExiste,
+        localExiste,
+      });
+    }
+  }
+
+  return detectados;
+}
+
+/**
+ * Obtiene la configuración de un runtime específico
+ */
+function obtenerRuntime(id) {
+  const runtime = RUNTIMES[id];
+  if (!runtime) {
+    throw new Error(
+      `Runtime desconocido: "${id}". Disponibles: ${Object.keys(RUNTIMES).join(', ')}`
+    );
+  }
+  return { id, ...runtime };
+}
+
+/**
+ * Calcula las rutas de instalación para un runtime
+ */
+function calcularRutas(runtimeId, opciones = {}) {
+  const runtime = obtenerRuntime(runtimeId);
+  const base = opciones.global ? runtime.global : path.resolve(runtime.local);
+
+  // Para instalación local, hooks van en ./hooks/ (raíz del proyecto)
+  // Para instalación global, hooks van dentro del directorio del runtime
+  const hooksDir = runtime.soportaHooks
+    ? (opciones.global ? path.join(base, 'hooks') : path.join(base, '..', 'hooks'))
+    : null;
+
+  const rutas = {
+    base,
+    agentes: runtime.dirAgentes ? path.join(base, runtime.dirAgentes) : null,
+    habilidades: runtime.dirHabilidades ? path.join(base, runtime.dirHabilidades) : null,
+    comandos: runtime.dirComandos ? path.join(base, runtime.dirComandos, 'swl') : null,
+    reglas: runtime.dirReglas ? path.join(base, runtime.dirReglas) : null,
+    hooks: hooksDir,
+  };
+
+  return rutas;
+}
+
+/**
+ * Resumen de detección para mostrar al usuario
+ */
+function resumenDeteccion() {
+  const detectados = detectarRuntimes();
+  const lineas = ['Runtimes detectados:'];
+
+  if (detectados.length === 0) {
+    lineas.push('  (ninguno encontrado)');
+    lineas.push('');
+    lineas.push('Runtimes soportados:');
+    for (const [id, config] of Object.entries(RUNTIMES)) {
+      const marca = config.experimental ? ' [experimental]' : '';
+      lineas.push(`  - ${id}: ${config.nombre}${marca}`);
+    }
+  } else {
+    for (const r of detectados) {
+      const ubicacion = [];
+      if (r.globalExiste) ubicacion.push('global');
+      if (r.localExiste) ubicacion.push('local');
+      const marca = r.experimental ? ' [experimental]' : '';
+      lineas.push(`  + ${r.id}: ${r.nombre} (${ubicacion.join(', ')})${marca}`);
+    }
+  }
+
+  return lineas.join('\n');
+}
+
+module.exports = {
+  RUNTIMES,
+  detectarRuntimes,
+  obtenerRuntime,
+  calcularRutas,
+  resumenDeteccion,
+};

package/scripts/lib/estado.js

@@ -0,0 +1,112 @@
+'use strict';
+
+/**
+ * Gestión de estado de instalación SWL.
+ * Persiste qué se instaló, dónde y cuándo para soporte de doctor/repair/uninstall.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const NOMBRE_ESTADO = '.swl-install-state.json';
+
+/**
+ * Crea un nuevo registro de estado de instalación
+ */
+function crearEstado(opciones) {
+  return {
+    version: 2,
+    sistema: 'swl-software-engineering-system',
+    versionSistema: opciones.versionSistema || '1.0.0',
+    target: opciones.target,
+    perfil: opciones.perfil,
+    rutaBase: opciones.rutaBase,
+    global: opciones.global || false,
+    componentesInstalados: [],
+    archivosInstalados: [],
+    hooksRegistrados: 0,
+    settingsModificado: false,
+    instaladoEn: new Date().toISOString(),
+    actualizadoEn: new Date().toISOString(),
+  };
+}
+
+/**
+ * Registra un archivo instalado en el estado
+ */
+function registrarArchivo(estado, archivo) {
+  estado.archivosInstalados.push({
+    origen: archivo.origen,
+    destino: archivo.destino,
+    tipo: archivo.tipo, // agente, habilidad, comando, regla, hook
+    checksum: archivo.checksum || null,
+    instaladoEn: new Date().toISOString(),
+  });
+  estado.actualizadoEn = new Date().toISOString();
+}
+
+/**
+ * Registra un componente instalado
+ */
+function registrarComponente(estado, componente) {
+  if (!estado.componentesInstalados.includes(componente)) {
+    estado.componentesInstalados.push(componente);
+    estado.actualizadoEn = new Date().toISOString();
+  }
+}
+
+/**
+ * Guarda el estado en disco
+ */
+function guardarEstado(estado, directorio) {
+  const rutaEstado = path.join(directorio, NOMBRE_ESTADO);
+  fs.writeFileSync(rutaEstado, JSON.stringify(estado, null, 2), 'utf-8');
+  return rutaEstado;
+}
+
+/**
+ * Carga el estado desde disco
+ */
+function cargarEstado(directorio) {
+  const rutaEstado = path.join(directorio, NOMBRE_ESTADO);
+  if (!fs.existsSync(rutaEstado)) {
+    return null;
+  }
+  try {
+    return JSON.parse(fs.readFileSync(rutaEstado, 'utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Verifica integridad del estado contra archivos en disco
+ */
+function verificarIntegridad(estado) {
+  const problemas = [];
+
+  for (const archivo of estado.archivosInstalados) {
+    if (!fs.existsSync(archivo.destino)) {
+      problemas.push({
+        tipo: 'faltante',
+        archivo: archivo.destino,
+        mensaje: `Archivo instalado no encontrado: ${archivo.destino}`,
+      });
+    }
+  }
+
+  return {
+    integro: problemas.length === 0,
+    problemas,
+  };
+}
+
+module.exports = {
+  NOMBRE_ESTADO,
+  crearEstado,
+  registrarArchivo,
+  registrarComponente,
+  guardarEstado,
+  cargarEstado,
+  verificarIntegridad,
+};

package/scripts/lib/hooks-settings.js

@@ -0,0 +1,283 @@
+'use strict';
+
+/**
+ * Gestión de hooks en settings.json del runtime destino.
+ *
+ * Funciones para registrar, desregistrar y verificar hooks SWL
+ * en la configuración del runtime (Claude Code, Gemini CLI, etc.).
+ *
+ * Los hooks SWL se identifican por la presencia de "hooks/" + nombre
+ * del archivo en el campo `command`.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const RAIZ_PKG = path.resolve(__dirname, '..', '..');
+
+/**
+ * Carga la configuración de hooks desde manifiestos/hooks-config.json
+ * @returns {object} Mapa de nombre_archivo → { event, matcher, description, blocking }
+ */
+function cargarHooksConfig() {
+  const configPath = path.join(RAIZ_PKG, 'manifiestos', 'hooks-config.json');
+  const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+  return config.hooks;
+}
+
+/**
+ * Lee settings.json del runtime. Si no existe, retorna objeto base.
+ * @param {string} settingsPath - Ruta completa al archivo settings.json
+ * @returns {object}
+ */
+function leerSettings(settingsPath) {
+  if (!fs.existsSync(settingsPath)) {
+    return {};
+  }
+  try {
+    return JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Escribe settings.json preservando formato legible.
+ * @param {string} settingsPath
+ * @param {object} settings
+ */
+function escribirSettings(settingsPath, settings) {
+  const dir = path.dirname(settingsPath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
+}
+
+/**
+ * Determina si un hook entry en settings.json pertenece a SWL.
+ * @param {object} entry - { matcher, command }
+ * @returns {boolean}
+ */
+function esHookSWL(entry) {
+  const cmd = entry.command || '';
+  // Los hooks SWL usan el patrón: node hooks/nombre-hook.js
+  return /node\s+.*hooks\/[a-z-]+\.js/.test(cmd);
+}
+
+/**
+ * Calcula la ruta del settings.json para un runtime.
+ * @param {object} runtime - Configuración del runtime
+ * @param {string} base - Directorio base (.claude, ~/.claude, etc.)
+ * @returns {string} Ruta completa al settings.json
+ */
+function rutaSettings(runtime, base) {
+  const configFile = runtime.hookConfig || 'settings.json';
+  return path.join(base, configFile);
+}
+
+/**
+ * Genera el comando para ejecutar un hook desde el directorio de trabajo.
+ * @param {string} hookFilename - Nombre del archivo de hook (ej: "escaneo-secretos.js")
+ * @param {string} hooksDir - Directorio donde se instalaron los hooks
+ * @param {boolean} esGlobal - Si es instalación global
+ * @returns {string} Comando ejecutable
+ */
+function generarComando(hookFilename, hooksDir, esGlobal) {
+  if (esGlobal) {
+    // Para instalación global, usar ruta absoluta
+    const rutaAbsoluta = path.join(hooksDir, hookFilename);
+    return `node "${rutaAbsoluta}"`;
+  }
+  // Para instalación local, ruta relativa al proyecto
+  return `node hooks/${hookFilename}`;
+}
+
+/**
+ * Registra los hooks SWL en settings.json del runtime.
+ * Preserva hooks existentes no-SWL. Reemplaza hooks SWL previos.
+ *
+ * @param {object} opciones
+ * @param {string} opciones.settingsPath - Ruta al settings.json
+ * @param {string} opciones.hooksDir - Directorio donde están los hooks
+ * @param {boolean} opciones.esGlobal - Si es instalación global
+ * @param {string[]} opciones.hookFiles - Lista de archivos de hooks instalados
+ * @returns {{ registrados: number, preservados: number }}
+ */
+function registrarHooks(opciones) {
+  const { settingsPath, hooksDir, esGlobal, hookFiles } = opciones;
+  const hooksConfig = cargarHooksConfig();
+  const settings = leerSettings(settingsPath);
+
+  // Inicializar sección hooks si no existe
+  if (!settings.hooks) {
+    settings.hooks = {};
+  }
+
+  let registrados = 0;
+  let preservados = 0;
+
+  // Agrupar hooks SWL por evento
+  const hooksPorEvento = {};
+  for (const filename of hookFiles) {
+    const config = hooksConfig[filename];
+    if (!config) continue;
+
+    const evento = config.event;
+    if (!hooksPorEvento[evento]) {
+      hooksPorEvento[evento] = [];
+    }
+
+    hooksPorEvento[evento].push({
+      matcher: config.matcher || undefined,
+      command: generarComando(filename, hooksDir, esGlobal),
+    });
+    registrados++;
+  }
+
+  // Para cada tipo de evento, preservar hooks no-SWL y agregar los SWL
+  for (const evento of ['PreToolUse', 'PostToolUse']) {
+    const existentes = settings.hooks[evento] || [];
+    const noSWL = existentes.filter(entry => !esHookSWL(entry));
+    preservados += noSWL.length;
+
+    const swlNuevos = hooksPorEvento[evento] || [];
+
+    // Limpiar entradas con matcher vacío (Claude Code no necesita la key)
+    const swlLimpios = swlNuevos.map(h => {
+      const entry = { command: h.command };
+      if (h.matcher) entry.matcher = h.matcher;
+      return entry;
+    });
+
+    const combinados = [...noSWL, ...swlLimpios];
+
+    if (combinados.length > 0) {
+      settings.hooks[evento] = combinados;
+    } else {
+      delete settings.hooks[evento];
+    }
+  }
+
+  // Limpiar sección hooks si quedó vacía
+  if (Object.keys(settings.hooks).length === 0) {
+    delete settings.hooks;
+  }
+
+  escribirSettings(settingsPath, settings);
+
+  return { registrados, preservados };
+}
+
+/**
+ * Desregistra todos los hooks SWL de settings.json.
+ * Preserva hooks no-SWL intactos.
+ *
+ * @param {string} settingsPath - Ruta al settings.json
+ * @returns {{ eliminados: number, preservados: number }}
+ */
+function desregistrarHooks(settingsPath) {
+  const settings = leerSettings(settingsPath);
+
+  if (!settings.hooks) {
+    return { eliminados: 0, preservados: 0 };
+  }
+
+  let eliminados = 0;
+  let preservados = 0;
+
+  for (const evento of ['PreToolUse', 'PostToolUse']) {
+    const existentes = settings.hooks[evento] || [];
+    const noSWL = [];
+
+    for (const entry of existentes) {
+      if (esHookSWL(entry)) {
+        eliminados++;
+      } else {
+        noSWL.push(entry);
+        preservados++;
+      }
+    }
+
+    if (noSWL.length > 0) {
+      settings.hooks[evento] = noSWL;
+    } else {
+      delete settings.hooks[evento];
+    }
+  }
+
+  // Limpiar sección hooks si quedó vacía
+  if (Object.keys(settings.hooks).length === 0) {
+    delete settings.hooks;
+  }
+
+  escribirSettings(settingsPath, settings);
+
+  return { eliminados, preservados };
+}
+
+/**
+ * Verifica que los hooks SWL estén correctamente registrados en settings.json.
+ *
+ * @param {string} settingsPath - Ruta al settings.json
+ * @param {string[]} hookFiles - Lista de archivos de hooks que deberían estar registrados
+ * @returns {{ ok: boolean, registrados: string[], faltantes: string[], incorrectos: string[] }}
+ */
+function verificarHooks(settingsPath, hookFiles) {
+  const hooksConfig = cargarHooksConfig();
+  const settings = leerSettings(settingsPath);
+
+  const registrados = [];
+  const faltantes = [];
+  const incorrectos = [];
+
+  for (const filename of hookFiles) {
+    const config = hooksConfig[filename];
+    if (!config) {
+      faltantes.push(filename);
+      continue;
+    }
+
+    const evento = config.event;
+    const entradas = (settings.hooks && settings.hooks[evento]) || [];
+
+    // Buscar si existe un hook SWL que referencie este archivo
+    const encontrado = entradas.find(entry => {
+      const cmd = entry.command || '';
+      return cmd.includes(filename);
+    });
+
+    if (!encontrado) {
+      faltantes.push(filename);
+      continue;
+    }
+
+    // Verificar matcher correcto
+    const matcherEsperado = config.matcher || undefined;
+    const matcherActual = encontrado.matcher || undefined;
+
+    if (matcherEsperado !== matcherActual) {
+      incorrectos.push(`${filename}: matcher esperado="${matcherEsperado || '(ninguno)'}" actual="${matcherActual || '(ninguno)'}"`);
+    } else {
+      registrados.push(filename);
+    }
+  }
+
+  return {
+    ok: faltantes.length === 0 && incorrectos.length === 0,
+    registrados,
+    faltantes,
+    incorrectos,
+  };
+}
+
+module.exports = {
+  cargarHooksConfig,
+  leerSettings,
+  escribirSettings,
+  rutaSettings,
+  registrarHooks,
+  desregistrarHooks,
+  verificarHooks,
+  esHookSWL,
+};

package/scripts/lib/manifiestos.js

@@ -0,0 +1,138 @@
+'use strict';
+
+/**
+ * Carga y resuelve manifiestos de instalación SWL.
+ * Tres niveles: perfiles → módulos → archivos.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const RAIZ_PKG = path.resolve(__dirname, '..', '..');
+
+/**
+ * Carga todos los manifiestos
+ */
+function cargarManifiestos() {
+  const perfiles = JSON.parse(
+    fs.readFileSync(path.join(RAIZ_PKG, 'manifiestos', 'perfiles.json'), 'utf-8')
+  );
+  const modulos = JSON.parse(
+    fs.readFileSync(path.join(RAIZ_PKG, 'manifiestos', 'modulos.json'), 'utf-8')
+  );
+  return { perfiles: perfiles.perfiles, modulos: modulos.modulos };
+}
+
+/**
+ * Resuelve un perfil a lista de archivos con rutas absolutas
+ */
+function resolverPerfil(nombrePerfil, opciones = {}) {
+  const { perfiles, modulos } = cargarManifiestos();
+
+  const perfil = perfiles[nombrePerfil];
+  if (!perfil) {
+    throw new Error(
+      `Perfil desconocido: "${nombrePerfil}". Disponibles: ${Object.keys(perfiles).join(', ')}`
+    );
+  }
+
+  let modulosSeleccionados = [...perfil.modulos];
+
+  // Agregar módulos con --with
+  if (opciones.with) {
+    const extras = opciones.with.split(',').map(s => s.trim());
+    for (const extra of extras) {
+      if (!modulosSeleccionados.includes(extra)) {
+        modulosSeleccionados.push(extra);
+      }
+    }
+  }
+
+  // Excluir módulos con --without
+  if (opciones.without) {
+    const excluir = opciones.without.split(',').map(s => s.trim());
+    modulosSeleccionados = modulosSeleccionados.filter(m => !excluir.includes(m));
+  }
+
+  // Resolver a archivos
+  const archivos = [];
+  const modulosResueltos = [];
+  const warnings = [];
+
+  for (const nombreModulo of modulosSeleccionados) {
+    const modulo = modulos[nombreModulo];
+    if (!modulo) {
+      warnings.push(`Módulo desconocido ignorado: "${nombreModulo}"`);
+      continue;
+    }
+
+    // Verificar soporte de target
+    if (opciones.target && !modulo.targets.includes(opciones.target)) {
+      warnings.push(`Módulo "${nombreModulo}" no soporta target "${opciones.target}", omitido`);
+      continue;
+    }
+
+    modulosResueltos.push(nombreModulo);
+
+    for (const rutaRelativa of modulo.archivos) {
+      const rutaAbsoluta = path.join(RAIZ_PKG, rutaRelativa);
+      archivos.push({
+        origen: rutaAbsoluta,
+        rutaRelativa,
+        tipo: modulo.tipo,
+        modulo: nombreModulo,
+      });
+    }
+  }
+
+  return {
+    perfil: nombrePerfil,
+    descripcion: perfil.descripcion,
+    modulos: modulosResueltos,
+    archivos,
+    warnings,
+  };
+}
+
+/**
+ * Genera un plan de instalación legible para el usuario
+ */
+function generarPlan(resolucion, rutasDestino) {
+  const lineas = [];
+  lineas.push(`Plan de instalación SWL`);
+  lineas.push(`${'='.repeat(50)}`);
+  lineas.push(`Perfil: ${resolucion.perfil} — ${resolucion.descripcion}`);
+  lineas.push(`Módulos: ${resolucion.modulos.length}`);
+  lineas.push(`Archivos: ${resolucion.archivos.length}`);
+  lineas.push('');
+
+  // Agrupar por tipo
+  const porTipo = {};
+  for (const archivo of resolucion.archivos) {
+    if (!porTipo[archivo.tipo]) porTipo[archivo.tipo] = [];
+    porTipo[archivo.tipo].push(archivo);
+  }
+
+  for (const [tipo, archivosDelTipo] of Object.entries(porTipo)) {
+    lineas.push(`[${tipo}] (${archivosDelTipo.length} archivos)`);
+    for (const a of archivosDelTipo) {
+      lineas.push(`  + ${a.rutaRelativa}`);
+    }
+    lineas.push('');
+  }
+
+  if (resolucion.warnings.length > 0) {
+    lineas.push('Advertencias:');
+    for (const w of resolucion.warnings) {
+      lineas.push(`  ! ${w}`);
+    }
+  }
+
+  return lineas.join('\n');
+}
+
+module.exports = {
+  cargarManifiestos,
+  resolverPerfil,
+  generarPlan,
+};