@saulwade/swl-ses 1.0.0

package/hooks/lib/sync-status.js

@@ -0,0 +1,228 @@
+'use strict';
+
+/**
+ * Sync Status — Detección de desincronización entre fuente y destino.
+ *
+ * Compara el directorio fuente (habilidades/, agentes/) con los directorios
+ * de instalación (.claude/skills/, .claude/agents/) para detectar:
+ *   - Skills/agentes faltantes en destino
+ *   - Skills/agentes modificados localmente (divergidos)
+ *   - Skills/agentes extra en destino (no en fuente)
+ *
+ * Patrón adoptado de skillshare (diff, status commands).
+ *
+ * Zero dependencias externas.
+ *
+ * Uso:
+ *   const { calcularStatus, formatearStatus } = require('./lib/sync-status');
+ *   const status = calcularStatus('/ruta/habilidades', '/ruta/.claude/skills');
+ *   console.log(formatearStatus(status));
+ *
+ * @module hooks/lib/sync-status
+ */
+
+const fs   = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+// ---------------------------------------------------------------------------
+// Funciones internas
+// ---------------------------------------------------------------------------
+
+/**
+ * Calcula un hash rápido del contenido de un directorio o archivo.
+ * Para directorios, hashea el contenido de SKILL.md (si existe).
+ *
+ * @param {string} ruta - Ruta al archivo o directorio
+ * @returns {string|null} Hash MD5 o null si no se puede leer
+ */
+function _hashContenido(ruta) {
+  try {
+    const stat = fs.statSync(ruta);
+    let contenido;
+
+    if (stat.isDirectory()) {
+      // Para directorios de skills, hashear SKILL.md
+      const skillMd = path.join(ruta, 'SKILL.md');
+      if (fs.existsSync(skillMd)) {
+        contenido = fs.readFileSync(skillMd, 'utf8');
+      } else {
+        // Para agentes (.md), hashear el archivo directamente
+        return null;
+      }
+    } else {
+      contenido = fs.readFileSync(ruta, 'utf8');
+    }
+
+    return crypto.createHash('md5').update(contenido).digest('hex');
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Lista los componentes en un directorio.
+ *
+ * @param {string} dir - Directorio a listar
+ * @param {'directory'|'file'} tipo - Tipo de entrada a buscar
+ * @returns {Map<string, string>} Mapa nombre → hash
+ */
+function _listarComponentes(dir, tipo = 'directory') {
+  const mapa = new Map();
+  if (!fs.existsSync(dir)) return mapa;
+
+  try {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const esValido = tipo === 'directory' ? entry.isDirectory() : entry.isFile();
+      if (!esValido) continue;
+      if (entry.name.startsWith('.')) continue;
+
+      const ruta = path.join(dir, entry.name);
+      const hash = _hashContenido(ruta);
+      mapa.set(entry.name, hash);
+    }
+  } catch {
+    // Error leyendo directorio
+  }
+
+  return mapa;
+}
+
+// ---------------------------------------------------------------------------
+// API pública
+// ---------------------------------------------------------------------------
+
+/**
+ * @typedef {object} SyncStatus
+ * @property {string[]} faltantes    - En fuente pero no en destino
+ * @property {string[]} extra        - En destino pero no en fuente
+ * @property {string[]} sincronizados - En ambos con mismo hash
+ * @property {string[]} divergidos   - En ambos pero con hash diferente
+ * @property {number} total          - Total de componentes en fuente
+ * @property {boolean} enSync        - true si no hay faltantes ni divergidos
+ */
+
+/**
+ * Calcula el estado de sincronización entre fuente y destino.
+ *
+ * @param {string} dirFuente  - Directorio fuente (ej: habilidades/)
+ * @param {string} dirDestino - Directorio destino (ej: .claude/skills/)
+ * @param {object} [opciones]
+ * @param {'directory'|'file'} [opciones.tipo='directory'] - Tipo de componente
+ * @returns {SyncStatus}
+ */
+function calcularStatus(dirFuente, dirDestino, opciones = {}) {
+  const tipo = opciones.tipo || 'directory';
+
+  const fuente  = _listarComponentes(dirFuente, tipo);
+  const destino = _listarComponentes(dirDestino, tipo);
+
+  const faltantes = [];
+  const sincronizados = [];
+  const divergidos = [];
+  const extra = [];
+
+  // Comparar fuente → destino
+  for (const [nombre, hashFuente] of fuente) {
+    if (!destino.has(nombre)) {
+      faltantes.push(nombre);
+    } else {
+      const hashDestino = destino.get(nombre);
+      if (hashFuente && hashDestino && hashFuente === hashDestino) {
+        sincronizados.push(nombre);
+      } else if (hashFuente && hashDestino) {
+        divergidos.push(nombre);
+      } else {
+        sincronizados.push(nombre); // No se pudo comparar hash — asumir sync
+      }
+    }
+  }
+
+  // Componentes extra en destino (no en fuente)
+  for (const nombre of destino.keys()) {
+    if (!fuente.has(nombre)) {
+      extra.push(nombre);
+    }
+  }
+
+  return {
+    faltantes: faltantes.sort(),
+    extra: extra.sort(),
+    sincronizados: sincronizados.sort(),
+    divergidos: divergidos.sort(),
+    total: fuente.size,
+    enSync: faltantes.length === 0 && divergidos.length === 0,
+  };
+}
+
+/**
+ * Formatea el estado de sincronización para mostrar en terminal.
+ *
+ * @param {SyncStatus} status
+ * @param {string} [label=''] - Etiqueta (ej: "Skills", "Agentes")
+ * @returns {string}
+ */
+function formatearStatus(status, label = '') {
+  const lineas = [];
+  const prefix = label ? `[${label}] ` : '';
+
+  if (status.enSync) {
+    lineas.push(`${prefix}Sincronizado (${status.sincronizados.length}/${status.total})`);
+  } else {
+    lineas.push(`${prefix}Desincronizado:`);
+
+    if (status.faltantes.length > 0) {
+      lineas.push(`  Faltantes (${status.faltantes.length}): ${status.faltantes.slice(0, 10).join(', ')}${status.faltantes.length > 10 ? '...' : ''}`);
+    }
+
+    if (status.divergidos.length > 0) {
+      lineas.push(`  Divergidos (${status.divergidos.length}): ${status.divergidos.slice(0, 10).join(', ')}${status.divergidos.length > 10 ? '...' : ''}`);
+    }
+
+    if (status.extra.length > 0) {
+      lineas.push(`  Extra (${status.extra.length}): ${status.extra.slice(0, 10).join(', ')}${status.extra.length > 10 ? '...' : ''}`);
+    }
+
+    lineas.push(`  Sincronizados: ${status.sincronizados.length}/${status.total}`);
+  }
+
+  return lineas.join('\n');
+}
+
+/**
+ * Calcula el status completo del sistema (skills + agentes + hooks).
+ *
+ * @param {string} raizProyecto - Ruta raíz del proyecto
+ * @param {string} raizSWL      - Ruta raíz del paquete swl-ses
+ * @returns {{ skills: SyncStatus, agentes: SyncStatus, enSync: boolean }}
+ */
+function statusCompleto(raizProyecto, raizSWL) {
+  const skills = calcularStatus(
+    path.join(raizSWL, 'habilidades'),
+    path.join(raizProyecto, '.claude', 'skills'),
+    { tipo: 'directory' }
+  );
+
+  const agentes = calcularStatus(
+    path.join(raizSWL, 'agentes'),
+    path.join(raizProyecto, '.claude', 'agents'),
+    { tipo: 'file' }
+  );
+
+  return {
+    skills,
+    agentes,
+    enSync: skills.enSync && agentes.enSync,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Exports
+// ---------------------------------------------------------------------------
+
+module.exports = {
+  calcularStatus,
+  formatearStatus,
+  statusCompleto,
+};

package/hooks/lib/taint-tracker.js

@@ -0,0 +1,107 @@
+'use strict';
+
+/**
+ * Taint Tracker — Rastreo de flujo de informacion entre operaciones.
+ *
+ * Implementa Information Flow Taint Tracking adoptado de OpenFang
+ * (crates/openfang-runtime/src/tool_runner.rs).
+ *
+ * Labels de taint se propagan desde fuentes (sources) hasta sumideros (sinks).
+ * Detecta cadenas peligrosas que los scanners estaticos pierden:
+ *   - Read de archivos sensibles seguido de Bash con envio a red
+ *   - Read de credenciales seguido de Write a logs
+ *   - WebFetch de URL externa seguido de Edit de config
+ *
+ * Zero dependencias externas.
+ *
+ * @module hooks/lib/taint-tracker
+ */
+
+const LABEL = Object.freeze({
+  SECRET:             'secret',
+  EXTERNAL_NETWORK:   'external_network',
+  USER_INPUT:         'user_input',
+  CREDENTIAL:         'credential',
+  INTERNAL_CONFIG:    'internal_config',
+});
+
+const SINK = Object.freeze({
+  SHELL_EXEC:    'shell_exec',
+  NET_FETCH:     'net_fetch',
+  FILE_WRITE:    'file_write',
+  LOG_OUTPUT:    'log_output',
+});
+
+const SOURCE_PATTERNS = [
+  { patron: /\.env$|credentials|\.pem$|\.key$/i, labels: [LABEL.SECRET, LABEL.CREDENTIAL] },
+  { patron: /\.ssh\//i, labels: [LABEL.CREDENTIAL] },
+  { patron: /tok[e]n|ap[i].?k[e]y|passw[o]rd|priv[a]te.?k[e]y/i, labels: [LABEL.SECRET] },
+  { patron: /settings\.json|config\.ya?ml|\.claude\//i, labels: [LABEL.INTERNAL_CONFIG] },
+  { patron: /^https?:\/\//i, labels: [LABEL.EXTERNAL_NETWORK] },
+];
+
+const BLOCKED_FLOWS = [
+  { sourceLabel: LABEL.SECRET,           sink: SINK.SHELL_EXEC,  severity: 'CRITICAL', desc: 'Dato sensible en comando shell' },
+  { sourceLabel: LABEL.SECRET,           sink: SINK.NET_FETCH,   severity: 'CRITICAL', desc: 'Dato sensible enviado a red' },
+  { sourceLabel: LABEL.SECRET,           sink: SINK.LOG_OUTPUT,  severity: 'HIGH',     desc: 'Dato sensible expuesto en output' },
+  { sourceLabel: LABEL.CREDENTIAL,       sink: SINK.SHELL_EXEC,  severity: 'CRITICAL', desc: 'Credencial en comando shell' },
+  { sourceLabel: LABEL.CREDENTIAL,       sink: SINK.NET_FETCH,   severity: 'CRITICAL', desc: 'Credencial enviada a red' },
+  { sourceLabel: LABEL.CREDENTIAL,       sink: SINK.FILE_WRITE,  severity: 'HIGH',     desc: 'Credencial escrita a archivo' },
+  { sourceLabel: LABEL.EXTERNAL_NETWORK, sink: SINK.SHELL_EXEC,  severity: 'HIGH',     desc: 'Datos externos ejecutados como comando' },
+  { sourceLabel: LABEL.EXTERNAL_NETWORK, sink: SINK.FILE_WRITE,  severity: 'MEDIUM',   desc: 'Datos externos escritos a config' },
+  { sourceLabel: LABEL.INTERNAL_CONFIG,  sink: SINK.NET_FETCH,   severity: 'HIGH',     desc: 'Config interna enviada a red' },
+];
+
+const _taintedSources = [];
+const MAX_HISTORY = 100;
+
+const tracker = {
+  registrarSource(tool, pathOrUrl, labelsOverride) {
+    let labels = labelsOverride;
+    if (!labels) {
+      labels = [];
+      for (const { patron, labels: sl } of SOURCE_PATTERNS) {
+        if (patron.test(pathOrUrl)) labels.push(...sl);
+      }
+    }
+    if (labels.length === 0) return;
+    labels = [...new Set(labels)];
+    _taintedSources.push({ tool, path: pathOrUrl, labels, timestamp: Date.now() });
+    if (_taintedSources.length > MAX_HISTORY) _taintedSources.splice(0, _taintedSources.length - MAX_HISTORY);
+  },
+
+  verificarSink(tool, target) {
+    let sink;
+    if (/^Bash$/i.test(tool)) sink = SINK.SHELL_EXEC;
+    else if (/^WebFetch$/i.test(tool)) sink = SINK.NET_FETCH;
+    else if (/^Write|Edit$/i.test(tool)) sink = SINK.FILE_WRITE;
+    else return null;
+
+    const recientes = _taintedSources.slice(-20);
+    const ahora = Date.now();
+    const VENTANA_MS = 15 * 60 * 1000;
+
+    for (const source of recientes) {
+      if (ahora - source.timestamp > VENTANA_MS) continue;
+      for (const label of source.labels) {
+        const flow = BLOCKED_FLOWS.find(f => f.sourceLabel === label && f.sink === sink);
+        if (flow) {
+          return {
+            bloqueado: true,
+            severity: flow.severity,
+            descripcion: flow.desc,
+            source: { tool: source.tool, path: source.path, labels: source.labels },
+            sink: { tool, target: (target || '').substring(0, 100) },
+            flujo: source.tool + '(' + source.path + ') [' + label + '] -> ' + tool + '(' + (target || '').substring(0, 50) + ')',
+          };
+        }
+      }
+    }
+    return null;
+  },
+
+  historial() { return [..._taintedSources]; },
+  reset() { _taintedSources.length = 0; },
+};
+
+module.exports = { tracker, LABEL, SINK, BLOCKED_FLOWS };

package/hooks/lib/task-service.js

@@ -0,0 +1,295 @@
+'use strict';
+
+/**
+ * task-service.js — Servicio de tareas con ciclo de vida FSM.
+ *
+ * Portado del patrón TaskService de Multica (pkg/task/).
+ * Gestiona el ciclo de vida de tareas asíncronas para el sistema de agentes SWL:
+ *
+ *   pending → claimed → running → success
+ *                                 failed (con reintentos automáticos)
+ *
+ * Las tareas se persisten en .planning/task-queue.json.
+ * Escrituras atómicas via atomicWriteJSON — nunca se pierde estado intermedio.
+ *
+ * API:
+ *   crearTarea(cwd, tarea)              → string (taskId)
+ *   reclamarTarea(cwd, workerId)        → object | null
+ *   actualizarEstado(cwd, id, estado, datos)
+ *   completarTarea(cwd, id, output)     → void
+ *   fallarTarea(cwd, id, error)         → void
+ *   obtenerTarea(cwd, id)               → object | null
+ *   listarTareas(cwd, filtro)           → object[]
+ *   purgarCompletadas(cwd, maxAgeMs)    → number (tareas purgadas)
+ *
+ * @module hooks/lib/task-service
+ */
+
+const fs   = require('fs');
+const path = require('path');
+
+const { atomicWriteJSON } = require('./atomic-write');
+
+const TASK_FILE   = path.join('.planning', 'task-queue.json');
+const MAX_HISTORY = 500; // máximo de tareas terminadas a retener
+
+// ---------------------------------------------------------------------------
+// Generador de ID
+// ---------------------------------------------------------------------------
+
+/**
+ * Genera un ID de tarea único basado en timestamp + sufijo aleatorio.
+ * @returns {string}
+ */
+function generarId() {
+  return `task-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+
+// ---------------------------------------------------------------------------
+// I/O atómico
+// ---------------------------------------------------------------------------
+
+/**
+ * Lee la cola de tareas. Retorna estructura vacía si no existe.
+ *
+ * @param {string} cwd
+ * @returns {{ version: number, tareas: object[] }}
+ */
+function leerCola(cwd) {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(cwd, TASK_FILE), 'utf8'));
+  } catch (_) {
+    return { version: 1, tareas: [] };
+  }
+}
+
+/**
+ * Escribe la cola de tareas de forma atómica.
+ *
+ * @param {string} cwd
+ * @param {{ version: number, tareas: object[] }} cola
+ */
+function escribirCola(cwd, cola) {
+  const planDir = path.join(cwd, '.planning');
+  if (!fs.existsSync(planDir)) fs.mkdirSync(planDir, { recursive: true });
+  atomicWriteJSON(path.join(cwd, TASK_FILE), cola);
+}
+
+// ---------------------------------------------------------------------------
+// API pública
+// ---------------------------------------------------------------------------
+
+/**
+ * Crea una nueva tarea en estado 'pending'.
+ *
+ * @param {string} cwd
+ * @param {object} tarea
+ * @param {string} tarea.tipo            - Tipo: 'agent' | 'bash' | 'prompt' | 'skill'
+ * @param {string} tarea.descripcion     - Descripción legible de la tarea
+ * @param {object} [tarea.payload]       - Datos para ejecutar la tarea
+ * @param {number} [tarea.prioridad]     - 1=alta … 5=baja (default: 3)
+ * @param {number} [tarea.maxReintentos] - Reintentos antes de marcar fallida (default: 3)
+ * @returns {string} taskId
+ */
+function crearTarea(cwd, tarea) {
+  const id   = generarId();
+  const cola = leerCola(cwd);
+
+  cola.tareas.push({
+    id,
+    tipo:          tarea.tipo          || 'generic',
+    descripcion:   tarea.descripcion   || '',
+    payload:       tarea.payload       || {},
+    prioridad:     Number(tarea.prioridad     || 3),
+    maxReintentos: Number(tarea.maxReintentos || 3),
+    estado:        'pending',
+    workerId:      null,
+    creadaEn:      new Date().toISOString(),
+    actualizadaEn: new Date().toISOString(),
+    completadaEn:  null,
+    reintentos:    0,
+    output:        null,
+    error:         null,
+  });
+
+  escribirCola(cwd, cola);
+  return id;
+}
+
+/**
+ * Reclama la siguiente tarea 'pending' de mayor prioridad.
+ * Marca la tarea como 'claimed' y la asigna al worker.
+ *
+ * @param {string} cwd
+ * @param {string} workerId - ID del worker que reclama la tarea
+ * @returns {object|null} La tarea reclamada, o null si no hay pendientes
+ */
+function reclamarTarea(cwd, workerId) {
+  const cola = leerCola(cwd);
+
+  const pendientes = cola.tareas
+    .filter(t => t.estado === 'pending')
+    .sort((a, b) => a.prioridad - b.prioridad || a.creadaEn.localeCompare(b.creadaEn));
+
+  if (pendientes.length === 0) return null;
+
+  const tarea         = pendientes[0];
+  tarea.estado        = 'claimed';
+  tarea.workerId      = String(workerId);
+  tarea.actualizadaEn = new Date().toISOString();
+
+  escribirCola(cwd, cola);
+  return { ...tarea };
+}
+
+/**
+ * Actualiza el estado de una tarea existente.
+ *
+ * @param {string} cwd
+ * @param {string} id     - ID de la tarea a actualizar
+ * @param {string} estado - Nuevo estado: 'claimed' | 'running' | 'success' | 'failed'
+ * @param {object} [datos] - Campos adicionales a actualizar (output, error, etc.)
+ */
+function actualizarEstado(cwd, id, estado, datos = {}) {
+  const cola = leerCola(cwd);
+  const idx  = cola.tareas.findIndex(t => t.id === id);
+  if (idx < 0) return;
+
+  const tarea         = cola.tareas[idx];
+  tarea.estado        = estado;
+  tarea.actualizadaEn = new Date().toISOString();
+
+  if (datos.output !== undefined) tarea.output = datos.output;
+  if (datos.error  !== undefined) tarea.error  = datos.error;
+  if (datos.workerId !== undefined) tarea.workerId = datos.workerId;
+  if (datos.reintentos !== undefined) tarea.reintentos = datos.reintentos;
+
+  if (estado === 'success' || estado === 'failed') {
+    tarea.completadaEn = new Date().toISOString();
+  }
+
+  escribirCola(cwd, cola);
+}
+
+/**
+ * Marca una tarea como completada exitosamente.
+ *
+ * @param {string} cwd
+ * @param {string} id
+ * @param {any}    output - Resultado de la ejecución
+ */
+function completarTarea(cwd, id, output) {
+  actualizarEstado(cwd, id, 'success', { output });
+}
+
+/**
+ * Marca una tarea como fallida.
+ * Si tiene reintentos disponibles, la regresa a 'pending' automáticamente.
+ *
+ * @param {string} cwd
+ * @param {string} id
+ * @param {string} error - Mensaje de error
+ */
+function fallarTarea(cwd, id, error) {
+  const cola = leerCola(cwd);
+  const idx  = cola.tareas.findIndex(t => t.id === id);
+  if (idx < 0) return;
+
+  const tarea        = cola.tareas[idx];
+  tarea.reintentos  += 1;
+  tarea.actualizadaEn = new Date().toISOString();
+
+  if (tarea.reintentos < tarea.maxReintentos) {
+    // Reintentar — volver a pending con workerId liberado
+    tarea.estado   = 'pending';
+    tarea.workerId = null;
+    tarea.error    = `Reintento ${tarea.reintentos}/${tarea.maxReintentos}: ${error}`;
+  } else {
+    // Sin más reintentos — marcar como fallida definitivamente
+    tarea.estado       = 'failed';
+    tarea.error        = error;
+    tarea.completadaEn = new Date().toISOString();
+  }
+
+  escribirCola(cwd, cola);
+}
+
+/**
+ * Obtiene una tarea por su ID.
+ *
+ * @param {string} cwd
+ * @param {string} id
+ * @returns {object|null}
+ */
+function obtenerTarea(cwd, id) {
+  return leerCola(cwd).tareas.find(t => t.id === id) || null;
+}
+
+/**
+ * Lista tareas con filtros opcionales.
+ *
+ * @param {string} cwd
+ * @param {object} [filtro={}]
+ * @param {string} [filtro.estado]    - Filtrar por estado
+ * @param {string} [filtro.tipo]      - Filtrar por tipo
+ * @param {string} [filtro.workerId]  - Filtrar por worker
+ * @returns {object[]}
+ */
+function listarTareas(cwd, filtro = {}) {
+  let tareas = leerCola(cwd).tareas;
+
+  if (filtro.estado)   tareas = tareas.filter(t => t.estado   === filtro.estado);
+  if (filtro.tipo)     tareas = tareas.filter(t => t.tipo     === filtro.tipo);
+  if (filtro.workerId) tareas = tareas.filter(t => t.workerId === filtro.workerId);
+
+  return tareas;
+}
+
+/**
+ * Elimina tareas completadas o fallidas más antiguas que maxAgeMs.
+ * Aplica un hard-cap de MAX_HISTORY tareas.
+ *
+ * @param {string} cwd
+ * @param {number} [maxAgeMs=86400000] - Edad máxima en ms (default: 24h)
+ * @returns {number} Número de tareas purgadas
+ */
+function purgarCompletadas(cwd, maxAgeMs = 86_400_000) {
+  const cola  = leerCola(cwd);
+  const ahora = Date.now();
+  const antes = cola.tareas.length;
+
+  // Eliminar terminadas antiguas
+  cola.tareas = cola.tareas.filter(t => {
+    if (t.estado !== 'success' && t.estado !== 'failed') return true;
+    if (!t.completadaEn) return true;
+    return (ahora - new Date(t.completadaEn).getTime()) < maxAgeMs;
+  });
+
+  // Hard cap: retener las terminadas más recientes si aún supera el límite
+  if (cola.tareas.length > MAX_HISTORY) {
+    const activas    = cola.tareas.filter(t => t.estado !== 'success' && t.estado !== 'failed');
+    const terminadas = cola.tareas
+      .filter(t => t.estado === 'success' || t.estado === 'failed')
+      .sort((a, b) => (b.completadaEn || '').localeCompare(a.completadaEn || ''));
+
+    cola.tareas = [...activas, ...terminadas.slice(0, MAX_HISTORY - activas.length)];
+  }
+
+  escribirCola(cwd, cola);
+  return antes - cola.tareas.length;
+}
+
+// ---------------------------------------------------------------------------
+// Exports
+// ---------------------------------------------------------------------------
+
+module.exports = {
+  crearTarea,
+  reclamarTarea,
+  actualizarEstado,
+  completarTarea,
+  fallarTarea,
+  obtenerTarea,
+  listarTareas,
+  purgarCompletadas,
+};