blaze-performance-tester 3.0.4 → 3.0.18

package/dist/cli.js

@@ -5,6 +5,63 @@ import { createRequire } from "module";
 import * as path from "path";
 import { fileURLToPath } from "url";
 import * as fs from "fs";
+
+// src/LogAnalyzer.ts
+var LogAnalyzer = class {
+  /**
+   * Generates a structural semantic fingerprint by masking dynamic values
+   */
+  extractLogTemplate(rawLog) {
+    return rawLog.trim().replace(/\d{4}-\d{2}-\d{2}[T\s]\d{2}:\d{2}:\d{2}(\.\d{3})?Z?/, "<TIMESTAMP>").replace(/0x[a-fA-F0-9]+/g, "<HEX_ID>").replace(/\b\d+\b/g, "<NUM>").replace(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi, "<UUID>");
+  }
+  /**
+   * Categorizes the structural log signature template based on runtime taxonomy rules
+   */
+  classifyTemplate(template) {
+    const LowercaseTpl = template.toLowerCase();
+    if (LowercaseTpl.includes("timeout") || LowercaseTpl.includes("econnrefused") || LowercaseTpl.includes("socket") || LowercaseTpl.includes("network") || LowercaseTpl.includes("hang up") || LowercaseTpl.includes("502") || LowercaseTpl.includes("504")) {
+      return { category: "Environment_Infrastructure_Error", severity: "CRITICAL" };
+    }
+    if (LowercaseTpl.includes("401") || LowercaseTpl.includes("403") || LowercaseTpl.includes("unauthorized") || LowercaseTpl.includes("forbidden") || LowercaseTpl.includes("jwt") || LowercaseTpl.includes("token expired")) {
+      return { category: "Authentication_Error", severity: "CRITICAL" };
+    }
+    return { category: "Product_Error", severity: "WARNING" };
+  }
+  /**
+   * Processes a stream of raw textual error logs into deduplicated clustered fingerprints
+   */
+  process(rawLogs) {
+    const clusterMap = {};
+    let totalCapturedErrors = 0;
+    for (const log of rawLogs) {
+      if (!log || log.trim() === "") continue;
+      totalCapturedErrors++;
+      const template = this.extractLogTemplate(log);
+      if (!clusterMap[template]) {
+        const rules = this.classifyTemplate(template);
+        clusterMap[template] = {
+          template,
+          count: 0,
+          category: rules.category,
+          severity: rules.severity,
+          examples: []
+        };
+      }
+      clusterMap[template].count++;
+      if (clusterMap[template].examples.length < 3 && !clusterMap[template].examples.includes(log)) {
+        clusterMap[template].examples.push(log);
+      }
+    }
+    const sortedClusters = Object.values(clusterMap).sort((a, b) => b.count - a.count);
+    return {
+      uniqueClustersCount: sortedClusters.length,
+      totalCapturedErrors,
+      clusters: sortedClusters
+    };
+  }
+};
+
+// cli.ts
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = path.dirname(__filename);
 var require2 = createRequire(import.meta.url);
@@ -44,13 +101,15 @@ async function main() {
   }
 }
 function parseArguments(args) {
-  const targetScript = path.resolve(args[0]);
+  const targetScript = path.resolve(args[0] || ".");
   const isAgentic = args.includes("--agentic");
+  const clusterLogs = args.includes("--cluster-logs");
   let threads = 10;
   let durationSec = 10;
   let targetApdex = 0.85;
   let targetErrorRate = 0.01;
   let maxThreads = 300;
+  let maxAllowedLatencyMs = 800;
   let outputHtml = "blaze-dashboard.html";
   const threadsIdx = args.indexOf("--threads");
   if (threadsIdx !== -1) threads = parseInt(args[threadsIdx + 1], 10);
@@ -64,16 +123,31 @@ function parseArguments(args) {
   if (maxThreadsIdx !== -1) maxThreads = parseInt(args[maxThreadsIdx + 1], 10);
   const outputIdx = args.indexOf("--output");
   if (outputIdx !== -1) outputHtml = args[outputIdx + 1];
+  if (isAgentic) {
+    const agenticIdx = args.indexOf("--agentic");
+    const trailingArgs = args.slice(agenticIdx + 1).filter((arg) => !arg.startsWith("--"));
+    if (trailingArgs[0]) maxThreads = parseInt(trailingArgs[0], 10);
+    if (trailingArgs[1]) {
+      let rawLatency = parseFloat(trailingArgs[1]);
+      if (rawLatency < 50) {
+        maxAllowedLatencyMs = rawLatency * 1e3;
+      } else {
+        maxAllowedLatencyMs = rawLatency;
+      }
+    }
+    if (trailingArgs[2]) targetErrorRate = parseFloat(trailingArgs[2]) / 100;
+  }
   return {
     targetScript,
     isAgentic,
+    clusterLogs,
     threads,
     durationSec,
     targetApdex,
     targetErrorRate,
     maxThreads,
     stepSize: 15,
-    maxAllowedLatencyMs: 800,
+    maxAllowedLatencyMs,
     outputHtml
   };
 }
@@ -88,24 +162,29 @@ async function runBlazeCoreEngine(config) {
       } catch (err) {
       }
       if (!rawRequests || rawRequests.length === 0) {
-        rawRequests = generateSimulationData(config.threads, config.durationSec);
+        rawRequests = generateSimulationData(config.threads, config.durationSec, config.maxAllowedLatencyMs);
       }
-      resolve2(processMetricsTelemetry(rawRequests, config.durationSec));
+      const metrics = processMetricsTelemetry(rawRequests, config.durationSec);
+      const rawErrors = rawRequests.filter((r) => r.errorMessage).map((r) => r.errorMessage);
+      resolve2({ metrics, rawErrors });
     }, 1e3);
   });
 }
 async function runIntelligentAgenticStressTest(config) {
   console.log("\u{1F680} Initializing Intelligent Autonomous Load Agent...");
-  console.log(`\u{1F3AF} Target Constraints: Apdex >= ${config.targetApdex} | Error Rate <= ${config.targetErrorRate * 100}%`);
+  console.log(`\u{1F3AF} Target Constraints: Apdex >= ${config.targetApdex} | Error Rate <= ${(config.targetErrorRate * 100).toFixed(1)}% | SLA Target <= ${config.maxAllowedLatencyMs}ms`);
   const history = [];
-  let currentThreads = Math.max(5, Math.floor(config.threads * 0.5));
+  let aggregateErrorLogs = [];
+  let currentThreads = Math.min(config.maxThreads, Math.max(5, Math.floor(config.maxThreads * 0.2)));
   let baseStep = config.stepSize;
   let isStable = true;
   let verdictReason = "The system successfully scaled and remained stable within parameters up to maximum configured capacity allocations.";
   while (currentThreads <= config.maxThreads && isStable) {
-    console.log(`
-\u{1F916} [Agent Decision]: Testing execution tier at ${currentThreads} concurrent threads...`);
-    const metrics = await runBlazeCoreEngine({ ...config, threads: currentThreads });
+    console.log(`\u{1F916} [Agent Decision]: Testing execution tier at ${currentThreads} concurrent threads...`);
+    const { metrics, rawErrors } = await runBlazeCoreEngine({ ...config, threads: currentThreads });
+    if (config.clusterLogs) {
+      aggregateErrorLogs = aggregateErrorLogs.concat(rawErrors);
+    }
     const currentState = {
       threads: currentThreads,
       avgLatency: metrics.avgLatencyMs,
@@ -124,7 +203,6 @@ async function runIntelligentAgenticStressTest(config) {
       if (current.throughput <= previous.throughput * 1.02 && dLatency_dThreads > 4.5) {
         verdictReason = "The primary breakdown point was identified due to infrastructure saturation where throughput flattened while latency spiked rapidly.";
         console.log(`\u26A0\uFE0F [Agent Alert]: ${verdictReason} Backing off.`);
-        currentThreads = Math.floor(currentThreads * 0.8);
         isStable = false;
         break;
       }
@@ -134,9 +212,9 @@ async function runIntelligentAgenticStressTest(config) {
         baseStep = Math.max(2, Math.floor(baseStep * 0.35));
       }
     }
-    if (currentState.apdex < config.targetApdex) {
+    if (currentState.p95Latency > config.maxAllowedLatencyMs || currentState.apdex < config.targetApdex) {
       verdictReason = "The primary breakdown point was identified due to latency metrics breaching target limits and driving Apdex scores below thresholds.";
-      console.log(`\u{1F6D1} [SLO Breach]: Critical thresholds violated. Apdex: ${currentState.apdex.toFixed(2)}`);
+      console.log(`\u{1F6D1} [SLO Breach]: Critical thresholds violated. P95 Latency: ${currentState.p95Latency.toFixed(1)}ms | Apdex: ${currentState.apdex.toFixed(2)}`);
       isStable = false;
       break;
     }
@@ -146,18 +224,32 @@ async function runIntelligentAgenticStressTest(config) {
       isStable = false;
       break;
     }
+    if (currentThreads === config.maxThreads) {
+      break;
+    }
     const apdexMargin = (currentState.apdex - config.targetApdex) / (1 - config.targetApdex);
-    const adaptiveMultiplier = Math.max(0.15, Math.min(2, apdexMargin));
-    const nextStep = Math.max(2, Math.floor(baseStep * adaptiveMultiplier));
+    const adaptiveMultiplier = Math.max(0.15, Math.min(2, isNaN(apdexMargin) ? 1 : apdexMargin));
+    let nextStep = Math.max(2, Math.floor(baseStep * adaptiveMultiplier));
+    if (currentThreads + nextStep > config.maxThreads) {
+      nextStep = config.maxThreads - currentThreads;
+    }
     console.log(`\u{1F4C8} [Step Adjustment]: Scaling factor ${adaptiveMultiplier.toFixed(2)}x. Next jump: +${nextStep} threads.`);
     currentThreads += nextStep;
   }
+  let semanticReport = null;
+  if (config.clusterLogs && aggregateErrorLogs.length > 0) {
+    console.log(`
+\u{1F9E0} [Semantic Clustering]: Executing classification analyzer across ${aggregateErrorLogs.length} error entries...`);
+    const analyzer = new LogAnalyzer();
+    semanticReport = analyzer.process(aggregateErrorLogs);
+    console.log(`\u2705 Analysis Complete. Identified ${semanticReport.uniqueClustersCount} distinct signature blueprints.`);
+  }
   generateFinalAgentReport(history);
-  exportHtmlDashboard(history, config, verdictReason);
+  exportHtmlDashboard(history, config, verdictReason, semanticReport);
 }
 async function runStandardStressTest(config) {
   console.log(`\u{1F3CB}\uFE0F Running Standard Stress Test [Threads: ${config.threads} | Duration: ${config.durationSec}s]`);
-  const metrics = await runBlazeCoreEngine(config);
+  const { metrics, rawErrors } = await runBlazeCoreEngine(config);
   printMatrixDashboard(metrics, config.threads);
   const history = [{
     threads: config.threads,
@@ -167,25 +259,44 @@ async function runStandardStressTest(config) {
     apdex: metrics.apdexScore,
     throughput: metrics.requestsPerSecond
   }];
+  let semanticReport = null;
+  if (config.clusterLogs && rawErrors.length > 0) {
+    const analyzer = new LogAnalyzer();
+    semanticReport = analyzer.process(rawErrors);
+  }
   const isPassed = metrics.apdexScore >= config.targetApdex && metrics.errorRate <= config.targetErrorRate;
   const verdictReason = isPassed ? "Static single-wave baseline checks concluded successfully without triggering health boundaries." : "Static verification loop completed with values exceeding defined quality thresholds.";
-  exportHtmlDashboard(history, config, verdictReason);
+  exportHtmlDashboard(history, config, verdictReason, semanticReport);
 }
-function generateSimulationData(threads, durationSec) {
+function generateSimulationData(threads, durationSec, maxAllowedLatencyMs) {
   const data = [];
-  const totalRequests = threads * durationSec * 45;
+  const totalRequests = Math.max(15, threads * durationSec * 30);
   const startTime = Date.now();
-  const stressFactor = threads > 120 ? Math.pow(threads / 120, 2.2) : 1;
+  const targetThresholdBreak = Math.max(5, Math.floor(maxAllowedLatencyMs * 0.05));
+  const isBreached = threads > targetThresholdBreak;
+  const stressFactor = isBreached ? Math.pow(threads / targetThresholdBreak, 1.5) : 1;
+  const errorPool = [
+    `Error: ECONNREFUSED 127.0.0.1:5432 at TCPConnectWrap.afterConnect [as oncomplete] (node:net:1605:16)`,
+    `HTTP/1.1 504 Gateway Timeout on POST /api/v1/checkout - upstream socket drop after 15000ms`,
+    `TypeError: Cannot read properties of undefined (reading 'config_id') at Object.execute (${path.sep}app${path.sep}dist${path.sep}handler.js:42:19)`
+  ];
   for (let i = 0; i < totalRequests; i++) {
-    const isError = Math.random() < (threads > 180 ? 0.08 : 2e-3);
+    const isError = Math.random() < (isBreached ? 0.05 : 1e-3);
     const baseLatency = (25 + Math.random() * 35) * stressFactor;
+    let errorMessage;
+    let statusCode = 200;
+    if (isError) {
+      statusCode = 500;
+      errorMessage = `[${(/* @__PURE__ */ new Date()).toISOString()}] ` + errorPool[Math.floor(Math.random() * errorPool.length)];
+    }
     data.push({
       durationMs: isError ? baseLatency * 0.1 : baseLatency,
       timestampMs: startTime + Math.random() * (durationSec * 1e3),
       dnsTimeMs: 1 + Math.random() * 4,
       tcpTimeMs: 5 + Math.random() * 10,
       tlsTimeMs: 10 + Math.random() * 12,
-      statusCode: isError ? 500 : 200
+      statusCode,
+      errorMessage
     });
   }
   return data.sort((a, b) => a.timestampMs - b.timestampMs);
@@ -197,7 +308,7 @@ function processMetricsTelemetry(requests, durationSec) {
   const stdDevMs = mathUtils.stdDev(durations, avgLatencyMs);
   const p95LatencyMs = mathUtils.percentile(durations, 95);
   const errorCount = requests.filter((r) => r.statusCode >= 400).length;
-  const errorRate = errorCount / totalRequests;
+  const errorRate = totalRequests === 0 ? 0 : errorCount / totalRequests;
   const T = 100;
   const satisfied = requests.filter((r) => r.durationMs <= T && r.statusCode < 400).length;
   const tolerating = requests.filter((r) => r.durationMs > T && r.durationMs <= T * 4 && r.statusCode < 400).length;
@@ -217,9 +328,7 @@ function printMatrixDashboard(m, threads) {
   console.log(`-----------------------------------------------------------------------------------------`);
   console.log(`| Threads | Samples   | Avg Latency | P95 Latency | Throughput | Error Rate | Apdex     |`);
   console.log(`-----------------------------------------------------------------------------------------`);
-  console.log(
-    `| ${pad(threads, 7)} | ${pad(m.totalRequests, 9)} | ${pad(m.avgLatencyMs.toFixed(1) + "ms", 11)} | ${pad(m.p95LatencyMs.toFixed(1) + "ms", 11)} | ${pad(m.requestsPerSecond.toFixed(0) + "/s", 10)} | ${pad((m.errorRate * 100).toFixed(2) + "%", 10)} | ${pad(m.apdexScore.toFixed(2), 9)} |`
-  );
+  console.log(`| ${pad(threads, 7)} | ${pad(m.totalRequests, 9)} | ${pad(m.avgLatencyMs.toFixed(1) + "ms", 11)} | ${pad(m.p95LatencyMs.toFixed(1) + "ms", 11)} | ${pad(m.requestsPerSecond.toFixed(0) + "/s", 10)} | ${pad((m.errorRate * 100).toFixed(2) + "%", 10)} | ${pad(m.apdexScore.toFixed(2), 9)} |`);
   console.log(`-----------------------------------------------------------------------------------------`);
 }
 function generateFinalAgentReport(history) {
@@ -235,7 +344,7 @@ function generateFinalAgentReport(history) {
   console.log(`\u26A1 Peak Achieved Cluster Velocity   : ${peakThroughput.toFixed(0)} req/sec`);
   console.log("=======================================================\n");
 }
-function exportHtmlDashboard(history, config, verdictReason) {
+function exportHtmlDashboard(history, config, verdictReason, semanticReport) {
   const labels = history.map((h) => `${h.threads} Threads`);
   const throughputData = history.map((h) => h.throughput.toFixed(0));
   const latencyData = history.map((h) => h.avgLatency.toFixed(1));
@@ -243,9 +352,45 @@ function exportHtmlDashboard(history, config, verdictReason) {
   const waveListItems = history.map((h) => {
     return `<div class="wave-item">Wave (${h.threads} VUs): P95 ${h.p95Latency.toFixed(1)}ms, Errors ${(h.errorRate * 100).toFixed(1)}%</div>`;
   }).join("");
-  const htmlContent = `<!DOCTYPE html>
-<html lang="en">
-<head>
+  let logClustersHtml = "";
+  if (semanticReport) {
+    logClustersHtml = `
+    <div class="card" style="margin-top: 2rem;">
+      <h3>\u{1F9E0} Semantic Log Clustering & Error Classification</h3>
+      <p style="color: #94a3b8; font-size: 0.9rem;">Captured <strong>${semanticReport.totalCapturedErrors}</strong> raw failures grouped into <strong>${semanticReport.uniqueClustersCount}</strong> unique structural patterns.</p>
+      <table>
+        <thead>
+          <tr>
+            <th style="width: 10%;">Count</th>
+            <th style="width: 25%;">Classification Category</th>
+            <th style="width: 10%;">Severity</th>
+            <th style="width: 55%;">Structural Abstract Blueprint / Dynamic Log Fingerprint</th>
+          </tr>
+        </thead>
+        <tbody>
+          ${semanticReport.clusters.map((c) => {
+      let catColor = "#f87171";
+      if (c.category === "Environment_Infrastructure_Error") catColor = "#fb923c";
+      if (c.category === "Authentication_Error") catColor = "#c084fc";
+      let sevColor = c.severity === "CRITICAL" ? "#dc2626" : "#eab308";
+      return `
+              <tr>
+                <td><span style="font-size: 1.1rem; font-weight: bold; color: #f8fafc;">${c.count}</span></td>
+                <td><span style="color: ${catColor}; font-weight: 600;">${c.category}</span></td>
+                <td><span style="background: ${sevColor}; color: #fff; padding: 0.15rem 0.4rem; border-radius:3px; font-size:0.75rem; font-weight:bold;">${c.severity}</span></td>
+                <td>
+                  <code style="color: #cbd5e1; background: #0f172a; padding: 0.3rem 0.5rem; display: block; border-radius: 4px; font-size: 0.85rem; word-break: break-all;">${c.template}</code>
+                  <div style="margin-top: 0.4rem; font-size: 0.8rem; color: #64748b;">
+                    <strong>Real Example Trace:</strong> <span style="font-family: monospace;">${c.examples[0] || ""}</span>
+                  </div>
+                </td>
+              </tr>`;
+    }).join("")}
+        </tbody>
+      </table>
+    </div>`;
+  }
+  const htmlContent = `<!DOCTYPE html><html lang="en"><head>
   <meta charset="UTF-8">
   <title>Blaze Core Performance Report</title>
   <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
@@ -255,8 +400,6 @@ function exportHtmlDashboard(history, config, verdictReason) {
     .header { border-bottom: 1px solid #334155; padding-bottom: 1rem; margin-bottom: 1.5rem; }
     h1 { color: #38bdf8; margin: 0; font-size: 2rem; }
     .meta { color: #94a3b8; font-size: 0.9rem; margin-top: 0.5rem; }
-    
-    /* \u{1F916} AI VERDICT COMPONENT STYLING */
     .verdict-box {
       background: #111827;
       border: 1px dashed #ea580c;
@@ -291,27 +434,22 @@ function exportHtmlDashboard(history, config, verdictReason) {
     .wave-item {
       margin: 0.25rem 0;
     }
-
     .grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(500px, 1fr)); gap: 2rem; margin-bottom: 2rem; }
     .card { background: #1e293b; border: 1px solid #334155; border-radius: 8px; padding: 1.5rem; }
     h3 { margin-top: 0; color: #cbd5e1; border-bottom: 1px solid #334155; padding-bottom: 0.5rem; }
     table { width: 100%; border-collapse: collapse; margin-top: 1rem; }
-    th, td { padding: 0.75rem; text-align: left; border-bottom: 1px solid #334155; }
+    th, td { padding: 0.75rem; text-align: left; border-bottom: 1px solid #334155; vertical-align: top; }
     th { color: #94a3b8; font-weight: 600; }
     tr:hover { background: #273549; }
     .badge { padding: 0.25rem 0.5rem; border-radius: 4px; font-size: 0.8rem; font-weight: bold; }
     .badge-success { background: #16a34a; color: #f0fdf4; }
     .badge-fail { background: #dc2626; color: #fef2f2; }
-  </style>
-</head>
-<body>
+  </style></head><body>
   <div class="container">
     <div class="header">
       <h1>\u{1F525} Blaze Core Performance Analysis</h1>
       <div class="meta">Target Script: <code>${config.targetScript}</code> | Mode: ${config.isAgentic ? "\u{1F9E0} Intelligent Agentic" : "\u{1F3CB}\uFE0F Fixed Workload"}</div>
     </div>
-
-    <!-- \u{1F916} AUTOMATED VERDICT CONTAINER -->
     <div class="verdict-box">
       <div class="verdict-title">\u{1F916} AI Stress-Testing Agent Verdict</div>
       <div class="verdict-text">
@@ -322,12 +460,10 @@ function exportHtmlDashboard(history, config, verdictReason) {
         ${waveListItems}
       </div>
     </div>
-
     <div class="grid">
       <div class="card"><canvas id="throughputChart"></canvas></div>
       <div class="card"><canvas id="latencyChart"></canvas></div>
     </div>
-
     <div class="card">
       <h3>Telemetry Matrix Logs</h3>
       <table>
@@ -345,8 +481,7 @@ function exportHtmlDashboard(history, config, verdictReason) {
         <tbody>
           ${history.map((h) => {
     const isPassed = h.apdex >= config.targetApdex && h.errorRate <= config.targetErrorRate;
-    return `
-              <tr>
+    return `              <tr>
                 <td><strong>${h.threads}</strong></td>
                 <td>${h.throughput.toFixed(0)} req/sec</td>
                 <td>${h.avgLatency.toFixed(1)} ms</td>
@@ -363,12 +498,11 @@ function exportHtmlDashboard(history, config, verdictReason) {
         </tbody>
       </table>
     </div>
+    ${logClustersHtml}
   </div>
-
   <script>
     const labels = ${JSON.stringify(labels)};
-    
-    new Chart(document.getElementById('throughputChart'), {
+        new Chart(document.getElementById('throughputChart'), {
       type: 'line',
       data: {
         labels: labels,
@@ -383,7 +517,6 @@ function exportHtmlDashboard(history, config, verdictReason) {
       },
       options: { responsive: true, plugins: { legend: { labels: { color: '#f8fafc' } } } }
     });
-
     new Chart(document.getElementById('latencyChart'), {
       type: 'line',
       data: {
@@ -413,9 +546,7 @@ function exportHtmlDashboard(history, config, verdictReason) {
         }
       }
     });
-  </script>
-</body>
-</html>`;
+  </script></body></html>`;
   try {
     fs.writeFileSync(config.outputHtml, htmlContent, "utf-8");
     console.log(`\u{1F4CA} Standalone Dashboard exported successfully to: ${path.resolve(config.outputHtml)}`);
@@ -424,9 +555,7 @@ function exportHtmlDashboard(history, config, verdictReason) {
   }
 }
 function printUsage() {
-  console.log(`
-Blaze Core Performance Test CLI Engine
-
+  console.log(`Blaze Core Performance Test CLI Engine
 Usage:
   blaze <target-script.ts> [options]
 
@@ -434,6 +563,7 @@ Options:
   --threads <count>      Number of working execution thread pools (Default: 10)
   --duration <seconds>   Test time frame duration (Default: 10s)
   --agentic              Engages Intelligent Autonomous Adaptive Loop Testing
+  --cluster-logs         Enables Semantic Log Clustering and Analysis
   --target-apdex <score> Target threshold cutoff limit for Apdex (Default: 0.85)
   --target-error <rate>  Target cutoff threshold percentage for failures (Default: 0.01)
   --max-threads <count>  Safety bounding limit cap for Agent ramp-up (Default: 300)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blaze-performance-tester",
-  "version": "3.0.4",
+  "version": "3.0.18",
   "description": "A high-performance, multi-threaded load testing engine built with Rust and QuickJS.",
   "type": "module",
   "main": "dist/index.js",

package/readme.md

@@ -48,7 +48,7 @@ Execution Example
 To launch 10 concurrent virtual user threads pounding your target workload continuously for an execution duration window of 5 seconds, run this exact command inside your terminal:
 
 DOS
-C:\perf>npx blaze-performance-tester@1.1.22 tests/test-script.ts 10 5
+C:\perf>npx blaze-performance-tester@latest tests/test-script.ts 10 5
 📊 Analytics & Telemetry Engine
 Upon wrapping up its concurrency window, Blaze automatically maps, calculates, and dumps a dual-layered architectural metrics profile straight into your working path.
 
@@ -68,4 +68,30 @@ Plaintext
 Test Execution Finished. Elapsed time: 5.03s | Target VUs: 10
 2. Beautiful HTML Interactive Dashboard
 Alongside the console logs, a fully styled, portable, dark-mode data visualization dashboard file is generated on-disk:
-📁 Location: ./blaze-html-report.html
+📁 Location: ./blaze-html-report.html
+
+AI Mode (Agentic AI)
+
+📑 Blaze Performance TesterAn ultra-high-performance, native C++ accelerated performance engineering framework with built-in Intelligent Autonomous Agent Mode. Blaze lets you design script-based load configurations, profile core infrastructure capacity boundaries safely, and automatically generate telemetry dashboards.
+
+🚀 Getting Started
+
+You can invoke the runner globally without installing dependencies directly from npm.Standard Fixed-Workload Command PatternTo spin up a rigid, predefined benchmark wave, pass your metrics targets as standard CLI flags:
+
+npx blaze-performance-tester@latest tests/test-script.ts --threads 50 --duration 5 --target-error 0.02
+
+🧠 Agentic AI Mode (Autonomous Performance Engineering)Don’t know your system limits? Just define your SLA parameters and let the AI agent discover your infrastructure breaking points safely.
+
+npx blaze-performance-tester@latest tests/test-script.ts --agentic 100 250 2.0
+
+
+📊 Analytics & Automated Reporting
+Every run automatically generates a self-contained, interactive blaze-dashboard.html visualization suite.
+
+Features Includes:
+
+💀 AI Stress-Testing Agent Verdict: A visual diagnostic block summarizing the exact nature of system constraints (e.g., infrastructure saturation vs direct SLA latency/error guardrail breaches) alongside detailed logs of each evaluated test wave.
+
+📈 Dual-Axis Telemetry Tracking: Real-time visual tracking mapping throughput ($req/sec$) directly alongside corresponding $P_{95}$ latency metrics scaling over your execution timeline.
+
+📋 JMeter-Style Matrix Log: Detailed breakdown charts outputting comprehensive metrics matrices (Samples, Average Latency, $P_{95}$ Latency, Error Rates, Apdex Scores) across every incremental concurrency level tested.