minercon 3.0.0

package/README.md

@@ -0,0 +1,401 @@
+# Minercon
+
+A full-featured RCON client for Minecraft servers — available both as a
+**VS Code extension** (integrated terminal panel) and as a **standalone CLI
+tool** (`minercon`) that runs in any terminal.
+
+![Version](https://img.shields.io/badge/version-3.0.0-blue)
+![VS Code](https://img.shields.io/badge/VS%20Code-%5E1.95.0-green)
+![License](https://img.shields.io/badge/license-MIT-brightgreen)
+
+> A heavy fork of "Minecraft RCON Terminal"
+
+![Demo](images/demo-autocomplete.gif)
+
+---
+
+## Features
+
+**Command completion**
+- Real-time suggestions as you type, cycling with Tab / Shift+Tab
+- Argument hints showing the full usage signature of the current command
+- Works with vanilla, Bukkit/Spigot/Paper, and plugin-extended servers
+- When the [Paper TabComplete](paper-plugin/) or [Spigot TabComplete](spigot-plugin/)
+  plugins or the [Fabric TabComplete](fabric-mod/) mod
+  is installed on your server, completions come directly from the
+  server (fastest, most accurate). Without it, the extension builds a local
+  command tree by crawling `/help` output once per server and caching it.
+
+**Emacs-style line editing**
+- Full cursor movement, word-jump, selection, and kill/yank (session-local kill ring)
+- Scrollable command history, persistent across reconnects
+
+**Ctrl-r command history search** -- with a filtered suggestion list
+
+**Minecraft color codes** — server responses render with full `§` color support
+
+**Robust connection handling** — exponential-backoff auto-reconnect on drop;
+TCP keepalive to detect silent disconnects
+
+**No response truncation** — custom RCON protocol implementation handles
+fragmented multi-packet responses correctly (vanilla server `/help` returns
+300+ commands in full)
+
+---
+
+## Server setup
+
+Add these lines to `server.properties` and restart:
+
+```properties
+enable-rcon=true
+rcon.port=25575
+rcon.password=your-secure-password
+```
+
+The password is only needed at connect time and is never written to disk by
+this tool.
+
+---
+
+## VS Code extension
+
+### Installation
+
+Search **"Minercon"** in the VS Code Extensions panel, or
+install from a `.vsix` file:
+
+```
+Ctrl+Shift+P → Extensions: Install from VSIX...
+```
+
+### Connecting
+
+| Command (Ctrl+Shift+P) | Description |
+|---|---|
+| Minercon: Connect to Server | Connect using saved defaults, or prompt if none saved |
+| Minercon: Connect with New Credentials | Always prompt for host, port, and password |
+| Minercon: Save Current Connection as Default | Save the current connection's host and port; password goes to VS Code's secure secret storage |
+
+You can also open a terminal via the **Terminal** menu → **New Terminal** →
+select **Minecraft Server** from the terminal profile picker.
+
+Multiple RCON terminals can be open simultaneously, each to a different server.
+
+### VS Code settings
+
+```json
+{
+  "minercon.defaultHost": "localhost",
+  "minercon.defaultPort": 25575
+}
+```
+
+The password is not stored in settings — it lives in VS Code's encrypted
+secret storage.
+
+---
+
+## CLI tool
+
+### Installation
+
+```sh
+npm install -g minercon
+```
+
+Or, after cloning and building locally:
+
+```sh
+npm run compile
+node out/minercon --help
+```
+
+### Usage
+
+```
+minercon [host] [port] [options]
+
+Options:
+  -p, --password <pw>   RCON password
+  --save                Save host/port/history-size to ~/.config/minercon/config.json
+  --log-file <path>     Write log output to a file instead of the console
+  --log-level <level>   consola log level, e.g. debug, info, warn, error (default: info)
+  --history-size <n>    Number of commands to remember in history (default: 100)
+  --no-plugin           Skip the server-side tab-complete plugin probe (manual
+                         testing only; not persisted to config)
+  --no-unpaginate       Do not request unpaginated output via the plugin
+                         (keep the server's small pages)
+  --no-pager            Do not page tall output; print it all at once
+  -h, --help            Show help
+
+Environment variables:
+  MCRCON_PASSWORD       RCON password (used when --password is not given)
+  MCRCON_LOG_FILE       Log file path (used when --log-file is not given)
+  MCRCON_LOG_LEVEL      Log level (used when --log-level is not given)
+  MCRCON_HISTORY_SIZE   History size (used when --history-size is not given)
+  MCRCON_UNPAGINATE     Set to 0 to disable unpaginated output (default on)
+  MCRCON_PAGER          Set to 0 to disable the output pager (default on)
+```
+
+**Password handling:** the CLI never writes the password to disk. Supply it
+with `--password`, the `MCRCON_PASSWORD` environment variable, or leave both
+unset and you will be prompted with masked input.
+
+**Saved host/port:** `--save` writes host and port (never the password) to
+`~/.config/minercon/config.json`. On subsequent invocations, those
+values are used as defaults so you can just run `minercon` with no
+arguments.
+
+**Kill/yank:** the CLI uses an in-process kill ring (Ctrl+K stashes text;
+Ctrl+Y yanks it back). The kill ring is not connected to the system clipboard.
+Ctrl+X / Ctrl+C-with-selection do the same within the session.
+
+**Log output:** diagnostic messages are printed via
+[consola](https://github.com/unjs/consola), colored and leveled by default.
+Use `--log-file` to redirect that output to a file instead (useful when
+console output would interfere with piped output or the interactive
+session). Use `--log-level debug` for verbose per-command RCON send/receive
+logging.
+
+**History size:** `--history-size` controls how many commands are remembered
+for `Up`/`Ctrl+P`/`Ctrl+R` recall and the `.history` command, and (with
+`--save`) persists to the saved config.
+
+**`--no-plugin`:** forces local mode (crawling `/help` for tab completion)
+even if the server-side TabComplete plugin/mod is installed. Intended for
+testing the local-mode crawl — see [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md#terminology)
+for what "local mode" vs. "plugin mode" means.
+
+**Unpaginated output & pager:** on Paper/Spigot, the TabComplete plugin exposes
+an `rcat` command that re-runs a command as the console so Bukkit's tiny RCON
+pagination (e.g. the `/help` "Help: Index (1/N)" pages) is bypassed — the
+terminal requests this automatically in plugin mode. Output taller than the
+window is then shown through a built-in pager (Space: more, `G`: all, `q`:
+quit) that keeps the content in your terminal scrollback. Disable either with
+`--no-unpaginate` / `--no-pager`, the `MCRCON_UNPAGINATE` / `MCRCON_PAGER`
+environment variables, or the `minercon.unpaginateOutput` /
+`minercon.terminalPager` VS Code settings. See
+[docs/UNPAGINATED_OUTPUT.md](docs/UNPAGINATED_OUTPUT.md).
+
+### Quick examples
+
+```sh
+# One-off connection (prompts for password)
+minercon localhost 25575
+
+# Password from environment
+MCRCON_PASSWORD=secret minercon mc.example.com
+
+# Save host/port for future sessions
+minercon mc.example.com 25575 --password secret --save
+
+# Next time, no arguments needed
+minercon
+```
+
+---
+
+## Keyboard shortcuts
+
+### Navigation and completion
+
+| Key | Action |
+|---|---|
+| `Tab` | Fetch / cycle to next suggestion |
+| `Shift+Tab` | Cycle to previous suggestion |
+| `Up` / `Ctrl+P` | Previous command in history (or move up in suggestion list) |
+| `Down` / `Ctrl+N` | Next command in history (or move down in suggestion list) |
+| `Ctrl+R` | Reverse search command history; press again to cycle to the next-older match |
+| `Page Up` / `Page Down` | Page through suggestion list |
+| `Esc` | Close suggestion list; if already closed, clear the line |
+| `Enter` | Submit the current command |
+
+### Cursor movement
+
+| Key | Action |
+|---|---|
+| `Left` / `Ctrl+B` | Move left one character |
+| `Right` / `Ctrl+F` | Move right one character |
+| `Ctrl+Left` / `Alt+B` | Move left one word |
+| `Ctrl+Right` / `Alt+F` | Move right one word |
+| `Home` / `Ctrl+A` | Move to start of line |
+| `End` / `Ctrl+E` | Move to end of line |
+
+### Selection
+
+| Key | Action |
+|---|---|
+| `Shift+Left` | Extend selection left |
+| `Shift+Right` | Extend selection right |
+| `Ctrl+Shift+Left` | Extend selection left by word |
+| `Ctrl+Shift+Right` | Extend selection right by word |
+| `Shift+Home` | Select to start of line |
+| `Shift+End` | Select to end of line |
+
+### Editing
+
+| Key | Action |
+|---|---|
+| `Backspace` | Delete character before cursor |
+| `Delete` | Delete character after cursor |
+| `Ctrl+T` | Transpose characters around cursor |
+| `Ctrl+K` | Kill (cut) from cursor to end of line → kill ring |
+| `Ctrl+U` | Kill from cursor to start of line → kill ring |
+| `Ctrl+W` / `Alt+Backspace` | Kill word before cursor → kill ring |
+| `Alt+D` | Kill word after cursor → kill ring |
+| `Ctrl+Y` | Yank (paste) from kill ring |
+| `Ctrl+X` | Cut selection → kill ring |
+| `Ctrl+C` | Copy selection → kill ring (if text selected); otherwise echo `^C` and clear line |
+| `Ctrl+V` | Paste from kill ring |
+
+The kill ring is session-local in both the CLI and VS Code extension.
+
+### Terminal control
+
+| Key | Action |
+|---|---|
+| `Ctrl+L` | Clear screen and redraw |
+| `Ctrl+D` | On a non-empty line: delete character under cursor (forward delete). On an empty line: disconnect and exit |
+
+---
+
+## Built-in commands
+
+These are handled by the terminal itself and never sent to the server. They
+use a `.` prefix so there is no conflict with server commands (which use `/`).
+
+| Command | Description |
+|---|---|
+| `.help` | Show this list of built-in commands and keyboard shortcuts |
+| `.clear` | Clear the terminal screen |
+| `.history` | Show command history |
+| `.reconnect` | Manually reconnect to the server |
+| `.disconnect` | Disconnect (stays open; use `Ctrl+D` to also exit) |
+| `.reload-commands` | Force a fresh crawl of the server's command tree (local mode only) |
+| `.clear-cache` | Delete the cached command tree for this server (local mode only) |
+| `.cache-info` | Show the age and location of the cached command tree |
+
+Everything else — including any `/command` — is sent directly to the server as
+an RCON command.
+
+---
+
+## Tab completion modes
+
+The terminal detects which mode to use automatically when it first connects.
+
+**Plugin mode** (preferred) — requires the [Paper TabComplete](paper-plugin/)
+or [Spigot TabComplete](spigot-plugin/) plugin (or the
+[Fabric TabComplete](fabric-mod/) mod) installed on your server. Completions
+are fetched live from the server as you type, identical to in-game tab
+completion.
+
+**Local mode** (fallback) — the terminal fetches and parses your server's
+`/help` output once, builds a command tree, and caches it to disk. Subsequent
+connections load from cache (nearly instant). Use `.reload-commands` to
+refresh after a server update.
+
+Cache location:
+- VS Code: `<extension global storage>/command-cache/<host>_<port>.json`
+- CLI: `~/.config/minercon/command-cache/<host>_<port>.json`
+
+---
+
+## Building and installing the TabComplete plugins
+
+### Paper
+
+The Paper plugin lives in [`paper-plugin/`](paper-plugin/). It requires Java 21
+and a Paper 1.21+ server, and uses
+[paperweight-userdev](https://docs.papermc.io/paper/dev/userdev/) for direct
+typed access to Paper's Brigadier command dispatcher (no reflection).
+
+**Build:**
+
+```sh
+cd paper-plugin
+./gradlew build
+```
+
+The built jar ends up at `paper-plugin/build/libs/paper-tabcomplete-1.0.0.jar`.
+
+### Spigot
+
+The Spigot plugin lives in [`spigot-plugin/`](spigot-plugin/). It requires
+Java 21 and a Spigot 1.21+ server.
+
+**Build:**
+
+```sh
+cd spigot-plugin
+./gradlew build
+```
+
+The built jar ends up at `spigot-plugin/build/libs/spigot-tabcomplete-1.0.0.jar`.
+
+### Install (both)
+
+Drop the jar into your server's `plugins/` directory and restart. No
+configuration is needed — the plugin activates automatically and exposes the
+`/tabcomplete` and `/cmdusage` RCON commands that this client uses.
+
+---
+
+## Troubleshooting
+
+**"Connection refused"** — verify `enable-rcon=true` in `server.properties`
+and that the RCON port is not blocked by a firewall.
+
+**"Authentication failed"** — double-check `rcon.password` in
+`server.properties`. Passwords are case-sensitive.
+
+**Autocomplete not working in local mode**
+1. `.clear-cache` to discard the old tree
+2. `.reload-commands` to re-crawl
+3. Check that your account has permission to run `/help` on the server
+4. In VS Code, check View → Output → Minercon for crawl diagnostics
+
+**Truncated responses** — this was a bug in versions before v2.0, which used
+an external library with a 4096-byte limit. The current implementation has no
+such limit.
+
+**Suggestion display looks wrong** — try `.clear` to redraw the screen. If
+the issue persists in the CLI, ensure your terminal reports correct dimensions
+(`echo $COLUMNS $LINES`).
+
+---
+
+## Contributing
+
+```sh
+git clone https://github.com/xton/minercon.git
+cd minercon
+npm install
+npm run compile
+npm test
+```
+
+The test suite runs inside VS Code's extension host. Run it with `npm test`; no
+live server is required — the RCON layer has a record/replay fixture harness.
+
+See [CHANGELOG.md](CHANGELOG.md) for version history and
+[CONTRIBUTING.md](CONTRIBUTING.md) for development guidelines.
+
+---
+
+## Acknowledgements
+
+Minercon (formerly "Minecraft RCON Terminal") began as a fork of
+[jaketcooper/Minecraft-rcon](https://github.com/jaketcooper/Minecraft-rcon),
+which provided the initial RCON protocol implementation and VS Code extension
+scaffold, help-based tab completion, interactive terminal experience, line editing. 
+Plugin-mode tab-completion, standalone CLI, history search, lots of testing, loads 
+of polish, countless fixes, and the new name were developed from there with significant
+help from [Claude](https://claude.ai).
+
+---
+
+## License
+
+MIT — see [LICENSE](LICENSE).

package/out/ansi.js

@@ -0,0 +1,123 @@
+"use strict";
+// src/ansi.ts
+//
+// Named ANSI SGR (Select Graphic Rendition) escape codes for terminal
+// output, plus small `style`/color helpers that wrap text and reset
+// afterward. Centralizes the raw `\x1b[...m` literals previously scattered
+// across rconSession.ts, displaySuggestion.ts, lineEditor.ts,
+// rconConnectionManager.ts, and cli.ts.
+//
+// Also home to `formatMinecraftColors`/`stripColors`, which translate the
+// server-controlled Minecraft `§`-color-code alphabet to/from ANSI - a
+// distinct input alphabet from the literals above, but the same output
+// format, so it lives alongside them rather than in
+// commandTreeParsingBrigadier.ts.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hidden = exports.reverse = exports.boldBrightWhite = exports.boldCyan = exports.boldGreen = exports.boldRed = exports.brightYellow = exports.dim = exports.gray = exports.cyan = exports.yellow = exports.green = exports.red = exports.BOLD_BRIGHT_WHITE = exports.BOLD_CYAN = exports.BOLD_GREEN = exports.BOLD_RED = exports.BRIGHT_YELLOW = exports.GRAY = exports.CYAN = exports.YELLOW = exports.GREEN = exports.RED = exports.HIDDEN = exports.REVERSE_OFF = exports.REVERSE = exports.DIM = exports.RESET = void 0;
+exports.style = style;
+exports.formatMinecraftColors = formatMinecraftColors;
+exports.stripColors = stripColors;
+exports.stripAnsi = stripAnsi;
+exports.RESET = '\x1b[0m';
+exports.DIM = '\x1b[2m';
+exports.REVERSE = '\x1b[7m';
+exports.REVERSE_OFF = '\x1b[27m';
+exports.HIDDEN = '\x1b[8m';
+exports.RED = '\x1b[31m';
+exports.GREEN = '\x1b[32m';
+exports.YELLOW = '\x1b[33m';
+exports.CYAN = '\x1b[36m';
+exports.GRAY = '\x1b[90m';
+exports.BRIGHT_YELLOW = '\x1b[93m';
+exports.BOLD_RED = '\x1b[1;31m';
+exports.BOLD_GREEN = '\x1b[1;32m';
+exports.BOLD_CYAN = '\x1b[1;36m';
+exports.BOLD_BRIGHT_WHITE = '\x1b[1;97m';
+/** Wraps `text` in `code`, resetting afterward. */
+function style(code, text) {
+    return `${code}${text}${exports.RESET}`;
+}
+const red = (text) => style(exports.RED, text);
+exports.red = red;
+const green = (text) => style(exports.GREEN, text);
+exports.green = green;
+const yellow = (text) => style(exports.YELLOW, text);
+exports.yellow = yellow;
+const cyan = (text) => style(exports.CYAN, text);
+exports.cyan = cyan;
+const gray = (text) => style(exports.GRAY, text);
+exports.gray = gray;
+const dim = (text) => style(exports.DIM, text);
+exports.dim = dim;
+const brightYellow = (text) => style(exports.BRIGHT_YELLOW, text);
+exports.brightYellow = brightYellow;
+const boldRed = (text) => style(exports.BOLD_RED, text);
+exports.boldRed = boldRed;
+const boldGreen = (text) => style(exports.BOLD_GREEN, text);
+exports.boldGreen = boldGreen;
+const boldCyan = (text) => style(exports.BOLD_CYAN, text);
+exports.boldCyan = boldCyan;
+const boldBrightWhite = (text) => style(exports.BOLD_BRIGHT_WHITE, text);
+exports.boldBrightWhite = boldBrightWhite;
+const reverse = (text) => style(exports.REVERSE, text);
+exports.reverse = reverse;
+const hidden = (text) => style(exports.HIDDEN, text);
+exports.hidden = hidden;
+// Minecraft `§`-color codes to ANSI escape sequences
+const MINECRAFT_COLOR_MAP = {
+    '§0': '\x1b[30m', // Black
+    '§1': '\x1b[34m', // Dark Blue
+    '§2': '\x1b[32m', // Dark Green
+    '§3': '\x1b[36m', // Dark Aqua
+    '§4': '\x1b[31m', // Dark Red
+    '§5': '\x1b[35m', // Dark Purple
+    '§6': '\x1b[33m', // Gold
+    '§7': '\x1b[37m', // Gray
+    '§8': '\x1b[90m', // Dark Gray
+    '§9': '\x1b[94m', // Blue
+    '§a': '\x1b[92m', // Green
+    '§b': '\x1b[96m', // Aqua
+    '§c': '\x1b[91m', // Red
+    '§d': '\x1b[95m', // Light Purple
+    '§e': '\x1b[93m', // Yellow
+    '§f': '\x1b[97m', // White
+    '§r': exports.RESET, // Reset
+    '§l': '\x1b[1m', // Bold
+    '§o': '\x1b[3m', // Italic
+    '§n': '\x1b[4m', // Underline
+    '§m': '\x1b[9m', // Strikethrough
+    '§k': '\x1b[5m', // Obfuscated (blinking)
+};
+// Matches any single `§X` color/format code; the replacer looks each up in
+// MINECRAFT_COLOR_MAP. The character class covers exactly that map's keys.
+const MINECRAFT_COLOR_PATTERN = /§[0-9a-fklmnor]/g;
+/**
+ * Convert Minecraft `§`-color codes to ANSI escape sequences.
+ */
+function formatMinecraftColors(text) {
+    // Collapse the `§` UTF-8 mojibake of the section sign first (same encodings
+    // stripColors handles) — otherwise the orphaned `Â` is left in the colored
+    // output once the `§x` after it is converted.
+    let result = text.replace(/§/g, '§').replace(MINECRAFT_COLOR_PATTERN, code => MINECRAFT_COLOR_MAP[code] ?? '');
+    if (!result.endsWith(exports.RESET)) {
+        result += exports.RESET;
+    }
+    return result;
+}
+/**
+ * Remove Minecraft `§`-color codes, e.g. before parsing.
+ */
+function stripColors(text) {
+    // Handle both § and § encodings (UTF-8 issues)
+    return text.replace(/[§Â]§[0-9a-fklmnor]/g, '')
+        .replace(/§[0-9a-fklmnor]/g, '');
+}
+/**
+ * Remove ANSI SGR (color/style) escape sequences — e.g. to measure a styled
+ * string's *visible* width. Distinct from `stripColors`, which removes the
+ * Minecraft `§`-code alphabet rather than the ANSI escapes those map to.
+ */
+function stripAnsi(text) {
+    return text.replace(/\x1b\[[0-9;]*m/g, '');
+}
+//# sourceMappingURL=ansi.js.map

package/out/argumentHint.js

@@ -0,0 +1,43 @@
+"use strict";
+// src/argumentHint.ts
+//
+// Pure formatting for the "argument hint" display: given a command's usage
+// string (e.g. "gamemode <mode> [<target>]") and the line the user has typed
+// so far, work out which argument position they're at and which token in the
+// usage string corresponds to it (so it can be highlighted).
+//
+// This is presentation logic, not decision logic — it has no notion of
+// fetching, timing, or staleness — so it lives apart from completionEngine's
+// state machine, as its own pure, independently-testable function.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatArgumentHint = formatArgumentHint;
+const ARGUMENT_TOKEN_PATTERN = /(<[^>]+>|\[[^\]]+\]|\([^)]+\))/g;
+/** Returns null when there's no usage text to show anything for. */
+function formatArgumentHint(usage, line) {
+    if (!usage) {
+        return null;
+    }
+    const tokens = usage.match(ARGUMENT_TOKEN_PATTERN) || [];
+    // The literal words before the first argument token are the command path —
+    // derived straight from the usage string so we don't need a separate
+    // "commandPath" concept threaded in from wherever the usage came from.
+    const firstTokenStart = usage.search(ARGUMENT_TOKEN_PATTERN);
+    const literalPrefix = (firstTokenStart >= 0 ? usage.slice(0, firstTokenStart) : usage).trim();
+    const commandPrefixWordCount = literalPrefix.length > 0 ? literalPrefix.split(/\s+/).length : 0;
+    const commandPrefixText = '/' + literalPrefix;
+    const parts = line.trim().split(' ').filter(p => p.length > 0);
+    const hasTrailingSpace = line.endsWith(' ');
+    const argumentCount = Math.max(0, parts.length - commandPrefixWordCount);
+    let currentArgIndex;
+    if (argumentCount === 0 && !hasTrailingSpace) {
+        currentArgIndex = -1; // still typing the command/subcommand itself
+    }
+    else if (hasTrailingSpace) {
+        currentArgIndex = argumentCount; // ready for the next argument
+    }
+    else {
+        currentArgIndex = argumentCount - 1; // currently typing this argument
+    }
+    return { commandPrefixText, tokens, currentArgIndex };
+}
+//# sourceMappingURL=argumentHint.js.map

package/out/bukkitHelpParsing.js

@@ -0,0 +1,62 @@
+"use strict";
+// src/bukkitHelpParsing.ts
+//
+// Pure parsing of Bukkit's hand-written `/help <command>` pages - a
+// "§e--------- §fHelp: /<cmd> ----...§e" banner line followed by
+// `Description:`/`Usage:`/`Aliases:` lines. This is a different grammar from
+// the flat Brigadier `/cmd <args>` blobs `helpTextParsing.ts` handles
+// (`minecraft:help`, vanilla's plain `help`): on a server where the
+// `minecraft:` namespace is supported (Paper/Spigot), `help <path>` is
+// *always* one of these pages, for every command - vanilla-backed or
+// Bukkit-added alike - so no shape-sniffing is needed to decide which parser
+// applies, only `LocalCommandTree.supportsMinecraftNamespace`.
+//
+// No state, no IO — every export here is a deterministic function of its
+// arguments.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractBukkitUsageLines = extractBukkitUsageLines;
+exports.extractBukkitAliases = extractBukkitAliases;
+const ansi_1 = require("./ansi");
+/**
+ * Extract the `Usage: ...` line(s) from a Bukkit-style `/help <command>`
+ * response (e.g. "Description: ...\nUsage: /version [plugin name]\nAliases:
+ * ..."), normalized so each reads as `<commandPath> ...` for `parseHelpLines`.
+ * Returns `[]` if there's no Usage line, or if its content is just the bare
+ * command name with nothing after it — the generic response Bukkit gives for
+ * Brigadier-backed (vanilla) commands ("Description: A Mojang provided
+ * command.\nUsage: <name>"), which carries no argument info.
+ */
+function extractBukkitUsageLines(helpText, commandPath) {
+    const lines = (0, ansi_1.stripColors)(helpText).split('\n').map(line => line.trim());
+    const usageIndex = lines.findIndex(line => /^Usage:\s*/i.test(line));
+    if (usageIndex === -1) {
+        return [];
+    }
+    const result = [lines[usageIndex].replace(/^Usage:\s*/i, '')];
+    for (let i = usageIndex + 1; i < lines.length; i++) {
+        const line = lines[i];
+        if (!line || /^[A-Za-z][A-Za-z ]*:/.test(line) || line.startsWith('---')) {
+            break;
+        }
+        result.push(line);
+    }
+    const normalizedPath = commandPath.toLowerCase();
+    return result.filter(line => line.replace(/^\//, '').toLowerCase() !== normalizedPath);
+}
+/**
+ * Extract alias names from a Bukkit-style `/help <command>` response's
+ * `Aliases: a, b, c` line (e.g. "Description: ...\nUsage: ...\nAliases: ver,
+ * about"). Returns `[]` if there's no Aliases line.
+ */
+function extractBukkitAliases(helpText) {
+    const lines = (0, ansi_1.stripColors)(helpText).split('\n').map(line => line.trim());
+    const aliasesLine = lines.find(line => /^Aliases:\s*/i.test(line));
+    if (!aliasesLine) {
+        return [];
+    }
+    return aliasesLine.replace(/^Aliases:\s*/i, '')
+        .split(',')
+        .map(alias => alias.trim())
+        .filter(alias => alias.length > 0);
+}
+//# sourceMappingURL=bukkitHelpParsing.js.map