@saulwade/swl-ses 1.0.0

package/hooks/linea-estado.js

@@ -0,0 +1,324 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Hook: linea-estado.js
+ * Tipo: PostToolUse
+ *
+ * Muestra una línea de estado compacta con:
+ *   - Modelo activo
+ *   - Tarea actual (derivada del tool_name y parámetros)
+ *   - Directorio de trabajo abreviado
+ *   - Barra de progreso de contexto estimado
+ *
+ * Además escribe un archivo bridge en /tmp/swl-ctx-{session}.json
+ * para que otros hooks (monitor-contexto, etc.) lean el estado.
+ *
+ * Integración con Claude Code hooks:
+ *   El hook no bloquea (exit 0 siempre).
+ *   Los mensajes informativos se escriben en stderr para que
+ *   Claude Code los muestre en la barra de estado o los ignore;
+ *   sin interferir con el flujo JSON en stdout.
+ */
+
+const fs   = require('fs');
+const path = require('path');
+const os   = require('os');
+
+// ---------------------------------------------------------------------------
+// Constantes de configuración
+// ---------------------------------------------------------------------------
+
+/** Ancho de la barra de progreso del contexto (en caracteres de bloque). */
+const BARRA_ANCHO = 10;
+
+/**
+ * Techo por defecto cuando no se detecta el modelo.
+ * Mantiene la heurística histórica para compatibilidad.
+ */
+const TOKENS_MAXIMOS_DEFAULT = 200_000;
+
+/**
+ * Techos de contexto por modelo (en tokens).
+ *
+ * IMPORTANTE: las claves son prefijos del `model_id` reportado por Claude Code
+ * en el evento del hook. La detección hace `modelId.includes(prefijo)` en orden;
+ * los prefijos más específicos van primero para que `claude-opus-4-7` no
+ * matchee accidentalmente con la entrada genérica `claude-opus`.
+ *
+ * Si el `model_id` contiene el sufijo `[1m]` (ej: `claude-opus-4-7[1m]`), el
+ * techo se fuerza a 1M independientemente del modelo base — Anthropic usa
+ * ese sufijo para indicar la variante de 1M context.
+ */
+const TECHOS_POR_MODELO = {
+  // Opus 4.7 — variante de 1M context (la actual por defecto)
+  'claude-opus-4-7':  1_000_000,
+  // Resto de modelos modernos: 200k context
+  'claude-opus-4-6':    200_000,
+  'claude-opus-4-5':    200_000,
+  'claude-sonnet-4-6':  200_000,
+  'claude-sonnet-4-5':  200_000,
+  'claude-haiku-4-5':   200_000,
+  // Catch-all genéricos (orden: deben ir DESPUÉS de los específicos)
+  'claude-opus':        200_000,
+  'claude-sonnet':      200_000,
+  'claude-haiku':       200_000,
+};
+
+/**
+ * Modelos conocidos y su etiqueta corta para la barra.
+ * Clave: prefijo del model_id. Valor: etiqueta legible.
+ */
+const ETIQUETAS_MODELO = {
+  'claude-opus':   'opus',
+  'claude-sonnet': 'sonnet',
+  'claude-haiku':  'haiku',
+};
+
+/**
+ * Determina el techo de tokens del contexto según el modelo activo.
+ *
+ * Reglas (en orden):
+ *   1. Si el `modelId` contiene `[1m]` → 1_000_000 (variante explícita 1M).
+ *   2. Si el `modelId` matchea un prefijo de TECHOS_POR_MODELO → ese techo.
+ *   3. Default → TOKENS_MAXIMOS_DEFAULT (200k).
+ *
+ * @param {string} modelId - Identificador completo del modelo, posiblemente
+ *                           con sufijo de variante (ej: `claude-opus-4-7[1m]`).
+ * @returns {number} Techo de tokens del contexto.
+ */
+function techoTokens(modelId) {
+  if (!modelId) return TOKENS_MAXIMOS_DEFAULT;
+  const id = String(modelId);
+  if (id.includes('[1m]') || id.includes('-1m')) return 1_000_000;
+  for (const [prefijo, techo] of Object.entries(TECHOS_POR_MODELO)) {
+    if (id.includes(prefijo)) return techo;
+  }
+  return TOKENS_MAXIMOS_DEFAULT;
+}
+
+// ---------------------------------------------------------------------------
+// Utilidades
+// ---------------------------------------------------------------------------
+
+/**
+ * Construye la etiqueta corta del modelo activo.
+ * @param {string} modelId - Identificador completo del modelo.
+ * @returns {string}
+ */
+function etiquetaModelo(modelId) {
+  if (!modelId) return 'modelo?';
+  for (const [prefijo, etiqueta] of Object.entries(ETIQUETAS_MODELO)) {
+    if (modelId.includes(prefijo)) return etiqueta;
+  }
+  // Fallback: primeros 12 caracteres del modelo
+  return String(modelId).slice(0, 12);
+}
+
+/**
+ * Determina la tarea actual a partir del nombre de la herramienta
+ * y sus parámetros de entrada.
+ * @param {string} toolName - Nombre de la tool que acaba de ejecutarse.
+ * @param {object} toolInput - Parámetros de entrada de la tool.
+ * @returns {string}
+ */
+function tareaActual(toolName, toolInput) {
+  if (!toolName) return 'idle';
+
+  const nombre = String(toolName).toLowerCase();
+
+  switch (nombre) {
+    case 'write':
+    case 'edit': {
+      const filePath = toolInput?.file_path || toolInput?.path || '';
+      const base = path.basename(String(filePath));
+      return `editando ${base || 'archivo'}`;
+    }
+    case 'read': {
+      const filePath = toolInput?.file_path || toolInput?.path || '';
+      const base = path.basename(String(filePath));
+      return `leyendo ${base || 'archivo'}`;
+    }
+    case 'bash': {
+      // Mostrar primeros 28 chars del comando, sin saltos de línea
+      const cmd = String(toolInput?.command || '').replace(/\s+/g, ' ').slice(0, 28);
+      return `bash: ${cmd || '...'}`;
+    }
+    case 'grep': {
+      const patron = String(toolInput?.pattern || '').slice(0, 20);
+      return `grep: ${patron || '...'}`;
+    }
+    case 'glob': {
+      const patron = String(toolInput?.pattern || '').slice(0, 20);
+      return `glob: ${patron || '...'}`;
+    }
+    case 'task':
+    case 'agent':
+      return `agente: ${String(toolInput?.description || '').slice(0, 25) || '...'}`;
+    default:
+      return nombre.slice(0, 30);
+  }
+}
+
+/**
+ * Abrevia una ruta de directorio para mostrar en la barra de estado.
+ * Muestra sólo los últimos N segmentos.
+ * @param {string} dirPath - Ruta completa.
+ * @param {number} maxSegmentos - Número máximo de segmentos a mostrar.
+ * @returns {string}
+ */
+function abreviarDirectorio(dirPath, maxSegmentos = 2) {
+  if (!dirPath) return '.';
+  // Normalizar separadores en Windows
+  const normalizado = String(dirPath).replace(/\\/g, '/');
+  const partes = normalizado.split('/').filter(Boolean);
+  if (partes.length <= maxSegmentos) return normalizado;
+  return '…/' + partes.slice(-maxSegmentos).join('/');
+}
+
+/**
+ * Construye la barra de progreso visual.
+ * @param {number} porcentaje - Valor entre 0 y 100.
+ * @returns {string} Ej: "████████░░ 80%"
+ */
+function barraProgreso(porcentaje) {
+  const pct = Math.max(0, Math.min(100, porcentaje));
+  const llenos = Math.round((pct / 100) * BARRA_ANCHO);
+  const vacios = BARRA_ANCHO - llenos;
+  const barra = '█'.repeat(llenos) + '░'.repeat(vacios);
+  return `${barra} ${pct}%`;
+}
+
+/**
+ * Estima el porcentaje de contexto utilizado.
+ * Claude Code no expone directamente los tokens consumidos en el hook,
+ * por lo que usamos una heurística basada en el número de invocaciones
+ * de herramientas acumuladas en la sesión cuando el campo `usage` no está.
+ *
+ * La función lee el archivo bridge previo para mantener el contador,
+ * y lo incrementa en cada invocación.
+ *
+ * @param {string} bridgePath - Ruta del archivo bridge.
+ * @param {number} tokensReportados - Tokens reportados por Claude (si existen).
+ * @param {number} techo - Techo de tokens del modelo activo.
+ * @returns {{ porcentaje: number, invocaciones: number, techo: number }}
+ */
+function estimarContexto(bridgePath, tokensReportados, techo) {
+  const techoEfectivo = (typeof techo === 'number' && techo > 0)
+    ? techo
+    : TOKENS_MAXIMOS_DEFAULT;
+  let invocaciones = 1;
+
+  // Leer estado previo del bridge
+  try {
+    const previo = JSON.parse(fs.readFileSync(bridgePath, 'utf8'));
+    invocaciones = (previo.invocaciones || 0) + 1;
+  } catch (_) {
+    // Archivo no existe aún — primera invocación
+  }
+
+  // Si Claude reporta tokens usados (campo no-estándar, puede no existir)
+  if (typeof tokensReportados === 'number' && tokensReportados > 0) {
+    const pct = Math.min(100, Math.round((tokensReportados / techoEfectivo) * 100));
+    return { porcentaje: pct, invocaciones, techo: techoEfectivo };
+  }
+
+  // Heurística: cada invocación consume ~500 tokens promedio (conversación + tool)
+  const tokenesEstimados = invocaciones * 500;
+  const pct = Math.min(99, Math.round((tokenesEstimados / techoEfectivo) * 100));
+  return { porcentaje: pct, invocaciones, techo: techoEfectivo };
+}
+
+// ---------------------------------------------------------------------------
+// Entrypoint principal
+// ---------------------------------------------------------------------------
+
+// Solo conectar stdin cuando se ejecuta como script (hook),
+// no cuando se carga vía require() desde tests u otros módulos.
+if (require.main === module) iniciarHook();
+
+function iniciarHook() {
+let inputRaw = '';
+
+process.stdin.on('data', chunk => {
+  inputRaw += chunk;
+});
+
+process.stdin.on('end', () => {
+  try {
+    const data = JSON.parse(inputRaw);
+
+    // Extraer campos del evento de hook de Claude Code
+    // Estructura documentada de PostToolUse:
+    //   data.session_id, data.model, data.tool_name, data.tool_input,
+    //   data.tool_result, data.usage (si existe)
+    const sessionId    = String(data.session_id || 'default');
+    const modelId      = String(data.model || '');
+    const toolName     = String(data.tool_name || '');
+    const toolInput    = data.tool_input || {};
+    const tokensUsados = data.usage?.input_tokens ?? data.usage?.total_tokens ?? 0;
+
+    // Ruta del archivo bridge compartido entre hooks
+    const bridgePath = path.join(os.tmpdir(), `swl-ctx-${sessionId}.json`);
+
+    // Resolver techo según modelo (Opus 4.7 con sufijo [1m] = 1M; resto 200k)
+    const techo = techoTokens(modelId);
+
+    // Calcular métricas
+    const { porcentaje, invocaciones } = estimarContexto(bridgePath, tokensUsados, techo);
+    const modeloLabel  = etiquetaModelo(modelId);
+    const tarea        = tareaActual(toolName, toolInput);
+    const directorio   = abreviarDirectorio(process.cwd());
+    const barra        = barraProgreso(porcentaje);
+
+    // Construir payload del bridge para otros hooks
+    const bridgePayload = {
+      sessionId,
+      modelId,
+      modeloLabel,
+      tarea,
+      directorio,
+      porcentaje,
+      invocaciones,
+      tokensUsados,
+      techoTokens: techo,
+      timestamp: new Date().toISOString(),
+    };
+
+    // Escribir bridge (ignorar error si /tmp no existe en este entorno)
+    try {
+      fs.writeFileSync(bridgePath, JSON.stringify(bridgePayload, null, 2), 'utf8');
+    } catch (errBridge) {
+      // No bloquear el flujo si no se puede escribir el bridge
+      // No se pudo escribir bridge — ignorar
+    }
+
+    // Construir la línea de estado como JSON válido para Claude Code
+    const lineaEstado = `${modeloLabel} | ${tarea} | ${directorio} | ctx: ${barra}`;
+
+    // PostToolUse hooks: no escribir nada a stdout para permitir
+    // que Claude Code procese la respuesta sin interferencia.
+
+  } catch (err) {
+    // Si el hook falla por cualquier razón, nunca bloquear a Claude
+    // No escribir a stderr — Claude Code lo reporta como hook error
+  }
+});
+}
+
+if (require.main !== module) {
+  module.exports = {
+    techoTokens,
+    estimarContexto,
+    etiquetaModelo,
+    tareaActual,
+    abreviarDirectorio,
+    barraProgreso,
+    _internals: {
+      TECHOS_POR_MODELO,
+      TOKENS_MAXIMOS_DEFAULT,
+      ETIQUETAS_MODELO,
+      BARRA_ANCHO,
+    },
+  };
+}

package/hooks/metricas-evolucion.js

@@ -0,0 +1,209 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Hook: metricas-evolucion.js
+ * Tipo: Stop (async: true — fire-and-forget)
+ *
+ * Cada sesión consolida métricas del ciclo de evolución y actualiza
+ * .planning/evolucion/metricas.json con:
+ *   - nudges emitidos / accionados / pendientes (14d)
+ *   - tasa de acción por tipo de nudge
+ *   - instintos populados vs capacidad
+ *   - evoluciones aplicadas (del log de /swl:evolucionar)
+ *   - fallos vs éxitos de agentes en 14d
+ *   - alertas persistentes activas
+ *
+ * Además dispara escalarSiAplica() del nudge-tracker.
+ *
+ * El hook nunca bloquea (siempre exit 0). Zero-deps.
+ */
+
+const fs   = require('fs');
+const path = require('path');
+
+let atomicWriteJSON;
+try {
+  ({ atomicWriteJSON } = require('./lib/atomic-write'));
+} catch {
+  atomicWriteJSON = (p, obj) => fs.writeFileSync(p, JSON.stringify(obj, null, 2), 'utf8');
+}
+
+let nudgeTracker;
+try {
+  nudgeTracker = require('./lib/nudge-tracker');
+} catch {
+  nudgeTracker = null;
+}
+
+const CWD = process.cwd();
+const DIR_EVOL = path.join(CWD, '.planning', 'evolucion');
+const METRICAS_PATH = path.join(DIR_EVOL, 'metricas.json');
+const INSTINTOS_PROYECTO = path.join(CWD, 'instintos', 'proyecto.yaml');
+const INSTINTOS_GLOBAL = path.join(CWD, 'instintos', 'global.yaml');
+const INSTINTOS_PERFIL = path.join(CWD, 'instintos', 'perfil-usuario.yaml');
+const AGENTES_LOG = path.join(CWD, '.planning', 'auto-evolucion', 'agentes.jsonl');
+const APRENDIZAJES = path.join(CWD, '.planning', 'APRENDIZAJES.md');
+const EVOLUCIONES_LOG = path.join(DIR_EVOL, 'evoluciones.jsonl');
+
+// ---------------------------------------------------------------------------
+// Utilidades
+// ---------------------------------------------------------------------------
+
+function ensureDir() {
+  try { fs.mkdirSync(DIR_EVOL, { recursive: true }); } catch { /* ignore */ }
+}
+
+function contarInstintos(archivo) {
+  try {
+    const c = fs.readFileSync(archivo, 'utf8');
+    const m = c.match(/^total_instintos:\s*(\d+)/m);
+    if (m) return parseInt(m[1], 10);
+    // Fallback: contar entries `- id:`
+    const entries = c.match(/^\s*- id:\s*\S+/gm);
+    return entries ? entries.length : 0;
+  } catch {
+    return 0;
+  }
+}
+
+function contarAprendizajes() {
+  try {
+    const c = fs.readFileSync(APRENDIZAJES, 'utf8');
+    const headers = c.match(/^##\s+\[\d{4}-\d{2}-\d{2}\]/gm);
+    return headers ? headers.length : 0;
+  } catch {
+    return 0;
+  }
+}
+
+function leerJsonl(p, dias = 14) {
+  try {
+    const limite = Date.now() - dias * 24 * 3600 * 1000;
+    return fs.readFileSync(p, 'utf8')
+      .split(/\r?\n/)
+      .filter(Boolean)
+      .map(l => { try { return JSON.parse(l); } catch { return null; } })
+      .filter(e => {
+        if (!e) return false;
+        const t = Date.parse(e.ts);
+        return Number.isFinite(t) && t >= limite;
+      });
+  } catch {
+    return [];
+  }
+}
+
+function resumenAgentes() {
+  const entries = leerJsonl(AGENTES_LOG, 14);
+  const porAgente = {};
+  for (const e of entries) {
+    if (!porAgente[e.agente]) porAgente[e.agente] = { runs: 0, fallos: 0, triviales: 0 };
+    if (e.trivial) porAgente[e.agente].triviales++;
+    else {
+      porAgente[e.agente].runs++;
+      if (e.status === 'failed') porAgente[e.agente].fallos++;
+    }
+  }
+  const totalRuns = entries.filter(e => !e.trivial).length;
+  const totalFallos = entries.filter(e => !e.trivial && e.status === 'failed').length;
+  return {
+    totalRuns,
+    totalFallos,
+    tasaExito: totalRuns > 0 ? Math.round((1 - totalFallos / totalRuns) * 1000) / 10 : null,
+    porAgente,
+  };
+}
+
+function resumenEvoluciones() {
+  const entries = leerJsonl(EVOLUCIONES_LOG, 30);
+  const aplicadas = entries.filter(e => e.tipo === 'aplicada').length;
+  const revertidas = entries.filter(e => e.tipo === 'revertida').length;
+  return { aplicadas, revertidas, neta: aplicadas - revertidas };
+}
+
+// ---------------------------------------------------------------------------
+// Entrypoint
+// ---------------------------------------------------------------------------
+
+let inputRaw = '';
+process.stdin.on('data', chunk => { inputRaw += chunk; });
+
+process.stdin.on('end', () => {
+  try {
+    ensureDir();
+
+    const nudges = nudgeTracker ? nudgeTracker.resumen({ dias: 14 }) : null;
+    if (nudgeTracker) {
+      try { nudgeTracker.escalarSiAplica({ threshold: 5 }); } catch { /* ignore */ }
+    }
+
+    const metricas = {
+      generado: new Date().toISOString(),
+      ventana_dias: 14,
+      nudges: nudges || { total: 0, accionados: 0, pendientes: 0 },
+      instintos: {
+        proyecto: contarInstintos(INSTINTOS_PROYECTO),
+        global:   contarInstintos(INSTINTOS_GLOBAL),
+        perfil:   contarInstintos(INSTINTOS_PERFIL),
+      },
+      aprendizajes_totales: contarAprendizajes(),
+      agentes: resumenAgentes(),
+      evoluciones: resumenEvoluciones(),
+    };
+
+    // Health score compuesto (0-100). Útil para dashboard.
+    metricas.health_score = calcularHealthScore(metricas);
+
+    atomicWriteJSON(METRICAS_PATH, metricas);
+  } catch {
+    // Nunca bloquear por error interno
+  }
+});
+
+/**
+ * Health score compuesto del ciclo de evolución (0-100).
+ *
+ * Componentes (pesos):
+ *   - Tasa de acción de nudges (30%): accionados / total
+ *   - Densidad de instintos (20%): sum vs capacidad objetivo (20 proyecto + 5 global)
+ *   - Tasa de éxito de agentes (30%): (runs - fallos) / runs
+ *   - Evoluciones netas positivas (10%): aplicadas - revertidas
+ *   - Ausencia de alertas persistentes (10%): -5pt por cada alerta activa
+ */
+function calcularHealthScore(m) {
+  let score = 0;
+
+  // Nudges (30pt)
+  if (m.nudges.total > 0) {
+    score += Math.round(m.nudges.accionados / m.nudges.total * 30);
+  } else {
+    score += 15; // sin nudges = neutral
+  }
+
+  // Instintos (20pt) — objetivo: 20 proyecto + 5 global
+  const totalInst = m.instintos.proyecto + m.instintos.global;
+  const objetivo = 25;
+  score += Math.min(20, Math.round(totalInst / objetivo * 20));
+
+  // Agentes (30pt)
+  if (m.agentes.totalRuns > 0) {
+    score += Math.round(m.agentes.tasaExito / 100 * 30);
+  } else {
+    score += 15;
+  }
+
+  // Evoluciones (10pt)
+  if (m.evoluciones.aplicadas > 0) {
+    const netaRatio = Math.max(0, m.evoluciones.neta / m.evoluciones.aplicadas);
+    score += Math.round(netaRatio * 10);
+  } else {
+    score += 5;
+  }
+
+  // Alertas (10pt)
+  const alertas = (m.nudges.alertasActivas || []).length;
+  score += Math.max(0, 10 - alertas * 5);
+
+  return Math.min(100, Math.max(0, score));
+}