mcp-jvm-diagnostics 0.1.0

package/build/parsers/gc-log.js

@@ -0,0 +1,100 @@
+/**
+ * GC log parser.
+ *
+ * Supports:
+ * - Unified JVM logging format (-Xlog:gc*) — Java 9+
+ * - G1, ZGC, Parallel, Serial GC
+ * - Legacy -verbose:gc format (basic support)
+ */
+// Unified logging: [0.123s][info][gc] GC(0) Pause Young (Normal) (G1 Evacuation Pause) 24M->8M(256M) 1.234ms
+const UNIFIED_GC_RE = /\[(\d+[.,]\d+)s\].*?GC\(\d+\)\s+(Pause\s+\S+(?:\s+\([^)]*\))*)\s+(\d+)M->(\d+)M\((\d+)M\)\s+(\d+[.,]\d+)ms/;
+// Unified concurrent: [0.123s][info][gc] GC(0) Concurrent Mark 1.234ms
+const UNIFIED_CONCURRENT_RE = /\[(\d+[.,]\d+)s\].*?GC\(\d+\)\s+(Concurrent\s+\S+(?:\s+\S+)?)\s+(\d+[.,]\d+)ms/;
+// Legacy format: [GC (Allocation Failure) 65536K->12345K(251392K), 0.0123456 secs]
+const LEGACY_GC_RE = /\[(Full )?GC\s*\(([^)]+)\)\s+(\d+)K->(\d+)K\((\d+)K\),\s+(\d+[.,]\d+)\s+secs\]/;
+// ZGC format: [0.123s][info][gc] GC(0) Garbage Collection (Warmup) 24M(1%)->8M(0%) 1.234ms
+const ZGC_RE = /\[(\d+[.,]\d+)s\].*?GC\(\d+\)\s+Garbage Collection\s+\([^)]+\)\s+(\d+)M\(\d+%\)->(\d+)M\(\d+%\)\s+(\d+[.,]\d+)ms/;
+export function parseGcLog(text) {
+    const lines = text.replace(/\r\n/g, "\n").split("\n");
+    const events = [];
+    let algorithm = "Unknown";
+    // Detect algorithm from log content
+    if (text.includes("Using G1"))
+        algorithm = "G1";
+    else if (text.includes("Using ZGC"))
+        algorithm = "ZGC";
+    else if (text.includes("Using Parallel"))
+        algorithm = "Parallel";
+    else if (text.includes("Using Serial"))
+        algorithm = "Serial";
+    else if (text.includes("Using Shenandoah"))
+        algorithm = "Shenandoah";
+    else if (text.includes("G1 Evacuation") || text.includes("G1 Humongous"))
+        algorithm = "G1";
+    else if (text.includes("Garbage Collection ("))
+        algorithm = "ZGC";
+    else if (text.includes("PSYoungGen") || text.includes("ParOldGen"))
+        algorithm = "Parallel";
+    for (const line of lines) {
+        // Try unified format first
+        const unifiedMatch = line.match(UNIFIED_GC_RE);
+        if (unifiedMatch) {
+            events.push({
+                timestamp: parseFloat(unifiedMatch[1].replace(",", ".")),
+                type: unifiedMatch[2].trim(),
+                pauseMs: parseFloat(unifiedMatch[6].replace(",", ".")),
+                heapBeforeMb: parseInt(unifiedMatch[3], 10),
+                heapAfterMb: parseInt(unifiedMatch[4], 10),
+                heapTotalMb: parseInt(unifiedMatch[5], 10),
+            });
+            continue;
+        }
+        // Try ZGC format
+        const zgcMatch = line.match(ZGC_RE);
+        if (zgcMatch) {
+            events.push({
+                timestamp: parseFloat(zgcMatch[1].replace(",", ".")),
+                type: "Pause Young (ZGC)",
+                pauseMs: parseFloat(zgcMatch[4].replace(",", ".")),
+                heapBeforeMb: parseInt(zgcMatch[2], 10),
+                heapAfterMb: parseInt(zgcMatch[3], 10),
+                heapTotalMb: 0,
+            });
+            continue;
+        }
+        // Try unified concurrent
+        const concurrentMatch = line.match(UNIFIED_CONCURRENT_RE);
+        if (concurrentMatch) {
+            events.push({
+                timestamp: parseFloat(concurrentMatch[1].replace(",", ".")),
+                type: concurrentMatch[2].trim(),
+                pauseMs: 0, // concurrent phases don't pause
+                heapBeforeMb: 0,
+                heapAfterMb: 0,
+                heapTotalMb: 0,
+            });
+            continue;
+        }
+        // Try legacy format
+        const legacyMatch = line.match(LEGACY_GC_RE);
+        if (legacyMatch) {
+            const isFull = legacyMatch[1] === "Full ";
+            events.push({
+                timestamp: 0,
+                type: isFull ? "Pause Full" : "Pause Young",
+                pauseMs: parseFloat(legacyMatch[6].replace(",", ".")) * 1000,
+                heapBeforeMb: Math.round(parseInt(legacyMatch[3], 10) / 1024),
+                heapAfterMb: Math.round(parseInt(legacyMatch[4], 10) / 1024),
+                heapTotalMb: Math.round(parseInt(legacyMatch[5], 10) / 1024),
+            });
+        }
+    }
+    // Calculate time span
+    let timeSpanMs = 0;
+    if (events.length > 1) {
+        const firstTs = events[0].timestamp;
+        const lastTs = events[events.length - 1].timestamp;
+        timeSpanMs = (lastTs - firstTs) * 1000;
+    }
+    return { algorithm, events, timeSpanMs };
+}

package/build/parsers/heap-histo.js

@@ -0,0 +1,121 @@
+/**
+ * Parser for `jmap -histo` output.
+ *
+ * Example format:
+ *  num     #instances         #bytes  class name (module)
+ * -------------------------------------------------------
+ *    1:        123456       12345678  [B (java.base)
+ *    2:         98765        9876543  java.lang.String (java.base)
+ *    3:         45678        4567800  java.lang.Object[] (java.base)
+ * ...
+ * Total        500000       50000000
+ */
+// Common JDK internal classes that are expected to be large
+const JDK_INTERNALS = new Set([
+    "[B", "[C", "[I", "[J", "[S", "[Z", "[D", "[F",
+    "java.lang.String", "java.lang.Object[]", "java.lang.Class",
+    "java.util.HashMap$Node", "java.util.concurrent.ConcurrentHashMap$Node",
+    "java.lang.reflect.Method", "java.lang.ref.Finalizer",
+]);
+const HISTO_LINE_RE = /^\s*(\d+):\s+(\d+)\s+(\d+)\s+(.+?)(?:\s+\((.+?)\))?\s*$/;
+const TOTAL_LINE_RE = /^Total\s+(\d+)\s+(\d+)/;
+export function parseHeapHisto(text) {
+    const lines = text.replace(/\r\n/g, "\n").split("\n");
+    const entries = [];
+    let totalInstances = 0;
+    let totalBytes = 0;
+    for (const line of lines) {
+        const totalMatch = TOTAL_LINE_RE.exec(line);
+        if (totalMatch) {
+            totalInstances = parseInt(totalMatch[1], 10);
+            totalBytes = parseInt(totalMatch[2], 10);
+            continue;
+        }
+        const match = HISTO_LINE_RE.exec(line);
+        if (match) {
+            entries.push({
+                rank: parseInt(match[1], 10),
+                instances: parseInt(match[2], 10),
+                bytes: parseInt(match[3], 10),
+                className: match[4].trim(),
+                module: match[5] || null,
+            });
+        }
+    }
+    if (totalInstances === 0 && entries.length > 0) {
+        totalInstances = entries.reduce((sum, e) => sum + e.instances, 0);
+        totalBytes = entries.reduce((sum, e) => sum + e.bytes, 0);
+    }
+    const issues = [];
+    const recommendations = [];
+    if (entries.length === 0) {
+        issues.push({
+            severity: "CRITICAL",
+            message: "No histogram entries found — input may not be a valid jmap -histo output",
+            className: "",
+        });
+        return { entries, totalInstances, totalBytes, issues, recommendations };
+    }
+    // Analyze top entries for suspicious patterns
+    for (const entry of entries.slice(0, 30)) {
+        const pctBytes = totalBytes > 0 ? (entry.bytes / totalBytes) * 100 : 0;
+        const isJdkInternal = JDK_INTERNALS.has(entry.className);
+        // Large non-JDK class consuming > 10% of heap
+        if (pctBytes > 10 && !isJdkInternal) {
+            issues.push({
+                severity: "CRITICAL",
+                message: `${entry.className} consumes ${pctBytes.toFixed(1)}% of heap (${formatBytes(entry.bytes)}, ${entry.instances} instances) — potential memory leak`,
+                className: entry.className,
+            });
+            recommendations.push(`Investigate ${entry.className} — use Eclipse MAT or VisualVM to trace retention paths. Check for unbounded caches or collections.`);
+        }
+        // Very high instance count for non-JDK class (> 100K)
+        if (entry.instances > 100_000 && !isJdkInternal && pctBytes <= 10) {
+            issues.push({
+                severity: "WARNING",
+                message: `${entry.className} has ${entry.instances.toLocaleString()} instances (${formatBytes(entry.bytes)}) — may indicate an object creation hotspot`,
+                className: entry.className,
+            });
+        }
+        // Finalizer objects indicate slow finalization
+        if (entry.className === "java.lang.ref.Finalizer" && entry.instances > 10_000) {
+            issues.push({
+                severity: "WARNING",
+                message: `${entry.instances.toLocaleString()} Finalizer objects — finalization queue may be backed up. Classes using finalize() are blocking GC.`,
+                className: entry.className,
+            });
+            recommendations.push("Replace finalize() with Cleaner or try-with-resources. Finalizers delay GC and can cause memory pressure.");
+        }
+        // Char arrays ([C) or byte arrays ([B) dominating — usually String-related
+        if ((entry.className === "[B" || entry.className === "[C") && pctBytes > 40) {
+            issues.push({
+                severity: "WARNING",
+                message: `${entry.className === "[B" ? "Byte" : "Char"} arrays consume ${pctBytes.toFixed(1)}% of heap — likely driven by String retention. Check for large string caches or log buffering.`,
+                className: entry.className,
+            });
+        }
+    }
+    // Check for class loader leak indicators
+    const classCount = entries.find(e => e.className === "java.lang.Class");
+    if (classCount && classCount.instances > 30_000) {
+        issues.push({
+            severity: "WARNING",
+            message: `${classCount.instances.toLocaleString()} loaded classes — possible classloader leak (hot redeploy, dynamic proxy generation)`,
+            className: "java.lang.Class",
+        });
+        recommendations.push("Check for classloader leaks if using hot deployment (Tomcat, Spring DevTools). Consider restarting instead of redeploying.");
+    }
+    if (issues.length === 0) {
+        recommendations.push("Heap histogram looks healthy. For deeper analysis, capture a full heap dump: jmap -dump:live,format=b,file=heap.hprof <pid>");
+    }
+    return { entries, totalInstances, totalBytes, issues, recommendations };
+}
+function formatBytes(bytes) {
+    if (bytes >= 1_073_741_824)
+        return `${(bytes / 1_073_741_824).toFixed(1)} GB`;
+    if (bytes >= 1_048_576)
+        return `${(bytes / 1_048_576).toFixed(1)} MB`;
+    if (bytes >= 1024)
+        return `${(bytes / 1024).toFixed(0)} KB`;
+    return `${bytes} B`;
+}

package/build/parsers/jfr-summary.js

@@ -0,0 +1,160 @@
+/**
+ * Parser for `jfr summary <file>` output.
+ *
+ * The jfr summary command prints event statistics from a JDK Flight Recorder
+ * (.jfr) file: event types, counts, and sizes. This parser extracts that data
+ * and produces analytical insights.
+ */
+/**
+ * Parse `jfr summary` output text.
+ *
+ * Handles both the tabular format:
+ *   Event Type                          Count  Size (bytes)
+ *   ===========================================================
+ *   jdk.ObjectAllocationInNewTLAB         542       28184
+ *
+ * And the summary lines at the top (start time, duration, etc.).
+ */
+export function parseJfrSummary(text) {
+    if (!text || text.trim().length === 0) {
+        throw new Error("Empty JFR summary input");
+    }
+    const lines = text.split("\n");
+    const events = [];
+    let startTime;
+    let duration;
+    // Match event rows: event_name  count  size
+    // Format: "  jdk.GCPhasePause                     123      45678"
+    const eventLineRegex = /^\s*([\w.]+(?:\s+\([^)]+\))?)\s+(\d+)\s+(\d+)\s*$/;
+    // Alternative format without size column
+    const eventNoSizeRegex = /^\s*([\w.]+)\s+(\d+)\s*$/;
+    // Header metadata patterns
+    const startTimeRegex = /start\s*(?:time)?[:=]\s*(.+)/i;
+    const durationRegex = /duration[:=]\s*(.+)/i;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // Skip empty lines, headers, separators
+        if (!trimmed || /^[=\-]+$/.test(trimmed) || /^Event\s+Type/i.test(trimmed)) {
+            continue;
+        }
+        // Check for metadata lines
+        const startMatch = trimmed.match(startTimeRegex);
+        if (startMatch) {
+            startTime = startMatch[1].trim();
+            continue;
+        }
+        const durMatch = trimmed.match(durationRegex);
+        if (durMatch) {
+            duration = durMatch[1].trim();
+            continue;
+        }
+        // Parse event lines (with size)
+        const eventMatch = line.match(eventLineRegex);
+        if (eventMatch) {
+            events.push({
+                name: eventMatch[1].trim(),
+                count: parseInt(eventMatch[2], 10),
+                size: parseInt(eventMatch[3], 10),
+            });
+            continue;
+        }
+        // Parse event lines (without size — some JFR versions)
+        const noSizeMatch = line.match(eventNoSizeRegex);
+        if (noSizeMatch && !trimmed.startsWith("#") && !/^[A-Z][a-z]+:/.test(trimmed)) {
+            events.push({
+                name: noSizeMatch[1].trim(),
+                count: parseInt(noSizeMatch[2], 10),
+                size: 0,
+            });
+        }
+    }
+    if (events.length === 0) {
+        throw new Error("No JFR events found in summary. Ensure input is from `jfr summary <file>`.");
+    }
+    const totalEvents = events.reduce((sum, e) => sum + e.count, 0);
+    const totalSize = events.reduce((sum, e) => sum + e.size, 0);
+    const { issues, recommendations } = analyzeJfrEvents(events, totalEvents, totalSize);
+    return {
+        events,
+        totalEvents,
+        totalSize,
+        startTime,
+        duration,
+        issues,
+        recommendations,
+    };
+}
+function analyzeJfrEvents(events, totalEvents, totalSize) {
+    const issues = [];
+    const recommendations = [];
+    // Build a lookup by event name
+    const byName = new Map(events.map((e) => [e.name, e]));
+    // Check for excessive GC events
+    const gcEvents = events.filter((e) => e.name.startsWith("jdk.GC") || e.name.startsWith("jdk.G1") || e.name.startsWith("jdk.ZGC"));
+    const gcCount = gcEvents.reduce((sum, e) => sum + e.count, 0);
+    if (gcCount > 1000) {
+        issues.push(`High GC activity: ${gcCount.toLocaleString()} GC events recorded. Possible memory pressure.`);
+        recommendations.push("Analyze GC logs with `analyze_gc_log` for pause time breakdown and tuning recommendations.");
+    }
+    // Check for excessive allocation events
+    const allocTLAB = byName.get("jdk.ObjectAllocationInNewTLAB");
+    const allocOutside = byName.get("jdk.ObjectAllocationOutsideTLAB");
+    if (allocOutside && allocOutside.count > 100) {
+        issues.push(`${allocOutside.count.toLocaleString()} allocations outside TLAB — objects too large for thread-local allocation buffers.`);
+        recommendations.push("Review large object allocations. Consider increasing TLAB size with -XX:TLABSize or reducing object sizes.");
+    }
+    // Check for thread contention
+    const monitorEnter = byName.get("jdk.JavaMonitorEnter");
+    const monitorWait = byName.get("jdk.JavaMonitorWait");
+    if (monitorEnter && monitorEnter.count > 500) {
+        issues.push(`${monitorEnter.count.toLocaleString()} monitor enter events — significant lock contention.`);
+        recommendations.push("Use `analyze_thread_dump` to identify contention hotspots and consider lock-free alternatives.");
+    }
+    // Check for thread starts (churn)
+    const threadStart = byName.get("jdk.ThreadStart");
+    if (threadStart && threadStart.count > 200) {
+        issues.push(`${threadStart.count.toLocaleString()} threads started — possible thread churn. Consider thread pooling.`);
+    }
+    // Check for exception events
+    const exceptions = byName.get("jdk.JavaExceptionThrow");
+    if (exceptions && exceptions.count > 500) {
+        issues.push(`${exceptions.count.toLocaleString()} exceptions thrown — exceptions are expensive and may indicate control flow issues.`);
+        recommendations.push("Review exception handling patterns. Avoid using exceptions for control flow.");
+    }
+    // Check for class loading
+    const classLoad = byName.get("jdk.ClassLoad");
+    if (classLoad && classLoad.count > 1000) {
+        issues.push(`${classLoad.count.toLocaleString()} class loads — excessive class loading may indicate classloader leak or dynamic proxy overuse.`);
+    }
+    // Check for file/socket I/O
+    const fileRead = byName.get("jdk.FileRead");
+    const fileWrite = byName.get("jdk.FileWrite");
+    const socketRead = byName.get("jdk.SocketRead");
+    const socketWrite = byName.get("jdk.SocketWrite");
+    const ioCount = [fileRead, fileWrite, socketRead, socketWrite]
+        .filter(Boolean)
+        .reduce((sum, e) => sum + e.count, 0);
+    if (ioCount > 5000) {
+        issues.push(`High I/O activity: ${ioCount.toLocaleString()} file/socket events. Consider batching or buffering.`);
+    }
+    // Check for compilation events
+    const compilation = byName.get("jdk.Compilation");
+    if (compilation && compilation.count > 500) {
+        issues.push(`${compilation.count.toLocaleString()} JIT compilations — may indicate insufficient code cache or deoptimizations.`);
+        recommendations.push("Check -XX:ReservedCodeCacheSize and look for deoptimization events.");
+    }
+    // Recording size analysis
+    if (totalSize > 100_000_000) {
+        recommendations.push(`Recording is ${(totalSize / 1_048_576).toFixed(0)} MB. Consider narrowing event filters with jfc settings.`);
+    }
+    // If dominant event type uses >50% of total
+    if (events.length > 0) {
+        const sorted = [...events].sort((a, b) => b.count - a.count);
+        const topEvent = sorted[0];
+        const topPct = totalEvents > 0 ? (topEvent.count / totalEvents) * 100 : 0;
+        if (topPct > 50) {
+            recommendations.push(`Event "${topEvent.name}" dominates at ${topPct.toFixed(0)}% of all events. Focus analysis there.`);
+        }
+    }
+    return { issues, recommendations };
+}

package/build/parsers/thread-dump.js

@@ -0,0 +1,118 @@
+/**
+ * HotSpot thread dump parser.
+ *
+ * Parses jstack/kill -3 output into structured thread data including:
+ * - Thread name, state, daemon status
+ * - Stack traces
+ * - Lock information (waiting on, holding)
+ */
+// Java 21+ thread dumps include [os_thread_id] after #id:
+// "Finalizer" #11 [2523503] daemon prio=8 os_prio=0 ...
+const THREAD_HEADER_RE = /^"(.+?)"\s*(#\d+)?\s*(?:\[\d+\])?\s*(daemon)?\s*(?:prio=(\d+))?\s*(?:os_prio=\d+)?\s*(?:cpu=[\d.]+ms)?\s*(?:elapsed=[\d.]+s)?\s*(?:tid=(0x[0-9a-f]+))?\s*(?:nid=(0x[0-9a-f]+|\d+))?\s*(.*)/;
+const STATE_RE = /java\.lang\.Thread\.State:\s*(\S+)/;
+const WAITING_ON_RE = /- waiting to lock\s+<(0x[0-9a-f]+)>/;
+const LOCKED_RE = /- locked\s+<(0x[0-9a-f]+)>/;
+const PARKING_RE = /- parking to wait for\s+<(0x[0-9a-f]+)>/;
+const WAITING_OBJ_RE = /- waiting on\s+<(0x[0-9a-f]+)>/;
+export function parseThreadDump(text) {
+    const lines = text.replace(/\r\n/g, "\n").split("\n");
+    const threads = [];
+    let jvmInfo = "";
+    let timestamp = "";
+    // Extract JVM info and timestamp from header
+    for (const line of lines) {
+        if (line.startsWith("Full thread dump")) {
+            jvmInfo = line.replace("Full thread dump ", "").replace(":", "").trim();
+            break;
+        }
+    }
+    // Look for timestamp (common format: YYYY-MM-DD HH:MM:SS)
+    const tsMatch = text.match(/(\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2})/);
+    if (tsMatch) {
+        timestamp = tsMatch[1];
+    }
+    let currentThread = null;
+    let inStack = false;
+    for (const line of lines) {
+        // Try matching thread header
+        const headerMatch = line.match(THREAD_HEADER_RE);
+        if (headerMatch && line.startsWith('"')) {
+            // Save previous thread
+            if (currentThread) {
+                threads.push(currentThread);
+            }
+            currentThread = {
+                name: headerMatch[1],
+                state: "UNKNOWN",
+                isDaemon: headerMatch[3] === "daemon",
+                priority: headerMatch[4] ? parseInt(headerMatch[4], 10) : 5,
+                tid: headerMatch[5] || "",
+                nid: headerMatch[6] || "",
+                stackTrace: [],
+                waitingOn: null,
+                holdsLocks: [],
+                blockedBy: null,
+            };
+            // Some thread headers include state inline (e.g., "runnable", "waiting on condition")
+            const inlineState = headerMatch[7]?.trim();
+            if (inlineState) {
+                if (inlineState.includes("runnable"))
+                    currentThread.state = "RUNNABLE";
+                else if (inlineState.includes("waiting on condition"))
+                    currentThread.state = "TIMED_WAITING";
+                else if (inlineState.includes("waiting for monitor"))
+                    currentThread.state = "BLOCKED";
+                else if (inlineState.includes("in Object.wait"))
+                    currentThread.state = "WAITING";
+                else if (inlineState.includes("sleeping"))
+                    currentThread.state = "TIMED_WAITING";
+            }
+            inStack = true;
+            continue;
+        }
+        if (!currentThread || !inStack)
+            continue;
+        // Thread state line
+        const stateMatch = line.match(STATE_RE);
+        if (stateMatch) {
+            currentThread.state = stateMatch[1];
+            continue;
+        }
+        // Stack trace line
+        if (line.match(/^\s+at\s+/)) {
+            currentThread.stackTrace.push(line.trim());
+            continue;
+        }
+        // Lock information
+        const waitMatch = line.match(WAITING_ON_RE);
+        if (waitMatch) {
+            currentThread.waitingOn = waitMatch[1];
+            currentThread.blockedBy = waitMatch[1];
+            continue;
+        }
+        const lockMatch = line.match(LOCKED_RE);
+        if (lockMatch) {
+            currentThread.holdsLocks.push(lockMatch[1]);
+            continue;
+        }
+        const parkMatch = line.match(PARKING_RE);
+        if (parkMatch) {
+            currentThread.waitingOn = parkMatch[1];
+            continue;
+        }
+        const waitObjMatch = line.match(WAITING_OBJ_RE);
+        if (waitObjMatch) {
+            currentThread.waitingOn = waitObjMatch[1];
+            continue;
+        }
+        // Empty line ends the current thread's stack
+        if (line.trim() === "" && currentThread.stackTrace.length > 0) {
+            inStack = false;
+        }
+    }
+    // Push last thread
+    if (currentThread) {
+        threads.push(currentThread);
+    }
+    return { jvmInfo, timestamp, threads };
+}

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "mcp-jvm-diagnostics",
+  "version": "0.1.0",
+  "description": "MCP server for JVM diagnostics — analyze thread dumps, detect deadlocks, parse GC logs, and get JVM tuning recommendations",
+  "author": "Dmytro Lisnichenko",
+  "type": "module",
+  "main": "./build/index.js",
+  "bin": {
+    "mcp-jvm-diagnostics": "./build/index.js"
+  },
+  "scripts": {
+    "build": "tsc && chmod 755 build/index.js",
+    "test": "vitest run",
+    "dev": "tsc --watch",
+    "start": "node build/index.js",
+    "prepublishOnly": "npm run build && npm test"
+  },
+  "files": [
+    "build/**/*.js",
+    "!build/__tests__",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "jvm",
+    "java",
+    "thread-dump",
+    "deadlock",
+    "gc-log",
+    "garbage-collection",
+    "diagnostics",
+    "performance",
+    "ai",
+    "claude"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Dmitriusan/mcp-jvm-diagnostics"
+  },
+  "homepage": "https://github.com/Dmitriusan/mcp-jvm-diagnostics#readme",
+  "bugs": {
+    "url": "https://github.com/Dmitriusan/mcp-jvm-diagnostics/issues"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "zod": "^3.24.2"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.8.2",
+    "vitest": "^4.0.18"
+  }
+}