@saulwade/swl-ses 1.0.0

package/hooks/lib/tech-skills-map.js

@@ -0,0 +1,146 @@
+'use strict';
+
+/**
+ * Tech Skills Map — Conecta tecnologías detectadas con skills SWL recomendados.
+ *
+ * Usa el resultado de detectarTecnologias() para generar una lista priorizada
+ * de skills que deberian cargarse automaticamente al inicio de sesion.
+ *
+ * Integración:
+ *   - inyeccion-contexto.js puede usar sugerirSkills() para recomendar skills
+ *   - agent-matcher.js puede usar obtenerAgentesPorStack() para routing
+ *   - orquestador-swl puede consultar al asignar agentes a tareas
+ *
+ * @module hooks/lib/tech-skills-map
+ */
+
+const { detectarTecnologias } = require('./detectar-package-manager');
+
+// ---------------------------------------------------------------------------
+// API pública
+// ---------------------------------------------------------------------------
+
+/**
+ * Genera lista de skills recomendados basandose en las tecnologias detectadas.
+ * Los skills se deduplican y se ordenan por frecuencia (mas tecnologias lo referencian = mas arriba).
+ *
+ * @param {string} dir - Directorio raiz del proyecto.
+ * @returns {{ skills: Array<{name: string, sources: string[], priority: number}>, agentes: Array<{name: string, source: string}>, combos: Array<{id: string, skills: string[], pipeline: string}> }}
+ */
+function sugerirSkills(dir) {
+  const { tecnologias, combos } = detectarTecnologias(dir);
+
+  // Agrupar skills con sus fuentes
+  const skillMap = new Map(); // skillName → { sources: Set, priority: number }
+
+  for (const tech of tecnologias) {
+    for (const skill of tech.skills) {
+      if (!skillMap.has(skill)) {
+        skillMap.set(skill, { sources: new Set(), priority: 0 });
+      }
+      const entry = skillMap.get(skill);
+      entry.sources.add(tech.name);
+      entry.priority++;
+    }
+  }
+
+  // Agregar skills de combos con prioridad bonus
+  for (const combo of combos) {
+    for (const skill of combo.skills) {
+      if (!skillMap.has(skill)) {
+        skillMap.set(skill, { sources: new Set(), priority: 0 });
+      }
+      const entry = skillMap.get(skill);
+      entry.sources.add(`combo:${combo.id}`);
+      entry.priority += 2; // bonus por ser combo
+    }
+  }
+
+  // Convertir a array y ordenar por prioridad descendente
+  const skills = Array.from(skillMap.entries())
+    .map(([name, { sources, priority }]) => ({
+      name,
+      sources: Array.from(sources),
+      priority,
+    }))
+    .sort((a, b) => b.priority - a.priority);
+
+  // Agentes recomendados (deduplicados)
+  const agenteSet = new Map();
+  for (const tech of tecnologias) {
+    if (tech.agente && !agenteSet.has(tech.agente)) {
+      agenteSet.set(tech.agente, tech.name);
+    }
+  }
+  const agentes = Array.from(agenteSet.entries())
+    .map(([name, source]) => ({ name, source }));
+
+  return { skills, agentes, combos };
+}
+
+/**
+ * Obtiene los agentes recomendados para el stack del proyecto.
+ *
+ * @param {string} dir
+ * @returns {Array<{agente: string, tecnologia: string, skills: string[]}>}
+ */
+function obtenerAgentesPorStack(dir) {
+  const { tecnologias } = detectarTecnologias(dir);
+  const agenteMap = new Map(); // agenteName → { tecnologias: [], skills: Set }
+
+  for (const tech of tecnologias) {
+    if (!tech.agente) continue;
+    if (!agenteMap.has(tech.agente)) {
+      agenteMap.set(tech.agente, { tecnologias: [], skills: new Set() });
+    }
+    const entry = agenteMap.get(tech.agente);
+    entry.tecnologias.push(tech.name);
+    tech.skills.forEach(s => entry.skills.add(s));
+  }
+
+  return Array.from(agenteMap.entries())
+    .map(([agente, { tecnologias: techs, skills }]) => ({
+      agente,
+      tecnologia: techs.join(', '),
+      skills: Array.from(skills),
+    }));
+}
+
+/**
+ * Genera un resumen compacto del stack para inyectar en contexto.
+ * Formato: una linea por tecnologia con skills recomendados.
+ *
+ * @param {string} dir
+ * @returns {string} Resumen en texto plano, vacio si no detecta nada.
+ */
+function generarResumenStack(dir) {
+  const { skills, agentes, combos } = sugerirSkills(dir);
+  if (skills.length === 0) return '';
+
+  const lines = ['## Stack detectado'];
+
+  if (agentes.length > 0) {
+    lines.push('Agentes recomendados: ' + agentes.map(a => a.name).join(', '));
+  }
+
+  if (skills.length > 0) {
+    const top = skills.slice(0, 10).map(s => s.name);
+    lines.push('Skills sugeridos: ' + top.join(', '));
+  }
+
+  if (combos.length > 0) {
+    lines.push('Combos: ' + combos.map(c => c.id + ' (' + c.pipeline + ')').join(', '));
+  }
+
+  return lines.join('\n');
+}
+
+// ---------------------------------------------------------------------------
+// Exports
+// ---------------------------------------------------------------------------
+
+module.exports = {
+  sugerirSkills,
+  obtenerAgentesPorStack,
+  generarResumenStack,
+};

package/hooks/lib/telegram-cliente.js

@@ -0,0 +1,159 @@
+'use strict';
+
+/**
+ * Cliente HTTP Telegram — zero-deps.
+ *
+ * Provee `enviarMensaje(token, chatId, texto, opts)` con:
+ *   - Escape HTML automático
+ *   - Truncado a 3500 chars con sufijo "… [truncado]"
+ *   - Reintentos con backoff exponencial (100/200/400ms) para respuestas 5xx
+ *   - Sin reintento para respuestas 4xx
+ *   - Timeout de 8 segundos
+ *
+ * Dependencias: solo módulos node: (https, fs, path, os).
+ *
+ * @module hooks/lib/telegram-cliente
+ */
+
+const https = require('node:https');
+
+// Límite de Telegram es 4096 chars; usamos 3500 para dar margen al wrapper HTML.
+const LIMITE_CHARS = 3500;
+const SUFIJO_TRUNCADO = '\n… [truncado]';
+const TIMEOUT_MS = 8000;
+const REINTENTOS_MAX = 3;
+const BACKOFF_BASE_MS = 100;
+
+/**
+ * Escapa caracteres HTML especiales para parse_mode HTML de Telegram.
+ *
+ * @param {string} texto - Texto a escapar.
+ * @returns {string} Texto con &, < y > escapados.
+ */
+function escaparHtml(texto) {
+  return String(texto)
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;');
+}
+
+/**
+ * Trunca el texto si supera el límite, agregando el sufijo de truncado.
+ *
+ * @param {string} texto - Texto a truncar.
+ * @param {number} limite - Límite máximo de caracteres.
+ * @returns {string} Texto truncado o el original si cabe.
+ */
+function truncar(texto, limite) {
+  const s = String(texto);
+  if (s.length <= limite) return s;
+  const corte = limite - SUFIJO_TRUNCADO.length;
+  return s.slice(0, corte).trimEnd() + SUFIJO_TRUNCADO;
+}
+
+/**
+ * Realiza un intento de envío HTTP hacia la API de Telegram.
+ *
+ * @param {string} token   - Token del bot de Telegram.
+ * @param {string} chatId  - ID del chat destinatario.
+ * @param {string} texto   - Texto del mensaje (ya preparado para enviar).
+ * @param {object} opts    - Opciones adicionales del mensaje.
+ * @returns {Promise<{ok: boolean, statusCode: number, cuerpo: string}>}
+ */
+function _intentarEnvio(token, chatId, texto, opts) {
+  const payload = JSON.stringify({
+    chat_id: chatId,
+    text: texto,
+    parse_mode: 'HTML',
+    disable_web_page_preview: true,
+    ...opts,
+  });
+
+  return new Promise((resolve) => {
+    const req = https.request(
+      {
+        method: 'POST',
+        hostname: 'api.telegram.org',
+        path: `/bot${token}/sendMessage`,
+        headers: {
+          'Content-Type': 'application/json',
+          'Content-Length': Buffer.byteLength(payload),
+        },
+        timeout: TIMEOUT_MS,
+      },
+      (res) => {
+        let cuerpo = '';
+        res.on('data', (chunk) => { cuerpo += chunk; });
+        res.on('end', () => {
+          resolve({ ok: res.statusCode >= 200 && res.statusCode < 300, statusCode: res.statusCode, cuerpo });
+        });
+      }
+    );
+
+    req.on('timeout', () => {
+      req.destroy();
+      resolve({ ok: false, statusCode: 0, cuerpo: 'timeout' });
+    });
+
+    req.on('error', (err) => {
+      resolve({ ok: false, statusCode: 0, cuerpo: err.message });
+    });
+
+    req.write(payload);
+    req.end();
+  });
+}
+
+/**
+ * Pausa durante `ms` milisegundos.
+ *
+ * @param {number} ms - Milisegundos a esperar.
+ * @returns {Promise<void>}
+ */
+function _esperar(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/**
+ * Envía un mensaje de Telegram con escape HTML, truncado y reintentos.
+ *
+ * Solo reintenta en errores 5xx (falla de servidor). Los errores 4xx
+ * (credenciales inválidas, chat no encontrado) no se reintentan porque
+ * volver a intentar no resolvería el problema.
+ *
+ * @param {string} token   - Token del bot (`123:ABC...`).
+ * @param {string} chatId  - ID numérico del chat destino.
+ * @param {string} texto   - Texto del mensaje. Se escapa y trunca automáticamente.
+ * @param {object} [opts]  - Campos adicionales para el body de sendMessage.
+ * @returns {Promise<{ok: boolean, statusCode: number, error?: string}>}
+ */
+async function enviarMensaje(token, chatId, texto, opts = {}) {
+  const textoPrepado = truncar(escaparHtml(texto), LIMITE_CHARS);
+
+  for (let intento = 0; intento < REINTENTOS_MAX; intento++) {
+    const resultado = await _intentarEnvio(token, chatId, textoPrepado, opts);
+
+    if (resultado.cuerpo === 'timeout') {
+      return { ok: false, statusCode: 0, error: 'timeout' };
+    }
+
+    if (resultado.ok) {
+      return { ok: true, statusCode: resultado.statusCode };
+    }
+
+    // Errores 4xx: no reintentar (credenciales inválidas, chat inexistente, etc.)
+    if (resultado.statusCode >= 400 && resultado.statusCode < 500) {
+      const etiqueta = resultado.statusCode === 401 ? 'unauthorized' : `http-${resultado.statusCode}`;
+      return { ok: false, statusCode: resultado.statusCode, error: etiqueta };
+    }
+
+    // Error de red (statusCode 0) o 5xx: reintento con backoff exponencial
+    if (intento < REINTENTOS_MAX - 1) {
+      await _esperar(BACKOFF_BASE_MS * Math.pow(2, intento));
+    }
+  }
+
+  return { ok: false, statusCode: 0, error: 'max-retries-exceeded' };
+}
+
+module.exports = { enviarMensaje, escaparHtml, truncar };

package/hooks/lib/telegram-config.js

@@ -0,0 +1,170 @@
+'use strict';
+
+/**
+ * Configuración de notificaciones Telegram — zero-deps.
+ *
+ * Lee credenciales desde `~/.claude/notifications/.env`, valida campos
+ * requeridos y gestiona la lista de proyectos silenciados (`muted.json`).
+ *
+ * Convenciones del parser .env:
+ *   - Líneas que comienzan con # son comentarios y se ignoran.
+ *   - El separador es el PRIMER `=` de la línea; el valor puede contener `=`.
+ *   - Las comillas simples y dobles se eliminan solo si envuelven el valor completo.
+ *   - Los espacios alrededor de nombre y valor se recortan.
+ *
+ * @module hooks/lib/telegram-config
+ */
+
+const fs   = require('node:fs');
+const path = require('node:path');
+const os   = require('node:os');
+
+const { atomicWriteJSON } = require('./atomic-write');
+
+// Directorio donde viven las credenciales y estado
+const DIR_NOTIFICACIONES = path.join(os.homedir(), '.claude', 'notifications');
+const RUTA_ENV           = path.join(DIR_NOTIFICACIONES, '.env');
+const RUTA_MUTED         = path.join(DIR_NOTIFICACIONES, 'muted.json');
+
+// Campos que deben estar presentes para que las notificaciones funcionen
+const CAMPOS_REQUERIDOS = ['TELEGRAM_BOT_TOKEN', 'TELEGRAM_CHAT_ID'];
+
+/**
+ * Parsea el contenido de un archivo .env.
+ *
+ * Respeta el primer `=` como separador, de modo que valores como
+ * `TOKEN=abc=def` producen `{ TOKEN: "abc=def" }`.
+ *
+ * @param {string} contenido - Texto completo del archivo .env.
+ * @returns {Record<string, string>} Mapa de variables.
+ */
+function _parsearEnv(contenido) {
+  const resultado = {};
+
+  for (const linea of contenido.split(/\r?\n/)) {
+    const recortada = linea.trim();
+
+    // Ignorar líneas vacías y comentarios
+    if (!recortada || recortada.startsWith('#')) continue;
+
+    // El nombre es todo hasta el primer `=`
+    const posIgual = recortada.indexOf('=');
+    if (posIgual === -1) continue;
+
+    const nombre = recortada.slice(0, posIgual).trim();
+    let valor    = recortada.slice(posIgual + 1).trim();
+
+    // Eliminar comillas envolventes (simples o dobles)
+    if (
+      (valor.startsWith('"') && valor.endsWith('"')) ||
+      (valor.startsWith("'") && valor.endsWith("'"))
+    ) {
+      valor = valor.slice(1, -1);
+    }
+
+    // Solo guardar si el nombre es un identificador de variable válido
+    if (/^[A-Z_][A-Z0-9_]*$/.test(nombre)) {
+      resultado[nombre] = valor;
+    }
+  }
+
+  return resultado;
+}
+
+/**
+ * Carga la configuración de notificaciones desde `~/.claude/notifications/.env`.
+ *
+ * Las variables del proceso (`process.env`) tienen precedencia sobre el archivo
+ * para permitir inyección en entornos CI o de prueba.
+ *
+ * @returns {{ config: Record<string, string>, valido: boolean, errores: string[] }}
+ */
+function cargarConfig() {
+  let configArchivo = {};
+
+  if (fs.existsSync(RUTA_ENV)) {
+    try {
+      const contenido = fs.readFileSync(RUTA_ENV, 'utf8');
+      configArchivo = _parsearEnv(contenido);
+    } catch (_) {
+      // Si el archivo no se puede leer, continuar con vacío
+    }
+  }
+
+  // Las variables de entorno del proceso tienen precedencia
+  const config = { ...configArchivo };
+  for (const campo of CAMPOS_REQUERIDOS) {
+    if (process.env[campo]) config[campo] = process.env[campo];
+  }
+
+  const errores = CAMPOS_REQUERIDOS.filter((c) => !config[c] || !config[c].trim());
+  return { config, valido: errores.length === 0, errores };
+}
+
+/**
+ * Lee la lista actual de proyectos silenciados.
+ *
+ * @returns {string[]} Lista de nombres de proyecto silenciados.
+ */
+function _leerMuted() {
+  try {
+    if (!fs.existsSync(RUTA_MUTED)) return [];
+    const contenido = fs.readFileSync(RUTA_MUTED, 'utf8');
+    const datos = JSON.parse(contenido);
+    return Array.isArray(datos) ? datos : [];
+  } catch (_) {
+    return [];
+  }
+}
+
+/**
+ * Agrega un proyecto a la lista de silenciados.
+ *
+ * Idempotente: si el proyecto ya estaba silenciado, no lo duplica.
+ *
+ * @param {string} proyecto - Nombre del proyecto a silenciar.
+ */
+function agregarMute(proyecto) {
+  const actuales = _leerMuted();
+  if (!actuales.includes(proyecto)) {
+    actuales.push(proyecto);
+    atomicWriteJSON(RUTA_MUTED, actuales);
+  }
+}
+
+/**
+ * Elimina un proyecto de la lista de silenciados.
+ *
+ * Idempotente: si el proyecto no estaba silenciado, no hace nada.
+ *
+ * @param {string} proyecto - Nombre del proyecto a des-silenciar.
+ */
+function eliminarMute(proyecto) {
+  const actuales = _leerMuted();
+  const nuevos   = actuales.filter((p) => p !== proyecto);
+  // Solo escribir si cambió algo
+  if (nuevos.length !== actuales.length) {
+    atomicWriteJSON(RUTA_MUTED, nuevos);
+  }
+}
+
+/**
+ * Verifica si un proyecto está actualmente silenciado.
+ *
+ * @param {string} proyecto - Nombre del proyecto a verificar.
+ * @returns {boolean} `true` si el proyecto está en la lista de silenciados.
+ */
+function estaMuted(proyecto) {
+  return _leerMuted().includes(proyecto);
+}
+
+module.exports = {
+  cargarConfig,
+  agregarMute,
+  eliminarMute,
+  estaMuted,
+  // Exportar rutas para facilitar pruebas
+  RUTA_ENV,
+  RUTA_MUTED,
+  DIR_NOTIFICACIONES,
+};

package/hooks/lib/token-budget.js

@@ -0,0 +1,156 @@
+/**
+ * token-budget.js — Calculador de presupuesto de tokens para inyección de contexto
+ *
+ * Estima tokens y distribuye un presupuesto limitado entre bloques de contexto
+ * priorizados por recencia e importancia. Inspirado en el sistema de token
+ * budget de agentmemory.
+ * Zero dependencias externas — aritmética pura de Node.js.
+ *
+ * Uso:
+ *   const { estimateTokens, allocateBudget } = require('./token-budget');
+ *   const tokens = estimateTokens('texto de ejemplo');
+ *   const bloques = allocateBudget(candidatos, 2000);
+ */
+
+'use strict';
+
+/**
+ * Estima el número de tokens en un texto.
+ * Heurística: ~4 caracteres por token en inglés/español, ~3 para código.
+ * No es exacta pero es suficiente para presupuestación sin dependencias externas.
+ *
+ * @param {string} text - Texto a estimar
+ * @param {'prose'|'code'|'mixed'} [type='mixed'] - Tipo de contenido
+ * @returns {number} Estimación de tokens
+ */
+function estimateTokens(text, type) {
+  if (!text || typeof text !== 'string') return 0;
+
+  const len = text.length;
+  switch (type) {
+    case 'prose': return Math.ceil(len / 4.2);
+    case 'code':  return Math.ceil(len / 3.0);
+    case 'mixed':
+    default:      return Math.ceil(len / 3.5);
+  }
+}
+
+/**
+ * Bloque de contexto candidato para inyección.
+ * @typedef {Object} ContextBlock
+ * @property {string} type - Tipo: 'summary'|'observation'|'memory'|'rule'|'skill'
+ * @property {string} content - Contenido del bloque
+ * @property {number} [tokens] - Tokens pre-calculados (se estima si no se da)
+ * @property {number} [recency] - Timestamp Unix de última relevancia (más reciente = mayor prioridad)
+ * @property {number} [importance] - Importancia 0.0-1.0 (default 0.5)
+ */
+
+/**
+ * Calcula el score de prioridad de un bloque.
+ * Combina recencia (60%) e importancia (40%) para ordenar candidatos.
+ *
+ * @param {ContextBlock} block - Bloque a evaluar
+ * @param {number} now - Timestamp actual en ms
+ * @returns {number} Score normalizado 0.0-1.0
+ */
+function scoreBlock(block, now) {
+  const importance = typeof block.importance === 'number'
+    ? Math.max(0, Math.min(1, block.importance))
+    : 0.5;
+
+  let recencyScore = 0.5;
+  if (typeof block.recency === 'number' && block.recency > 0) {
+    const ageMs = now - block.recency;
+    const ageHours = ageMs / (1000 * 60 * 60);
+    // Decaimiento exponencial: pierde 50% de recencia cada 24 horas
+    recencyScore = Math.exp(-0.693 * ageHours / 24);
+  }
+
+  return recencyScore * 0.6 + importance * 0.4;
+}
+
+/**
+ * Distribuye un presupuesto de tokens entre bloques candidatos.
+ * Prioriza por score (recencia + importancia). Incluye bloques completos
+ * hasta agotar el presupuesto — no corta bloques a la mitad.
+ *
+ * @param {ContextBlock[]} candidates - Bloques candidatos
+ * @param {number} budget - Presupuesto total de tokens
+ * @param {Object} [options] - Opciones de configuración
+ * @param {number} [options.reserveTokens=200] - Tokens reservados para overhead del prompt
+ * @param {number} [options.maxBlocks=20] - Máximo de bloques a incluir
+ * @returns {{ selected: ContextBlock[], totalTokens: number, rejected: number }}
+ */
+function allocateBudget(candidates, budget, options) {
+  const opts = options || {};
+  const reserve = typeof opts.reserveTokens === 'number' ? opts.reserveTokens : 200;
+  const maxBlocks = typeof opts.maxBlocks === 'number' ? opts.maxBlocks : 20;
+  const effectiveBudget = Math.max(0, budget - reserve);
+  const now = Date.now();
+
+  if (!Array.isArray(candidates) || candidates.length === 0) {
+    return { selected: [], totalTokens: 0, rejected: 0 };
+  }
+
+  // Estimar tokens si no están pre-calculados
+  const scored = candidates.map(block => {
+    const tokens = typeof block.tokens === 'number'
+      ? block.tokens
+      : estimateTokens(block.content);
+    return {
+      ...block,
+      tokens,
+      _score: scoreBlock(block, now)
+    };
+  });
+
+  // Ordenar por score descendente
+  scored.sort((a, b) => b._score - a._score);
+
+  const selected = [];
+  let totalTokens = 0;
+
+  for (const block of scored) {
+    if (selected.length >= maxBlocks) break;
+    if (totalTokens + block.tokens > effectiveBudget) continue;
+
+    selected.push({
+      type: block.type,
+      content: block.content,
+      tokens: block.tokens,
+      recency: block.recency,
+      importance: block.importance
+    });
+    totalTokens += block.tokens;
+  }
+
+  return {
+    selected,
+    totalTokens,
+    rejected: candidates.length - selected.length
+  };
+}
+
+/**
+ * Calcula estadísticas de uso de tokens para un conjunto de contenidos.
+ * Útil para reportes de eficiencia y diagnóstico.
+ *
+ * @param {Object.<string, string>} namedContents - Mapa nombre→contenido
+ * @returns {Object.<string, number>} Mapa nombre→tokens estimados
+ */
+function tokenBreakdown(namedContents) {
+  const result = {};
+  if (!namedContents || typeof namedContents !== 'object') return result;
+
+  for (const [name, content] of Object.entries(namedContents)) {
+    result[name] = estimateTokens(content);
+  }
+  return result;
+}
+
+module.exports = {
+  estimateTokens,
+  scoreBlock,
+  allocateBudget,
+  tokenBreakdown
+};