nts_java_memory: инструмент анализа кучи и аллокаций

- JavaMemoryTool: discover, snapshot, compare, alloc
- HeapSnapshot/HeapComparisonReport: модели данных для снапшотов кучи
- JfrReport: форматирование отчётов профайлера (отдельный класс)
- JfrComparisonReport: дельта-отчёты между записями
- AnalysisOptions: конфигурация фокуса анализа (cpu, memory, contention, gc, io)
- Тесты: JavaMemoryToolTest

Author: Nefrols

app/src/main/java/ru/nts/tools/mcp/tools/system/AnalysisOptions.java

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2026 Aristo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package ru.nts.tools.mcp.tools.system;
+
+import java.util.Set;
+
+/**
+ * Internal configuration for JFR analysis.
+ * Not exposed in MCP schema — constructed from the minimal user-facing parameters.
+ */
+record AnalysisOptions(
+        int topN,
+        int stackDepth,
+        String focus,
+        Set<String> collapsePackages
+) {
+
+    private static final Set<String> DEFAULT_COLLAPSE = Set.of("java.", "jdk.", "sun.", "javax.");
+    private static final Set<String> VALID_FOCUS = Set.of("cpu", "cpu-time", "memory", "contention", "gc", "io", "all");
+
+    static AnalysisOptions defaults() {
+        return new AnalysisOptions(8, 10, "all", DEFAULT_COLLAPSE);
+    }
+
+    static AnalysisOptions withFocus(String focus) {
+        String normalized = focus == null || focus.isBlank() ? "all" : focus.trim().toLowerCase();
+        if (!VALID_FOCUS.contains(normalized)) {
+            normalized = "all";
+        }
+        return new AnalysisOptions(8, 10, normalized, DEFAULT_COLLAPSE);
+    }
+
+    boolean includes(String area) {
+        return "all".equals(focus) || focus.equals(area);
+    }
+
+    boolean shouldCollapse(String className) {
+        if (className == null) {
+            return false;
+        }
+        for (String prefix : collapsePackages) {
+            if (className.startsWith(prefix)) {
+                return true;
+            }
+        }
+        return false;
+    }
+}

app/src/main/java/ru/nts/tools/mcp/tools/system/HeapComparisonReport.java

@@ -0,0 +1,262 @@
+/*
+ * Copyright 2026 Aristo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package ru.nts.tools.mcp.tools.system;
+
+import java.time.Duration;
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+
+/**
+ * Delta report comparing two {@link HeapSnapshot}s.
+ * Shows classes with biggest growth in bytes and instances.
+ */
+record HeapComparisonReport(
+        String baselineId,
+        String targetId,
+        Instant baselineTimestamp,
+        Instant targetTimestamp,
+        long baselineTotalBytes,
+        long targetTotalBytes,
+        long baselineTotalInstances,
+        long targetTotalInstances,
+        List<ClassDelta> deltas,
+        List<String> warnings
+) {
+
+    record ClassDelta(
+            String className,
+            long baselineBytes,
+            long targetBytes,
+            long deltaBytes,
+            long baselineInstances,
+            long targetInstances,
+            long deltaInstances
+    ) {}
+
+    /**
+     * Compares two snapshots and produces a delta report.
+     * Sorted by absolute byte growth descending.
+     */
+    static HeapComparisonReport compare(HeapSnapshot baseline, HeapSnapshot target) {
+        Map<String, long[]> baseMap = new it.unimi.dsi.fastutil.objects.Object2ObjectLinkedOpenHashMap<>();
+        Map<String, long[]> targetMap = new it.unimi.dsi.fastutil.objects.Object2ObjectLinkedOpenHashMap<>();
+
+        for (HeapSnapshot.ClassEntry e : baseline.classes()) {
+            baseMap.put(e.className(), new long[]{e.bytes(), e.instances()});
+        }
+        for (HeapSnapshot.ClassEntry e : target.classes()) {
+            targetMap.put(e.className(), new long[]{e.bytes(), e.instances()});
+        }
+
+        List<ClassDelta> deltas = new it.unimi.dsi.fastutil.objects.ObjectArrayList<>();
+        // Union of all class names
+        var allClasses = new LinkedHashMap<String, Boolean>();
+        targetMap.keySet().forEach(k -> allClasses.put(k, true));
+        baseMap.keySet().forEach(k -> allClasses.putIfAbsent(k, true));
+
+        for (String className : allClasses.keySet()) {
+            long[] base = baseMap.getOrDefault(className, new long[]{0, 0});
+            long[] tgt = targetMap.getOrDefault(className, new long[]{0, 0});
+            long deltaBytes = tgt[0] - base[0];
+            long deltaInstances = tgt[1] - base[1];
+            if (deltaBytes != 0 || deltaInstances != 0) {
+                deltas.add(new ClassDelta(className,
+                        base[0], tgt[0], deltaBytes,
+                        base[1], tgt[1], deltaInstances));
+            }
+        }
+
+        // Sort by absolute byte delta descending
+        deltas.sort(Comparator.comparingLong((ClassDelta d) -> Math.abs(d.deltaBytes())).reversed());
+
+        List<String> warnings = new it.unimi.dsi.fastutil.objects.ObjectArrayList<>();
+        if (baseline.liveOnly() != target.liveOnly()) {
+            warnings.add("Snapshots have different liveOnly settings — comparison may be misleading.");
+        }
+        if (baseline.pid() != target.pid()) {
+            warnings.add("Snapshots are from different PIDs (" + baseline.pid() + " vs " + target.pid() + ").");
+        }
+
+        return new HeapComparisonReport(
+                baseline.snapshotId(), target.snapshotId(),
+                baseline.timestamp(), target.timestamp(),
+                baseline.totalBytes(), target.totalBytes(),
+                baseline.totalInstances(), target.totalInstances(),
+                deltas, warnings
+        );
+    }
+
+    String renderMarkdown(int topN) {
+        StringBuilder sb = new StringBuilder();
+        sb.append("### Heap Comparison\n");
+        sb.append("Baseline: ").append(baselineId)
+                .append(" (").append(JfrReport.formatBytes(baselineTotalBytes))
+                .append(", ").append(String.format(Locale.ROOT, "%,d", baselineTotalInstances))
+                .append(" instances)\n");
+        sb.append("Target: ").append(targetId)
+                .append(" (").append(JfrReport.formatBytes(targetTotalBytes))
+                .append(", ").append(String.format(Locale.ROOT, "%,d", targetTotalInstances))
+                .append(" instances)\n");
+
+        // Time elapsed
+        Duration elapsed = (baselineTimestamp != null && targetTimestamp != null)
+                ? Duration.between(baselineTimestamp, targetTimestamp) : null;
+        if (elapsed != null) {
+            sb.append("Elapsed: ").append(JfrReport.formatDuration(elapsed)).append("\n");
+        }
+
+        // Byte delta
+        long bytesDelta = targetTotalBytes - baselineTotalBytes;
+        String bytesSign = bytesDelta >= 0 ? "+" : "";
+        double bytesPct = baselineTotalBytes > 0 ? (bytesDelta * 100.0) / baselineTotalBytes : 0;
+        sb.append("Bytes delta: ").append(bytesSign).append(JfrReport.formatBytes(Math.abs(bytesDelta)));
+        if (bytesDelta < 0) sb.append(" (shrunk)");
+        sb.append(String.format(Locale.ROOT, " (%s%.1f%%)", bytesSign, bytesPct));
+        if (elapsed != null && elapsed.toSeconds() > 0) {
+            long bytesPerSec = Math.abs(bytesDelta) / elapsed.toSeconds();
+            sb.append(" — ").append(bytesSign).append(JfrReport.formatBytes(bytesPerSec)).append("/s");
+        }
+        sb.append("\n");
+
+        // Instance delta
+        long instDelta = targetTotalInstances - baselineTotalInstances;
+        String instSign = instDelta >= 0 ? "+" : "";
+        sb.append("Instances delta: ").append(instSign)
+                .append(String.format(Locale.ROOT, "%,d", instDelta));
+        if (elapsed != null && elapsed.toSeconds() > 0) {
+            long instPerSec = Math.abs(instDelta) / elapsed.toSeconds();
+            sb.append(" — ").append(instSign).append(String.format(Locale.ROOT, "%,d", instPerSec)).append("/s");
+        }
+        sb.append("\n");
+
+        if (!warnings.isEmpty()) {
+            sb.append("\n**Warnings:**\n");
+            for (String w : warnings) {
+                sb.append("- ").append(w).append("\n");
+            }
+        }
+
+        if (!deltas.isEmpty()) {
+            // NEW classes (only in target, not in baseline) — strongest leak signal
+            List<ClassDelta> newClasses = deltas.stream()
+                    .filter(d -> d.baselineBytes() == 0 && d.targetBytes() > 0)
+                    .sorted(Comparator.comparingLong(ClassDelta::targetBytes).reversed())
+                    .limit(topN)
+                    .toList();
+            if (!newClasses.isEmpty()) {
+                sb.append("\n**⚠ New Classes (absent in baseline):**\n");
+                for (ClassDelta d : newClasses) {
+                    sb.append(String.format(Locale.ROOT, "- **%s**: %s (%,d instances) — NEW\n",
+                            d.className(), JfrReport.formatBytes(d.targetBytes()), d.targetInstances()));
+                }
+            }
+
+            // Top growers — with % growth and rate
+            List<ClassDelta> growers = deltas.stream()
+                    .filter(d -> d.deltaBytes() > 0 && d.baselineBytes() > 0) // exclude new classes
+                    .sorted(Comparator.comparingLong(ClassDelta::deltaBytes).reversed())
+                    .limit(topN)
+                    .toList();
+            if (!growers.isEmpty()) {
+                sb.append("\n**Top Growers:**\n");
+                for (ClassDelta d : growers) {
+                    double growthPct = d.baselineBytes() > 0 ? (d.deltaBytes() * 100.0) / d.baselineBytes() : 0;
+                    sb.append(String.format(Locale.ROOT, "- %s: +%s (+%.0f%%, +%,d instances)",
+                            d.className(), JfrReport.formatBytes(d.deltaBytes()), growthPct, d.deltaInstances()));
+                    if (elapsed != null && elapsed.toSeconds() > 0) {
+                        sb.append(String.format(Locale.ROOT, " — %s/s",
+                                JfrReport.formatBytes(d.deltaBytes() / elapsed.toSeconds())));
+                    }
+                    sb.append("\n");
+                }
+            }
+
+            // Suspicious growth: high % increase even if small absolute
+            List<ClassDelta> suspicious = deltas.stream()
+                    .filter(d -> d.baselineBytes() > 0 && d.deltaBytes() > 0)
+                    .filter(d -> {
+                        double pct = (d.deltaBytes() * 100.0) / d.baselineBytes();
+                        return pct > 100 && d.deltaBytes() > 1024; // >100% growth and at least 1KB
+                    })
+                    .sorted(Comparator.comparingDouble((ClassDelta d) ->
+                            (d.deltaBytes() * 1.0) / Math.max(1, d.baselineBytes())).reversed())
+                    .limit(5)
+                    .toList();
+            // Only show if different from top growers
+            List<String> growerNames = growers.stream().map(ClassDelta::className).toList();
+            suspicious = suspicious.stream().filter(d -> !growerNames.contains(d.className())).toList();
+            if (!suspicious.isEmpty()) {
+                sb.append("\n**⚠ Suspicious Growth (high % increase):**\n");
+                for (ClassDelta d : suspicious) {
+                    double growthPct = (d.deltaBytes() * 100.0) / d.baselineBytes();
+                    sb.append(String.format(Locale.ROOT, "- %s: %s → %s (+%.0f%%)\n",
+                            d.className(), JfrReport.formatBytes(d.baselineBytes()),
+                            JfrReport.formatBytes(d.targetBytes()), growthPct));
+                }
+            }
+
+            // Top shrinkers (compact)
+            List<ClassDelta> shrinkers = deltas.stream()
+                    .filter(d -> d.deltaBytes() < 0)
+                    .sorted(Comparator.comparingLong(ClassDelta::deltaBytes))
+                    .limit(topN)
+                    .toList();
+            if (!shrinkers.isEmpty()) {
+                sb.append("\n**Top Shrinkers:**\n");
+                for (ClassDelta d : shrinkers) {
+                    sb.append(String.format(Locale.ROOT, "- %s: -%s (%,d instances)\n",
+                            d.className(), JfrReport.formatBytes(Math.abs(d.deltaBytes())), d.deltaInstances()));
+                }
+            }
+        } else {
+            sb.append("\nNo class-level changes detected.\n");
+        }
+
+        // Leak extrapolation
+        if (bytesDelta > 0 && elapsed != null && elapsed.toSeconds() > 5) {
+            // Only meaningful if we know heap max (estimate from target total as proxy)
+            long heapEstimate = targetTotalBytes * 3; // rough: assume heap ~3x current usage
+            long secondsToFull = (heapEstimate - targetTotalBytes) / Math.max(1, bytesDelta / elapsed.toSeconds());
+            if (secondsToFull > 0 && secondsToFull < 86400) { // less than 24h
+                sb.append(String.format(Locale.ROOT,
+                        "\n**⚠ Leak Extrapolation:** At current growth rate (%s/s), heap pressure will ~triple in %s.\n",
+                        JfrReport.formatBytes(bytesDelta / elapsed.toSeconds()),
+                        JfrReport.formatDuration(Duration.ofSeconds(secondsToFull))));
+                sb.append("> This is a rough estimate. Use `nts_java_profiler(action='profile', focus='gc')` for actual heap max.\n");
+            }
+        }
+
+        // Insights
+        sb.append("\n**Insights:**\n");
+        if (bytesDelta > 0) {
+            sb.append("- Heap grew. If this is under steady-state load, it may indicate a memory leak.\n");
+            sb.append("- Verify with `nts_java_memory(action='snapshot', liveOnly=true)` — if growth survives Full GC, it's retained.\n");
+        } else if (bytesDelta < 0) {
+            sb.append("- Heap shrank — GC reclaimed memory. No leak signal.\n");
+        } else {
+            sb.append("- No heap change. Memory is stable.\n");
+        }
+        sb.append("- To find allocation sources: `nts_java_memory(action='alloc')`\n");
+        sb.append("- To see GC impact: `nts_java_profiler(action='profile', focus='gc')`\n");
+
+        return sb.toString().stripTrailing();
+    }
+}