javaperf 1.0.0

package/.cursor/mcp.json

@@ -0,0 +1,12 @@
+{
+  "mcpServers": {
+    "javaperf": {
+      "command": "node",
+      "args": ["dist/index.js"],
+      "cwd": "${workspaceFolder}",
+      "env": {
+        "JAVA_HOME": "/home/sharque/.sdkman/candidates/java/current"
+      }
+    }
+  }
+}

package/README.md

@@ -0,0 +1,185 @@
+# javaperf
+
+[![npm version](https://img.shields.io/npm/v/javaperf.svg)](https://www.npmjs.com/package/javaperf)
+
+> MCP (Model Context Protocol) server for profiling Java applications via JDK utilities (jcmd, jfr, jps)
+
+Enables AI assistants to diagnose performance, analyze threads, and inspect JFR recordings without manual CLI usage.
+
+📦 **Install**: `npm install -g javaperf` or use via npx  
+🌐 **npm**: https://www.npmjs.com/package/javaperf
+
+## Requirements
+
+- **Node.js** v18+
+- **JDK** 8u262+ or 11+ with JFR support
+
+JDK tools (`jps`, `jcmd`, `jfr`) are auto-detected via `JAVA_HOME` or `which java`. If not found, set `JAVA_HOME` to your JDK root.
+
+## Quick Start
+
+### For Users (using npm package)
+
+```bash
+# No installation needed - use directly in Cursor/Claude Desktop
+# Just configure it as described in Integration section below
+```
+
+### For Developers
+
+1. Clone the repository:
+```bash
+git clone <repo-url>
+cd mcp-jperf
+```
+
+2. Install dependencies:
+```bash
+npm install
+```
+
+3. Build the project:
+```bash
+npm run build
+```
+
+## Usage
+
+### Development Mode
+
+```bash
+npm run dev
+```
+
+### Production Mode
+
+```bash
+npm start
+```
+
+### MCP Inspector
+
+Debug and test with MCP Inspector:
+```bash
+npx @modelcontextprotocol/inspector node dist/index.js
+```
+
+## Integration
+
+### Cursor IDE
+
+1. Open Cursor Settings → Features → Model Context Protocol
+2. Click "Edit Config" button
+3. Add one of the configurations below
+
+#### Option 1: Via npm (Recommended)
+
+Installs from npm registry automatically:
+
+```json
+{
+  "mcpServers": {
+    "javaperf": {
+      "command": "npx",
+      "args": ["-y", "javaperf"]
+    }
+  }
+}
+```
+
+#### Option 2: Via npm link (Development)
+
+For local development with live changes:
+
+```json
+{
+  "mcpServers": {
+    "javaperf": {
+      "command": "javaperf"
+    }
+  }
+}
+```
+
+Requires: `cd /path/to/mcp-jperf && npm link -g`
+
+#### Option 3: Direct path
+
+```json
+{
+  "mcpServers": {
+    "javaperf": {
+      "command": "node",
+      "args": ["dist/index.js"],
+      "cwd": "${workspaceFolder}",
+      "env": {
+        "JAVA_HOME": "/path/to/your/jdk"
+      }
+    }
+  }
+}
+```
+
+If `list_java_processes` fails with "jps not found", the MCP server may not inherit your shell's `JAVA_HOME`. Add the `env` block above with your JDK root path (e.g. `/usr/lib/jvm/java-17` or `~/.sdkman/candidates/java/current`).
+
+### Claude Desktop
+
+Edit `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS) or `%APPDATA%\Claude\claude_desktop_config.json` (Windows):
+
+```json
+{
+  "mcpServers": {
+    "javaperf": {
+      "command": "npx",
+      "args": ["-y", "javaperf"]
+    }
+  }
+}
+```
+
+### Continue.dev
+
+Edit `.continue/config.json`:
+
+```json
+{
+  "mcpServers": {
+    "javaperf": {
+      "command": "npx",
+      "args": ["-y", "javaperf"]
+    }
+  }
+}
+```
+
+## Tools
+
+| Tool | Description |
+|------|-------------|
+| `list_java_processes` | List running Java processes (pid, mainClass, args). Use `topN` (default 10) to limit. |
+| `start_profiling` | Start JFR recording with `settings=profile`. Pass `pid`, `duration` (seconds), optional `recordingName`. |
+| `stop_profiling` | Stop recording and save to file. Requires `pid` and `recordingId` from start_profiling. |
+| `analyze_threads` | Thread dump (jstack). Pass `pid`, optional `topN` (default 10) to limit threads. |
+| `heap_histogram` | Class histogram (GC.class_histogram). Top classes by instances/bytes. Pass `pid`, optional `topN` (20), `all` (include unreachable). |
+| `heap_dump` | Create .hprof heap dump for MAT/VisualVM. Pass `pid`. Saved to recordings/heap_dump.hprof. |
+| `heap_info` | Brief heap summary. Pass `pid`. |
+| `vm_info` | JVM info: uptime, version, flags. Pass `pid`. |
+| `trace_method` | Build call tree for a method from a .jfr file. Pass `filepath`, `className`, `methodName`, optional `topN`. |
+| `parse_jfr_summary` | Parse .jfr into summary: top methods, GC stats, anomalies. Pass `filepath`, optional `events`, `topN`. |
+| `profile_memory` | Memory profile: top allocators, GC, potential leaks. Pass `filepath`, optional `topN`. |
+| `profile_time` | CPU bottleneck profile (bottom-up). Pass `filepath`, optional `topN`. |
+| `profile_frequency` | Call frequency profile (leaf frames). Pass `filepath`, optional `topN`. |
+
+## Example Workflow
+
+1. **List processes** → `list_java_processes`
+2. **Start recording** → `start_profiling` with `pid` and `duration` (e.g. 60)
+3. Wait for `duration` seconds (or let it run)
+4. **Stop and save** → `stop_profiling` with `pid` and `recordingId`
+5. **Analyze** → Use `parse_jfr_summary`, `profile_memory`, `profile_time`, `profile_frequency`, or `trace_method` with the saved .jfr path
+
+## Limitations
+
+- **Sampling**: JFR samples ~10ms; fast methods may not appear in ExecutionSample
+- **Local only**: Runs on the machine where MCP is started
+- **Permissions**: Must run as same user as target JVM for jcmd access

package/README_RU.md

@@ -0,0 +1,185 @@
+# javaperf
+
+[![npm version](https://img.shields.io/npm/v/javaperf.svg)](https://www.npmjs.com/package/javaperf)
+
+> MCP-сервер для профилирования Java-приложений через утилиты JDK (jcmd, jfr, jps)
+
+Позволяет AI-ассистентам диагностировать производительность, анализировать потоки и просматривать JFR-записи без ручного использования CLI.
+
+📦 **Установка**: `npm install -g javaperf` или через npx  
+🌐 **npm**: https://www.npmjs.com/package/javaperf
+
+## Требования
+
+- **Node.js** v18+
+- **JDK** 8u262+ или 11+ с поддержкой JFR
+
+Утилиты JDK (`jps`, `jcmd`, `jfr`) находятся автоматически через `JAVA_HOME` или `which java`. Если не найдены — задайте `JAVA_HOME` на корень JDK.
+
+## Быстрый старт
+
+### Для пользователей (через npm)
+
+```bash
+# Установка не требуется — можно использовать прямо в Cursor/Claude Desktop
+# Настройте по инструкции в разделе Интеграция ниже
+```
+
+### Для разработчиков
+
+1. Клонируйте репозиторий:
+```bash
+git clone <repo-url>
+cd mcp-jperf
+```
+
+2. Установите зависимости:
+```bash
+npm install
+```
+
+3. Соберите проект:
+```bash
+npm run build
+```
+
+## Использование
+
+### Режим разработки
+
+```bash
+npm run dev
+```
+
+### Production
+
+```bash
+npm start
+```
+
+### MCP Inspector
+
+Отладка и тестирование:
+```bash
+npx @modelcontextprotocol/inspector node dist/index.js
+```
+
+## Интеграция
+
+### Cursor IDE
+
+1. Откройте Cursor Settings → Features → Model Context Protocol
+2. Нажмите "Edit Config"
+3. Добавьте одну из конфигураций ниже
+
+#### Вариант 1: Через npm (рекомендуется)
+
+Устанавливается из npm автоматически:
+
+```json
+{
+  "mcpServers": {
+    "javaperf": {
+      "command": "npx",
+      "args": ["-y", "javaperf"]
+    }
+  }
+}
+```
+
+#### Вариант 2: Через npm link (для разработки)
+
+Для локальной разработки с живыми изменениями:
+
+```json
+{
+  "mcpServers": {
+    "javaperf": {
+      "command": "javaperf"
+    }
+  }
+}
+```
+
+Требуется: `cd /путь/к/mcp-jperf && npm link -g`
+
+#### Вариант 3: Прямой путь
+
+```json
+{
+  "mcpServers": {
+    "javaperf": {
+      "command": "node",
+      "args": ["dist/index.js"],
+      "cwd": "${workspaceFolder}",
+      "env": {
+        "JAVA_HOME": "/путь/к/вашему/jdk"
+      }
+    }
+  }
+}
+```
+
+Если `list_java_processes` выдаёт "jps not found", MCP-сервер может не наследовать `JAVA_HOME` из shell. Добавьте блок `env` с путём к корню JDK (например `/usr/lib/jvm/java-17` или `~/.sdkman/candidates/java/current`).
+
+### Claude Desktop
+
+Редактировать `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS) или `%APPDATA%\Claude\claude_desktop_config.json` (Windows):
+
+```json
+{
+  "mcpServers": {
+    "javaperf": {
+      "command": "npx",
+      "args": ["-y", "javaperf"]
+    }
+  }
+}
+```
+
+### Continue.dev
+
+Редактировать `.continue/config.json`:
+
+```json
+{
+  "mcpServers": {
+    "javaperf": {
+      "command": "npx",
+      "args": ["-y", "javaperf"]
+    }
+  }
+}
+```
+
+## Инструменты
+
+| Инструмент | Описание |
+|------------|----------|
+| `list_java_processes` | Список Java-процессов (pid, mainClass, args). Параметр `topN` (по умолчанию 10) ограничивает вывод. |
+| `start_profiling` | Запуск JFR-записи с `settings=profile`. Параметры: `pid`, `duration` (сек), опционально `recordingName`. |
+| `stop_profiling` | Остановка записи и сохранение в файл. Требует `pid` и `recordingId` из start_profiling. |
+| `analyze_threads` | Дамп потоков (jstack). Параметры: `pid`, опционально `topN` (по умолчанию 10). |
+| `heap_histogram` | Гистограмма классов (GC.class_histogram). Топ классов по количеству объектов и памяти. Параметры: `pid`, опционально `topN` (20), `all`. |
+| `heap_dump` | Создание .hprof дампа кучи для MAT/VisualVM. Параметр: `pid`. Сохраняется в recordings/heap_dump.hprof. |
+| `heap_info` | Краткая сводка по куче. Параметр: `pid`. |
+| `vm_info` | Информация о JVM: uptime, version, flags. Параметр: `pid`. |
+| `trace_method` | Построение дерева вызовов метода из .jfr. Параметры: `filepath`, `className`, `methodName`, опционально `topN`. |
+| `parse_jfr_summary` | Разбор .jfr в сводку: топ методов, GC, аномалии. Параметры: `filepath`, опционально `events`, `topN`. |
+| `profile_memory` | Профиль по памяти: топ аллокаторов, GC, утечки. Параметры: `filepath`, опционально `topN`. |
+| `profile_time` | Профиль по времени (узкие места CPU). Параметры: `filepath`, опционально `topN`. |
+| `profile_frequency` | Профиль по частоте вызовов. Параметры: `filepath`, опционально `topN`. |
+
+## Пример работы
+
+1. **Список процессов** → `list_java_processes`
+2. **Старт записи** → `start_profiling` с `pid` и `duration` (например 60)
+3. Подождать `duration` секунд
+4. **Остановка и сохранение** → `stop_profiling` с `pid` и `recordingId`
+5. **Анализ** → Использовать `parse_jfr_summary`, `profile_memory`, `profile_time`, `profile_frequency` или `trace_method` с путём к сохранённому .jfr
+
+## Ограничения
+
+- **Семплинг**: JFR делает снимки ~10 мс; быстрые методы могут не попасть в ExecutionSample
+- **Локальность**: Работает только на машине, где запущен MCP
+- **Права**: Нужен доступ к целевой JVM (пользователь MCP = пользователь JVM)

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,255 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { listJavaProcesses } from "./tools/list_procs.js";
+import { startProfiling } from "./tools/start_profiling.js";
+import { stopProfiling } from "./tools/stop_profiling.js";
+import { analyzeThreads } from "./tools/analyze_threads.js";
+import { traceMethod } from "./tools/trace_method.js";
+import { parseJfrSummary } from "./tools/parse_jfr.js";
+import { profileMemory } from "./tools/profile_memory.js";
+import { profileTime } from "./tools/profile_time.js";
+import { profileFrequency } from "./tools/profile_frequency.js";
+import { heapHistogram } from "./tools/heap_histogram.js";
+import { heapDump } from "./tools/heap_dump.js";
+import { heapInfo } from "./tools/heap_info.js";
+import { vmInfo } from "./tools/vm_info.js";
+const server = new McpServer({
+    name: "javaperf",
+    version: "1.0.0",
+});
+server.registerTool("list_java_processes", {
+    description: "Lists all running Java processes on the machine. Returns an array of objects with pid, mainClass, and args. Use this tool first to discover the target process PID before calling start_profiling or analyze_threads. Data is obtained via jps -l -m.",
+    inputSchema: z.object({
+        topN: z
+            .number()
+            .int()
+            .min(1)
+            .max(100)
+            .optional()
+            .default(10)
+            .describe("Maximum number of processes to return in the list. Default: 10. Use higher values if many Java processes are running."),
+    }),
+}, async ({ topN }) => ({
+    content: [{ type: "text", text: await listJavaProcesses({ topN }) }],
+}));
+server.registerTool("start_profiling", {
+    description: "Starts a Java Flight Recorder (JFR) recording on the specified Java process. Uses settings=profile for a full dump. Before starting, rotates files: deletes old_profile.jfr, renames new_profile.jfr → old_profile.jfr. This keeps only 2 files for before/after comparison. Call stop_profiling after duration to save to recordings/new_profile.jfr.",
+    inputSchema: z.object({
+        pid: z
+            .number()
+            .int()
+            .positive()
+            .describe("Process ID of the Java application to profile. Get this from list_java_processes."),
+        duration: z
+            .number()
+            .int()
+            .positive()
+            .describe("Recording duration in seconds. Typical values: 10–60 for quick checks, 300+ for load testing."),
+    }),
+}, async (args) => ({
+    content: [{ type: "text", text: await startProfiling(args) }],
+}));
+server.registerTool("stop_profiling", {
+    description: "Stops an active JFR recording and saves it to recordings/new_profile.jfr. Use recordings/new_profile.jfr for current data, recordings/old_profile.jfr for previous (before/after comparison).",
+    inputSchema: z.object({
+        pid: z
+            .number()
+            .int()
+            .positive()
+            .describe("Process ID of the Java process that has the active recording. Must match the pid used in start_profiling."),
+        recordingId: z
+            .string()
+            .describe("ID of the recording to stop. This is the recordingId returned by start_profiling (e.g. '1' or '2')."),
+    }),
+}, async (args) => ({
+    content: [{ type: "text", text: await stopProfiling(args) }],
+}));
+server.registerTool("analyze_threads", {
+    description: "Produces a thread dump of the specified Java process (equivalent to jstack -l). Shows each thread's name, state, and full stack trace with lock information. Use for diagnosing deadlocks, blocked threads, or high thread counts.",
+    inputSchema: z.object({
+        pid: z
+            .number()
+            .int()
+            .positive()
+            .describe("Process ID of the Java application. Get this from list_java_processes."),
+        topN: z
+            .number()
+            .int()
+            .min(1)
+            .max(500)
+            .optional()
+            .default(10)
+            .describe("Maximum number of threads to include in the output. Default: 10. Increase for applications with many threads."),
+    }),
+}, async (args) => ({
+    content: [{ type: "text", text: await analyzeThreads(args) }],
+}));
+server.registerTool("heap_histogram", {
+    description: "Class histogram of live objects in the heap (jcmd GC.class_histogram). Returns top classes by memory usage — useful for memory leak investigation. Classes with unusually high instance count or bytes may indicate a leak.",
+    inputSchema: z.object({
+        pid: z
+            .number()
+            .int()
+            .positive()
+            .describe("Process ID of the Java application. Get this from list_java_processes."),
+        topN: z
+            .number()
+            .int()
+            .min(1)
+            .max(200)
+            .optional()
+            .default(20)
+            .describe("Maximum number of top classes to return. Default: 20."),
+        all: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("Include unreachable objects (full GC). Use with caution — can cause pause."),
+    }),
+}, async (args) => ({
+    content: [{ type: "text", text: await heapHistogram(args) }],
+}));
+server.registerTool("heap_dump", {
+    description: "Creates a heap dump (.hprof file) for offline analysis in Eclipse MAT, VisualVM, or JProfiler. Saved to recordings/heap_dump.hprof (overwritten each call). Warning: file can be large (hundreds of MB to GB).",
+    inputSchema: z.object({
+        pid: z
+            .number()
+            .int()
+            .positive()
+            .describe("Process ID of the Java application. Get this from list_java_processes."),
+    }),
+}, async (args) => ({
+    content: [{ type: "text", text: await heapDump(args) }],
+}));
+server.registerTool("heap_info", {
+    description: "Brief heap usage summary: capacities, used, committed regions. Quick snapshot without full dump.",
+    inputSchema: z.object({
+        pid: z
+            .number()
+            .int()
+            .positive()
+            .describe("Process ID of the Java application. Get this from list_java_processes."),
+    }),
+}, async (args) => ({
+    content: [{ type: "text", text: await heapInfo(args) }],
+}));
+server.registerTool("vm_info", {
+    description: "JVM information: uptime, version, and flags. Useful for environment verification.",
+    inputSchema: z.object({
+        pid: z
+            .number()
+            .int()
+            .positive()
+            .describe("Process ID of the Java application. Get this from list_java_processes."),
+    }),
+}, async (args) => ({
+    content: [{ type: "text", text: await vmInfo(args) }],
+}));
+server.registerTool("trace_method", {
+    description: "Builds a call tree for a specific method from a .jfr file. Filters ExecutionSample events to find stack traces containing the given class and method, then aggregates call paths. Use when you want to see who calls a particular method and from where. Limitation: JFR sampling (~10 ms) may miss very fast methods.",
+    inputSchema: z.object({
+        filepath: z
+            .string()
+            .describe("Path to .jfr file. Shortcuts: 'new_profile' (current) or 'old_profile' (previous). Or full path e.g. recordings/new_profile.jfr."),
+        className: z
+            .string()
+            .describe("Fully qualified class name (e.g. com.example.MyService) or a substring to match. Used to filter stack frames."),
+        methodName: z
+            .string()
+            .describe("Method name to search for (e.g. processRequest). Matches the method in the stack trace."),
+        events: z
+            .array(z.string())
+            .optional()
+            .describe("Optional list of JFR event types to parse. Default: jdk.ExecutionSample. Advanced users can specify other event types."),
+        topN: z
+            .number()
+            .int()
+            .min(1)
+            .max(100)
+            .optional()
+            .default(10)
+            .describe("Maximum number of call paths (branches) to return in the call tree. Default: 10."),
+    }),
+}, async (args) => ({
+    content: [{ type: "text", text: await traceMethod(args) }],
+}));
+server.registerTool("parse_jfr_summary", {
+    description: "Parses a .jfr file and returns a structured summary: top methods by CPU samples, GC statistics, thread allocation stats, and anomaly hints (e.g. high GC count). Use for a quick high-level overview of the recording before diving into specific profiles.",
+    inputSchema: z.object({
+        filepath: z
+            .string()
+            .describe("Path to .jfr file. Shortcuts: 'new_profile' (current) or 'old_profile' (previous). Or full path e.g. recordings/new_profile.jfr."),
+        events: z
+            .array(z.string())
+            .optional()
+            .describe("Optional list of JFR event types to include. Default: jdk.ExecutionSample, jdk.GarbageCollection, jdk.JavaThreadStatistics, jdk.ThreadAllocationStatistics."),
+        topN: z
+            .number()
+            .int()
+            .min(1)
+            .max(100)
+            .optional()
+            .default(10)
+            .describe("Maximum number of top methods to include in the summary. Default: 10."),
+    }),
+}, async (args) => ({
+    content: [{ type: "text", text: await parseJfrSummary(args) }],
+}));
+server.registerTool("profile_memory", {
+    description: "Memory-focused profile from a .jfr file. Returns top memory allocators (class+method), GC statistics, and potential leak candidates from OldObjectSample events. Use when the goal is to find who allocates the most memory or identify memory leaks. Requires a recording made with settings=profile (which start_profiling uses by default).",
+    inputSchema: z.object({
+        filepath: z
+            .string()
+            .describe("Path to .jfr file. Shortcuts: 'new_profile' (current) or 'old_profile' (previous). Or full path e.g. recordings/new_profile.jfr."),
+        topN: z
+            .number()
+            .int()
+            .min(1)
+            .max(100)
+            .optional()
+            .default(10)
+            .describe("Maximum number of top allocators to return. Default: 10."),
+    }),
+}, async (args) => ({
+    content: [{ type: "text", text: await profileMemory(args) }],
+}));
+server.registerTool("profile_time", {
+    description: "CPU time (bottleneck) profile from a .jfr file. Uses bottom-up aggregation: each method is counted in every sample where it appears in the stack, including time spent in callees. Returns methods consuming the most CPU time. Use when the goal is to find performance bottlenecks and slow code paths.",
+    inputSchema: z.object({
+        filepath: z
+            .string()
+            .describe("Path to .jfr file. Shortcuts: 'new_profile' (current) or 'old_profile' (previous). Or full path e.g. recordings/new_profile.jfr."),
+        topN: z
+            .number()
+            .int()
+            .min(1)
+            .max(100)
+            .optional()
+            .default(10)
+            .describe("Maximum number of top methods by CPU time to return. Default: 10."),
+    }),
+}, async (args) => ({
+    content: [{ type: "text", text: await profileTime(args) }],
+}));
+server.registerTool("profile_frequency", {
+    description: "Call frequency profile from a .jfr file. Counts methods that appear at the leaf (top) of the stack in ExecutionSample events — i.e. methods that were actively executing when sampled. Returns the most frequently sampled methods (exclusive, not cumulative). Use when looking for hot spots or the most often executed code paths.",
+    inputSchema: z.object({
+        filepath: z
+            .string()
+            .describe("Path to .jfr file. Shortcuts: 'new_profile' (current) or 'old_profile' (previous). Or full path e.g. recordings/new_profile.jfr."),
+        topN: z
+            .number()
+            .int()
+            .min(1)
+            .max(100)
+            .optional()
+            .default(10)
+            .describe("Maximum number of top methods by call frequency to return. Default: 10."),
+    }),
+}, async (args) => ({
+    content: [{ type: "text", text: await profileFrequency(args) }],
+}));
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/dist/tools/analyze_threads.d.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+export declare const analyzeThreadsSchema: z.ZodObject<{
+    pid: z.ZodNumber;
+    topN: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    topN: number;
+    pid: number;
+}, {
+    pid: number;
+    topN?: number | undefined;
+}>;
+export type AnalyzeThreadsInput = z.infer<typeof analyzeThreadsSchema>;
+export declare function analyzeThreads(input: AnalyzeThreadsInput): Promise<string>;

package/dist/tools/analyze_threads.js

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import { runJcmd } from "../utils/jdk.js";
+export const analyzeThreadsSchema = z.object({
+    pid: z.number().int().positive(),
+    topN: z.number().int().min(1).max(500).optional().default(10),
+});
+export async function analyzeThreads(input) {
+    const { pid, topN } = input;
+    const output = runJcmd(pid, "Thread.print -l");
+    const threadSections = [];
+    let current = "";
+    for (const line of output.split("\n")) {
+        if (line.match(/^"\S/)) {
+            if (current.trim())
+                threadSections.push(current.trim());
+            current = line + "\n";
+        }
+        else {
+            current += line + "\n";
+        }
+    }
+    if (current.trim())
+        threadSections.push(current.trim());
+    const limited = threadSections.slice(0, topN);
+    return limited.join("\n\n");
+}