@saulwade/swl-ses 1.3.8 → 1.4.1

package/scripts/audit-tools/audit-history.js

@@ -0,0 +1,330 @@
+// Adaptado de temp/ultraship-main/tools/audit-history.mjs bajo MIT License
+// Fuente: Houseofmvps/ultraship (https://github.com/Houseofmvps/ultraship)
+'use strict';
+
+const { readFileSync, writeFileSync, appendFileSync, existsSync, mkdirSync } = require('fs');
+const { join, resolve, dirname } = require('path');
+const { outputJSON, outputError } = require('./lib/output');
+
+/** Número máximo de entradas a conservar por categoría. */
+const MAX_ENTRIES_PER_CATEGORY = 100;
+
+/** Ruta por defecto del historial de auditorías. */
+const DEFAULT_HISTORY_PATH = join(process.cwd(), '.planning', 'audit', 'history.jsonl');
+
+/**
+ * Lee todas las entradas del historial JSONL.
+ * @param {string} historyPath
+ * @returns {object[]}
+ */
+function readHistory(historyPath) {
+  if (!existsSync(historyPath)) return [];
+  try {
+    return readFileSync(historyPath, 'utf8')
+      .split('\n')
+      .filter(Boolean)
+      .map(line => JSON.parse(line));
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Reescribe el archivo JSONL completo con las entradas proporcionadas.
+ * @param {string} historyPath
+ * @param {object[]} entries
+ */
+function writeHistory(historyPath, entries) {
+  const dir = dirname(historyPath);
+  mkdirSync(dir, { recursive: true, mode: 0o700 });
+  writeFileSync(historyPath, entries.map(e => JSON.stringify(e)).join('\n') + (entries.length > 0 ? '\n' : ''), 'utf8');
+}
+
+/**
+ * Agrega una nueva entrada al historial JSONL, respetando el límite de 100 por categoría.
+ * Si se supera el límite, reescribe el archivo con las entradas más recientes de esa categoría.
+ *
+ * @param {string} historyPath
+ * @param {object} entry       - Objeto que DEBE incluir campos `category` y `timestamp`.
+ */
+function appendHistory(historyPath, entry) {
+  const dir = dirname(historyPath);
+  mkdirSync(dir, { recursive: true, mode: 0o700 });
+
+  const existing = readHistory(historyPath);
+  const category = entry.category || 'general';
+
+  // Filtrar entradas de la misma categoría
+  const sameCategory = existing.filter(e => (e.category || 'general') === category);
+
+  if (sameCategory.length >= MAX_ENTRIES_PER_CATEGORY) {
+    // Hay que podar: mantener las (MAX-1) más recientes de esta categoría + agregar la nueva
+    const otherCategories = existing.filter(e => (e.category || 'general') !== category);
+    const trimmed = sameCategory.slice(-(MAX_ENTRIES_PER_CATEGORY - 1));
+    writeHistory(historyPath, [...otherCategories, ...trimmed, entry]);
+  } else {
+    // Hay espacio: solo hacer append
+    appendFileSync(historyPath, JSON.stringify(entry) + '\n', 'utf8');
+  }
+}
+
+/**
+ * Obtiene la última entrada de una categoría específica.
+ * @param {object[]} entries
+ * @param {string}   category
+ * @returns {object|null}
+ */
+function getLastEntryForCategory(entries, category) {
+  const categoryEntries = entries.filter(e => (e.category || 'general') === category);
+  if (categoryEntries.length === 0) return null;
+  return categoryEntries[categoryEntries.length - 1];
+}
+
+/**
+ * Calcula la tendencia comparando el score actual con el anterior.
+ * @param {number} current
+ * @param {number} previous
+ * @returns {'improving'|'declining'|'stable'}
+ */
+function calculateTrend(current, previous) {
+  if (current > previous + 0.5) return 'improving';
+  if (current < previous - 0.5) return 'declining';
+  return 'stable';
+}
+
+/**
+ * Formatea un número como diferencia con signo.
+ * @param {number} diff
+ * @returns {string}
+ */
+function formatDiff(diff) {
+  if (diff > 0)  return `+${diff.toFixed(1)}`;
+  if (diff < 0)  return diff.toFixed(1);
+  return '0.0';
+}
+
+/**
+ * Guarda una nueva entrada de auditoría en el historial.
+ * @param {object} options
+ * @param {string} options.historyPath
+ * @param {string} options.category     - Categoría de la auditoría (ej: 'security', 'performance').
+ * @param {number} options.score        - Puntuación de 0 a 100.
+ * @param {object} [options.metadata]   - Datos adicionales opcionales.
+ * @returns {object} Entrada guardada + tendencia detectada.
+ */
+function saveEntry(options) {
+  const { historyPath, category, score, metadata = {} } = options;
+
+  const existing = readHistory(historyPath);
+  const previous = getLastEntryForCategory(existing, category);
+
+  const entry = {
+    timestamp: new Date().toISOString(),
+    category,
+    score,
+    metadata,
+  };
+
+  appendHistory(historyPath, entry);
+
+  const trend = previous !== null
+    ? calculateTrend(score, previous.score)
+    : 'first_run';
+
+  return {
+    entry,
+    trend,
+    previous_score: previous ? previous.score : null,
+    diff: previous ? score - previous.score : null,
+  };
+}
+
+/**
+ * Muestra el historial de una categoría con tendencias.
+ * @param {string} historyPath
+ * @param {string} [category]   - Si se omite, muestra todas las categorías.
+ * @param {number} [limit]      - Número máximo de entradas a mostrar.
+ * @returns {object}
+ */
+function showHistory(historyPath, category, limit) {
+  const all = readHistory(historyPath);
+  const filtered = category
+    ? all.filter(e => (e.category || 'general') === category)
+    : all;
+
+  const entries = limit ? filtered.slice(-limit) : filtered;
+
+  // Agrupar por categoría para estadísticas
+  const byCategory = {};
+  for (const entry of all) {
+    const cat = entry.category || 'general';
+    if (!byCategory[cat]) byCategory[cat] = [];
+    byCategory[cat].push(entry.score);
+  }
+
+  const summaries = Object.entries(byCategory).map(([cat, scores]) => {
+    const avg = scores.reduce((s, v) => s + v, 0) / scores.length;
+    const last = scores[scores.length - 1];
+    const prev = scores.length >= 2 ? scores[scores.length - 2] : null;
+    return {
+      category:    cat,
+      entries:     scores.length,
+      avg_score:   Math.round(avg * 10) / 10,
+      last_score:  last,
+      trend:       prev !== null ? calculateTrend(last, prev) : 'first_run',
+    };
+  });
+
+  return {
+    total_entries: filtered.length,
+    shown:         entries.length,
+    category_filter: category || null,
+    summaries,
+    entries,
+  };
+}
+
+/**
+ * Calcula el diff entre la última y penúltima entrada de una categoría.
+ * @param {string} historyPath
+ * @param {string} category
+ * @returns {object}
+ */
+function diffHistory(historyPath, category) {
+  const all = readHistory(historyPath);
+  const categoryEntries = category
+    ? all.filter(e => (e.category || 'general') === category)
+    : all;
+
+  if (categoryEntries.length === 0) {
+    return { success: false, message: `Sin entradas en el historial para categoría: ${category || 'todas'}` };
+  }
+
+  if (categoryEntries.length === 1) {
+    return {
+      success:        true,
+      message:        'Solo existe una entrada — no hay diff disponible',
+      current:        categoryEntries[0],
+      previous:       null,
+      diff:           null,
+      trend:          'first_run',
+    };
+  }
+
+  const current  = categoryEntries[categoryEntries.length - 1];
+  const previous = categoryEntries[categoryEntries.length - 2];
+  const diff     = current.score - previous.score;
+  const trend    = calculateTrend(current.score, previous.score);
+
+  // Comparar metadata keys si existen
+  const metaDiff = [];
+  const currMeta = current.metadata  || {};
+  const prevMeta = previous.metadata || {};
+
+  const allKeys = new Set([...Object.keys(currMeta), ...Object.keys(prevMeta)]);
+  for (const key of allKeys) {
+    const curr = currMeta[key];
+    const prev = prevMeta[key];
+    if (curr !== prev) {
+      metaDiff.push({ key, current: curr, previous: prev });
+    }
+  }
+
+  return {
+    success:        true,
+    category:       category || 'todas',
+    current,
+    previous,
+    diff:           parseFloat(formatDiff(diff)),
+    diff_formatted: formatDiff(diff),
+    trend,
+    metadata_changes: metaDiff,
+  };
+}
+
+function main() {
+  const args        = process.argv.slice(2);
+  const command     = args[0];
+  const historyPath = (() => {
+    const hp = args.find(a => a.startsWith('--history='));
+    return hp ? resolve(hp.split('=')[1]) : DEFAULT_HISTORY_PATH;
+  })();
+
+  if (command === 'save') {
+    // save --category=X --score=N [--meta-key=value ...]
+    const categoryArg = args.find(a => a.startsWith('--category='));
+    const scoreArg    = args.find(a => a.startsWith('--score='));
+
+    if (!categoryArg || !scoreArg) {
+      outputError('Uso: audit-history.js save --category=X --score=N [--history=ruta] [--meta-KEY=VALOR ...]');
+      process.exit(0);
+    }
+
+    const category = categoryArg.split('=')[1];
+    const score    = parseFloat(scoreArg.split('=')[1]);
+
+    if (isNaN(score)) {
+      outputError(`Puntuación inválida: ${scoreArg.split('=')[1]}`);
+      process.exit(0);
+    }
+
+    // Extraer metadata extra (--meta-KEY=VALOR)
+    const metadata = {};
+    for (const arg of args) {
+      if (arg.startsWith('--meta-')) {
+        const rest     = arg.slice(7); // quitar "--meta-"
+        const eqIndex  = rest.indexOf('=');
+        if (eqIndex > 0) {
+          const key    = rest.slice(0, eqIndex);
+          const value  = rest.slice(eqIndex + 1);
+          metadata[key] = value;
+        }
+      }
+    }
+
+    const result = saveEntry({ historyPath, category, score, metadata });
+    outputJSON({
+      success:        true,
+      saved:          result.entry,
+      trend:          result.trend,
+      previous_score: result.previous_score,
+      diff:           result.diff,
+    });
+
+  } else if (command === 'show') {
+    const categoryArg = args.find(a => a.startsWith('--category='));
+    const limitArg    = args.find(a => a.startsWith('--limit='));
+    const category    = categoryArg ? categoryArg.split('=')[1] : undefined;
+    const limit       = limitArg    ? parseInt(limitArg.split('=')[1], 10) : 20;
+
+    const result = showHistory(historyPath, category, limit);
+    outputJSON({ success: true, ...result });
+
+  } else if (command === 'diff') {
+    const categoryArg = args.find(a => a.startsWith('--category='));
+    const category    = categoryArg ? categoryArg.split('=')[1] : undefined;
+
+    const result = diffHistory(historyPath, category);
+    outputJSON(result);
+
+  } else {
+    outputError(`Comando desconocido: "${command || '(ninguno)'}". Comandos válidos: save, show, diff`);
+    process.exit(0);
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  readHistory,
+  writeHistory,
+  appendHistory,
+  saveEntry,
+  showHistory,
+  diffHistory,
+  calculateTrend,
+  getLastEntryForCategory,
+  MAX_ENTRIES_PER_CATEGORY,
+};

package/scripts/audit-tools/bundle-tracker.js

@@ -0,0 +1,290 @@
+// Adaptado de temp/ultraship-main/tools/bundle-tracker.mjs bajo MIT License
+// Fuente: Houseofmvps/ultraship (https://github.com/Houseofmvps/ultraship)
+'use strict';
+
+const { readFileSync, appendFileSync, existsSync, readdirSync, statSync, mkdirSync } = require('fs');
+const { join, relative, extname, resolve } = require('path');
+const { outputJSON, outputError } = require('./lib/output');
+
+/**
+ * Formatea bytes a unidad legible.
+ * @param {number} bytes
+ * @returns {string}
+ */
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${Math.round(bytes / 1024 * 10) / 10}KB`;
+  return `${Math.round(bytes / (1024 * 1024) * 10) / 10}MB`;
+}
+
+/**
+ * Detecta el directorio de build de un proyecto.
+ * @param {string} dir
+ * @returns {{ dir: string, path: string } | null}
+ */
+function findBuildOutput(dir) {
+  const candidates = ['dist', 'build', '.next', 'out', '.output', '.vercel/output'];
+  for (const d of candidates) {
+    const p = join(dir, d);
+    try {
+      if (existsSync(p) && statSync(p).isDirectory()) return { dir: d, path: p };
+    } catch { /* skip */ }
+  }
+  return null;
+}
+
+/**
+ * Recorre recursivamente un directorio y devuelve archivos con las extensiones indicadas.
+ * @param {string} dir
+ * @param {string[]} extensions
+ * @returns {{ path: string, size: number }[]}
+ */
+function walkFiles(dir, extensions) {
+  const extSet = new Set(extensions.map(e => e.toLowerCase()));
+  const files = [];
+
+  function walk(d) {
+    try {
+      for (const entry of readdirSync(d)) {
+        if (entry.startsWith('.')) continue;
+        const p = join(d, entry);
+        try {
+          const s = statSync(p);
+          if (s.isDirectory()) walk(p);
+          else if (extSet.has(extname(entry).toLowerCase())) {
+            files.push({ path: p, size: s.size });
+          }
+        } catch { /* skip */ }
+      }
+    } catch { /* skip */ }
+  }
+
+  walk(dir);
+  return files;
+}
+
+/** Dependencias pesadas conocidas con estimación de tamaño y alternativas. */
+const HEAVY_DEPS = {
+  'moment': { size: '300KB+', alternative: 'dayjs (2KB)' },
+  'lodash': { size: '70KB+', alternative: 'lodash-es o imports individuales' },
+  'jquery': { size: '90KB+', alternative: 'APIs DOM nativas' },
+  'axios': { size: '30KB+', alternative: 'fetch nativo' },
+  'underscore': { size: '30KB+', alternative: 'métodos nativos de Array' },
+  'core-js': { size: '150KB+', alternative: 'polyfills específicos únicamente' },
+  'date-fns': { size: '75KB+ (completo)', alternative: 'importar solo funciones necesarias' },
+  'validator': { size: '50KB+', alternative: 'zod o comprobaciones individuales' },
+  'bluebird': { size: '80KB+', alternative: 'Promises nativas' },
+  'request': { size: '50KB+', alternative: 'fetch nativo o undici' },
+};
+
+/**
+ * Analiza las dependencias del package.json en un directorio.
+ * @param {string} dir
+ * @returns {{ production_deps: number, dev_deps: number, heavy_deps: object[] } | null}
+ */
+function analyzeDependencies(dir) {
+  const pkgPath = join(dir, 'package.json');
+  if (!existsSync(pkgPath)) return null;
+
+  let pkg;
+  try {
+    pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+  } catch {
+    return null;
+  }
+
+  const deps = Object.keys(pkg.dependencies || {});
+  const devDeps = Object.keys(pkg.devDependencies || {});
+
+  const heavyFound = [];
+  for (const dep of deps) {
+    if (HEAVY_DEPS[dep]) {
+      heavyFound.push({
+        dependency: dep,
+        estimated_size: HEAVY_DEPS[dep].size,
+        alternative: HEAVY_DEPS[dep].alternative,
+        severity: 'medium',
+      });
+    }
+  }
+
+  return {
+    production_deps: deps.length,
+    dev_deps: devDeps.length,
+    heavy_deps: heavyFound,
+  };
+}
+
+/**
+ * Lee la última entrada del historial JSONL.
+ * @param {string} historyPath
+ * @returns {object | null}
+ */
+function readLastHistoryEntry(historyPath) {
+  if (!existsSync(historyPath)) return null;
+  try {
+    const lines = readFileSync(historyPath, 'utf8')
+      .split('\n')
+      .filter(Boolean);
+    if (lines.length === 0) return null;
+    return JSON.parse(lines[lines.length - 1]);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Agrega una entrada al historial JSONL.
+ * @param {string} historyPath
+ * @param {object} entry
+ */
+function appendHistoryEntry(historyPath, entry) {
+  const dir = require('path').dirname(historyPath);
+  mkdirSync(dir, { recursive: true, mode: 0o700 });
+  appendFileSync(historyPath, JSON.stringify(entry) + '\n', 'utf8');
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  const dir = resolve(args.find(a => !a.startsWith('--')) || process.cwd());
+  const shouldSave = args.includes('--save');
+
+  if (!existsSync(dir)) {
+    outputError(`Directorio no encontrado: ${dir}`);
+    process.exit(0);
+  }
+
+  // Historial JSONL dentro del proyecto analizado
+  const historyPath = join(dir, '.planning', 'bundles', 'history.jsonl');
+
+  const findings = [];
+
+  // ── Análisis de bundle ─────────────────────────────────────────────────────
+  const buildOutput = findBuildOutput(dir);
+  let bundleAnalysis = null;
+
+  if (buildOutput) {
+    const jsFiles  = walkFiles(buildOutput.path, ['.js', '.mjs', '.cjs']);
+    const cssFiles = walkFiles(buildOutput.path, ['.css']);
+    const imageFiles = walkFiles(buildOutput.path, ['.png', '.jpg', '.jpeg', '.gif', '.svg', '.webp', '.avif']);
+    const allFiles = walkFiles(buildOutput.path, [
+      '.js', '.mjs', '.cjs', '.css', '.html', '.htm',
+      '.json', '.map', '.png', '.jpg', '.jpeg', '.gif',
+      '.svg', '.webp', '.avif',
+    ]);
+
+    const totalJsSize    = jsFiles.reduce((s, f) => s + f.size, 0);
+    const totalCssSize   = cssFiles.reduce((s, f) => s + f.size, 0);
+    const totalImageSize = imageFiles.reduce((s, f) => s + f.size, 0);
+    const totalSize      = allFiles.reduce((s, f) => s + f.size, 0);
+
+    const sourceMaps    = allFiles.filter(f => f.path.endsWith('.map'));
+    const sourceMapSize = sourceMaps.reduce((s, f) => s + f.size, 0);
+
+    const largestJs = jsFiles
+      .sort((a, b) => b.size - a.size)
+      .slice(0, 10)
+      .map(f => ({ file: relative(dir, f.path), size: formatSize(f.size), bytes: f.size }));
+
+    bundleAnalysis = {
+      build_dir: buildOutput.dir,
+      total_size: formatSize(totalSize),
+      total_bytes: totalSize,
+      js:           { files: jsFiles.length,     size: formatSize(totalJsSize),    bytes: totalJsSize    },
+      css:          { files: cssFiles.length,    size: formatSize(totalCssSize),   bytes: totalCssSize   },
+      images:       { files: imageFiles.length,  size: formatSize(totalImageSize), bytes: totalImageSize },
+      source_maps:  { files: sourceMaps.length,  size: formatSize(sourceMapSize),  bytes: sourceMapSize  },
+      largest_js_files: largestJs,
+    };
+
+    // Advertencias de tamaño
+    if (totalJsSize > 500 * 1024) {
+      findings.push({ severity: 'high', message: `Bundle JS total es ${formatSize(totalJsSize)} — objetivo: menos de 500 KB para buen rendimiento` });
+    } else if (totalJsSize > 250 * 1024) {
+      findings.push({ severity: 'medium', message: `Bundle JS total es ${formatSize(totalJsSize)} — considera code splitting para bundles mayores de 250 KB` });
+    }
+
+    for (const f of largestJs) {
+      if (f.bytes > 200 * 1024) {
+        findings.push({ severity: 'high', message: `${f.file} pesa ${f.size} — dividir en fragmentos más pequeños con dynamic imports` });
+      }
+    }
+
+    if (sourceMaps.length > 0) {
+      findings.push({ severity: 'low', message: `${sourceMaps.length} archivos de source map (${formatSize(sourceMapSize)}) en el build — considera excluirlos del despliegue` });
+    }
+
+    const largeImages = imageFiles.filter(f => f.size > 200 * 1024);
+    if (largeImages.length > 0) {
+      findings.push({ severity: 'medium', message: `${largeImages.length} imágenes mayores de 200 KB en el build — optimizar con conversión WebP/AVIF` });
+    }
+  } else {
+    findings.push({ severity: 'info', message: 'No se encontró directorio de build (dist/, build/, .next/, out/) — ejecuta el comando de build primero' });
+  }
+
+  // ── Análisis de dependencias ───────────────────────────────────────────────
+  const depAnalysis = analyzeDependencies(dir);
+  if (depAnalysis && depAnalysis.heavy_deps.length > 0) {
+    for (const dep of depAnalysis.heavy_deps) {
+      findings.push({
+        severity: dep.severity,
+        message: `Dependencia pesada: ${dep.dependency} (~${dep.estimated_size}) — considera ${dep.alternative}`,
+      });
+    }
+  }
+
+  // ── Comparación con historial ──────────────────────────────────────────────
+  let comparison = null;
+
+  if (shouldSave) {
+    const prev = readLastHistoryEntry(historyPath);
+
+    if (prev && prev.bundle && bundleAnalysis) {
+      const diff = bundleAnalysis.total_bytes - prev.bundle.total_bytes;
+      comparison = {
+        previous_size: prev.bundle.total_size,
+        current_size:  bundleAnalysis.total_size,
+        diff_bytes:    diff,
+        diff_formatted: (diff >= 0 ? '+' : '') + formatSize(Math.abs(diff)),
+        grew:           diff > 0,
+        previous_date:  prev.timestamp,
+      };
+
+      if (diff > 50 * 1024) {
+        findings.push({ severity: 'high',   message: `Bundle creció ${formatSize(diff)} desde la última revisión — investiga nuevas dependencias o tree-shaking ausente` });
+      } else if (diff > 10 * 1024) {
+        findings.push({ severity: 'medium', message: `Bundle creció ${formatSize(diff)} desde la última revisión` });
+      }
+    }
+
+    // Persistir entrada en JSONL
+    const entry = {
+      timestamp:    new Date().toISOString(),
+      bundle:       bundleAnalysis,
+      dependencies: depAnalysis,
+      findings_count: findings.length,
+    };
+    try {
+      appendHistoryEntry(historyPath, entry);
+    } catch (err) {
+      outputError('Error al guardar historial de bundle', { message: err.message });
+    }
+  }
+
+  outputJSON({
+    success:        true,
+    packages_scanned: 1,
+    bundle:         bundleAnalysis,
+    dependencies:   depAnalysis,
+    comparison,
+    findings,
+    report_saved:   shouldSave,
+    history_path:   shouldSave ? historyPath : null,
+  });
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = { findBuildOutput, walkFiles, analyzeDependencies, formatSize, HEAVY_DEPS };