@saulwade/swl-ses 1.0.0

package/scripts/check-update.js

@@ -0,0 +1,109 @@
+'use strict';
+
+/**
+ * swl-ses check-update
+ *
+ * Comando manual para forzar consulta de versión disponible en npm.
+ * Sin throttle (ignora la bandera de 24h del hook). Útil para:
+ *   - Verificar que la consulta funciona en este entorno (diagnóstico).
+ *   - Saber si hay una versión nueva AHORA, sin esperar el próximo prompt.
+ *
+ * Output:
+ *   - Versión local (del paquete instalado).
+ *   - Versión remota (la más reciente publicada en npm).
+ *   - Veredicto: al día / nueva disponible / no se pudo consultar.
+ *
+ * Zero-deps.
+ */
+
+const fs   = require('fs');
+const path = require('path');
+const os   = require('os');
+
+const { compararSemver, versionRemotaParalela } = require('./lib/npm-version');
+
+function versionLocal() {
+  try {
+    return require('../package.json').version;
+  } catch {
+    return null;
+  }
+}
+
+function limpiarFlagThrottle() {
+  try {
+    const flag = path.join(os.tmpdir(), 'swl-ses-update-check.json');
+    if (fs.existsSync(flag)) fs.unlinkSync(flag);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function main(opciones = {}) {
+  console.log('');
+  console.log('swl-ses check-update');
+  console.log('====================');
+  console.log('');
+
+  const local = versionLocal();
+  console.log(`  Versión local:  ${local || 'no detectada'}`);
+
+  process.stdout.write('  Consultando npm...');
+  const remota = await versionRemotaParalela();
+  process.stdout.write('\r                   \r');
+
+  if (!remota.version) {
+    console.log(`  Versión remota: no se pudo consultar`);
+    console.log('');
+    console.log('  Intentos:');
+    for (const i of remota.intentos) {
+      console.log(`    - ${i.paquete}: ${i.resultado}${i.error ? ' — ' + i.error : ''}`);
+    }
+    console.log('');
+    console.log('  Posibles causas:');
+    console.log('    - Sin conectividad a npm');
+    console.log('    - npm no está en PATH (prueba: `npm --version`)');
+    console.log('    - Registro privado requiere auth');
+    process.exit(2);
+  }
+
+  console.log(`  Versión remota: ${remota.version}  (paquete: ${remota.paquete})`);
+
+  const cmp = compararSemver(local, remota.version);
+  console.log('');
+
+  if (cmp === null) {
+    console.log('  Veredicto: versiones no comparables');
+  } else if (cmp === 0) {
+    console.log(`  Veredicto: AL DÍA — estás en la última versión publicada.`);
+  } else if (cmp > 0) {
+    console.log(`  Veredicto: LOCAL MAYOR — tu versión local (${local}) es más nueva que la publicada (${remota.version}).`);
+    console.log(`             Típico en máquinas de desarrollo antes de publicar un release.`);
+  } else {
+    console.log(`  Veredicto: NUEVA VERSIÓN DISPONIBLE — ${remota.version} (actual: ${local}).`);
+    console.log('');
+    console.log(`  Ejecuta: npx @saulwade/swl-ses@latest update`);
+    console.log(`  O desde Claude Code: /swl:actualizar`);
+    console.log(`  (usar @latest evita que npx use una versión cacheada vieja)`);
+  }
+
+  // Limpiar flag de throttle para que el hook vuelva a consultar en la
+  // próxima sesión aunque no hayan pasado 24h desde la última consulta.
+  if (opciones._args?.includes?.('--reset-throttle') || opciones.reset_throttle) {
+    const ok = limpiarFlagThrottle();
+    console.log('');
+    console.log(`  Throttle reset: ${ok ? 'ok' : 'falló'}`);
+  }
+  console.log('');
+  process.exit(cmp < 0 ? 1 : 0);
+}
+
+module.exports = main;
+
+if (require.main === module) {
+  main({ _args: process.argv.slice(2) }).catch(err => {
+    process.stderr.write(`[check-update] error fatal: ${err.message}\n`);
+    process.exit(2);
+  });
+}

package/scripts/comandos/agents.js

@@ -0,0 +1,105 @@
+'use strict';
+
+const { listarComponentes, agregarComponente, removerComponente } = require('../lib/gestor-componentes');
+
+const AYUDA = `
+swl-ses agents — Gestión de agentes
+
+USO:
+  swl-ses agents <subcomando> [opciones]
+
+SUBCOMANDOS:
+  list                           Lista agentes instalados
+  add <fuente> [--agent <n>]     Agrega agente desde repo Git o path local
+  remove <nombre>                Remueve un agente
+
+OPCIONES:
+  --target <runtime>    Runtime destino (default: claude)
+  --agent <nombre>      Nombre del agente a extraer del repo
+  --global              Operar en directorio global
+  --force               Sobreescribir sin confirmar
+
+EJEMPLOS:
+  swl-ses agents list
+  swl-ses agents add https://github.com/user/repo --agent mi-agente
+  swl-ses agents remove mi-agente
+`;
+
+function agents(subcomando, opciones) {
+  if (!subcomando || subcomando === 'help') {
+    console.log(AYUDA);
+    return;
+  }
+
+  switch (subcomando) {
+    case 'list': {
+      const resultado = listarComponentes('agents', opciones);
+      console.log(`\nAgentes instalados (${resultado.total}):\n`);
+      if (resultado.total === 0) {
+        console.log('  (ninguno)');
+      } else {
+        console.log('  Nombre                          Fuente     Válido');
+        console.log('  ' + '-'.repeat(60));
+        for (const c of resultado.componentes) {
+          const nombre = c.nombre.padEnd(30);
+          const fuente = (c.fuente || 'sistema').padEnd(10);
+          const valido = c.valido ? 'sí' : 'no';
+          console.log(`  ${nombre}  ${fuente} ${valido}`);
+        }
+      }
+      console.log('');
+      break;
+    }
+
+    case 'add': {
+      const fuente = opciones._args && opciones._args[0];
+      if (!fuente) {
+        console.error('Error: Se requiere una fuente (URL Git o path local)');
+        console.error('Ejemplo: swl-ses agents add https://github.com/user/repo');
+        process.exit(1);
+      }
+      console.log(`\nAgregando agente desde: ${fuente}\n`);
+      try {
+        const resultado = agregarComponente('agents', fuente, {
+          ...opciones,
+          nombre: opciones.agent,
+        });
+        console.log(`\nInstalados: ${resultado.instalados.length}`);
+        if (resultado.advertencias.length > 0) {
+          console.log('Advertencias:');
+          for (const a of resultado.advertencias) console.log(`  ! ${a}`);
+        }
+      } catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+      }
+      console.log('');
+      break;
+    }
+
+    case 'remove': {
+      const nombre = opciones._args && opciones._args[0];
+      if (!nombre) {
+        console.error('Error: Se requiere el nombre del agente a remover');
+        process.exit(1);
+      }
+      console.log(`\nRemoviendo agente: ${nombre}\n`);
+      try {
+        removerComponente('agents', nombre, opciones);
+        console.log('\nAgente removido exitosamente.');
+      } catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+      }
+      console.log('');
+      break;
+    }
+
+    default:
+      console.error(`Subcomando desconocido: "${subcomando}"`);
+      console.log(AYUDA);
+      process.exit(1);
+  }
+}
+
+module.exports = agents;

package/scripts/comandos/info.js

@@ -0,0 +1,108 @@
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const { detectarRuntimes, obtenerRuntime, calcularRutas } = require('../lib/detectar-runtime');
+const { cargarEstado } = require('../lib/estado');
+
+const VERSION = require('../../package.json').version;
+
+function info(_subcomando, opciones) {
+  // info no tiene subcomandos, _subcomando se ignora
+  if (!opciones && typeof _subcomando === 'object') {
+    opciones = _subcomando;
+  }
+  opciones = opciones || {};
+  const target = opciones.target || null;
+
+  console.log(`\nswl-ses v${VERSION} — Sistema de Ingeniería de Software SWL\n`);
+  console.log('='.repeat(50));
+
+  const runtimes = detectarRuntimes();
+
+  if (target) {
+    // Mostrar info de un target específico
+    mostrarInfoTarget(target, opciones);
+  } else {
+    // Mostrar info general
+    console.log(`\nRuntimes detectados: ${runtimes.length}\n`);
+
+    if (runtimes.length === 0) {
+      console.log('  (ninguno instalado)');
+      console.log('  Ejecuta: npx swl-ses@latest install --target claude');
+    } else {
+      for (const runtime of runtimes) {
+        const dirs = [];
+        if (runtime.globalExiste) dirs.push('global');
+        if (runtime.localExiste) dirs.push('local');
+        const marca = runtime.experimental ? ' [experimental]' : ' [estable]';
+        console.log(`  ${runtime.id}: ${runtime.nombre}${marca}`);
+        console.log(`    Ubicaciones: ${dirs.join(', ')}`);
+
+        // Cargar estado si existe
+        const baseDirs = [];
+        if (runtime.localExiste) baseDirs.push(path.resolve(runtime.local));
+        if (runtime.globalExiste) baseDirs.push(runtime.global);
+
+        for (const dir of baseDirs) {
+          const estado = cargarEstado(dir);
+          if (estado) {
+            console.log(`    Perfil: ${estado.perfil}`);
+            console.log(`    Archivos: ${estado.archivosInstalados.length}`);
+            console.log(`    Versión SWL: ${estado.versionSistema}`);
+            if (estado.componentesExternos && estado.componentesExternos.length > 0) {
+              console.log(`    Externos: ${estado.componentesExternos.length}`);
+            }
+          }
+        }
+        console.log('');
+      }
+    }
+  }
+
+  console.log('');
+}
+
+function mostrarInfoTarget(targetId, opciones) {
+  const esGlobal = opciones.global || false;
+  const runtime = obtenerRuntime(targetId);
+  const rutas = calcularRutas(targetId, { global: esGlobal });
+
+  console.log(`\nTarget: ${targetId} (${runtime.nombre})`);
+  console.log(`Base: ${rutas.base}`);
+  console.log(`Hooks: ${runtime.soportaHooks ? 'sí' : 'no'}`);
+  console.log(`Experimental: ${runtime.experimental ? 'sí' : 'no'}`);
+
+  const estado = cargarEstado(rutas.base);
+  if (estado) {
+    console.log(`\nEstado de instalación:`);
+    console.log(`  Perfil: ${estado.perfil}`);
+    console.log(`  Versión SWL: ${estado.versionSistema}`);
+    console.log(`  Archivos: ${estado.archivosInstalados.length}`);
+    console.log(`  Componentes: ${estado.componentesInstalados.length}`);
+    console.log(`  Hooks: ${estado.hooksRegistrados}`);
+    console.log(`  Instalado: ${estado.instaladoEn}`);
+    console.log(`  Actualizado: ${estado.actualizadoEn}`);
+
+    if (estado.componentesExternos && estado.componentesExternos.length > 0) {
+      console.log(`\nComponentes externos (${estado.componentesExternos.length}):`);
+      for (const ext of estado.componentesExternos) {
+        console.log(`  ${ext.tipo}: ${ext.nombre} (${ext.fuente})`);
+      }
+    }
+
+    // Contar por tipo
+    const porTipo = {};
+    for (const a of estado.archivosInstalados) {
+      porTipo[a.tipo] = (porTipo[a.tipo] || 0) + 1;
+    }
+    console.log('\nDesglose por tipo:');
+    for (const [tipo, count] of Object.entries(porTipo)) {
+      console.log(`  ${tipo}: ${count}`);
+    }
+  } else {
+    console.log('\n  (sin instalación detectada en esta ubicación)');
+  }
+}
+
+module.exports = info;

package/scripts/comandos/install-asistido.js

@@ -0,0 +1,186 @@
+'use strict';
+
+/**
+ * swl-ses install (modo asistido)
+ *
+ * Cuando el usuario ejecuta `swl-ses install` sin flags, este módulo lanza
+ * un flujo interactivo que pregunta:
+ *   1. Runtime destino (claude, openclaude, copilot, opencode, codex, gemini)
+ *   2. Perfil (core, backend-python, fullstack-node-react, completo, etc.)
+ *   3. Scope (global ~/.claude vs proyecto ./.claude)
+ *   4. Flags opcionales (--all-langs, --dry-run)
+ *   5. Confirmación final
+ *
+ * Tras las respuestas, invoca `scripts/instalador.js` con las opciones
+ * resueltas. En no-TTY, cae al comportamiento por defecto (claude + core +
+ * proyecto) sin prompts.
+ *
+ * Inspirado en `npx swl-ses skills add anthropics/skills` (flujo interactivo
+ * que ya existía para skills) extendido al installer principal.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const { preguntarSiNo, preguntarOpcion, ES_TTY } = require('../lib/ui');
+
+const RAIZ = path.resolve(__dirname, '..', '..');
+const PERFILES_PATH = path.join(RAIZ, 'manifiestos', 'perfiles.json');
+
+// ---------------------------------------------------------------------------
+// Opciones predefinidas
+// ---------------------------------------------------------------------------
+
+const RUNTIMES = [
+  { valor: 'claude',     descripcion: 'Claude Code (soporte completo, recomendado)' },
+  { valor: 'openclaude', descripcion: 'OpenClaude (soporte completo)' },
+  { valor: 'copilot',    descripcion: 'GitHub Copilot (soporte parcial)' },
+  { valor: 'opencode',   descripcion: 'OpenCode (soporte completo)' },
+  { valor: 'codex',      descripcion: 'Codex CLI (soporte parcial)' },
+  { valor: 'gemini',     descripcion: 'Gemini CLI (soporte completo)' },
+];
+
+const SCOPES = [
+  { valor: 'proyecto', descripcion: './.claude — solo este proyecto (recomendado)' },
+  { valor: 'global',   descripcion: '~/.claude — disponible en todos los proyectos' },
+];
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function cargarPerfiles() {
+  try {
+    const data = JSON.parse(fs.readFileSync(PERFILES_PATH, 'utf8'));
+    return data.perfiles || {};
+  } catch {
+    return {};
+  }
+}
+
+function construirOpcionesPerfil(perfiles) {
+  // Ordenar: 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];
+    const desc = (p.descripcion || '').slice(0, 90);
+    return { valor: k, descripcion: desc };
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Flujo asistido
+// ---------------------------------------------------------------------------
+
+async function flujoAsistido() {
+  if (!ES_TTY) {
+    console.log('');
+    console.log('[swl-ses install] sin TTY detectado — usando defaults: target=claude profile=core');
+    console.log('                   para instalación personalizada, pasa flags explícitos:');
+    console.log('                   swl-ses install --target <runtime> --profile <perfil>');
+    return { target: 'claude', profile: 'core', global: false };
+  }
+
+  console.log('');
+  console.log('═══════════════════════════════════════════════════════════════');
+  console.log('  swl-ses — Instalación asistida');
+  console.log('═══════════════════════════════════════════════════════════════');
+  console.log('');
+  console.log('  Responderás 3-4 preguntas. Puedes presionar Enter para');
+  console.log('  aceptar la opción marcada con *.');
+
+  // 1. Runtime
+  const target = await preguntarOpcion(
+    '¿En qué runtime instalas?',
+    RUNTIMES,
+    { indiceDefault: 0 },
+  );
+
+  // 2. Perfil
+  const perfiles = cargarPerfiles();
+  if (Object.keys(perfiles).length === 0) {
+    throw new Error('No se pudo cargar manifiestos/perfiles.json');
+  }
+  const opcionesPerfil = construirOpcionesPerfil(perfiles);
+  const profile = await preguntarOpcion(
+    '¿Qué perfil instalas?',
+    opcionesPerfil,
+    { indiceDefault: 0 },
+  );
+
+  // 3. Scope
+  const scope = await preguntarOpcion(
+    '¿Dónde se instala?',
+    SCOPES,
+    { indiceDefault: 0 },
+  );
+
+  // 4. ¿Incluir todos los lenguajes? (solo relevante para perfil "completo")
+  let all_langs = false;
+  if (profile === 'completo') {
+    all_langs = await preguntarSiNo(
+      '¿Incluir reglas/skills de todos los lenguajes (Java, Go, Rust, C#, Kotlin, Swift, PHP, Next.js)?',
+      false,
+    );
+  }
+
+  // 5. Dry-run
+  const dryRun = await preguntarSiNo(
+    '¿Hacer primero un dry-run (solo mostrar plan sin copiar archivos)?',
+    false,
+  );
+
+  // 6. Confirmación
+  console.log('');
+  console.log('  Resumen de la instalación planeada:');
+  console.log(`    Runtime:     ${target}`);
+  console.log(`    Perfil:      ${profile}${all_langs ? ' (+ all-langs)' : ''}`);
+  console.log(`    Scope:       ${scope} (${scope === 'global' ? '~/.claude' : './.claude'})`);
+  console.log(`    Dry-run:     ${dryRun ? 'sí (solo plan, no copia)' : 'no (ejecuta)'}`);
+  console.log('');
+
+  const confirmar = await preguntarSiNo('¿Continuar?', true);
+  if (!confirmar) {
+    console.log('Cancelado.');
+    process.exit(0);
+  }
+
+  return {
+    target,
+    profile,
+    global: scope === 'global',
+    all_langs,
+    dry_run: dryRun,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Entrypoint — invoca el instalador con las opciones resueltas
+// ---------------------------------------------------------------------------
+
+async function main() {
+  const opciones = await flujoAsistido();
+
+  // Delegamos al instalador clásico
+  const install = require('../instalador');
+  const fn = typeof install === 'function' ? install : install.install;
+  if (typeof fn !== 'function') {
+    throw new Error('scripts/instalador.js no exporta una función válida');
+  }
+  await fn(opciones);
+}
+
+module.exports = { flujoAsistido, main };
+
+if (require.main === module) {
+  main().catch(err => {
+    console.error('[swl-ses install] Error:', err.message);
+    process.exit(1);
+  });
+}