@rog0x/mcp-perf-tools 1.0.0

package/src/tools/bundle-analyzer.ts

@@ -0,0 +1,195 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as zlib from "node:zlib";
+
+export interface ModuleInfo {
+  filePath: string;
+  sizeBytes: number;
+  sizeKB: number;
+  /** Percentage of total bundle size */
+  percentage: number;
+}
+
+export interface TreeShakingOpportunity {
+  filePath: string;
+  reason: string;
+}
+
+export interface BundleAnalysis {
+  filePath: string;
+  rawSizeBytes: number;
+  rawSizeKB: number;
+  gzipEstimateBytes: number;
+  gzipEstimateKB: number;
+  compressionRatio: number;
+  moduleCount: number;
+  largestModules: ModuleInfo[];
+  treeShakingOpportunities: TreeShakingOpportunity[];
+  summary: string;
+}
+
+/**
+ * Detect import/require patterns to approximate module boundaries.
+ * This is a heuristic for bundled JS files.
+ */
+function detectModules(
+  content: string,
+  bundlePath: string
+): { modules: ModuleInfo[]; treeShaking: TreeShakingOpportunity[] } {
+  const modules: ModuleInfo[] = [];
+  const treeShaking: TreeShakingOpportunity[] = [];
+  const totalSize = Buffer.byteLength(content, "utf-8");
+
+  // Look for common bundle patterns:
+  // Webpack: /***/ "./path/to/module.js": or numbered modules
+  // Rollup: define blocks
+  // Generic: large comment blocks separating modules
+  const webpackModulePattern =
+    /\/\*{3}\/ ["']([^"']+)["']:|\/\*{3}\/ (\d+)/g;
+  const requirePattern =
+    /require\(["']([^"']+)["']\)/g;
+  const importPattern =
+    /(?:import|export)\s+.*?from\s+["']([^"']+)["']/g;
+
+  const moduleNames = new Set<string>();
+
+  let match: RegExpExecArray | null;
+
+  // Webpack-style modules
+  while ((match = webpackModulePattern.exec(content)) !== null) {
+    moduleNames.add(match[1] || match[2]);
+  }
+
+  // require() calls
+  while ((match = requirePattern.exec(content)) !== null) {
+    moduleNames.add(match[1]);
+  }
+
+  // ES import/export
+  while ((match = importPattern.exec(content)) !== null) {
+    moduleNames.add(match[1]);
+  }
+
+  // If we found module references, create approximate entries
+  for (const name of moduleNames) {
+    // Estimate module size by finding its content boundaries (rough heuristic)
+    const idx = content.indexOf(name);
+    if (idx === -1) continue;
+
+    // Rough estimate: count bytes between this reference and the next or end
+    const estimatedSize = Math.round(totalSize / Math.max(moduleNames.size, 1));
+
+    modules.push({
+      filePath: name,
+      sizeBytes: estimatedSize,
+      sizeKB: Math.round((estimatedSize / 1024) * 100) / 100,
+      percentage:
+        Math.round((estimatedSize / totalSize) * 100 * 100) / 100,
+    });
+  }
+
+  // If no patterns matched, treat whole file as single module
+  if (modules.length === 0) {
+    modules.push({
+      filePath: path.basename(bundlePath),
+      sizeBytes: totalSize,
+      sizeKB: Math.round((totalSize / 1024) * 100) / 100,
+      percentage: 100,
+    });
+  }
+
+  // Tree-shaking opportunity detection
+  // Look for unused exports, side-effect patterns, etc.
+  const sideEffectPatterns = [
+    { pattern: /\bconsole\.(log|warn|info|debug)\b/g, reason: "console statements found (side effects)" },
+    { pattern: /\bwindow\.\w+\s*=/g, reason: "global window property assignment (side effect)" },
+    { pattern: /\bglobal\.\w+\s*=/g, reason: "global property assignment (side effect)" },
+  ];
+
+  for (const { pattern, reason } of sideEffectPatterns) {
+    const sideMatch = pattern.exec(content);
+    if (sideMatch) {
+      treeShaking.push({ filePath: bundlePath, reason });
+    }
+  }
+
+  // Check for duplicate-looking module names (possible duplicates in bundle)
+  const baseNames = new Map<string, string[]>();
+  for (const name of moduleNames) {
+    const base = path.basename(name);
+    if (!baseNames.has(base)) baseNames.set(base, []);
+    baseNames.get(base)!.push(name);
+  }
+  for (const [base, paths] of baseNames) {
+    if (paths.length > 1) {
+      treeShaking.push({
+        filePath: base,
+        reason: `Possible duplicate: "${base}" appears ${paths.length} times with different paths`,
+      });
+    }
+  }
+
+  return { modules, treeShaking };
+}
+
+export function analyzeBundle(filePath: string): BundleAnalysis {
+  const resolvedPath = path.resolve(filePath);
+
+  if (!fs.existsSync(resolvedPath)) {
+    throw new Error(`File not found: ${resolvedPath}`);
+  }
+
+  const content = fs.readFileSync(resolvedPath, "utf-8");
+  const rawSizeBytes = Buffer.byteLength(content, "utf-8");
+  const rawSizeKB = Math.round((rawSizeBytes / 1024) * 100) / 100;
+
+  // Gzip estimate
+  const gzipped = zlib.gzipSync(content, { level: 6 });
+  const gzipEstimateBytes = gzipped.length;
+  const gzipEstimateKB =
+    Math.round((gzipEstimateBytes / 1024) * 100) / 100;
+  const compressionRatio =
+    rawSizeBytes > 0
+      ? Math.round((gzipEstimateBytes / rawSizeBytes) * 100 * 100) / 100
+      : 0;
+
+  const { modules, treeShaking } = detectModules(content, resolvedPath);
+
+  // Sort modules by size descending
+  modules.sort((a, b) => b.sizeBytes - a.sizeBytes);
+  const largestModules = modules.slice(0, 10);
+
+  const summary = [
+    `Bundle Analysis: ${path.basename(resolvedPath)}`,
+    `  Raw Size:         ${rawSizeKB} KB (${rawSizeBytes} bytes)`,
+    `  Gzip Estimate:    ${gzipEstimateKB} KB (${gzipEstimateBytes} bytes)`,
+    `  Compression:      ${compressionRatio}%`,
+    `  Modules Detected: ${modules.length}`,
+    "",
+    "Largest Modules:",
+    ...largestModules.map(
+      (m, i) =>
+        `  ${i + 1}. ${m.filePath} — ${m.sizeKB} KB (${m.percentage}%)`
+    ),
+  ];
+
+  if (treeShaking.length > 0) {
+    summary.push("", "Tree-Shaking Opportunities:");
+    for (const opp of treeShaking) {
+      summary.push(`  - ${opp.filePath}: ${opp.reason}`);
+    }
+  }
+
+  return {
+    filePath: resolvedPath,
+    rawSizeBytes,
+    rawSizeKB,
+    gzipEstimateBytes,
+    gzipEstimateKB,
+    compressionRatio,
+    moduleCount: modules.length,
+    largestModules,
+    treeShakingOpportunities: treeShaking,
+    summary: summary.join("\n"),
+  };
+}

package/src/tools/load-tester.ts

@@ -0,0 +1,216 @@
+import * as http from "node:http";
+import * as https from "node:https";
+import { URL } from "node:url";
+import { performance } from "node:perf_hooks";
+
+export interface LoadTestConfig {
+  url: string;
+  totalRequests: number;
+  concurrency: number;
+  method?: string;
+  headers?: Record<string, string>;
+  body?: string;
+  timeoutMs?: number;
+}
+
+export interface RequestResult {
+  statusCode: number | null;
+  durationMs: number;
+  error: string | null;
+  byteLength: number;
+}
+
+export interface LoadTestResult {
+  url: string;
+  totalRequests: number;
+  concurrency: number;
+  successCount: number;
+  errorCount: number;
+  errorRate: number;
+  totalDurationMs: number;
+  throughputReqPerSec: number;
+  avgResponseMs: number;
+  minResponseMs: number;
+  maxResponseMs: number;
+  medianResponseMs: number;
+  p95ResponseMs: number;
+  p99ResponseMs: number;
+  statusCodeDistribution: Record<string, number>;
+  totalBytesReceived: number;
+  summary: string;
+}
+
+function percentile(sorted: number[], p: number): number {
+  if (sorted.length === 0) return 0;
+  const idx = (p / 100) * (sorted.length - 1);
+  const lower = Math.floor(idx);
+  const upper = Math.ceil(idx);
+  if (lower === upper) return sorted[lower];
+  return sorted[lower] + (sorted[upper] - sorted[lower]) * (idx - lower);
+}
+
+function makeRequest(config: LoadTestConfig): Promise<RequestResult> {
+  return new Promise((resolve) => {
+    const parsedUrl = new URL(config.url);
+    const isHttps = parsedUrl.protocol === "https:";
+    const transport = isHttps ? https : http;
+
+    const startTime = performance.now();
+    const timeout = config.timeoutMs ?? 30000;
+
+    const options: http.RequestOptions = {
+      hostname: parsedUrl.hostname,
+      port: parsedUrl.port || (isHttps ? 443 : 80),
+      path: parsedUrl.pathname + parsedUrl.search,
+      method: config.method ?? "GET",
+      headers: config.headers ?? {},
+      timeout,
+    };
+
+    const req = transport.request(options, (res) => {
+      const chunks: Buffer[] = [];
+      res.on("data", (chunk: Buffer) => chunks.push(chunk));
+      res.on("end", () => {
+        const durationMs = performance.now() - startTime;
+        const body = Buffer.concat(chunks);
+        resolve({
+          statusCode: res.statusCode ?? null,
+          durationMs,
+          error: null,
+          byteLength: body.length,
+        });
+      });
+      res.on("error", (err) => {
+        resolve({
+          statusCode: res.statusCode ?? null,
+          durationMs: performance.now() - startTime,
+          error: err.message,
+          byteLength: 0,
+        });
+      });
+    });
+
+    req.on("error", (err) => {
+      resolve({
+        statusCode: null,
+        durationMs: performance.now() - startTime,
+        error: err.message,
+        byteLength: 0,
+      });
+    });
+
+    req.on("timeout", () => {
+      req.destroy();
+      resolve({
+        statusCode: null,
+        durationMs: performance.now() - startTime,
+        error: "Request timed out",
+        byteLength: 0,
+      });
+    });
+
+    if (config.body) {
+      req.write(config.body);
+    }
+
+    req.end();
+  });
+}
+
+export async function runLoadTest(
+  config: LoadTestConfig
+): Promise<LoadTestResult> {
+  const { totalRequests, concurrency } = config;
+  const results: RequestResult[] = [];
+
+  const overallStart = performance.now();
+
+  // Process requests in batches of `concurrency`
+  let sent = 0;
+  while (sent < totalRequests) {
+    const batchSize = Math.min(concurrency, totalRequests - sent);
+    const batch: Promise<RequestResult>[] = [];
+
+    for (let i = 0; i < batchSize; i++) {
+      batch.push(makeRequest(config));
+    }
+
+    const batchResults = await Promise.all(batch);
+    results.push(...batchResults);
+    sent += batchSize;
+  }
+
+  const overallEnd = performance.now();
+  const totalDurationMs = overallEnd - overallStart;
+
+  // Compute metrics
+  const durations = results.map((r) => r.durationMs);
+  const sortedDurations = [...durations].sort((a, b) => a - b);
+
+  const successCount = results.filter(
+    (r) => r.error === null && r.statusCode !== null && r.statusCode < 400
+  ).length;
+  const errorCount = totalRequests - successCount;
+  const errorRate =
+    Math.round((errorCount / totalRequests) * 100 * 100) / 100;
+
+  const statusDist: Record<string, number> = {};
+  for (const r of results) {
+    const key = r.error ? "error" : String(r.statusCode);
+    statusDist[key] = (statusDist[key] ?? 0) + 1;
+  }
+
+  const totalBytesReceived = results.reduce((s, r) => s + r.byteLength, 0);
+  const throughputReqPerSec =
+    totalDurationMs > 0 ? (totalRequests / totalDurationMs) * 1000 : 0;
+
+  const avgResponseMs =
+    durations.reduce((a, b) => a + b, 0) / durations.length;
+
+  const result: LoadTestResult = {
+    url: config.url,
+    totalRequests,
+    concurrency,
+    successCount,
+    errorCount,
+    errorRate,
+    totalDurationMs,
+    throughputReqPerSec: Math.round(throughputReqPerSec * 100) / 100,
+    avgResponseMs: Math.round(avgResponseMs * 100) / 100,
+    minResponseMs: Math.round(sortedDurations[0] * 100) / 100,
+    maxResponseMs:
+      Math.round(sortedDurations[sortedDurations.length - 1] * 100) / 100,
+    medianResponseMs: Math.round(percentile(sortedDurations, 50) * 100) / 100,
+    p95ResponseMs: Math.round(percentile(sortedDurations, 95) * 100) / 100,
+    p99ResponseMs: Math.round(percentile(sortedDurations, 99) * 100) / 100,
+    statusCodeDistribution: statusDist,
+    totalBytesReceived,
+    summary: "",
+  };
+
+  result.summary = [
+    `Load Test Results: ${config.method ?? "GET"} ${config.url}`,
+    `  Total Requests:  ${totalRequests}`,
+    `  Concurrency:     ${concurrency}`,
+    `  Total Duration:  ${totalDurationMs.toFixed(0)} ms`,
+    `  Throughput:      ${result.throughputReqPerSec} req/s`,
+    "",
+    "Response Times:",
+    `  Min:     ${result.minResponseMs} ms`,
+    `  Max:     ${result.maxResponseMs} ms`,
+    `  Avg:     ${result.avgResponseMs} ms`,
+    `  Median:  ${result.medianResponseMs} ms`,
+    `  P95:     ${result.p95ResponseMs} ms`,
+    `  P99:     ${result.p99ResponseMs} ms`,
+    "",
+    `Success: ${successCount}  Errors: ${errorCount}  Error Rate: ${errorRate}%`,
+    `Bytes Received: ${totalBytesReceived}`,
+    "",
+    "Status Code Distribution:",
+    ...Object.entries(statusDist).map(
+      ([code, count]) => `  ${code}: ${count}`
+    ),
+  ].join("\n");
+
+  return result;
+}

package/src/tools/memory-analyzer.ts

@@ -0,0 +1,145 @@
+export interface MemorySnapshot {
+  timestamp: number;
+  heapUsedMB: number;
+  heapTotalMB: number;
+  rssMB: number;
+  externalMB: number;
+  arrayBuffersMB: number;
+}
+
+export interface MemoryAnalysis {
+  current: MemorySnapshot;
+  history: MemorySnapshot[];
+  trend: "stable" | "growing" | "shrinking" | "insufficient_data";
+  growthRateMBPerSec: number | null;
+  potentialLeak: boolean;
+  summary: string;
+}
+
+const toMB = (bytes: number): number =>
+  Math.round((bytes / 1024 / 1024) * 100) / 100;
+
+const snapshotHistory: MemorySnapshot[] = [];
+
+export function takeMemorySnapshot(): MemorySnapshot {
+  const mem = process.memoryUsage();
+  const snapshot: MemorySnapshot = {
+    timestamp: Date.now(),
+    heapUsedMB: toMB(mem.heapUsed),
+    heapTotalMB: toMB(mem.heapTotal),
+    rssMB: toMB(mem.rss),
+    externalMB: toMB(mem.external),
+    arrayBuffersMB: toMB(mem.arrayBuffers),
+  };
+  snapshotHistory.push(snapshot);
+  return snapshot;
+}
+
+export function getSnapshotHistory(): MemorySnapshot[] {
+  return [...snapshotHistory];
+}
+
+export function clearSnapshotHistory(): void {
+  snapshotHistory.length = 0;
+}
+
+function linearRegression(
+  xs: number[],
+  ys: number[]
+): { slope: number; intercept: number; r2: number } {
+  const n = xs.length;
+  if (n < 2) return { slope: 0, intercept: ys[0] ?? 0, r2: 0 };
+
+  const sumX = xs.reduce((a, b) => a + b, 0);
+  const sumY = ys.reduce((a, b) => a + b, 0);
+  const sumXY = xs.reduce((a, x, i) => a + x * ys[i], 0);
+  const sumX2 = xs.reduce((a, x) => a + x * x, 0);
+
+  const denom = n * sumX2 - sumX * sumX;
+  if (denom === 0) return { slope: 0, intercept: sumY / n, r2: 0 };
+
+  const slope = (n * sumXY - sumX * sumY) / denom;
+  const intercept = (sumY - slope * sumX) / n;
+
+  // R-squared
+  const meanY = sumY / n;
+  const ssTot = ys.reduce((a, y) => a + (y - meanY) ** 2, 0);
+  const ssRes = ys.reduce((a, y, i) => a + (y - (slope * xs[i] + intercept)) ** 2, 0);
+  const r2 = ssTot === 0 ? 1 : 1 - ssRes / ssTot;
+
+  return { slope, intercept, r2 };
+}
+
+export function analyzeMemory(): MemoryAnalysis {
+  const current = takeMemorySnapshot();
+  const history = getSnapshotHistory();
+
+  let trend: MemoryAnalysis["trend"] = "insufficient_data";
+  let growthRateMBPerSec: number | null = null;
+  let potentialLeak = false;
+
+  if (history.length >= 3) {
+    const baseTime = history[0].timestamp;
+    const xs = history.map((s) => (s.timestamp - baseTime) / 1000); // seconds
+    const ys = history.map((s) => s.heapUsedMB);
+
+    const reg = linearRegression(xs, ys);
+    growthRateMBPerSec = reg.slope;
+
+    // Classify trend based on slope significance and R^2
+    const totalTimeSpan = xs[xs.length - 1] - xs[0];
+    if (totalTimeSpan < 0.1) {
+      trend = "insufficient_data";
+    } else if (Math.abs(reg.slope) < 0.01) {
+      trend = "stable";
+    } else if (reg.slope > 0) {
+      trend = "growing";
+    } else {
+      trend = "shrinking";
+    }
+
+    // Potential leak: consistent growth with high correlation
+    if (trend === "growing" && reg.r2 > 0.7 && reg.slope > 0.1) {
+      potentialLeak = true;
+    }
+  }
+
+  const lines: string[] = [
+    "Memory Analysis:",
+    `  Heap Used:      ${current.heapUsedMB} MB`,
+    `  Heap Total:     ${current.heapTotalMB} MB`,
+    `  RSS:            ${current.rssMB} MB`,
+    `  External:       ${current.externalMB} MB`,
+    `  Array Buffers:  ${current.arrayBuffersMB} MB`,
+    `  Snapshots:      ${history.length}`,
+    `  Trend:          ${trend}`,
+  ];
+
+  if (growthRateMBPerSec !== null) {
+    lines.push(`  Growth Rate:    ${growthRateMBPerSec.toFixed(4)} MB/s`);
+  }
+
+  if (potentialLeak) {
+    lines.push("  WARNING: Potential memory leak detected (consistent heap growth).");
+  }
+
+  return {
+    current,
+    history,
+    trend,
+    growthRateMBPerSec,
+    potentialLeak,
+    summary: lines.join("\n"),
+  };
+}
+
+export function formatSnapshot(snap: MemorySnapshot): string {
+  return [
+    `Memory Snapshot (${new Date(snap.timestamp).toISOString()}):`,
+    `  Heap Used:      ${snap.heapUsedMB} MB`,
+    `  Heap Total:     ${snap.heapTotalMB} MB`,
+    `  RSS:            ${snap.rssMB} MB`,
+    `  External:       ${snap.externalMB} MB`,
+    `  Array Buffers:  ${snap.arrayBuffersMB} MB`,
+  ].join("\n");
+}

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "Node16",
+    "moduleResolution": "Node16",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}