@rog0x/mcp-perf-tools 1.0.0

package/dist/tools/bundle-analyzer.js

@@ -0,0 +1,172 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeBundle = analyzeBundle;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const zlib = __importStar(require("node:zlib"));
+/**
+ * Detect import/require patterns to approximate module boundaries.
+ * This is a heuristic for bundled JS files.
+ */
+function detectModules(content, bundlePath) {
+    const modules = [];
+    const treeShaking = [];
+    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();
+    let match;
+    // 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();
+    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 };
+}
+function analyzeBundle(filePath) {
+    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"),
+    };
+}
+//# sourceMappingURL=bundle-analyzer.js.map

package/dist/tools/load-tester.d.ts

@@ -0,0 +1,36 @@
+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;
+}
+export declare function runLoadTest(config: LoadTestConfig): Promise<LoadTestResult>;
+//# sourceMappingURL=load-tester.d.ts.map

package/dist/tools/load-tester.js

@@ -0,0 +1,185 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runLoadTest = runLoadTest;
+const http = __importStar(require("node:http"));
+const https = __importStar(require("node:https"));
+const node_url_1 = require("node:url");
+const node_perf_hooks_1 = require("node:perf_hooks");
+function percentile(sorted, p) {
+    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) {
+    return new Promise((resolve) => {
+        const parsedUrl = new node_url_1.URL(config.url);
+        const isHttps = parsedUrl.protocol === "https:";
+        const transport = isHttps ? https : http;
+        const startTime = node_perf_hooks_1.performance.now();
+        const timeout = config.timeoutMs ?? 30000;
+        const options = {
+            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 = [];
+            res.on("data", (chunk) => chunks.push(chunk));
+            res.on("end", () => {
+                const durationMs = node_perf_hooks_1.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: node_perf_hooks_1.performance.now() - startTime,
+                    error: err.message,
+                    byteLength: 0,
+                });
+            });
+        });
+        req.on("error", (err) => {
+            resolve({
+                statusCode: null,
+                durationMs: node_perf_hooks_1.performance.now() - startTime,
+                error: err.message,
+                byteLength: 0,
+            });
+        });
+        req.on("timeout", () => {
+            req.destroy();
+            resolve({
+                statusCode: null,
+                durationMs: node_perf_hooks_1.performance.now() - startTime,
+                error: "Request timed out",
+                byteLength: 0,
+            });
+        });
+        if (config.body) {
+            req.write(config.body);
+        }
+        req.end();
+    });
+}
+async function runLoadTest(config) {
+    const { totalRequests, concurrency } = config;
+    const results = [];
+    const overallStart = node_perf_hooks_1.performance.now();
+    // Process requests in batches of `concurrency`
+    let sent = 0;
+    while (sent < totalRequests) {
+        const batchSize = Math.min(concurrency, totalRequests - sent);
+        const batch = [];
+        for (let i = 0; i < batchSize; i++) {
+            batch.push(makeRequest(config));
+        }
+        const batchResults = await Promise.all(batch);
+        results.push(...batchResults);
+        sent += batchSize;
+    }
+    const overallEnd = node_perf_hooks_1.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 = {};
+    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 = {
+        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;
+}
+//# sourceMappingURL=load-tester.js.map

package/dist/tools/memory-analyzer.d.ts

@@ -0,0 +1,22 @@
+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;
+}
+export declare function takeMemorySnapshot(): MemorySnapshot;
+export declare function getSnapshotHistory(): MemorySnapshot[];
+export declare function clearSnapshotHistory(): void;
+export declare function analyzeMemory(): MemoryAnalysis;
+export declare function formatSnapshot(snap: MemorySnapshot): string;
+//# sourceMappingURL=memory-analyzer.d.ts.map

package/dist/tools/memory-analyzer.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.takeMemorySnapshot = takeMemorySnapshot;
+exports.getSnapshotHistory = getSnapshotHistory;
+exports.clearSnapshotHistory = clearSnapshotHistory;
+exports.analyzeMemory = analyzeMemory;
+exports.formatSnapshot = formatSnapshot;
+const toMB = (bytes) => Math.round((bytes / 1024 / 1024) * 100) / 100;
+const snapshotHistory = [];
+function takeMemorySnapshot() {
+    const mem = process.memoryUsage();
+    const snapshot = {
+        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;
+}
+function getSnapshotHistory() {
+    return [...snapshotHistory];
+}
+function clearSnapshotHistory() {
+    snapshotHistory.length = 0;
+}
+function linearRegression(xs, ys) {
+    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 };
+}
+function analyzeMemory() {
+    const current = takeMemorySnapshot();
+    const history = getSnapshotHistory();
+    let trend = "insufficient_data";
+    let growthRateMBPerSec = 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 = [
+        "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"),
+    };
+}
+function formatSnapshot(snap) {
+    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");
+}
+//# sourceMappingURL=memory-analyzer.js.map

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@rog0x/mcp-perf-tools",
+  "version": "1.0.0",
+  "description": "Performance analysis tools for AI agents via MCP",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js"
+  },
+  "keywords": ["mcp", "performance", "benchmark", "profiling"],
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.1"
+  },
+  "devDependencies": {
+    "typescript": "^5.7.3",
+    "@types/node": "^22.15.2"
+  }
+}