@saulwade/swl-ses 1.0.0

package/hooks/inyeccion-contexto.js

@@ -0,0 +1,246 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Hook: inyeccion-contexto.js
+ * Tipo: PostToolUse
+ *
+ * Inyecta automáticamente contexto de la sesión anterior al inicio
+ * de una nueva sesión. Inspirado en claude-mem's context injection.
+ *
+ * Comportamiento:
+ *   - Solo actúa en la primera invocación de la sesión
+ *   - Lee la sesión anterior desde .planning/sessions/latest.json
+ *   - Genera un bloque de contexto con resumen, archivos, agentes
+ *   - Lee instintos activos del proyecto (instintos/proyecto.yaml)
+ *   - Escribe el contexto en stdout una sola vez
+ *   - Marca como inyectado en bridge para no repetir
+ *
+ * Resultado:
+ *   - Primera invocación con contexto previo: stdout con contexto
+ *   - Invocaciones siguientes: exit 0 silencioso
+ *   - Sin sesión previa: exit 0 silencioso
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const { getOrBuildSnapshot } = require('./lib/context-builder');
+const { sanitize: scanInjection } = require('./lib/prompt-injection-scanner');
+
+// Detección de stack para sugerencia de skills
+let _techDetector = null;
+try { _techDetector = require('./lib/tech-skills-map'); } catch (_) {}
+
+// Solo inyectar en la primera invocación
+const MAX_INVOCACION_PARA_INYECTAR = 1;
+
+function leerSesionAnterior(cwd) {
+  const latestPath = path.join(cwd, '.planning', 'sessions', 'latest.json');
+  if (!fs.existsSync(latestPath)) return null;
+
+  try {
+    const { path: sessionPath } = JSON.parse(fs.readFileSync(latestPath, 'utf8'));
+    if (!sessionPath || !fs.existsSync(sessionPath)) return null;
+    return JSON.parse(fs.readFileSync(sessionPath, 'utf8'));
+  } catch (_) {
+    return null;
+  }
+}
+
+function leerInstintosActivos(cwd) {
+  const instPath = path.join(cwd, 'instintos', 'proyecto.yaml');
+  if (!fs.existsSync(instPath)) return [];
+
+  try {
+    const contenido = fs.readFileSync(instPath, 'utf8');
+    // Parse simple YAML — extraer instintos con confidence > 0.7
+    const instintos = [];
+    const regex = /pattern:\s*"([^"]+)"[\s\S]*?confidence:\s*([\d.]+)/g;
+    let match;
+    while ((match = regex.exec(contenido)) !== null) {
+      const confidence = parseFloat(match[2]);
+      if (confidence >= 0.7) {
+        instintos.push({ pattern: match[1], confidence });
+      }
+    }
+    return instintos.sort((a, b) => b.confidence - a.confidence).slice(0, 5);
+  } catch (_) {
+    return [];
+  }
+}
+
+function leerContextoActivo(cwd) {
+  const ctxPath = path.join(cwd, '.planning', 'CONTEXTO.md');
+  if (!fs.existsSync(ctxPath)) return 'dev';
+
+  try {
+    const contenido = fs.readFileSync(ctxPath, 'utf8');
+    const match = contenido.match(/\*\*Modo\*\*:\s*(\w+)/);
+    return match ? match[1] : 'dev';
+  } catch (_) {
+    return 'dev';
+  }
+}
+
+function generarContexto(sesion, instintos, modo) {
+  const duracion = sesion.endTime
+    ? `${Math.round((new Date(sesion.endTime) - new Date(sesion.startTime)) / 60000)} min`
+    : 'en progreso';
+
+  const archivos = (sesion.filesChanged || []).slice(0, 10);
+  const agentes = (sesion.agentsInvoked || []).slice(0, 5);
+  const topTools = Object.entries(sesion.metricas?.herramientas || {})
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, 3)
+    .map(([tool, count]) => `${tool}(${count})`)
+    .join(', ');
+
+  const lineas = [
+    '',
+    '--- CONTEXTO DE SESIÓN ANTERIOR (inyectado automáticamente) ---',
+    `  Sesión: ${sesion.id} | ${duracion} | Modo: ${modo}`,
+    `  Tool calls: ${sesion.toolCalls} | Costo: ~$${(sesion.costEstimated || 0).toFixed(2)}`,
+  ];
+
+  if (topTools) {
+    lineas.push(`  Herramientas: ${topTools}`);
+  }
+
+  if (archivos.length > 0) {
+    lineas.push(`  Archivos modificados: ${archivos.slice(0, 5).join(', ')}${archivos.length > 5 ? ` (+${archivos.length - 5} mas)` : ''}`);
+  }
+
+  if (agentes.length > 0) {
+    lineas.push(`  Agentes: ${agentes.join(', ')}`);
+  }
+
+  if (sesion.summary) {
+    lineas.push(`  Resumen: ${sesion.summary.slice(0, 200)}`);
+  }
+
+  if (instintos.length > 0) {
+    lineas.push('  Instintos activos:');
+    for (const inst of instintos) {
+      lineas.push(`    - ${inst.pattern} (${(inst.confidence * 100).toFixed(0)}%)`);
+    }
+  }
+
+  lineas.push('--- FIN CONTEXTO ANTERIOR ---');
+  lineas.push('');
+
+  return lineas.join('\n');
+}
+
+/**
+ * Detecta el stack del proyecto y genera sugerencia de skills de comunidad
+ * si hay tecnologías con skills disponibles en skills.sh que SWL no cubre.
+ *
+ * @param {string} cwd
+ * @returns {string} Bloque de texto con sugerencia, o '' si no aplica.
+ */
+function generarSugerenciaSkillsComunidad(cwd) {
+  if (!_techDetector) return '';
+
+  try {
+    const { skills, agentes } = _techDetector.sugerirSkills(cwd);
+    if (skills.length === 0) return '';
+
+    // Verificar si ya hay skills de comunidad instalados (.agents/skills/)
+    const agentsSkillsDir = path.join(cwd, '.agents', 'skills');
+    const yaTieneComunidad = fs.existsSync(agentsSkillsDir);
+
+    // Generar resumen de stack
+    const resumen = _techDetector.generarResumenStack(cwd);
+    if (!resumen) return '';
+
+    const lineas = [
+      '',
+      '--- STACK DETECTADO ---',
+      `  ${resumen.split('\n').slice(1).join('\n  ')}`,
+    ];
+
+    if (!yaTieneComunidad) {
+      // Solo sugerir si no tiene skills de comunidad aun
+      lineas.push('  Skills de comunidad: ejecuta `npx autoskills --dry-run` para ver skills oficiales disponibles');
+    }
+
+    lineas.push('--- FIN STACK ---');
+    lineas.push('');
+
+    return lineas.join('\n');
+  } catch (_) {
+    return '';
+  }
+}
+
+// --- Entrypoint ---
+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');
+
+    // Leer bridge para verificar si ya inyectamos
+    const bridgePath = path.join(os.tmpdir(), `swl-ctx-${sessionId}.json`);
+    let bridge = {};
+    try {
+      bridge = JSON.parse(fs.readFileSync(bridgePath, 'utf8'));
+    } catch (_) {}
+
+    // Solo inyectar en la primera invocacion
+    const invocaciones = bridge.invocaciones || 0;
+    if (invocaciones > MAX_INVOCACION_PARA_INYECTAR || bridge.contextoInyectado) {
+      return;
+    }
+
+    const cwd = process.cwd();
+    const sesion = leerSesionAnterior(cwd);
+
+    // Solo inyectar si la sesion anterior tiene contenido util
+    if (!sesion || sesion.toolCalls < 5) {
+      return;
+    }
+
+    // No inyectar si la sesión anterior es la misma sesión activa
+    if (sesion.status === 'active') {
+      return;
+    }
+
+    const instintos = leerInstintosActivos(cwd);
+    const modo = leerContextoActivo(cwd);
+    let contexto = generarContexto(sesion, instintos, modo);
+
+    // Escanear contexto por inyecciones de prompt antes de inyectar
+    const scanResult = scanInjection(contexto, 'contexto-sesion-anterior');
+    if (scanResult.blocked) {
+      contexto = scanResult.content; // Placeholder de bloqueo
+    } else {
+      contexto = scanResult.content; // Original o con advertencia
+    }
+
+    // Marcar como inyectado en bridge
+    try {
+      bridge.contextoInyectado = true;
+      bridge.contextoTimestamp = new Date().toISOString();
+      fs.writeFileSync(bridgePath, JSON.stringify(bridge, null, 2), 'utf8');
+    } catch (_) {}
+
+    // Emitir contexto de sesión anterior
+    process.stdout.write(contexto);
+
+    // Emitir sugerencia de stack y skills de comunidad
+    const stackSugerencia = generarSugerenciaSkillsComunidad(cwd);
+    if (stackSugerencia) {
+      process.stdout.write(stackSugerencia);
+    }
+  } catch (err) {
+    // No escribir a stderr — Claude Code lo reporta como hook error
+  }
+});

package/hooks/lib/abort-registry.js

@@ -0,0 +1,214 @@
+'use strict';
+
+/**
+ * abort-registry.js
+ *
+ * Registro de señales de abort para sesiones SWL. Portado del patrón
+ * InMemoryAbortRegistry de rowboat con adaptación a Claude Code hooks.
+ *
+ * Diferencia graceful vs force:
+ *   graceful (abort)  — Señal SIGTERM: el agente puede terminar limpiamente,
+ *                       cerrar conexiones MCP y escribir estado final.
+ *   force (forceAbort) — Señal SIGKILL: termina inmediatamente, limpia todos
+ *                        los recursos sin esperar confirmaciones.
+ *
+ * Uso en hooks:
+ *   const abortRegistry = require('./abort-registry');
+ *
+ *   // En Stop hook o al detectar Ctrl+C:
+ *   abortRegistry.abort(sessionId);          // graceful
+ *   abortRegistry.forceAbort(sessionId);     // force
+ *
+ *   // En tool execution:
+ *   if (abortRegistry.isAborted(sessionId)) {
+ *     // terminar limpiamente
+ *   }
+ *
+ *   // Obtener AbortSignal para pasarla a fetch/execFile:
+ *   const signal = abortRegistry.getSignal(sessionId);
+ *   await fetch(url, { signal });
+ *
+ * Zero-dependencies (solo AbortController nativo de Node.js 15+).
+ */
+
+// ---------------------------------------------------------------------------
+// Estado (singleton por proceso)
+// ---------------------------------------------------------------------------
+
+/** @type {Map<string, AbortController>} */
+const controllers = new Map();
+
+/** @type {Set<string>} sessionIds con force abort */
+const forceAborted = new Set();
+
+/** @type {Map<string, Array<() => void>>} callbacks de cleanup por sessionId */
+const cleanupCallbacks = new Map();
+
+// ---------------------------------------------------------------------------
+// API pública
+// ---------------------------------------------------------------------------
+
+/**
+ * Obtiene (o crea) el AbortSignal asociado a una sesión.
+ * El signal se puede pasar a fetch(), execFile(), etc. para cancelación.
+ *
+ * @param {string} sessionId
+ * @returns {AbortSignal}
+ */
+function getSignal(sessionId) {
+  if (!controllers.has(sessionId)) {
+    controllers.set(sessionId, new AbortController());
+  }
+  return controllers.get(sessionId).signal;
+}
+
+/**
+ * Abort graceful: señaliza que la sesión debe terminar limpiamente.
+ * Invoca todos los callbacks de cleanup registrados.
+ *
+ * @param {string} sessionId
+ */
+function abort(sessionId) {
+  const ctrl = controllers.get(sessionId);
+  if (ctrl && !ctrl.signal.aborted) {
+    ctrl.abort();
+  }
+  // Invocar callbacks de cleanup registrados
+  const callbacks = cleanupCallbacks.get(sessionId) || [];
+  for (const cb of callbacks) {
+    try { cb(); } catch (_) { /* nunca propagar errores de cleanup */ }
+  }
+  cleanupCallbacks.delete(sessionId);
+}
+
+/**
+ * Abort forzado: termina inmediatamente sin esperar cleanup.
+ * Marca la sesión como force-aborted y llama a abort().
+ *
+ * @param {string} sessionId
+ */
+function forceAbort(sessionId) {
+  forceAborted.add(sessionId);
+  abort(sessionId);
+}
+
+/**
+ * Verifica si una sesión ha sido abortada (graceful o force).
+ *
+ * @param {string} sessionId
+ * @returns {boolean}
+ */
+function isAborted(sessionId) {
+  const ctrl = controllers.get(sessionId);
+  return (ctrl?.signal.aborted) || forceAborted.has(sessionId);
+}
+
+/**
+ * Verifica si una sesión fue abortada con force (SIGKILL semantics).
+ *
+ * @param {string} sessionId
+ * @returns {boolean}
+ */
+function isForceAborted(sessionId) {
+  return forceAborted.has(sessionId);
+}
+
+/**
+ * Registra un callback de cleanup que se invocará al hacer abort().
+ * Útil para cerrar conexiones MCP, escribir estado final, etc.
+ *
+ * @param {string} sessionId
+ * @param {() => void} callback
+ * @returns {() => void} Función para desregistrar el callback.
+ */
+function onAbort(sessionId, callback) {
+  if (!cleanupCallbacks.has(sessionId)) {
+    cleanupCallbacks.set(sessionId, []);
+  }
+  cleanupCallbacks.get(sessionId).push(callback);
+
+  return function unregister() {
+    const lista = cleanupCallbacks.get(sessionId);
+    if (!lista) return;
+    const idx = lista.indexOf(callback);
+    if (idx !== -1) lista.splice(idx, 1);
+  };
+}
+
+/**
+ * Limpia el estado de una sesión del registry (post-stop).
+ * Llamar desde el Stop hook después de procesar el resumen.
+ *
+ * @param {string} sessionId
+ */
+function cleanup(sessionId) {
+  controllers.delete(sessionId);
+  forceAborted.delete(sessionId);
+  cleanupCallbacks.delete(sessionId);
+}
+
+/**
+ * Estado del registry (para diagnóstico).
+ *
+ * @returns {{ active: string[], forceAborted: string[] }}
+ */
+function stats() {
+  return {
+    active:       Array.from(controllers.keys()),
+    forceAborted: Array.from(forceAborted),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Integración con señales del proceso (para hooks Stop)
+// ---------------------------------------------------------------------------
+
+let _sesionActiva = null;
+
+/**
+ * Registra la sesión activa para manejo de señales del proceso.
+ * El Stop hook debe llamar esto al inicio para que SIGTERM/SIGINT
+ * disparen abort() automáticamente.
+ *
+ * @param {string} sessionId
+ */
+function registrarSesionActiva(sessionId) {
+  _sesionActiva = sessionId;
+}
+
+// Instalar handlers de señal una sola vez
+let _handlersInstalados = false;
+function instalarHandlers() {
+  if (_handlersInstalados) return;
+  _handlersInstalados = true;
+
+  process.once('SIGTERM', () => {
+    if (_sesionActiva) abort(_sesionActiva);
+  });
+
+  // SIGINT (Ctrl+C) → primer hit graceful, segundo hit force
+  let _sigintCount = 0;
+  process.on('SIGINT', () => {
+    _sigintCount++;
+    if (!_sesionActiva) return;
+    if (_sigintCount === 1) {
+      abort(_sesionActiva);
+    } else {
+      forceAbort(_sesionActiva);
+    }
+  });
+}
+
+instalarHandlers();
+
+module.exports = {
+  getSignal,
+  abort,
+  forceAbort,
+  isAborted,
+  isForceAborted,
+  onAbort,
+  cleanup,
+  stats,
+  registrarSesionActiva,
+};

package/hooks/lib/agent-backend.js

@@ -0,0 +1,210 @@
+'use strict';
+
+/**
+ * agent-backend.js — Interfaz unificada de mensajes para ejecución de agentes.
+ *
+ * Portado del patrón Backend/Message/SessionResult de Multica.
+ * Define los tipos de mensaje que fluyen durante la ejecución de un agente SWL
+ * y proporciona factories para crear SessionResult estandarizados.
+ *
+ * Integra con event-bus.js para publicar eventos de agente en tiempo real.
+ * Zero-deps — solo módulos nativos de Node.js.
+ *
+ * Tipos de mensaje (alineados con Multica pkg/agent/agent.go):
+ *   text        — output textual del agente
+ *   thinking    — razonamiento interno (extended thinking)
+ *   tool_use    — herramienta siendo invocada
+ *   tool_result — resultado de una herramienta
+ *   status      — cambio de estado del agente (running, paused, stopped)
+ *   error       — error durante la ejecución
+ *   log         — mensaje de log interno
+ *
+ * @module hooks/lib/agent-backend
+ */
+
+// ---------------------------------------------------------------------------
+// Tipos de mensaje
+// ---------------------------------------------------------------------------
+
+/** @enum {string} */
+const MSG = {
+  TEXT:        'text',
+  THINKING:    'thinking',
+  TOOL_USE:    'tool_use',
+  TOOL_RESULT: 'tool_result',
+  STATUS:      'status',
+  ERROR:       'error',
+  LOG:         'log',
+};
+
+/** @enum {string} Estados posibles de un SessionResult */
+const STATUS = {
+  SUCCESS: 'success',
+  FAILED:  'failed',
+  STOPPED: 'stopped',
+};
+
+// ---------------------------------------------------------------------------
+// Factories
+// ---------------------------------------------------------------------------
+
+/**
+ * Crea un objeto Message estandarizado.
+ *
+ * @param {string} type     - Uno de MSG.*
+ * @param {string} content  - Contenido del mensaje
+ * @param {object} [meta]   - Metadatos opcionales (toolName, toolInput, etc.)
+ * @returns {{ type, content, meta, timestamp }}
+ */
+function crearMensaje(type, content, meta = {}) {
+  return {
+    type,
+    content: String(content || ''),
+    meta,
+    timestamp: new Date().toISOString(),
+  };
+}
+
+/**
+ * Crea un SessionResult estandarizado al finalizar la ejecución de un agente.
+ *
+ * @param {object} opts
+ * @param {'success'|'failed'|'stopped'} [opts.status]  - Estado final
+ * @param {string}   [opts.error]        - Mensaje de error si status='failed'
+ * @param {number}   [opts.inputTokens]  - Tokens de entrada consumidos
+ * @param {number}   [opts.outputTokens] - Tokens de salida producidos
+ * @param {number}   [opts.cacheRead]    - Tokens leídos de caché
+ * @param {string}   [opts.agente]       - Nombre del agente
+ * @param {string}   [opts.slice]        - Nombre del slice ejecutado
+ * @param {object[]} [opts.mensajes]     - Array de mensajes producidos durante la sesión
+ * @returns {object} SessionResult completo
+ */
+function crearSessionResult(opts = {}) {
+  const inputTokens  = Number(opts.inputTokens  || 0);
+  const outputTokens = Number(opts.outputTokens || 0);
+  const cacheRead    = Number(opts.cacheRead    || 0);
+
+  return {
+    status:  opts.status || STATUS.SUCCESS,
+    error:   opts.error  || null,
+    agente:  opts.agente || 'desconocido',
+    slice:   opts.slice  || '',
+    uso: {
+      inputTokens,
+      outputTokens,
+      totalTokens: inputTokens + outputTokens,
+      cacheRead,
+    },
+    mensajes:     opts.mensajes || [],
+    timestamp:    new Date().toISOString(),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Integración con event-bus
+// ---------------------------------------------------------------------------
+
+/**
+ * Publica un evento de agente al event-bus.
+ * Importación lazy para evitar dependencia circular.
+ *
+ * @param {string} tipo    - 'agent:started' | 'agent:message' | 'agent:completed' | 'agent:failed'
+ * @param {object} payload - Datos del evento
+ * @param {string} [runId] - ID de la sesión (default: 'default')
+ */
+function publicar(tipo, payload, runId = 'default') {
+  try {
+    const bus = require('./event-bus');
+    bus.publish({ type: tipo, runId, ...payload, timestamp: new Date().toISOString() });
+  } catch (_) {
+    // Silencioso — el bus puede no estar disponible en todos los contextos
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Helpers de ciclo de vida
+// ---------------------------------------------------------------------------
+
+/**
+ * Emite el evento de inicio de un agente.
+ *
+ * @param {string} agente    - Nombre del agente SWL
+ * @param {string} slice     - Slice que ejecuta
+ * @param {string} [runId]   - ID de sesión
+ */
+function emitirInicio(agente, slice, runId) {
+  publicar('agent:started', { agente, slice }, runId);
+}
+
+/**
+ * Emite un mensaje producido por el agente durante su ejecución.
+ *
+ * @param {object} mensaje - Objeto creado con crearMensaje()
+ * @param {string} agente  - Nombre del agente
+ * @param {string} [runId]
+ */
+function emitirMensaje(mensaje, agente, runId) {
+  publicar('agent:message', { mensaje, agente }, runId);
+}
+
+/**
+ * Emite el evento de finalización de un agente con su SessionResult.
+ *
+ * @param {object} sessionResult - Objeto creado con crearSessionResult()
+ * @param {string} [runId]
+ */
+function emitirCompletado(sessionResult, runId) {
+  const tipo = sessionResult.status === STATUS.FAILED ? 'agent:failed' : 'agent:completed';
+  publicar(tipo, { resultado: sessionResult }, runId);
+}
+
+// ---------------------------------------------------------------------------
+// Extracción de SessionResult desde payload de hook PostToolUse
+// ---------------------------------------------------------------------------
+
+/**
+ * Construye un SessionResult a partir del payload JSON que Claude Code envía
+ * al hook PostToolUse cuando la herramienta es 'Agent'.
+ *
+ * @param {object} hookPayload - Payload JSON del hook
+ * @returns {object} SessionResult
+ */
+function desdePayloadHook(hookPayload) {
+  const input   = hookPayload.tool_input  || {};
+  const result  = hookPayload.tool_result || {};
+  const agente  = String(input.subagent_type || 'general-purpose');
+  const slice   = String(input.description   || '').slice(0, 80);
+
+  // Detectar error en el resultado
+  const resultStr = typeof result === 'string' ? result : JSON.stringify(result || '');
+  const hayError  = /\berror\b|\bfailed\b|\bexception\b/i.test(resultStr);
+
+  // Extraer tokens del payload si el runtime los expone
+  const usage = hookPayload.usage || hookPayload.tool_result?.usage || {};
+
+  return crearSessionResult({
+    status:       hayError ? STATUS.FAILED : STATUS.SUCCESS,
+    error:        hayError ? resultStr.slice(0, 200) : null,
+    agente,
+    slice,
+    inputTokens:  Number(usage.input_tokens  || usage.inputTokens  || 0),
+    outputTokens: Number(usage.output_tokens || usage.outputTokens || 0),
+    cacheRead:    Number(usage.cache_read_tokens || 0),
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Exports
+// ---------------------------------------------------------------------------
+
+module.exports = {
+  MSG,
+  STATUS,
+  crearMensaje,
+  crearSessionResult,
+  publicar,
+  emitirInicio,
+  emitirMensaje,
+  emitirCompletado,
+  desdePayloadHook,
+};