@saulwade/swl-ses 1.0.0

package/hooks/monitor-contexto.js

@@ -0,0 +1,325 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Hook: monitor-contexto.js
+ * Tipo: PostToolUse
+ *
+ * Lee el archivo bridge generado por linea-estado.js y emite advertencias
+ * cuando el contexto estimado supera umbrales críticos:
+ *
+ *   ≤ 35% restante (uso ≥ 65%): WARNING  — evitar trabajo complejo
+ *   ≤ 25% restante (uso ≥ 75%): CRITICAL — detenerse, guardar estado, compactar
+ *
+ * Debounce: solo emite aviso cada N_DEBOUNCE invocaciones de herramienta.
+ * La escalación de severidad (pasar de WARNING a CRITICAL) bypasea el debounce.
+ *
+ * El hook nunca bloquea (siempre exit 0); sólo emite mensajes en stdout
+ * como texto enriquecido que Claude Code puede mostrar al usuario.
+ */
+
+const fs   = require('fs');
+const path = require('path');
+const os   = require('os');
+
+const { phase1_PruneToolResults, shouldCompress } = require('./lib/context-compressor');
+
+// ---------------------------------------------------------------------------
+// Constantes de configuración
+// ---------------------------------------------------------------------------
+
+/** Porcentaje de USO a partir del cual se emite WARNING. */
+const UMBRAL_WARNING  = 65;
+
+/** Porcentaje de USO a partir del cual se emite CRITICAL. */
+const UMBRAL_CRITICAL = 75;
+
+/**
+ * Número de invocaciones de herramienta entre avisos consecutivos del mismo nivel.
+ * La escalación de severidad siempre bypasea este valor.
+ */
+const N_DEBOUNCE = 5;
+
+/** Cada N invocaciones, sugerir compactacion si estamos en punto natural. */
+const N_COMPACTACION_PROACTIVA = 40;
+
+/** Umbral de uso para activar compactacion proactiva (antes del warning). */
+const UMBRAL_COMPACTACION_PROACTIVA = 50;
+
+/**
+ * Ruta del archivo de estado interno de este monitor.
+ * Almacena cuándo se emitió el último aviso y con qué severidad.
+ */
+function rutaEstadoMonitor(sessionId) {
+  return path.join(os.tmpdir(), `swl-monitor-${sessionId}.json`);
+}
+
+// ---------------------------------------------------------------------------
+// Tipos de severidad
+// ---------------------------------------------------------------------------
+const SEVERIDAD = {
+  NINGUNA:  0,
+  WARNING:  1,
+  CRITICAL: 2,
+};
+
+// ---------------------------------------------------------------------------
+// Utilidades
+// ---------------------------------------------------------------------------
+
+/**
+ * Lee el archivo bridge de linea-estado.js.
+ * @param {string} sessionId
+ * @returns {object|null} Payload del bridge o null si no existe/falla.
+ */
+function leerBridge(sessionId) {
+  const bridgePath = path.join(os.tmpdir(), `swl-ctx-${sessionId}.json`);
+  try {
+    return JSON.parse(fs.readFileSync(bridgePath, 'utf8'));
+  } catch (_) {
+    return null;
+  }
+}
+
+/**
+ * Lee el estado interno previo del monitor.
+ * @param {string} estadoPath
+ * @returns {{ ultimaInvocacion: number, ultimaSeveridad: number }}
+ */
+function leerEstadoMonitor(estadoPath) {
+  try {
+    const datos = JSON.parse(fs.readFileSync(estadoPath, 'utf8'));
+    return {
+      ultimaInvocacion:  datos.ultimaInvocacion  ?? 0,
+      ultimaSeveridad:   datos.ultimaSeveridad   ?? SEVERIDAD.NINGUNA,
+      compresionEmitida: datos.compresionEmitida ?? false,
+    };
+  } catch (_) {
+    return { ultimaInvocacion: 0, ultimaSeveridad: SEVERIDAD.NINGUNA, compresionEmitida: false };
+  }
+}
+
+/**
+ * Persiste el estado del monitor.
+ * @param {string} estadoPath
+ * @param {object} estado
+ */
+function guardarEstadoMonitor(estadoPath, estado) {
+  try {
+    fs.writeFileSync(estadoPath, JSON.stringify(estado, null, 2), 'utf8');
+  } catch (_) {
+    // Ignorar errores de escritura — no bloquear el flujo
+  }
+}
+
+/**
+ * Determina la severidad actual en función del porcentaje de uso.
+ * @param {number} porcentajeUso - Porcentaje de contexto consumido (0-100).
+ * @returns {number} Valor de SEVERIDAD.*
+ */
+function calcularSeveridad(porcentajeUso) {
+  if (porcentajeUso >= UMBRAL_CRITICAL) return SEVERIDAD.CRITICAL;
+  if (porcentajeUso >= UMBRAL_WARNING)  return SEVERIDAD.WARNING;
+  return SEVERIDAD.NINGUNA;
+}
+
+/**
+ * Detecta si la ultima operacion es un punto natural para compactar.
+ * Puntos naturales:
+ *   - Despues de un git commit exitoso
+ *   - Despues de correr tests exitosamente
+ *   - Cuando tool_name es "Agent" (fin de subagente)
+ * @param {object} data - Payload del hook
+ * @returns {boolean}
+ */
+function esPuntoNatural(data) {
+  const toolName = String(data.tool_name || '');
+  const toolInput = data.tool_input || {};
+  const comando = String(toolInput.command || '');
+
+  // Despues de un commit exitoso
+  if (toolName === 'Bash' && /\bgit\s+commit\b/.test(comando)) return true;
+
+  // Despues de correr tests
+  if (toolName === 'Bash' && /\b(pytest|jest|vitest|go test|cargo test|dotnet test|phpunit|npm test)\b/.test(comando)) return true;
+
+  // Fin de un subagente
+  if (toolName === 'Agent') return true;
+
+  return false;
+}
+
+/**
+ * Genera el mensaje de sugerencia de compactacion proactiva.
+ * @param {number} porcentajeUso
+ * @param {number} invocaciones
+ * @returns {string}
+ */
+function generarMensajeCompactacion(porcentajeUso, invocaciones) {
+  return [
+    '',
+    '--- SUGERENCIA DE COMPACTACION ---',
+    `  Contexto: ${porcentajeUso}% usado | ${invocaciones} tool calls en sesion`,
+    '  Punto natural de pausa detectado.',
+    '  Considera ejecutar /compact o /swl:compactar para liberar contexto',
+    '  antes de continuar con tareas complejas.',
+    '',
+  ].join('\n');
+}
+
+/**
+ * Genera el mensaje de advertencia según severidad.
+ * El mensaje se emite en stdout para que Claude Code lo procese
+ * como feedback informativo dentro de la conversación.
+ *
+ * @param {number} severidad
+ * @param {number} porcentajeUso
+ * @param {number} porcentajeRestante
+ * @returns {string}
+ */
+function generarMensaje(severidad, porcentajeUso, porcentajeRestante) {
+  const barra = '█'.repeat(Math.round(porcentajeUso / 10)) +
+                '░'.repeat(10 - Math.round(porcentajeUso / 10));
+
+  if (severidad === SEVERIDAD.CRITICAL) {
+    return [
+      '',
+      '╔══════════════════════════════════════════════════════╗',
+      '║  CONTEXTO CRÍTICO — ACCIÓN REQUERIDA                 ║',
+      '╚══════════════════════════════════════════════════════╝',
+      `  Contexto usado: ${barra} ${porcentajeUso}%  (${porcentajeRestante}% restante)`,
+      '',
+      '  Acciones recomendadas:',
+      '  1. Guarda el estado actual con un commit atómico.',
+      '  2. Ejecuta /compact o solicita compactación del contexto.',
+      '  3. Divide la tarea en partes más pequeñas.',
+      '  4. No inicies trabajo complejo hasta compactar.',
+      '',
+    ].join('\n');
+  }
+
+  if (severidad === SEVERIDAD.WARNING) {
+    return [
+      '',
+      '⚠  ADVERTENCIA DE CONTEXTO',
+      `   Contexto usado: ${barra} ${porcentajeUso}%  (${porcentajeRestante}% restante)`,
+      '   Evitar tareas complejas. Considera compactar pronto.',
+      '',
+    ].join('\n');
+  }
+
+  return '';
+}
+
+// ---------------------------------------------------------------------------
+// Entrypoint principal
+// ---------------------------------------------------------------------------
+
+let inputRaw = '';
+
+process.stdin.on('data', chunk => {
+  inputRaw += chunk;
+});
+
+process.stdin.on('end', () => {
+  try {
+    const data = JSON.parse(inputRaw);
+
+    const sessionId = String(data.session_id || 'default');
+    const estadoPath = rutaEstadoMonitor(sessionId);
+
+    // Leer el bridge de linea-estado
+    const bridge = leerBridge(sessionId);
+    if (!bridge) {
+      // Sin bridge no hay datos — salir silenciosamente
+      return;
+    }
+
+    const porcentajeUso       = bridge.porcentaje     ?? 0;
+    const invocacionesActual  = bridge.invocaciones   ?? 0;
+    const porcentajeRestante  = 100 - porcentajeUso;
+    const severidadActual     = calcularSeveridad(porcentajeUso);
+
+    // Leer estado previo del monitor (necesario tanto para WARNING/CRITICAL como para proactiva)
+    const estadoPrevio = leerEstadoMonitor(estadoPath);
+    const { ultimaInvocacion, ultimaSeveridad } = estadoPrevio;
+
+    // Resetear flag de compresión si el contexto bajó (post-compactación real)
+    if (severidadActual < SEVERIDAD.CRITICAL && estadoPrevio.compresionEmitida) {
+      guardarEstadoMonitor(estadoPath, {
+        ...estadoPrevio,
+        compresionEmitida: false,
+        timestamp: new Date().toISOString(),
+      });
+    }
+
+    if (severidadActual !== SEVERIDAD.NINGUNA) {
+      // Determinar si debemos emitir aviso:
+      //   a) Escalación de severidad → siempre emitir (bypasea debounce)
+      //   b) Mismo nivel → solo si han pasado N_DEBOUNCE invocaciones
+      const esEscalacion = severidadActual > ultimaSeveridad;
+      const invocacionesDesdeUltimoAviso = invocacionesActual - ultimaInvocacion;
+      const debounceExpirado = invocacionesDesdeUltimoAviso >= N_DEBOUNCE;
+
+      const debeEmitir = esEscalacion || debounceExpirado;
+
+      if (debeEmitir) {
+        const mensaje = generarMensaje(severidadActual, porcentajeUso, porcentajeRestante);
+        if (mensaje) {
+          // Emitir advertencia como systemMessage (stderr causa hook error)
+          process.stdout.write(JSON.stringify({ systemMessage: mensaje }));
+        }
+
+        // Actualizar estado del monitor
+        guardarEstadoMonitor(estadoPath, {
+          ultimaInvocacion: invocacionesActual,
+          ultimaSeveridad:  severidadActual,
+          compresionEmitida: estadoPrevio.compresionEmitida || false,
+          timestamp:        new Date().toISOString(),
+        });
+      }
+    }
+
+    // --- Compresión automática Fase 1 (sin LLM) al llegar a CRITICAL ---
+    // Solo emitir UNA VEZ por sesión para evitar spam de banners
+    if (severidadActual === SEVERIDAD.CRITICAL && shouldCompress(porcentajeUso)) {
+      const yaEmitioBanner = estadoPrevio.compresionEmitida === true;
+      if (!yaEmitioBanner) {
+        try {
+          const mensajeCompresion = [
+            '',
+            '--- COMPRESION AUTOMATICA (Fases 1+1b) ---',
+            `  Contexto: ${porcentajeUso}% usado`,
+            '  Fase 1: tool results antiguos podados por posición.',
+            '  Fase 1b: resultados de Read/Bash/Grep/Glob > 15 turnos comprimidos por TTL.',
+            '  Para compresión avanzada (Fases 2-4), ejecuta /swl:compactar',
+            '  o pide: "comprime el contexto preservando las decisiones clave".',
+            '',
+          ].join('\n');
+          process.stdout.write(JSON.stringify({ systemMessage: mensajeCompresion }));
+          // Marcar como emitido para no repetir
+          guardarEstadoMonitor(estadoPath, {
+            ...estadoPrevio,
+            ultimaInvocacion: invocacionesActual,
+            ultimaSeveridad: severidadActual,
+            compresionEmitida: true,
+            timestamp: new Date().toISOString(),
+          });
+        } catch (_) {}
+      }
+    }
+
+    // --- Compactacion proactiva: sugerir en punto natural antes de alcanzar WARNING ---
+    if (severidadActual === SEVERIDAD.NINGUNA &&
+        porcentajeUso >= UMBRAL_COMPACTACION_PROACTIVA &&
+        invocacionesActual % N_COMPACTACION_PROACTIVA === 0 &&
+        esPuntoNatural(data)) {
+      const mensajeCompactacion = generarMensajeCompactacion(porcentajeUso, invocacionesActual);
+      process.stdout.write(JSON.stringify({ systemMessage: mensajeCompactacion }));
+    }
+
+  } catch (err) {
+    // El hook nunca bloquea por errores internos
+    // No escribir a stderr — Claude Code lo reporta como hook error
+  }
+});

package/hooks/notificacion-sesion-stop.js

@@ -0,0 +1,198 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Hook: notificacion-sesion-stop.js
+ * Tipo: Stop
+ *
+ * Al terminar una sesión (o turno largo), envía una notificación al gateway
+ * multi-plataforma con contexto útil: duración, tool calls, costo, últimos
+ * archivos modificados y el último tramo de output.
+ *
+ * Inspirado en Claude-Code-Remote (smtp.js líneas 292-340) — trae al aviso
+ * el contexto de qué hizo Claude en el turno, no solo "sesión terminada".
+ *
+ * Se activa solo si:
+ *   - gateway está habilitado en manifiestos/gateway-config.json
+ *   - notifications.onSessionComplete no es false
+ *   - la sesión tuvo al menos UMBRAL_TOOL_CALLS tool calls (evita ruido en turnos triviales)
+ *
+ * Opt-in adicional por variable de entorno:
+ *   SWL_NOTIFICAR_STOP=0 → desactiva completamente el hook
+ *
+ * Zero-deps. Nunca bloquea: exit 0 siempre.
+ */
+
+const fs   = require('fs');
+const path = require('path');
+const os   = require('os');
+
+const { notificarGateway, gatewayHabilitado } = require('./lib/gateway-notify');
+
+// Umbral mínimo de tool calls para emitir notificación.
+// Debajo de esto, la sesión se considera trivial (consulta puntual).
+const UMBRAL_TOOL_CALLS = 10;
+
+// Longitud máxima del tramo de transcripción a incluir en la notificación.
+const MAX_TRANSCRIPT_CHARS = 800;
+
+/**
+ * Lee el estado del bridge de tracking-costos.
+ */
+function leerBridge(sessionId) {
+  const bridgePath = path.join(os.tmpdir(), `swl-costs-${sessionId}.json`);
+  try {
+    return JSON.parse(fs.readFileSync(bridgePath, 'utf8'));
+  } catch (_) {
+    return null;
+  }
+}
+
+/**
+ * Lee el último tramo del transcript de la sesión.
+ * El payload del hook Stop incluye transcript_path apuntando al JSONL.
+ */
+function leerUltimoTramoTranscript(transcriptPath, maxChars) {
+  if (!transcriptPath || !fs.existsSync(transcriptPath)) return '';
+
+  try {
+    const raw = fs.readFileSync(transcriptPath, 'utf8');
+    const lineas = raw.trim().split(/\r?\n/);
+    // Tomar las últimas líneas y extraer texto de mensajes assistant
+    const ultimasLineas = lineas.slice(-30);
+    const textos = [];
+    for (const linea of ultimasLineas) {
+      try {
+        const evento = JSON.parse(linea);
+        const msg = evento.message || evento;
+        const role = msg.role || msg.type;
+        const content = msg.content;
+        if (role !== 'assistant' && role !== 'user') continue;
+        if (typeof content === 'string') {
+          textos.push(content);
+        } else if (Array.isArray(content)) {
+          for (const block of content) {
+            if (block && block.type === 'text' && block.text) {
+              textos.push(block.text);
+            }
+          }
+        }
+      } catch (_) { /* línea corrupta, ignorar */ }
+    }
+    const unido = textos.join('\n').trim();
+    if (unido.length <= maxChars) return unido;
+    return '…' + unido.slice(-maxChars);
+  } catch (_) {
+    return '';
+  }
+}
+
+/**
+ * Lista archivos modificados recientemente (últimos 10 min) en el cwd.
+ */
+function archivosRecientes(maxItems = 5) {
+  try {
+    const { execSync } = require('child_process');
+    const out = execSync('git status --porcelain', {
+      cwd: process.cwd(),
+      encoding: 'utf8',
+      timeout: 5000,
+    });
+    const lineas = out.trim().split(/\r?\n/).filter(l => l.trim());
+    return lineas.slice(0, maxItems).map(l => l.trim());
+  } catch (_) {
+    return [];
+  }
+}
+
+/**
+ * Formatea número con separador de miles.
+ */
+function fmt(n) {
+  try { return Number(n).toLocaleString('es-MX'); } catch (_) { return String(n); }
+}
+
+/**
+ * Construye el mensaje de notificación.
+ */
+function construirMensaje(estado, transcriptPath) {
+  const tool = estado?.toolCalls || 0;
+  const tokens = estado?.tokensTotal || 0;
+  const costo = estado?.costoTotal || 0;
+  const modelo = estado?.modeloPredominante || 'unknown';
+
+  const c = estado?.componentesSWL || {};
+  const agentes  = (c.agentes  || []).length;
+  const skills   = (c.skills   || []).length;
+  const comandos = (c.comandos || []).length;
+
+  const archivos = archivosRecientes(5);
+  const tramo = leerUltimoTramoTranscript(transcriptPath, MAX_TRANSCRIPT_CHARS);
+
+  const lineas = [];
+  lineas.push('✅ *Sesión SWL terminada*');
+  lineas.push(`Modelo: \`${modelo}\` | Llamadas: ${fmt(tool)} | Tokens: ~${fmt(tokens)} | Costo: ~$${Number(costo).toFixed(2)} USD`);
+
+  if (agentes + skills + comandos > 0) {
+    lineas.push(`SWL: ${agentes} agentes, ${skills} skills, ${comandos} comandos`);
+  }
+
+  if (archivos.length > 0) {
+    lineas.push('');
+    lineas.push('*Archivos modificados:*');
+    lineas.push('```');
+    for (const a of archivos) lineas.push(a);
+    lineas.push('```');
+  }
+
+  if (tramo) {
+    lineas.push('');
+    lineas.push('*Último tramo:*');
+    lineas.push('```');
+    lineas.push(tramo);
+    lineas.push('```');
+  }
+
+  return lineas.join('\n');
+}
+
+// ---------------------------------------------------------------------------
+// Entrypoint
+// ---------------------------------------------------------------------------
+
+let inputRaw = '';
+
+process.stdin.on('data', chunk => { inputRaw += chunk; });
+
+process.stdin.on('end', () => {
+  try {
+    if (process.env.SWL_NOTIFICAR_STOP === '0') return;
+    if (!gatewayHabilitado()) return;
+
+    const data = JSON.parse(inputRaw);
+    const sessionId = String(data.session_id || 'default');
+    const transcriptPath = data.transcript_path || null;
+
+    const estado = leerBridge(sessionId);
+    const toolCalls = estado?.toolCalls || 0;
+    if (toolCalls < UMBRAL_TOOL_CALLS) return;
+
+    const texto = construirMensaje(estado, transcriptPath);
+
+    notificarGateway({
+      tipo:   'session-stop',
+      titulo: 'Sesión SWL terminada',
+      texto,
+      to:     'all',
+      payload: {
+        sessionId,
+        toolCalls,
+        tokensTotal: estado?.tokensTotal || 0,
+        costoTotal:  estado?.costoTotal  || 0,
+        modelo:      estado?.modeloPredominante || 'unknown',
+      },
+    });
+  } catch (_) {
+    // Nunca bloquear
+  }
+});

package/hooks/notificacion-telegram-notification.js

@@ -0,0 +1,4 @@
+'use strict';
+// Stub para el evento Notification — delega al hook principal.
+// El handler unificado lee hook_event_name del stdin y enruta correctamente.
+require('./notificacion-telegram');

package/hooks/notificacion-telegram-subagent.js

@@ -0,0 +1,4 @@
+'use strict';
+// Stub para el evento SubagentStop — delega al hook principal.
+// El handler unificado lee hook_event_name del stdin y enruta correctamente.
+require('./notificacion-telegram');