@saulwade/swl-ses 1.0.0

package/hooks/check-update.js

@@ -0,0 +1,211 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Hook: check-update.js
+ * Tipo: UserPromptSubmit (aplica a todos los mensajes del usuario)
+ * Registrado en: UserPromptSubmit (matcher vacío)
+ *
+ * Verifica al inicio de cada sesión si existe una versión nueva de swl-ses
+ * publicada en npm. Si la hay, emite una notificación discreta en stderr.
+ *
+ * Comportamiento:
+ *   - Throttled a 1 verificación cada 24h (flag en /tmp)
+ *   - Usa `npm view swl-ses version --json` (non-blocking, timeout 5s)
+ *   - Nunca bloquea (siempre exit 0)
+ *   - Solo emite notificación si hay versión nueva, nunca molesta si está al día
+ *
+ * Patrón VS Code: detección silenciosa + notificación discreta.
+ */
+
+const fs   = require('fs');
+const path = require('path');
+const os   = require('os');
+
+const { compararSemver, versionRemotaParalela } = require('../scripts/lib/npm-version');
+
+// ---------------------------------------------------------------------------
+// Constantes
+// ---------------------------------------------------------------------------
+
+/** Intervalo mínimo entre checks exitosos (24 horas en ms). */
+const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
+
+/** Intervalo entre reintentos cuando el último check falló en resolver remota (1 hora). */
+const RETRY_INTERVAL_MS = 60 * 60 * 1000;
+
+/** Timeout para npm view (5 segundos). */
+const NPM_TIMEOUT_MS = 5000;
+
+/** Archivo flag para throttling entre sesiones. */
+function flagPath() {
+  return path.join(os.tmpdir(), 'swl-ses-update-check.json');
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Lee la versión local del sistema SWL.
+ *
+ * Orden de búsqueda:
+ *   1. package.json del repo madre (cuando se trabaja en swl-ses mismo) —
+ *      se detecta por `name` que contenga "swl".
+ *   2. .swl-install-state.json de las ubicaciones conocidas —
+ *      creado por el instalador, contiene `versionSistema`. Cubre tanto
+ *      instalaciones locales al proyecto (.claude/ del proyecto) como
+ *      globales (~/.claude/) y las de otros runtimes (.github/, .codex/,
+ *      .gemini/, .opencode/). Si hay varias, toma la MÁS RECIENTE por
+ *      mtime — el usuario suele actualizar la que usa más seguido.
+ *   3. package.json colocado junto a este hook (fallback cuando el hook
+ *      se instaló como copia dentro de .claude/hooks del proyecto).
+ */
+function versionLocal() {
+  // Intento 1: repo madre swl-ses (package.json con name que incluye "swl")
+  const pkgsCandidatos = [
+    path.join(process.cwd(), 'package.json'),
+    path.join(__dirname, '..', 'package.json'),
+  ];
+  for (const ruta of pkgsCandidatos) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(ruta, 'utf8'));
+      if (pkg.name && pkg.name.includes('swl') && pkg.version) return pkg.version;
+    } catch { /* continuar */ }
+  }
+
+  // Intento 2: state del instalador — global, local o de otros runtimes
+  const stateCandidatos = [
+    path.join(os.homedir(), '.claude', '.swl-install-state.json'),        // global Claude
+    path.join(process.cwd(), '.claude', '.swl-install-state.json'),       // local al proyecto
+    path.join(process.cwd(), '.github', '.swl-install-state.json'),       // Copilot
+    path.join(process.cwd(), '.codex', '.swl-install-state.json'),        // Codex CLI
+    path.join(process.cwd(), '.gemini', '.swl-install-state.json'),       // Gemini CLI
+    path.join(process.cwd(), '.opencode', '.swl-install-state.json'),     // OpenCode
+    path.join(__dirname, '..', '..', '.claude', '.swl-install-state.json'),
+  ];
+
+  let mejorVersion = null;
+  let mejorMtime = 0;
+  for (const ruta of stateCandidatos) {
+    try {
+      const stat = fs.statSync(ruta);
+      const state = JSON.parse(fs.readFileSync(ruta, 'utf8'));
+      if (state.versionSistema && stat.mtimeMs > mejorMtime) {
+        mejorVersion = state.versionSistema;
+        mejorMtime = stat.mtimeMs;
+      }
+    } catch { /* continuar */ }
+  }
+  if (mejorVersion) return mejorVersion;
+
+  // Intento 3: fallback — package.json junto al hook sin filtro de nombre
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf8'));
+    if (pkg.version) return pkg.version;
+  } catch { /* silencioso */ }
+
+  return null;
+}
+
+/**
+ * True si remota es mayor que local en SemVer (con tolerancia a pre-release).
+ */
+function esVersionNueva(local, remota) {
+  const cmp = compararSemver(local, remota);
+  return cmp !== null && cmp < 0;
+}
+
+/**
+ * Verifica si ya se hizo check recientemente.
+ *
+ * Usa dos intervalos distintos:
+ *   - CHECK_INTERVAL_MS (24h) cuando el último check resolvió la versión remota.
+ *   - RETRY_INTERVAL_MS (1h) cuando el último check falló en resolver remota.
+ *     Esto evita cachear un "no pude verificar" por 24 horas completas — un npm
+ *     lento o un PATH roto no debe silenciar la alerta hasta el día siguiente.
+ */
+function debeVerificar() {
+  try {
+    const data = JSON.parse(fs.readFileSync(flagPath(), 'utf8'));
+    const intervalo = data.remota ? CHECK_INTERVAL_MS : RETRY_INTERVAL_MS;
+    return (Date.now() - data.timestamp) > intervalo;
+  } catch {
+    return true; // Sin flag = primera vez
+  }
+}
+
+/**
+ * Registra que se hizo un check.
+ */
+function registrarCheck(local, remota, hayNueva) {
+  try {
+    fs.writeFileSync(flagPath(), JSON.stringify({
+      timestamp: Date.now(),
+      local,
+      remota,
+      hayNueva,
+    }), 'utf8');
+  } catch { /* silencioso */ }
+}
+
+// ---------------------------------------------------------------------------
+// Entrypoint
+// ---------------------------------------------------------------------------
+
+let inputRaw = '';
+
+process.stdin.on('data', chunk => { inputRaw += chunk; });
+
+process.stdin.on('end', async () => {
+  try {
+    // Throttle: solo verificar cada 24h
+    if (!debeVerificar()) {
+      // Si el último check detectó actualización, repetir notificación (1 vez)
+      try {
+        const data = JSON.parse(fs.readFileSync(flagPath(), 'utf8'));
+        if (data.hayNueva && data.notificado < 2) {
+          process.stderr.write(
+            `[swl-ses] Versión ${data.remota} disponible (actual: ${data.local}). ` +
+            `Ejecuta: npx @saulwade/swl-ses@latest update\n`
+          );
+          data.notificado = (data.notificado || 0) + 1;
+          fs.writeFileSync(flagPath(), JSON.stringify(data), 'utf8');
+        }
+      } catch (err) {
+        // No bloquear pero dejar señal de diagnóstico cuando el flag está corrupto
+        process.stderr.write(`[swl-ses/check-update] flag inválido: ${String(err.message).slice(0, 80)}\n`);
+      }
+      return;
+    }
+
+    const local = versionLocal();
+    if (!local) return; // No se pudo determinar versión local
+
+    const { version: remota } = await versionRemotaParalela({ timeoutMs: NPM_TIMEOUT_MS });
+    if (!remota) {
+      // Sin conectividad o npm no disponible — registrar intento y salir
+      registrarCheck(local, null, false);
+      return;
+    }
+
+    const hayNueva = esVersionNueva(local, remota);
+    registrarCheck(local, remota, hayNueva);
+
+    if (hayNueva) {
+      const msg = [
+        '',
+        `[swl-ses] Nueva versión disponible: ${remota} (actual: ${local})`,
+        `  Ejecuta: npx @saulwade/swl-ses@latest update`,
+        `  O desde Claude Code: /swl:actualizar`,
+        '',
+      ].join('\n');
+      process.stderr.write(msg);
+    }
+  } catch (err) {
+    // El hook NUNCA bloquea Claude Code, pero deja una traza diagnóstica.
+    // Sin esto, regresiones de lógica quedan silenciosas hasta que alguien
+    // se da cuenta de que el aviso de update no aparece.
+    process.stderr.write(`[swl-ses/check-update] error interno: ${String(err.message || err).slice(0, 120)}\n`);
+  }
+});

package/hooks/clasificador-mensajes.js

@@ -0,0 +1,271 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Hook: clasificador-mensajes.js
+ * Tipo: UserPromptSubmit
+ *
+ * Analiza el mensaje del usuario antes de que Claude lo procese e inyecta
+ * hints de routing para el orquestador. Detecta señales por regex en español
+ * e inglés para clasificar la intención: decisión, bug, requisito,
+ * arquitectura, seguridad, performance, refactor, documentación.
+ *
+ * Inspirado en obsidian-mind classify-message.py.
+ * Zero-dependencies: regex puro en JS.
+ *
+ * Resultado:
+ *   - Señales detectadas → hookSpecificOutput con hints de routing
+ *   - Sin señales → exit 0 silencioso
+ *   - Error interno → exit 0 silencioso (nunca bloquear)
+ */
+
+// ---------------------------------------------------------------------------
+// Mapa de complejidad de tarea → modelo recomendado
+//
+// Basado en el principio del PDF "A Practical Guide to Building Agents":
+//   "No todo requiere el modelo más capaz. Sustituir modelos menores donde sea posible."
+//
+// Lógica de asignación:
+//   haiku  → tareas simples: documentación, formatting, consultas factuales
+//   sonnet → tareas medias: implementación, debug, testing, refactor
+//   opus   → tareas complejas: arquitectura, decisiones estratégicas, seguridad crítica
+// ---------------------------------------------------------------------------
+
+const COMPLEJIDAD_POR_SIGNAL = {
+  'DECISIÓN DE ARQUITECTURA': 'opus',
+  'BUG / ERROR':              'sonnet',
+  'REQUISITO / FEATURE':      'sonnet',
+  'SEGURIDAD':                'opus',
+  'RENDIMIENTO':              'sonnet',
+  'REFACTOR':                 'sonnet',
+  'DOCUMENTACIÓN':            'haiku',
+  'REVISIÓN DE CÓDIGO':       'sonnet',
+  'TESTING':                  'sonnet',
+};
+
+/**
+ * Determina el modelo recomendado a partir de las señales detectadas.
+ * Si hay múltiples señales, gana el modelo más capaz.
+ *
+ * @param {string[]} signalNames - Nombres de señales detectadas.
+ * @returns {{ modelo: string, razon: string }}
+ */
+function determinarModelo(signalNames) {
+  const JERARQUIA = ['opus', 'sonnet', 'haiku'];
+  let modeloElegido = 'sonnet'; // default seguro
+
+  for (const name of signalNames) {
+    const modeloSignal = COMPLEJIDAD_POR_SIGNAL[name];
+    if (!modeloSignal) continue;
+    const idxElegido = JERARQUIA.indexOf(modeloElegido);
+    const idxSignal  = JERARQUIA.indexOf(modeloSignal);
+    // Menor índice = modelo más capaz; gana el más capaz
+    if (idxSignal < idxElegido) {
+      modeloElegido = modeloSignal;
+    }
+  }
+
+  const descripciones = {
+    haiku:  'Tarea simple (docs/formatting) — Haiku es suficiente y reduce costo ~75%',
+    sonnet: 'Tarea de implementación/análisis — Sonnet es el balance óptimo',
+    opus:   'Tarea de alta complejidad (arquitectura/seguridad) — Opus recomendado',
+  };
+
+  return { modelo: modeloElegido, razon: descripciones[modeloElegido] };
+}
+
+// ---------------------------------------------------------------------------
+// Señales con patrones en español e inglés
+// ---------------------------------------------------------------------------
+
+const SIGNALS = [
+  {
+    name: 'DECISIÓN DE ARQUITECTURA',
+    hint: 'Decisión arquitectónica detectada — considerar invocar arquitecto-swl y documentar como ADR en .planning/adrs/',
+    patterns: [
+      // Español
+      'decidimos', 'decidí', 'la decisión es', 'optamos por', 'elegimos',
+      'vamos con', 'cambiamos a', 'migramos a', 'reemplazamos',
+      'arquitectura', 'diseño del sistema', 'patrón de diseño',
+      // Inglés
+      'decided', 'decision', 'we chose', 'agreed to', 'architecture',
+      'system design', 'design pattern', 'trade-off', 'adr',
+    ],
+  },
+  {
+    name: 'BUG / ERROR',
+    hint: 'Bug o error detectado — considerar invocar depurador-swl con método científico antes de corregir',
+    patterns: [
+      // Español
+      'bug', 'error', 'falla', 'fallo', 'no funciona', 'se rompe', 'roto',
+      'crashea', 'excepción', 'traceback', 'stack trace', 'no carga',
+      'regresión', 'se cayó', 'no responde', 'timeout',
+      // Inglés
+      'broken', 'crash', 'exception', 'failing', 'regression',
+      'not working', 'stacktrace',
+    ],
+  },
+  {
+    name: 'REQUISITO / FEATURE',
+    hint: 'Requisito o feature nueva detectada — considerar flujo completo: discutir-fase → planear-fase → ejecutar-fase',
+    patterns: [
+      // Español
+      'necesitamos', 'hay que agregar', 'falta', 'requiere', 'requisito',
+      'feature', 'funcionalidad', 'implementar', 'desarrollar', 'construir',
+      'crear', 'nuevo módulo', 'nueva pantalla', 'nuevo endpoint',
+      // Inglés
+      'implement', 'build', 'create', 'add feature', 'requirement',
+      'new module', 'new endpoint',
+    ],
+  },
+  {
+    name: 'SEGURIDAD',
+    hint: 'Tema de seguridad detectado — considerar invocar revisor-seguridad-swl y cargar Skill("checklist-seguridad")',
+    patterns: [
+      // Español
+      'seguridad', 'vulnerabilidad', 'cve', 'inyección', 'xss', 'csrf',
+      'autenticación', 'autorización', 'token', 'secreto', 'credencial',
+      'owasp', 'penetración', 'auditoría de seguridad',
+      // Inglés
+      'security', 'vulnerability', 'injection', 'authentication',
+      'authorization', 'secret', 'credential', 'pentest',
+    ],
+  },
+  {
+    name: 'RENDIMIENTO',
+    hint: 'Tema de rendimiento detectado — considerar invocar rendimiento-swl y cargar Skill("performance-baseline")',
+    patterns: [
+      // Español
+      'lento', 'rendimiento', 'performance', 'optimizar', 'latencia',
+      'cuello de botella', 'bottleneck', 'caché', 'indexar', 'n+1',
+      'memoria', 'cpu', 'profiling',
+      // Inglés
+      'slow', 'optimize', 'latency', 'throughput', 'caching',
+    ],
+  },
+  {
+    name: 'REFACTOR',
+    hint: 'Refactorización detectada — considerar revisor-codigo-swl primero para evaluar alcance, luego planificar',
+    patterns: [
+      // Español
+      'refactorizar', 'refactor', 'limpiar', 'simplificar', 'reorganizar',
+      'deuda técnica', 'código legacy', 'mejorar la estructura',
+      'extraer', 'separar en módulos',
+      // Inglés
+      'refactor', 'clean up', 'simplify', 'tech debt', 'legacy',
+      'restructure', 'extract',
+    ],
+  },
+  {
+    name: 'DOCUMENTACIÓN',
+    hint: 'Documentación detectada — considerar invocar documentador-swl y actualizar docs según regla de documentación obligatoria',
+    patterns: [
+      // Español
+      'documentar', 'documentación', 'readme', 'manual', 'guía',
+      'changelog', 'api docs', 'runbook',
+      // Inglés
+      'document', 'documentation', 'readme',
+    ],
+  },
+  {
+    name: 'REVISIÓN DE CÓDIGO',
+    hint: 'Revisión de código detectada — considerar usar /swl:revisar con el lenguaje apropiado',
+    patterns: [
+      // Español
+      'revisar', 'revisión', 'code review', 'pr review', 'pull request',
+      'revisar código', 'revisar calidad', 'auditar',
+      // Inglés
+      'review', 'code review', 'pull request',
+    ],
+  },
+  {
+    name: 'TESTING',
+    hint: 'Testing detectado — considerar invocar tdd-qa-swl y cargar Skill("tdd-workflow")',
+    patterns: [
+      // Español
+      'test', 'prueba', 'cobertura', 'coverage', 'tdd', 'unitario',
+      'integración', 'e2e', 'mock', 'fixture',
+      // Inglés
+      'test', 'coverage', 'unit test', 'integration test',
+    ],
+  },
+];
+
+// ---------------------------------------------------------------------------
+// Detección
+// ---------------------------------------------------------------------------
+
+/**
+ * Verifica si algún patrón aparece como palabra/frase en el texto.
+ * Usa lookaround de letras latinas para compatibilidad con texto mixto.
+ * @param {string[]} patterns
+ * @param {string} text - Texto en minúsculas.
+ * @returns {boolean}
+ */
+function anyMatch(patterns, text) {
+  for (const phrase of patterns) {
+    // Escapar caracteres especiales de regex
+    const escaped = phrase.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const re = new RegExp('(?<![a-záéíóúñü])' + escaped + '(?![a-záéíóúñü])', 'i');
+    if (re.test(text)) return true;
+  }
+  return false;
+}
+
+/**
+ * Clasifica el mensaje del usuario.
+ * @param {string} prompt
+ * @returns {{ hints: string[], signalNames: string[] }}
+ */
+function classify(prompt) {
+  const text = (prompt || '').toLowerCase();
+  const hints = [];
+  const signalNames = [];
+  for (const sig of SIGNALS) {
+    if (anyMatch(sig.patterns, text)) {
+      hints.push(sig.hint);
+      signalNames.push(sig.name);
+    }
+  }
+  return { hints, signalNames };
+}
+
+// ---------------------------------------------------------------------------
+// Entrypoint
+// ---------------------------------------------------------------------------
+
+let inputRaw = '';
+
+process.stdin.on('data', chunk => { inputRaw += chunk; });
+
+process.stdin.on('end', () => {
+  try {
+    const data = JSON.parse(inputRaw);
+    const prompt = data.prompt || '';
+    if (!prompt) return;
+
+    const { hints, signalNames } = classify(prompt);
+    if (hints.length === 0) return;
+
+    const hintList = hints.map(h => '- ' + h).join('\n');
+
+    // Determinar modelo recomendado según complejidad de las señales detectadas
+    const { modelo, razon } = determinarModelo(signalNames);
+    const modeloHint = `- Modelo sugerido para esta tarea: **${modelo}** — ${razon}`;
+
+    const output = {
+      hookSpecificOutput: {
+        hookEventName: 'UserPromptSubmit',
+        additionalContext:
+          'Clasificación del mensaje (actúa sobre estos hints si aplican):\n' +
+          hintList + '\n' +
+          modeloHint +
+          '\n\nRecuerda: usar agentes SWL especializados, cargar skills relevantes, seguir CLAUDE.md.',
+      },
+    };
+
+    process.stdout.write(JSON.stringify(output));
+  } catch (_) {
+    // Nunca bloquear por errores internos
+  }
+});