@saulwade/swl-ses 1.0.0

package/scripts/lib/schedule-parser.js

@@ -0,0 +1,305 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Módulo: schedule-parser.js
+ * Parser de lenguaje natural a expresiones cron.
+ *
+ * Convierte frases en inglés y expresiones cron crudas a un objeto estructurado.
+ * Zero dependencias externas — basado exclusivamente en regex y Node.js stdlib.
+ *
+ * Patrones soportados:
+ *   "every N minutes"           → cron (asterisco)/N * * * *
+ *   "every N hours"             → cron 0 (asterisco)/N * * *
+ *   "hourly"                    → 0 * * * *
+ *   "daily" / "every day"       → 0 9 * * *
+ *   "weekly"                    → 0 9 * * 1
+ *   "every morning at TIME"     → 0 H * * *
+ *   "every evening at TIME"     → 0 H * * *
+ *   "daily at TIME"             → 0 H * * *
+ *   "at TIME every day"         → 0 H * * *
+ *   "weekly on DAYNAME"         → 0 9 * * DOW
+ *   "every DAYNAME"             → 0 9 * * DOW
+ *   "every DAYNAME at TIME"     → M H * * DOW
+ *   Expresión cron cruda (5 campos) → passthrough
+ *
+ * Fuente original: mission-control-main/src/lib/schedule-parser.ts (MIT)
+ * Portado 2026-04-19 a JavaScript zero-deps para swl-ses.
+ *
+ * @module schedule-parser
+ */
+
+// ---------------------------------------------------------------------------
+// Mapa de nombres de día a número de día-de-semana cron (0=domingo, 1=lunes…)
+// ---------------------------------------------------------------------------
+
+/** @type {Object.<string, number>} */
+const MAPA_DIAS = {
+  sunday: 0,    sun: 0,
+  monday: 1,    mon: 1,
+  tuesday: 2,   tue: 2,
+  wednesday: 3, wed: 3,
+  thursday: 4,  thu: 4,
+  friday: 5,    fri: 5,
+  saturday: 6,  sat: 6,
+};
+
+/**
+ * Convierte un nombre de día (en inglés) a número de día-de-semana cron.
+ * Retorna null si el nombre no se reconoce.
+ *
+ * @param {string} entrada
+ * @returns {number|null}
+ */
+function parsearNombreDia(entrada) {
+  const valor = MAPA_DIAS[entrada.toLowerCase()];
+  return valor !== undefined ? valor : null;
+}
+
+/**
+ * Parsea una expresión de hora como "9am", "9:30am", "14:00", "9:30 pm".
+ * Retorna { hora, minuto } o null si el formato no se reconoce o los valores
+ * están fuera de rango.
+ *
+ * @param {string} entrada
+ * @returns {{ hora: number, minuto: number }|null}
+ */
+function parsearHora(entrada) {
+  // Acepta: "9", "9am", "9:30am", "9:30 pm", "14:00", "21"
+  const coincidencia = entrada.match(/^(\d{1,2})(?::(\d{2}))?\s*(am|pm)?$/i);
+  if (!coincidencia) return null;
+
+  let hora = parseInt(coincidencia[1], 10);
+  const minuto = coincidencia[2] ? parseInt(coincidencia[2], 10) : 0;
+  const ampm = coincidencia[3] ? coincidencia[3].toLowerCase() : null;
+
+  if (ampm === 'pm' && hora < 12) hora += 12;
+  if (ampm === 'am' && hora === 12) hora = 0;
+
+  if (hora < 0 || hora > 23 || minuto < 0 || minuto > 59) return null;
+  return { hora, minuto };
+}
+
+/**
+ * Formatea la hora para descripción legible en inglés (para consistencia con origen).
+ * Ej: hora=9, minuto=0 → "9:00 AM"; hora=14, minuto=30 → "2:30 PM"
+ *
+ * @param {number} hora
+ * @param {number} minuto
+ * @returns {string}
+ */
+function formatearHoraLegible(hora, minuto) {
+  const sufijo = hora < 12 ? 'AM' : 'PM';
+  const horaDisplay = hora % 12 || 12;
+  const minutoDisplay = minuto > 0 ? `:${String(minuto).padStart(2, '0')}` : '';
+  return `${horaDisplay}${minutoDisplay} ${sufijo}`;
+}
+
+// Regex para detectar expresiones cron crudas de 5 campos
+const REGEX_CRON = /^(\*|[\d,\-\/]+)\s+(\*|[\d,\-\/]+)\s+(\*|[\d,\-\/]+)\s+(\*|[\d,\-\/]+)\s+(\*|[\d,\-\/]+)$/;
+
+// ---------------------------------------------------------------------------
+// Función principal de parseo
+// ---------------------------------------------------------------------------
+
+/**
+ * Parsea una expresión de schedule en lenguaje natural o cron crudo.
+ *
+ * Retorna un objeto con la expresión cron equivalente y una descripción
+ * legible en inglés. Retorna null si la expresión no se reconoce.
+ *
+ * @param {string} texto - Frase en lenguaje natural o expresión cron cruda.
+ * @returns {{ cron: string, descripcion: string }|null}
+ */
+function parseNaturalSchedule(texto) {
+  if (!texto || typeof texto !== 'string') return null;
+  const entrada = texto.trim();
+  if (!entrada) return null;
+
+  // Passthrough: expresión cron cruda de 5 campos
+  if (REGEX_CRON.test(entrada)) {
+    return { cron: entrada, descripcion: `Programación personalizada (${entrada})` };
+  }
+
+  const lower = entrada.toLowerCase();
+
+  // "hourly"
+  if (lower === 'hourly') {
+    return { cron: '0 * * * *', descripcion: 'Cada hora' };
+  }
+
+  // "daily" / "every day"
+  if (lower === 'daily' || lower === 'every day') {
+    return { cron: '0 9 * * *', descripcion: 'Diariamente a las 9:00 AM' };
+  }
+
+  // "weekly" (sin día específico)
+  if (lower === 'weekly') {
+    return { cron: '0 9 * * 1', descripcion: 'Cada lunes a las 9:00 AM' };
+  }
+
+  // "every N minutes"
+  const cadaNMinutos = lower.match(/^every\s+(\d+)\s+minutes?$/);
+  if (cadaNMinutos) {
+    const n = parseInt(cadaNMinutos[1], 10);
+    if (n > 0 && n <= 59) {
+      return {
+        cron: `*/${n} * * * *`,
+        descripcion: `Cada ${n} minuto${n > 1 ? 's' : ''}`,
+      };
+    }
+  }
+
+  // "every N hours"
+  const cadaNHoras = lower.match(/^every\s+(\d+)\s+hours?$/);
+  if (cadaNHoras) {
+    const n = parseInt(cadaNHoras[1], 10);
+    if (n > 0 && n <= 23) {
+      return {
+        cron: `0 */${n} * * *`,
+        descripcion: `Cada ${n} hora${n > 1 ? 's' : ''}`,
+      };
+    }
+  }
+
+  // "every morning at TIME" / "every evening at TIME" / "every day at TIME" / "daily at TIME"
+  const diarioA = lower.match(/^(?:every\s+(?:morning|evening|day)|daily)\s+at\s+(.+)$/);
+  if (diarioA) {
+    const tiempo = parsearHora(diarioA[1]);
+    if (tiempo) {
+      return {
+        cron: `${tiempo.minuto} ${tiempo.hora} * * *`,
+        descripcion: `Diariamente a las ${formatearHoraLegible(tiempo.hora, tiempo.minuto)}`,
+      };
+    }
+  }
+
+  // "at TIME every day"
+  const aTiempoCadaDia = lower.match(/^at\s+(.+?)\s+every\s+day$/);
+  if (aTiempoCadaDia) {
+    const tiempo = parsearHora(aTiempoCadaDia[1]);
+    if (tiempo) {
+      return {
+        cron: `${tiempo.minuto} ${tiempo.hora} * * *`,
+        descripcion: `Diariamente a las ${formatearHoraLegible(tiempo.hora, tiempo.minuto)}`,
+      };
+    }
+  }
+
+  // "weekly on DAYNAME" / "every DAYNAME" (sin hora)
+  const semanalEn = lower.match(/^(?:weekly\s+on|every)\s+(\w+)$/);
+  if (semanalEn) {
+    const numDia = parsearNombreDia(semanalEn[1]);
+    if (numDia !== null) {
+      const nombreDia = semanalEn[1].charAt(0).toUpperCase() + semanalEn[1].slice(1);
+      return {
+        cron: `0 9 * * ${numDia}`,
+        descripcion: `Cada ${nombreDia} a las 9:00 AM`,
+      };
+    }
+  }
+
+  // "every DAYNAME at TIME"
+  const cadaDiaA = lower.match(/^every\s+(\w+)\s+at\s+(.+)$/);
+  if (cadaDiaA) {
+    const numDia = parsearNombreDia(cadaDiaA[1]);
+    if (numDia !== null) {
+      const tiempo = parsearHora(cadaDiaA[2]);
+      if (tiempo) {
+        const nombreDia = cadaDiaA[1].charAt(0).toUpperCase() + cadaDiaA[1].slice(1);
+        return {
+          cron: `${tiempo.minuto} ${tiempo.hora} * * ${numDia}`,
+          descripcion: `Cada ${nombreDia} a las ${formatearHoraLegible(tiempo.hora, tiempo.minuto)}`,
+        };
+      }
+    }
+  }
+
+  return null;
+}
+
+// ---------------------------------------------------------------------------
+// Verificación de ejecución pendiente
+// ---------------------------------------------------------------------------
+
+/**
+ * Evalúa si una expresión cron está pendiente de ejecutarse en la fecha dada,
+ * evitando lanzamientos duplicados dentro del mismo minuto.
+ *
+ * @param {string}  cronExpr         - Expresión cron de 5 campos.
+ * @param {number}  ahoraMs          - Timestamp actual en milisegundos.
+ * @param {number}  [ultimoLanzadoMs=0] - Timestamp de la última ejecución en ms.
+ * @returns {boolean}
+ */
+function isCronDue(cronExpr, ahoraMs, ultimoLanzadoMs = 0) {
+  const ahora = new Date(ahoraMs);
+  const partes = cronExpr.split(/\s+/);
+  if (partes.length !== 5) return false;
+
+  const [exprMin, exprHora, , , exprDow] = partes;
+
+  if (!coincideCampoCron(exprMin,  ahora.getMinutes())) return false;
+  if (!coincideCampoCron(exprHora, ahora.getHours()))   return false;
+  if (!coincideCampoCron(exprDow,  ahora.getDay()))     return false;
+
+  // Prevenir doble lanzamiento dentro del mismo minuto
+  if (ultimoLanzadoMs > 0) {
+    const ultimo = new Date(ultimoLanzadoMs);
+    if (
+      ultimo.getFullYear() === ahora.getFullYear() &&
+      ultimo.getMonth()    === ahora.getMonth()    &&
+      ultimo.getDate()     === ahora.getDate()     &&
+      ultimo.getHours()    === ahora.getHours()    &&
+      ultimo.getMinutes()  === ahora.getMinutes()
+    ) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+/**
+ * Evalúa si un campo cron (ej: "(asterisco)/5", "1,3,5", "9-17", "*") coincide con
+ * el valor numérico dado.
+ *
+ * @param {string} expr  - Campo cron.
+ * @param {number} valor - Valor actual (ej: hora, minuto, día).
+ * @returns {boolean}
+ */
+function coincideCampoCron(expr, valor) {
+  if (expr === '*') return true;
+
+  // Paso: */N
+  if (expr.startsWith('*/')) {
+    const paso = parseInt(expr.slice(2), 10);
+    return paso > 0 && valor % paso === 0;
+  }
+
+  // Valores separados por coma
+  const segmentos = expr.split(',');
+  for (const seg of segmentos) {
+    // Rango: N-M
+    if (seg.includes('-')) {
+      const [inicio, fin] = seg.split('-').map(Number);
+      if (valor >= inicio && valor <= fin) return true;
+    } else {
+      if (parseInt(seg, 10) === valor) return true;
+    }
+  }
+
+  return false;
+}
+
+// ---------------------------------------------------------------------------
+// Exports
+// ---------------------------------------------------------------------------
+
+module.exports = {
+  parseNaturalSchedule,
+  isCronDue,
+  // Exponer helpers para tests y uso avanzado
+  parsearNombreDia,
+  parsearHora,
+  coincideCampoCron,
+};

package/scripts/lib/scoring-instintos.js

@@ -0,0 +1,240 @@
+'use strict';
+
+/**
+ * scoring-instintos.js
+ *
+ * Sistema de decay exponencial + maturity transitions para instintos.
+ *
+ * Patrón adaptado de ACE (Agentic Context Engineering) en
+ * `temp/cass_memory_system-main/src/scoring.ts`. Diferencias:
+ *   - Funciones puras zero-deps (Node stdlib only).
+ *   - Backward compatible: instintos sin los campos nuevos siguen siendo válidos.
+ *   - No persiste — el caller decide cuándo escribir el resultado.
+ *
+ * Modelo:
+ *   - `confidence` original es estática (asignada al crear).
+ *   - `effective_confidence` se calcula dinámicamente:
+ *       confidence × decay_factor − harmful_penalty
+ *   - `decay_factor` = 2^(-days_since_validated / half_life_days) (default 90d).
+ *   - `harmful_penalty` = HARMFUL_PENALTY_WEIGHT × harmful_ratio.
+ *   - `maturity` se deriva de effective_confidence + evidence_count + harmful_ratio.
+ *   - `shouldAutoDeprecate` cuando harmful_ratio > HARMFUL_RATIO_THRESHOLD
+ *     con al menos MIN_FEEDBACK_FOR_DEPRECATION eventos.
+ *
+ * Campos NUEVOS opcionales en instintos (todos con defaults seguros):
+ *   - decay_half_life_days  (default: 90)
+ *   - helpful_count         (default: 0)
+ *   - harmful_count         (default: 0)
+ *   - last_validated_at     (default: last_validated, o created_at)
+ *
+ * @module scripts/lib/scoring-instintos
+ */
+
+// ── constantes ────────────────────────────────────────────────────────────────
+
+const HALF_LIFE_DEFAULT_DAYS       = 90;
+const HARMFUL_RATIO_THRESHOLD      = 0.3;
+const MIN_FEEDBACK_FOR_DEPRECATION = 3;
+const HARMFUL_PENALTY_WEIGHT       = 0.5;
+const PROVEN_CONFIDENCE_THRESHOLD  = 0.7;
+const ESTABLISHED_THRESHOLD        = 0.5;
+const PROVEN_EVIDENCE_THRESHOLD    = 3;
+
+// ── helpers ───────────────────────────────────────────────────────────────────
+
+/**
+ * Días enteros entre dos fechas YYYY-MM-DD (o Date).
+ * Tolerante a formato inválido: devuelve 0 si no parsea.
+ */
+function daysBetween(d1, d2) {
+  const t1 = d1 instanceof Date ? d1.getTime() : Date.parse(String(d1));
+  const t2 = d2 instanceof Date ? d2.getTime() : Date.parse(String(d2));
+  if (Number.isNaN(t1) || Number.isNaN(t2)) return 0;
+  const diffMs = Math.abs(t2 - t1);
+  return Math.floor(diffMs / (24 * 3600 * 1000));
+}
+
+function clamp(n, min, max) {
+  if (Number.isNaN(n)) return min;
+  return Math.max(min, Math.min(max, n));
+}
+
+function getValidatedDate(instinto) {
+  return instinto.last_validated_at
+      || instinto.last_validated
+      || instinto.created_at
+      || null;
+}
+
+// ── funciones puras de scoring ────────────────────────────────────────────────
+
+/**
+ * Factor de decay exponencial.
+ *
+ * decay(0)      = 1.0
+ * decay(half)   = 0.5
+ * decay(2×half) = 0.25
+ *
+ * @param {number} daysSinceValidated
+ * @param {number} [halfLifeDays=90]
+ * @returns {number} factor en [0, 1]
+ */
+function decayFactor(daysSinceValidated, halfLifeDays = HALF_LIFE_DEFAULT_DAYS) {
+  if (daysSinceValidated <= 0) return 1.0;
+  if (halfLifeDays <= 0) return 1.0;
+  return Math.pow(2, -daysSinceValidated / halfLifeDays);
+}
+
+/**
+ * Ratio de feedback dañino sobre el total de feedback recibido.
+ * Devuelve 0 si no hay feedback.
+ */
+function harmfulRatio(instinto) {
+  const helpful = instinto.helpful_count || 0;
+  const harmful = instinto.harmful_count || 0;
+  const total = helpful + harmful;
+  if (total === 0) return 0;
+  return harmful / total;
+}
+
+/**
+ * Confianza efectiva considerando decay temporal y feedback negativo.
+ *
+ * @param {object} instinto
+ * @param {string|Date} [currentDate=now] — fecha de referencia
+ * @returns {number} en [0, 1]
+ */
+function effectiveConfidence(instinto, currentDate) {
+  const now = currentDate || new Date();
+  const validatedAt = getValidatedDate(instinto);
+  const halfLife = instinto.decay_half_life_days || HALF_LIFE_DEFAULT_DAYS;
+
+  const days = validatedAt ? daysBetween(validatedAt, now) : 0;
+  const decay = decayFactor(days, halfLife);
+  const baseConfidence = clamp(instinto.confidence || 0, 0, 1);
+  const penalty = HARMFUL_PENALTY_WEIGHT * harmfulRatio(instinto);
+
+  return clamp(baseConfidence * decay - penalty, 0, 1);
+}
+
+/**
+ * Si el feedback negativo supera el umbral, recomendar auto-deprecación.
+ * Requiere al menos MIN_FEEDBACK_FOR_DEPRECATION eventos para evitar
+ * sobre-reaccionar a un solo voto.
+ */
+function shouldAutoDeprecate(instinto) {
+  const helpful = instinto.helpful_count || 0;
+  const harmful = instinto.harmful_count || 0;
+  const total = helpful + harmful;
+  if (total < MIN_FEEDBACK_FOR_DEPRECATION) return false;
+  return harmfulRatio(instinto) > HARMFUL_RATIO_THRESHOLD;
+}
+
+/**
+ * Estado de maduración derivado de effective_confidence + evidencia + feedback.
+ *
+ * Estados:
+ *   - candidate    : effective < 0.5 (recién aprendido o decaído)
+ *   - established  : 0.5 ≤ effective < 0.7
+ *   - proven       : effective ≥ 0.7 AND evidence_count ≥ 3
+ *   - deprecated   : shouldAutoDeprecate, status === 'archived', o
+ *                    status === 'degraded' con contradictions ≥ 3
+ */
+function maturityState(instinto, currentDate) {
+  if (instinto.status === 'archived') return 'deprecated';
+  if (shouldAutoDeprecate(instinto)) return 'deprecated';
+  if (instinto.status === 'degraded' && (instinto.contradictions || 0) >= 3) {
+    return 'deprecated';
+  }
+
+  const eff = effectiveConfidence(instinto, currentDate);
+  const evidence = instinto.evidence_count || 0;
+
+  if (eff >= PROVEN_CONFIDENCE_THRESHOLD && evidence >= PROVEN_EVIDENCE_THRESHOLD) {
+    return 'proven';
+  }
+  if (eff >= ESTABLISHED_THRESHOLD) return 'established';
+  return 'candidate';
+}
+
+/**
+ * Aplicar feedback al instinto (pure: devuelve copia).
+ * type: 'helpful' | 'harmful'
+ *
+ * Refresca last_validated_at — un feedback es una validación implícita.
+ */
+function applyFeedback(instinto, type, currentDate) {
+  if (type !== 'helpful' && type !== 'harmful') {
+    throw new Error(`Tipo de feedback inválido: ${type}`);
+  }
+  const now = (currentDate instanceof Date)
+    ? currentDate.toISOString().slice(0, 10)
+    : (currentDate || new Date().toISOString().slice(0, 10));
+
+  const next = { ...instinto };
+  if (type === 'helpful') next.helpful_count = (next.helpful_count || 0) + 1;
+  else next.harmful_count = (next.harmful_count || 0) + 1;
+  next.last_validated_at = now;
+  return next;
+}
+
+/**
+ * Recomputa status legacy + maturity como vista unificada.
+ * Pure: devuelve un objeto enriquecido sin mutar el original.
+ *
+ * Si shouldAutoDeprecate, propone status='degraded' (no archive — el archive
+ * es decisión humana). El caller decide si persistir el cambio.
+ */
+function recomputeStatus(instinto, currentDate) {
+  const maturity = maturityState(instinto, currentDate);
+  const effective = effectiveConfidence(instinto, currentDate);
+  const proposed = { ...instinto, maturity, effective_confidence: Math.round(effective * 1000) / 1000 };
+
+  if (shouldAutoDeprecate(instinto) && instinto.status !== 'archived') {
+    proposed.status_proposed = 'degraded';
+    proposed.deprecation_reason = `harmful_ratio=${harmfulRatio(instinto).toFixed(2)} con ${(instinto.helpful_count||0)+(instinto.harmful_count||0)} eventos`;
+  }
+
+  return proposed;
+}
+
+/**
+ * Adjuntar source tracing a un instinto (pure: devuelve copia).
+ * Mantiene unicidad y orden de inserción.
+ */
+function addSource(instinto, { sessionId, agentName } = {}) {
+  const next = { ...instinto };
+  if (sessionId) {
+    const s = new Set(next.source_sessions || []);
+    s.add(sessionId);
+    next.source_sessions = [...s];
+  }
+  if (agentName) {
+    const a = new Set(next.source_agents || []);
+    a.add(agentName);
+    next.source_agents = [...a];
+  }
+  return next;
+}
+
+// ── exports ───────────────────────────────────────────────────────────────────
+
+module.exports = {
+  daysBetween,
+  decayFactor,
+  harmfulRatio,
+  effectiveConfidence,
+  shouldAutoDeprecate,
+  maturityState,
+  applyFeedback,
+  recomputeStatus,
+  addSource,
+  // constantes exportadas para tests y configuración
+  HALF_LIFE_DEFAULT_DAYS,
+  HARMFUL_RATIO_THRESHOLD,
+  MIN_FEEDBACK_FOR_DEPRECATION,
+  HARMFUL_PENALTY_WEIGHT,
+  PROVEN_CONFIDENCE_THRESHOLD,
+  ESTABLISHED_THRESHOLD,
+  PROVEN_EVIDENCE_THRESHOLD,
+};

package/scripts/lib/seguridad.js

@@ -0,0 +1,160 @@
+'use strict';
+
+/**
+ * Módulo de seguridad SWL
+ * Prevención de path traversal, prompt injection y comandos peligrosos.
+ */
+
+const path = require('path');
+
+// Patrones de path traversal
+const PATRONES_TRAVERSAL = [
+  /\.\.\//g,
+  /\.\.\\/g,
+  /~\//g,
+  /%2e%2e/gi,
+  /%252e%252e/gi,
+];
+
+// Comandos peligrosos que requieren confirmación
+const COMANDOS_PELIGROSOS = [
+  /rm\s+(-rf?|--recursive)/i,
+  /rmdir/i,
+  /del\s+\/[sfq]/i,
+  /format\s+[a-z]:/i,
+  /drop\s+(table|database|schema)/i,
+  /truncate\s+table/i,
+  /delete\s+from\s+\w+\s*(;|\s*$)/i,
+  /git\s+push\s+.*--force/i,
+  /git\s+reset\s+--hard/i,
+  /chmod\s+777/i,
+  /curl.*\|\s*(bash|sh|zsh)/i,
+];
+
+// Patrones de prompt injection
+const PATRONES_INJECTION = [
+  /ignore\s+(all\s+)?previous\s+instructions/i,
+  /you\s+are\s+now\s+/i,
+  /forget\s+(all\s+)?your\s+(previous\s+)?instructions/i,
+  /system\s*:\s*you\s+are/i,
+  /\[INST\]/i,
+  /<\|im_start\|>/i,
+  /\{\{.*system.*\}\}/i,
+];
+
+// Lista de archivos/patrones sensibles
+// NOTA: Los patrones deben ser específicos para evitar falsos positivos
+// con nombres de skills/hooks del sistema (ej. "design-tokens", "iam-secretos")
+const ARCHIVOS_SENSIBLES = [
+  /\.env$/,
+  /\.env\.\w+$/,
+  /credentials\.json$/,
+  /\.pem$/,
+  /\.key$/,
+  /id_rsa/,
+  /\.ssh\//,
+  /^\.?password$/i,
+  /\.secret$/i,
+  /secret[_-]?key/i,
+  /\.token$/i,
+  /access[_-]?token/i,
+  /auth[_-]?token/i,
+  /\.npmrc$/,
+  /\.netrc$/,
+];
+
+/**
+ * Valida que una ruta no contenga path traversal
+ */
+function validarRuta(rutaBase, rutaDestino) {
+  const resuelta = path.resolve(rutaBase, rutaDestino);
+  const baseNormalizada = path.resolve(rutaBase);
+
+  if (!resuelta.startsWith(baseNormalizada)) {
+    throw new Error(
+      `Ruta bloqueada por seguridad: "${rutaDestino}" intenta salir de "${rutaBase}"`
+    );
+  }
+
+  for (const patron of PATRONES_TRAVERSAL) {
+    if (patron.test(rutaDestino)) {
+      throw new Error(
+        `Path traversal detectado en: "${rutaDestino}"`
+      );
+    }
+  }
+
+  return resuelta;
+}
+
+/**
+ * Verifica si un comando es potencialmente peligroso
+ */
+function esComandoPeligroso(comando) {
+  for (const patron of COMANDOS_PELIGROSOS) {
+    if (patron.test(comando)) {
+      return {
+        peligroso: true,
+        razon: `Comando coincide con patrón peligroso: ${patron}`,
+      };
+    }
+  }
+  return { peligroso: false };
+}
+
+/**
+ * Detecta intentos de prompt injection en contenido
+ */
+function detectarInjection(contenido) {
+  const hallazgos = [];
+  for (const patron of PATRONES_INJECTION) {
+    if (patron.test(contenido)) {
+      hallazgos.push({
+        patron: patron.toString(),
+        tipo: 'prompt_injection',
+      });
+    }
+  }
+  return hallazgos;
+}
+
+/**
+ * Verifica si un archivo es sensible (no debería commitearse)
+ */
+function esArchivoSensible(nombreArchivo) {
+  return ARCHIVOS_SENSIBLES.some(patron => patron.test(nombreArchivo));
+}
+
+/**
+ * Sanitiza texto para prevenir inyección en plantillas
+ */
+function sanitizar(texto) {
+  if (typeof texto !== 'string') return '';
+  return texto
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/\$/g, '&#36;')
+    .replace(/`/g, '&#96;');
+}
+
+/**
+ * Filtra secretos de un texto de log
+ */
+function filtrarSecretos(texto) {
+  if (typeof texto !== 'string') return '';
+  // Reemplazar patrones comunes de tokens/keys
+  return texto
+    .replace(/(api[_-]?key|token|secret|password|credential)['":\s]*[=:]\s*['"]?[\w\-./+=]{8,}['"]?/gi, '$1=***FILTRADO***')
+    .replace(/Bearer\s+[\w\-./+=]+/g, 'Bearer ***FILTRADO***')
+    .replace(/ghp_[\w]+/g, 'ghp_***FILTRADO***')
+    .replace(/sk-[\w]+/g, 'sk-***FILTRADO***');
+}
+
+module.exports = {
+  validarRuta,
+  esComandoPeligroso,
+  detectarInjection,
+  esArchivoSensible,
+  sanitizar,
+  filtrarSecretos,
+};