prix-r9 1.0.0

package/README.md

@@ -0,0 +1,233 @@
+# Prix-R9 — Pruebas de Estrés HTTP para Node.js
+
+Herramienta CLI ligera para pruebas de carga y rendimiento de APIs REST. Permite realizar envíos concurrentes de alto volumen simulando usuarios simultáneos con escalado progresivo (**Ramp-Up**) e inyección de **variables dinámicas** para evitar colisiones de datos en bases de datos.
+
+---
+
+## Instalación
+
+```bash
+npm install -g prix-r9
+```
+
+---
+
+## Cómo Empezar
+
+```bash
+prix-r9 --config mi-config.json
+```
+
+Toda la configuración (URL, cabeceras, métodos y tiempos) reside dentro del archivo JSON que le pases como parámetro. Esto te permite guardar un historial de todos los servicios estresados.
+
+---
+
+## Importador Automático desde cURL
+
+No tienes que escribir el archivo JSON a mano. Si tienes una petición que ya funciona en **Postman, Swagger o en tu Navegador**, simplemente cópiala como formato `cURL` y la herramienta creará el JSON por ti.
+
+```bash
+# 1. Guarda tu comando cURL en un archivo de texto
+#    (Click derecho en Network tab del navegador → Copy as cURL)
+
+# 2. Convierte a config JSON
+prix-r9-curl -i mi-curl.txt -o casos/mi-endpoint.json
+
+# 3. Lanza la prueba
+prix-r9 --config casos/mi-endpoint.json
+```
+
+**¿Qué hace?**
+- Extrae la URL y el Método HTTP automáticamente.
+- Extrae todas las cabeceras (Tokens, ApiKeys).
+- Detecta si es un envío JSON regular (`--data`) o un envío de Archivo pesado (`--form`). Si es archivo, automáticamente separa la ruta física local (`file` / `filekey`) y construye el `body` con los campos extra.
+- Le inyecta un **Ramp-Up predeterminado** (5 a 50 req/s en 5 segundos), listo para que lo afines.
+
+---
+
+## Organización por Casos de Prueba (Recomendado)
+
+Para no perder la configuración de un WebService que probaste y que podrías volver a ocupar en meses, guarda los archivos JSON divididos por carpetas:
+
+```text
+mi-proyecto/
+ └── casos/
+      ├── modulo-usuarios/
+      │    └── crear-usuario.json
+      ├── modulo-reportes/
+      │    └── generar-reporte.json
+      └── modulo-archivos/
+           └── upload-csv.json
+```
+
+> **IMPORTANTE:** Tú y tu equipo deciden cómo nombrar las carpetas. Pueden ser por Producto, Módulo, Ambiente de QA o Sprint.
+
+---
+
+## Motor de Carga (Rate & Ramp-Up)
+
+La herramienta permite moldear cómo las peticiones van entrando a tu API a través del tiempo usando cuatro valores clave:
+
+* **`startRate`** (Ej: `5`): Peticiones por segundo al inicio de la prueba.
+* **`targetRate`** (Ej: `50`): Máximo de peticiones por segundo al que se quiere llegar.
+* **`rampUpTime`** (Ej: `5`): Segundos que toma escalar de `startRate` a `targetRate`.
+* **`duration`** (Ej: `10`): Duración total de la prueba en segundos.
+
+### Fórmula de cálculo por segundo
+
+```
+Si s < rampUpTime:
+  rate(s) = PISO( startRate + (targetRate - startRate) * (s / rampUpTime) )
+
+Si s >= rampUpTime:
+  rate(s) = targetRate
+```
+
+**Ejemplo con `startRate: 3, targetRate: 5, rampUpTime: 10, duration: 15`:**
+
+| Segundo (s) | Fracción = s ÷ 10 | Incremento = (5-3) × fracción | rate = 3 + incremento | Redondeado |
+|:-----------:|:-----------------:|:-----------------------------:|:---------------------:|:----------:|
+| 1           | 0.1               | 0.2                           | 3.2                   | **3**      |
+| 2           | 0.2               | 0.4                           | 3.4                   | **3**      |
+| 3           | 0.3               | 0.6                           | 3.6                   | **3**      |
+| 4           | 0.4               | 0.8                           | 3.8                   | **3**      |
+| 5           | 0.5               | 1.0                           | 4.0                   | **4**      |
+| 6           | 0.6               | 1.2                           | 4.2                   | **4**      |
+| 7           | 0.7               | 1.4                           | 4.4                   | **4**      |
+| 8           | 0.8               | 1.6                           | 4.6                   | **4**      |
+| 9           | 0.9               | 1.8                           | 4.8                   | **4**      |
+| 10          | 1.0               | 2.0                           | 5.0                   | **5**      |
+| 11 – 15     | —                 | tope alcanzado                | 5 pet/s × 5 seg       | **25**     |
+| **TOTAL**   |                   |                               |                       | **62**     |
+
+---
+
+## Variables Dinámicas `{{ }}`
+
+Para evitar colisiones por restricciones `UNIQUE` en base de datos, puedes usar variables dinámicas en el `body` y `headers`:
+
+- **`{{uuid}}`**: Cadena alfanumérica única (ej: `123e4567-e89b-12d3...`).
+- **`{{timestamp}}`**: Tiempo actual en milisegundos (ej: `1702939129124`).
+- **`{{random_number}}`**: Número aleatorio del 0 al 9999.
+
+---
+
+## Ejemplo 1: Carga JSON
+
+```json
+{
+  "url": "https://api.tuempresa.com/v1/usuarios",
+  "method": "POST",
+  "startRate": 5,
+  "targetRate": 50,
+  "rampUpTime": 5,
+  "duration": 10,
+  "headers": {
+    "Authorization": "Bearer tu_token",
+    "X-Request-ID": "{{uuid}}"
+  },
+  "body": {
+    "id_unico": "{{uuid}}",
+    "correo_usuario": "prueba_{{timestamp}}@empresa.com",
+    "edad": "{{random_number}}"
+  }
+}
+```
+
+---
+
+## Ejemplo 2: Subida de Archivos (Multipart)
+
+```json
+{
+  "url": "https://api.tuempresa.com/v1/upload-foto",
+  "method": "POST",
+  "startRate": 2,
+  "targetRate": 10,
+  "rampUpTime": 2,
+  "duration": 5,
+  "headers": {
+    "Authorization": "Bearer tu_token"
+  },
+  "file": "./foto-pesada.jpg",
+  "filekey": "foto",
+  "body": {
+    "TypeFile": "1",
+    "ReasonProcess": "Carga desde V{{random_number}}"
+  }
+}
+```
+
+- **`file`:** Ruta del archivo a adjuntar en cada petición.
+- **`filekey`:** Nombre del campo que espera el backend (el `name` del `<input type="file">`).
+- **`body`:** Campos extra que acompañan al archivo en el `FormData`.
+
+---
+
+## Métricas Generadas
+
+Al terminar la prueba se imprime un resumen y se guarda en `reporte.txt`:
+
+```text
+===========================================
+RESUMEN DE LA PRUEBA
+===========================================
+Peticiones Totales  : 410
+Conexiones Máximas  : 50
+Rendimiento / Rate  : 23.50 Req/s
+
+DESGLOSE DE RESULTADOS:
+Exitosas (2xx)      : 410
+Errores Cliente (4xx): 0
+Errores Server (5xx): 0
+
+TIEMPOS DE RESPUESTA (Latencia en ms):
+   Mínimo : 60.88 ms
+   Máximo : 165.25 ms
+   Promedio: 75.93 ms
+   P95    : 88.99 ms
+
+CÓDIGOS DE ESTADO HTTP:
+   [200] -> 410 veces
+===========================================
+```
+
+> **P95**: El 95% de las peticiones tardó igual o menos que ese tiempo.
+> **Rendimiento**: Throughput real (Req/s) que el servidor procesó durante toda la prueba.
+
+---
+
+## Template para Informe con IA
+
+El paquete incluye el archivo `promptInforme.txt`, un template profesional para generar informes técnicos de rendimiento usando cualquier IA (ChatGPT, Claude, etc.).
+
+**Cómo usarlo:**
+1. Corre uno o varios escenarios de estrés con `prix-r9`
+2. Copia el contenido de cada `reporte.txt` generado
+3. Abre `promptInforme.txt` y pega los reportes en las secciones marcadas
+4. Envía el prompt completo a tu IA preferida
+
+El informe generado incluirá: resumen ejecutivo, tabla comparativa, análisis por escenario, diagnóstico del servidor, recomendaciones y semáforo de salud del sistema.
+
+El archivo se encuentra en:
+```
+node_modules/prix-r9/promptInforme.txt
+```
+
+---
+
+## Referencia Rápida
+
+```bash
+# Instalar globalmente
+npm install -g prix-r9
+
+# Convertir cURL a config JSON
+prix-r9-curl -i mi-curl.txt -o casos/endpoint.json
+
+# Ejecutar prueba de estrés
+prix-r9 --config casos/endpoint.json
+
+# Ver versión
+prix-r9 --version
+```

package/import-curl.js

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+const { program } = require('commander');
+const { toJsonString } = require('curlconverter');
+
+program
+  .version('1.0.0')
+  .description('Herramienta de importación de cURL a config.json para Pruebas de Estrés')
+  .requiredOption('-i, --input <path>', 'Archivo de texto (.txt) que contiene el comando cURL crudo')
+  .requiredOption('-o, --output <path>', 'Ruta de destino para el config JSON de la prueba (ej: casos/az/nuevo-endpoint.json)')
+  .parse(process.argv);
+
+const options = program.opts();
+
+if (!fs.existsSync(options.input)) {
+  console.error(`Error: El archivo de entrada "${options.input}" no existe.`);
+  process.exit(1);
+}
+
+try {
+  // 1. Leer RAW cURL
+  const curlCommand = fs.readFileSync(options.input, 'utf8').trim();
+  
+  // 2. Usar curlconverter para extraer obj (Devuelve un string JSON equivalente en fetch-obj, o Node.js puro)
+  // curlconverter toJsonString genera un JSON representativo del request:
+  // { url, method, headers, data }
+  const parsedCurlStr = toJsonString(curlCommand);
+  if (!parsedCurlStr) {
+      throw new Error("El comando cURL no pudo ser parseado.");
+  }
+  
+  const parsedCurl = JSON.parse(parsedCurlStr);
+
+  // 3. Generar la Plantilla de Cargo 
+  const outputConfig = {
+    url: parsedCurl.url,
+    method: parsedCurl.method || 'GET',
+    startRate: 5,
+    targetRate: 50,
+    rampUpTime: 5,
+    duration: 10,
+    headers: parsedCurl.headers || {},
+  };
+
+  // 4. Analizar BODY puro vs Multipart (Form-Data)
+  // `curlconverter` lo expone en "data" si es string literal
+  // Y lo expone como objeto {data:{}, files:{}} si es Form-Data
+  
+  // Utilidad para limpiar strings literales escapados que trae cURL a veces
+  function cleanVal(str) {
+      if(typeof str !== 'string') return str;
+      let clean = str.replace(/^\\"/, '"').replace(/\\"$/, '"');
+      clean = clean.replace(/^"|"$/g, '');
+      return clean.replace(/\\/g, ''); 
+  }
+
+  if (parsedCurl.files && Object.keys(parsedCurl.files).length > 0) {
+      // 4A. Es una peticion con Archivo (Multipart)
+      const fileKeys = Object.keys(parsedCurl.files);
+      const firstFileKey = fileKeys[0];
+      
+      outputConfig.filekey = firstFileKey;
+      let filePath = parsedCurl.files[firstFileKey];
+      
+      // Cleanup de path local para Windows (A veces de vuelve /C:/Users)
+      if (filePath.match(/^\/[A-Za-z]:\//)) {
+          filePath = filePath.substring(1); 
+      }
+      outputConfig.file = filePath;
+      
+      // Tiene campos de texto extra acompañando al form?
+      if (parsedCurl.data && Object.keys(parsedCurl.data).length > 0) {
+          outputConfig.body = {};
+          for (const [key, val] of Object.entries(parsedCurl.data)) {
+              outputConfig.body[key] = cleanVal(val);
+          }
+      }
+  } else if (parsedCurl.data) {
+     // 4B. Es una peticion normal con body JSON / texto
+     if(typeof parsedCurl.data === 'string') {
+         try {
+           outputConfig.body = JSON.parse(parsedCurl.data);
+         } catch(e) {
+           outputConfig.body = parsedCurl.data;
+         }
+     } else {
+         outputConfig.body = parsedCurl.data; // Si ya es objeto
+     }
+  }
+
+  // 5. Asegurar estructura de carpeta y Escribir
+  const destPath = path.resolve(options.output);
+  const destDir = path.dirname(destPath);
+  
+  if (!fs.existsSync(destDir)){
+      fs.mkdirSync(destDir, { recursive: true });
+  }
+
+  fs.writeFileSync(destPath, JSON.stringify(outputConfig, null, 2), 'utf8');
+  
+  console.log(`✅ ¡Éxito!`);
+  console.log(`Tu comando cURL ha sido convertido a una configuración de carga.`);
+  console.log(`Archivo generado: ${destPath}`);
+  console.log(`\nPuedes ejecutar la prueba ahora usando:`);
+  console.log(`node index.js --config ${options.output}`);
+
+} catch (err) {
+  console.error(`💥 Error al procesar el cURL:`, err.message);
+}

package/index.js

@@ -0,0 +1,352 @@
+#!/usr/bin/env node
+const axios = require('axios');
+const fs = require('fs');
+const FormData = require('form-data');
+const { program } = require('commander');
+const cliProgress = require('cli-progress');
+const { v4: uuidv4 } = require('uuid');
+
+// -------------------------------------------------------------
+// Configuración por Archivo JSON
+// -------------------------------------------------------------
+program
+  .version('2.0.0')
+  .description('Herramienta Avanzada HTTP/REST (Ramp-up y Datos Dinámicos)')
+  .requiredOption('-c, --config <path>', 'Ruta a un archivo JSON con toda la configuración (Obligatorio)')
+  .parse(process.argv);
+
+const cliOpts = program.opts();
+
+let options = {};
+try {
+  const configData = JSON.parse(fs.readFileSync(cliOpts.config, 'utf8'));
+  options = { ...configData };
+} catch (error) {
+  console.error(`Error crítico leyendo el archivo de configuración: ${error.message}`);
+  process.exit(1);
+}
+
+// -------------------------------------------------------------
+// Validaciones Básicas de la Configuración
+// -------------------------------------------------------------
+if (!options.url || !options.method) {
+  console.error('Error: Debes proporcionar "url" y "method" en el archivo de configuración JSON.');
+  process.exit(1);
+}
+
+const method = options.method.toUpperCase();
+if (!['GET', 'POST', 'PUT', 'DELETE', 'PATCH'].includes(method)) {
+  console.error(`Método HTTP no soportado: ${method}`);
+  process.exit(1);
+}
+
+// Manejar tasas estáticas o Ramp-Up
+const isRampUp = options.rampUpTime && options.targetRate;
+const startRate = isRampUp ? (options.startRate || 1) : (options.rate || 10);
+const targetRate = isRampUp ? options.targetRate : (options.rate || 10);
+const rampUpTime = isRampUp ? options.rampUpTime : 0;
+const duration = options.duration || 10; 
+
+// Función centralizada para calcular el rate en un segundo dado
+function calculateRate(second) {
+  if (!isRampUp) return startRate;
+  if (second >= rampUpTime) return targetRate;
+  const rateDiff = targetRate - startRate;
+  const percentageDone = second / rampUpTime;
+  return Math.floor(startRate + (rateDiff * Math.min(percentageDone, 1)));
+}
+
+let totalRequestsExpected = 0;
+if (isRampUp) {
+  // Sumar iteración exacta segundo a segundo para reflejar la realidad del while loop
+  for (let s = 1; s <= duration; s++) {
+    totalRequestsExpected += calculateRate(s);
+  }
+} else {
+  totalRequestsExpected = startRate * duration;
+}
+
+let parsedHeaders = options.headers || {};
+let templateBody = options.body ? JSON.stringify(options.body) : null;
+if (options.file && !fs.existsSync(options.file)) {
+  console.error(`El archivo especificado no existe: ${options.file}`);
+  process.exit(1);
+}
+
+// -------------------------------------------------------------
+// Utilidad: Reemplazar variables dinámicas
+// -------------------------------------------------------------
+function parseDynamicVariables(inputStr) {
+  if (!inputStr) return inputStr;
+  return inputStr
+    .replace(/\{\{timestamp\}\}/g, () => Date.now().toString())
+    .replace(/\{\{uuid\}\}/g, () => uuidv4())
+    .replace(/\{\{random_number\}\}/g, () => Math.floor(Math.random() * 10000).toString());
+}
+
+// -------------------------------------------------------------
+// Variables de Métricas
+// -------------------------------------------------------------
+const metrics = {
+  total: 0,
+  success: 0,
+  errors: 0,
+  latencies: [],
+  statusCodes: {},
+  startTime: null,
+  endTime: null
+};
+
+let activeConnections = 0;
+let maxConcurrentConnections = 0;
+
+// Barra de progreso visual
+const progressBar = new cliProgress.SingleBar({
+  format: 'Progreso | {bar} | {percentage}% || {value}/{total} Peticiones | Tasa: {throughput} req/s',
+  barCompleteChar: '\u2588',
+  barIncompleteChar: '\u2591',
+  hideCursor: true
+});
+
+// -------------------------------------------------------------
+// Función para crear la petición HTTP
+// -------------------------------------------------------------
+async function makeRequest() {
+  activeConnections++;
+  if (activeConnections > maxConcurrentConnections) {
+    maxConcurrentConnections = activeConnections;
+  }
+
+  const startTime = process.hrtime();
+  let reqConfig = {
+    method: method,
+    url: options.url,
+    headers: { ...parsedHeaders },
+    validateStatus: () => true, // Resolver siempre la promesa para capturar todos los códigos de estado
+    timeout: 60000, // Dar 60 segundos a QA para responder cada hilo individual
+  };
+
+  // Lógica de archivo (Multipart) vs JSON Body
+  let resolvedUrl = parseDynamicVariables(options.url);
+  reqConfig.url = resolvedUrl;
+
+  // Lógica de variables dinámicas en Content/Body y Headers
+  let finalHeaders = { ...parsedHeaders };
+  for (const [key, val] of Object.entries(finalHeaders)) {
+    if (typeof val === 'string') finalHeaders[key] = parseDynamicVariables(val);
+  }
+  reqConfig.headers = finalHeaders;
+
+  // Construir Payload (JSON puro vs Multipart)
+  if (options.file && ['POST', 'PUT', 'PATCH'].includes(method)) {
+    const form = new FormData();
+    // 1. Adjuntar Archivo
+    form.append(options.filekey || 'file', fs.createReadStream(options.file));
+    
+    // 2. Adjuntar otros campos del Body si existen
+    if (templateBody) {
+      const parsedDynamicString = parseDynamicVariables(templateBody);
+      const bodyObj = JSON.parse(parsedDynamicString);
+      for (const [key, value] of Object.entries(bodyObj)) {
+        // En multipart, todo lo extra va como string
+        form.append(key, String(value));
+      }
+    }
+
+    reqConfig.data = form;
+    Object.assign(reqConfig.headers, form.getHeaders());
+  } else if (templateBody && ['POST', 'PUT', 'PATCH'].includes(method)) {
+    const parsedDynamicString = parseDynamicVariables(templateBody);
+    reqConfig.data = JSON.parse(parsedDynamicString);
+    if (!reqConfig.headers['Content-Type']) {
+      reqConfig.headers['Content-Type'] = 'application/json';
+    }
+  }
+
+  try {
+    const response = await axios(reqConfig);
+    
+    // Calcular tiempo
+    const endTime = process.hrtime(startTime);
+    const latencyMs = (endTime[0] * 1000) + (endTime[1] / 1000000);
+    
+    metrics.latencies.push(latencyMs);
+    metrics.statusCodes[response.status] = (metrics.statusCodes[response.status] || 0) + 1;
+
+    // Consideramos éxito códigos 2xx y 3xx
+    if (response.status >= 200 && response.status < 400) {
+      metrics.success++;
+    } else {
+      metrics.errors++;
+    }
+
+  } catch (error) {
+    // Errores de red (Timeout, conexión rechazada, dns)
+    metrics.errors++;
+    metrics.statusCodes['NETWORK_ERROR'] = (metrics.statusCodes['NETWORK_ERROR'] || 0) + 1;
+  } finally {
+    activeConnections--;
+    metrics.total++;
+    
+    // Calcular throughput en vivo
+    const elapsedSecs = Math.max(0.1, (Date.now() - metrics.startTime) / 1000);
+    const currentThroughput = (metrics.total / elapsedSecs).toFixed(1);
+    
+    progressBar.increment(1, { throughput: currentThroughput });
+  }
+}
+
+// -------------------------------------------------------------
+// Motor de Ejecución (Ramp-up y Límite)
+// -------------------------------------------------------------
+async function runTest() {
+  // Guardar la cabecera de configuración para incluirla en reporte.txt
+  metrics.configHeader = [];
+  metrics.configHeader.push(`URL: ${options.url}`);
+  metrics.configHeader.push(`Método: ${method}`);
+  if (isRampUp) {
+    metrics.configHeader.push(`Ramp-up: De ${startRate} a ${targetRate} req/s en ${rampUpTime}s`);
+    metrics.configHeader.push(`Duración total: ${duration} segundos`);
+    metrics.configHeader.push(`Total Estimado: ~${totalRequestsExpected} peticiones`);
+  } else {
+    metrics.configHeader.push(`Peticiones constantes: ${startRate} req/s | Duración: ${duration}s`);
+    metrics.configHeader.push(`Total Estimado: ~${totalRequestsExpected} peticiones`);
+  }
+  if (options.file) metrics.configHeader.push(`Archivo adjunto: ${options.file}`);
+
+  console.log(`\nIniciando Prueba de Estrés HTTP 🚀`);
+  console.log(`URL: ${options.url}`);
+  console.log(`Método: ${method}`);
+  if (isRampUp) {
+    console.log(`Ramp-up: De ${startRate} a ${targetRate} req/s en ${rampUpTime}s`);
+    console.log(`Mantenido en ${targetRate} req/s hasta alcanzar los ${duration}s de prueba.`);
+  } else {
+    console.log(`Peticiones constantes: ${startRate} peticiones/s | Duración: ${duration}s`);
+  }
+  if (options.file) console.log(`Cargando archivo: ${options.file}`);
+  console.log(`Total Estimado: ~${totalRequestsExpected} peticiones\n`);
+
+  metrics.startTime = Date.now();
+  progressBar.start(totalRequestsExpected, 0, { throughput: 0 });
+
+  let currentSecond = 0;
+  let sentRequests = 0;
+
+  return new Promise((resolve) => {
+    const interval = setInterval(async () => {
+      currentSecond++;
+      const currentRate = calculateRate(currentSecond);
+      
+      const requestsForThisSecond = [];
+      for (let i = 0; i < currentRate; i++) {
+        if (sentRequests >= totalRequestsExpected) break;
+        requestsForThisSecond.push(makeRequest());
+        sentRequests++;
+      }
+      
+      if (currentSecond >= duration) {
+        clearInterval(interval);
+        
+        let waitTime = 0;
+        const checkDone = setInterval(() => {
+          waitTime++;
+          if (activeConnections === 0 || waitTime > 180) { 
+            // 90 segundos máximos de gracia esperando que Node reciba respuesta de QA (bottleneck)
+            clearInterval(checkDone);
+            metrics.endTime = Date.now();
+            progressBar.stop();
+            resolve();
+          }
+        }, 500);
+      }
+    }, 1000);
+  });
+}
+
+// -------------------------------------------------------------
+// Reporte de Métricas Final
+// -------------------------------------------------------------
+function analyzeMetrics() {
+  let reportText = "";
+  const logAndSave = (text) => {
+    console.log(text);
+    reportText += text + "\n";
+  };
+
+  // Encabezado de configuración al inicio del reporte
+  reportText += `CONFIGURACIÓN DE LA PRUEBA\n`;
+  reportText += `==========================================\n`;
+  if (metrics.configHeader) {
+    metrics.configHeader.forEach(line => { reportText += line + "\n"; });
+  }
+  reportText += `\n`;
+
+  logAndSave(`\n===========================================`);
+  logAndSave(`📊 RESUMEN DE LA PRUEBA`);
+  logAndSave(`===========================================`);
+  
+  if (metrics.total === 0) {
+    logAndSave("No se completó ninguna petición.");
+    fs.writeFileSync('reporte.txt', reportText, 'utf8');
+    return;
+  }
+
+  // Ordenar latencias numéricamente
+  metrics.latencies.sort((a, b) => a - b);
+  const min = metrics.latencies[0] || 0;
+  const max = metrics.latencies[metrics.latencies.length - 1] || 0;
+  const sum = metrics.latencies.reduce((a, b) => a + b, 0);
+  const avg = metrics.latencies.length > 0 ? sum / metrics.latencies.length : 0;
+  
+  // Percentil 95
+  const p95Index = Math.floor(metrics.latencies.length * 0.95);
+  const p95 = metrics.latencies[p95Index] || 0;
+
+  // Throughput Real
+  const totalTestDurationSecs = Math.max(0.1, (metrics.endTime - metrics.startTime) / 1000);
+  const avgThroughput = (metrics.total / totalTestDurationSecs).toFixed(2);
+
+  // Separar los distintos tipos de éxito/fallo
+  let count2xx = 0, count3xx = 0, count4xx = 0, count5xx = 0;
+  for (const code of Object.keys(metrics.statusCodes)) {
+    const numericCode = parseInt(code, 10);
+    if (numericCode >= 200 && numericCode < 300) count2xx += metrics.statusCodes[code];
+    else if (numericCode >= 300 && numericCode < 400) count3xx += metrics.statusCodes[code];
+    else if (numericCode >= 400 && numericCode < 500) count4xx += metrics.statusCodes[code];
+    else if (numericCode >= 500) count5xx += metrics.statusCodes[code];
+  }
+
+  logAndSave(`🎯 Peticiones Totales  : ${metrics.total}`);
+  logAndSave(`⚡ Conexiones Máximas : ${maxConcurrentConnections}`);
+  logAndSave(`🚀 Rendimiento / Rate  : ${avgThroughput} Req/s`);
+  logAndSave(`\n📊 DESGLOSE DE RESULTADOS:`);
+  logAndSave(`✅ Exitosas (2xx)      : ${count2xx}`);
+  if (count3xx > 0) logAndSave(`🔀 Redirecciones (3xx) : ${count3xx}`);
+  logAndSave(`⚠️  Errores Cliente (4xx): ${count4xx}  <- (Bloqueos, No Autorizado, Bad Request)`);
+  logAndSave(`❌ Errores Server (5xx): ${count5xx + (metrics.statusCodes['NETWORK_ERROR'] || 0)}  <- (Caídas del Servidor, Timeout)`);
+  
+  logAndSave(`\n⏱️  TIEMPOS DE RESPUESTA (Latencia en ms):`);
+  logAndSave(`   Mínimo : ${min.toFixed(2)} ms`);
+  logAndSave(`   Máximo : ${max.toFixed(2)} ms`);
+  logAndSave(`   Promedio: ${avg.toFixed(2)} ms`);
+  logAndSave(`   P95    : ${p95.toFixed(2)} ms`);
+  
+  logAndSave(`\n🏷️  CÓDIGOS DE ESTADO HTTP:`);
+  for (const [code, count] of Object.entries(metrics.statusCodes)) {
+    logAndSave(`   [${code}] -> ${count} veces`);
+  }
+  logAndSave(`===========================================\n`);
+
+  // Escribir el reporte completo en el archivo
+  try {
+    fs.writeFileSync('reporte.txt', reportText, 'utf8');
+    console.log(`\n📄 Reporte guardado exitosamente en: reporte.txt`);
+  } catch(e) {
+    console.error(`\nNo se pudo guardar el reporte.txt: ${e.message}`);
+  }
+}
+
+// Iniciar
+runTest().then(() => {
+  analyzeMetrics();
+}).catch(console.error);

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "prix-r9",
+  "version": "1.0.0",
+  "description": "Herramienta CLI ligera para pruebas de estrés de APIs REST con ramp-up progresivo y variables dinámicas.",
+  "main": "index.js",
+  "bin": {
+    "prix-r9": "index.js",
+    "prix-r9-curl": "import-curl.js"
+  },
+  "files": [
+    "index.js",
+    "import-curl.js",
+    "promptInforme.txt",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "stress",
+    "load",
+    "api",
+    "qa",
+    "testing",
+    "http",
+    "ramp-up",
+    "benchmark",
+    "performance"
+  ],
+  "author": "QA Team",
+  "license": "ISC",
+  "type": "commonjs",
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "repository": {},
+  "dependencies": {
+    "axios": "^1.13.5",
+    "cli-progress": "^3.12.0",
+    "commander": "^14.0.3",
+    "curlconverter": "^4.12.0",
+    "form-data": "^4.0.5",
+    "uuid": "^13.0.0"
+  }
+}

package/promptInforme.txt

@@ -0,0 +1,93 @@
+Actúa como un Ingeniero QA Senior con experiencia en pruebas de rendimiento y carga de APIs REST.
+A continuación te proporciono los resultados de MÚLTIPLES ESCENARIOS de pruebas de estrés HTTP
+realizadas contra endpoint(s) de un sistema financiero en ambiente QA.
+Cada escenario tiene una configuración distinta (diferente Ramp-Up, carga, duración, etc.)
+y fue ejecutado de forma independiente para comparar el comportamiento del servidor bajo distintos niveles de estrés.
+
+Necesito que redactes un INFORME TÉCNICO PROFESIONAL en español con las siguientes secciones:
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+1. RESUMEN EJECUTIVO
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Describe en 3-4 oraciones qué se probó, cuántos escenarios hubo y cuál fue la conclusión general.
+Redacta sin tecnicismos, orientado a gerencia.
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+2. TABLA COMPARATIVA DE ESCENARIOS
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Crea una tabla comparativa con una fila por escenario y las siguientes columnas:
+  - Escenario (nombre o número)
+  - Carga configurada (startRate → targetRate)
+  - Peticiones totales
+  - Exitosas (2xx)
+  - Errores cliente (4xx)
+  - Errores servidor (5xx)
+  - Rendimiento (Req/s)
+  - Latencia Promedio (ms)
+  - P95 (ms)
+  - Conexiones Máximas
+  - Resultado general (✅ Estable / ⚠️ Degradado / ❌ Crítico)
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+3. ANÁLISIS POR ESCENARIO
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Para cada escenario, analiza en detalle:
+  - Qué nivel de carga se aplicó y por qué el Ramp-Up gradual es importante
+  - Comportamiento del servidor: ¿respondió bien, se degradó, o se protegió?
+  - Interpretación de los errores 4xx vs 5xx
+  - Qué significa el P95 en ese contexto y por qué difiere del Promedio
+  - Qué indica el número de Conexiones Máximas sobre la concurrencia soportada
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+4. DIAGNÓSTICO GENERAL DEL SERVIDOR
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Basándote en el patrón de todos los escenarios, diagnostica:
+  - ¿En qué nivel de carga el servidor empieza a degradarse?
+  - ¿Los errores 401 son por autenticación inválida o por Rate Limiting / WAF?
+  - ¿Hay señales de cuello de botella en base de datos, memoria o red?
+  - ¿El servidor se recupera o se queda degradado una vez superado el umbral?
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+5. CONCLUSIONES Y RECOMENDACIONES
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  - ¿Cuál es la carga máxima segura que soporta el endpoint actualmente?
+  - Acciones concretas para el equipo de desarrollo e infraestructura
+  - ¿Qué escenario debería usarse como prueba de regresión en futuros sprints?
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+6. SEMÁFORO DE SALUD DEL SISTEMA
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Genera una tabla con los indicadores clave clasificados en:
+  🟢 Verde  = dentro de límites aceptables
+  🟡 Amarillo = requiere atención
+  🔴 Rojo   = crítico, acción inmediata requerida
+
+El tono debe ser formal y técnico, adecuado para presentar tanto al equipo de desarrollo como a gerencia de TI.
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+RESULTADOS DE LOS ESCENARIOS:
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+[ESCENARIO 1]
+[PEGA AQUÍ EL CONTENIDO DEL reporte.txt DEL ESCENARIO 1]
+
+---
+
+[ESCENARIO 2]
+[PEGA AQUÍ EL CONTENIDO DEL reporte.txt DEL ESCENARIO 2]
+
+---
+
+[ESCENARIO 3 - Agrega tantos como necesites con el mismo formato]
+[PEGA AQUÍ EL CONTENIDO DEL reporte.txt DEL ESCENARIO 3]
+
+
+
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+INFORMACIÓN ADICIONAL DEL SISTEMA:
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Endpoint evaluado: [Nombre del endpoint, ej: GetReportAlliedBusinessByCompany]
+Sistema: [Nombre del sistema, ej: MDL37 - Reportes de Comercios Aliados]
+Ambiente: QA
+Fecha de prueba: [Fecha]