minercon 3.0.0

package/out/connectionManager.js

@@ -0,0 +1,209 @@
+"use strict";
+// src/connectionManager.ts
+//
+// Owns the RCON connection lifecycle: the live `RconController` (recreated on
+// each reconnect attempt), connection/reconnection status, and the
+// exponential-backoff retry loop. Pulled out of RconTerminal as part of the
+// mega-module split — see lineEditor.ts / suggestionDisplay.ts for the sibling
+// extractions and their rationale.
+//
+// `RconSession` keeps `detectAndInitialize`/`initializeCommands` (they're
+// about the autocomplete command-tree and `pluginMode`, a different concern
+// that happens to run at similar times) but reads connection status and reaches
+// the live controller through this class, and is notified via `onReconnected`
+// when it should reload the command tree.
+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.ConnectionManager = void 0;
+const rconClient_1 = require("./rconClient");
+const logger_1 = require("./logger");
+const ansi = __importStar(require("./ansi"));
+const defaultControllerFactory = (host, port, password, logger) => new rconClient_1.RconController(host, port, password, logger);
+class ConnectionManager {
+    serverHost;
+    serverPort;
+    password;
+    logger;
+    host;
+    controllerFactory;
+    _controller;
+    _isConnected = true;
+    _isReconnecting = false;
+    reconnectAttempts = 0;
+    maxReconnectAttempts = 5;
+    reconnectDelay = 2000;
+    reconnectTimeout = null;
+    constructor(serverHost, serverPort, password, logger, controller, host, controllerFactory = defaultControllerFactory) {
+        this.serverHost = serverHost;
+        this.serverPort = serverPort;
+        this.password = password;
+        this.logger = logger;
+        this.host = host;
+        this.controllerFactory = controllerFactory;
+        this._controller = controller;
+    }
+    get controller() {
+        return this._controller;
+    }
+    get isConnected() {
+        return this._isConnected;
+    }
+    get isReconnecting() {
+        return this._isReconnecting;
+    }
+    /** Resets the reconnect-attempt counter, backoff delay, and any pending reconnect timer back to their initial state. */
+    resetReconnectState() {
+        this.reconnectAttempts = 0;
+        this.reconnectDelay = 2000;
+        if (this.reconnectTimeout) {
+            clearTimeout(this.reconnectTimeout);
+            this.reconnectTimeout = null;
+        }
+    }
+    /**
+     * Records that an in-flight command discovered the connection is gone, and
+     * schedules an auto-reconnect attempt shortly after. The "Connection
+     * lost..." message itself stays with the caller (`executeCommand` accounts
+     * for it in its output-line bookkeeping).
+     */
+    reportConnectionLost() {
+        this._isConnected = false;
+        this.resetReconnectState();
+        this.reconnectTimeout = setTimeout(() => {
+            this.reconnectTimeout = null;
+            this.attemptReconnect();
+        }, 1000);
+    }
+    disconnect() {
+        // No key-chord echo here: this runs for the typed /disconnect built-in.
+        // Ctrl+D echoes its own ^D in RconSession.handleCtrlD before closing.
+        this.host.write('Disconnecting...\r\n');
+        // Clear any pending reconnect
+        if (this.reconnectTimeout) {
+            clearTimeout(this.reconnectTimeout);
+            this.reconnectTimeout = null;
+        }
+        try {
+            this._controller.disconnect();
+        }
+        catch (err) {
+            this.logger.error(`Error during disconnect: ${err}`);
+        }
+        this._isConnected = false;
+        this._isReconnecting = false;
+        this.host.write('Connection closed. Type ' + ansi.yellow('/reconnect') + ' to reconnect.\r\n\r\n');
+        this.host.showPrompt();
+    }
+    async manualReconnect() {
+        if (this._isReconnecting) {
+            this.host.write(ansi.yellow('Already reconnecting...') + '\r\n\r\n');
+            this.host.showPrompt();
+            return;
+        }
+        this.resetReconnectState();
+        await this.attemptReconnect();
+    }
+    async attemptReconnect() {
+        if (this._isReconnecting) {
+            return;
+        }
+        if (this._isConnected) {
+            this.host.write(ansi.green('Already connected.') + '\r\n\r\n');
+            this.host.showPrompt();
+            return;
+        }
+        this._isReconnecting = true;
+        this.reconnectAttempts++;
+        const attemptText = this.reconnectAttempts > 1 ? ` (attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts})` : '';
+        this.host.write(ansi.yellow('Reconnecting to ' + this.serverHost + ':' + this.serverPort + attemptText + '...') + '\r\n');
+        try {
+            // Disconnect existing controller
+            try {
+                await this._controller.disconnect();
+            }
+            catch (err) {
+                // Ignore disconnect errors during reconnect
+            }
+            // Create new controller
+            this._controller = this.controllerFactory(this.serverHost, this.serverPort, this.password, this.logger);
+            await this._controller.connect();
+            this._isConnected = true;
+            this._isReconnecting = false;
+            this.resetReconnectState();
+            this.host.write(ansi.boldGreen('✓ Reconnected successfully!') + '\r\n\r\n');
+            // Reload commands after reconnection
+            this.host.onReconnected();
+        }
+        catch (err) {
+            this._isReconnecting = false;
+            if (this.reconnectAttempts < this.maxReconnectAttempts) {
+                this.host.write(ansi.red('✗ Connection failed: ' + (0, logger_1.errorMessage)(err)) + '\r\n');
+                this.host.write(ansi.yellow('Retrying in ' + (this.reconnectDelay / 1000) + ' seconds...') + '\r\n');
+                // Clear any existing timeout
+                if (this.reconnectTimeout) {
+                    clearTimeout(this.reconnectTimeout);
+                }
+                this.reconnectTimeout = setTimeout(() => {
+                    this.reconnectTimeout = null;
+                    this.attemptReconnect();
+                }, this.reconnectDelay);
+                // Exponential backoff with max delay
+                this.reconnectDelay = Math.min(this.reconnectDelay * 2, 32000);
+            }
+            else {
+                // Max attempts reached
+                this.host.write(ansi.boldRed('✗ Reconnection failed after ' + this.maxReconnectAttempts + ' attempts.') + '\r\n');
+                this.host.write('Type ' + ansi.yellow('/reconnect') + ' to try again.\r\n\r\n');
+                this.resetReconnectState();
+                this.host.showPrompt();
+            }
+        }
+    }
+    /** Tears down any pending reconnect timer and disconnects the controller — used by `RconSession.close()`. */
+    dispose() {
+        if (this.reconnectTimeout) {
+            clearTimeout(this.reconnectTimeout);
+            this.reconnectTimeout = null;
+        }
+        try {
+            this._controller.disconnect();
+        }
+        catch (err) {
+            this.logger.error(`Error during close: ${err}`);
+        }
+    }
+}
+exports.ConnectionManager = ConnectionManager;
+//# sourceMappingURL=connectionManager.js.map

package/out/displayArgumentHint.js

@@ -0,0 +1,43 @@
+"use strict";
+// src/displayArgumentHint.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 commandLine_1 = require("./commandLine");
+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, hasTrailingSpace } = (0, commandLine_1.splitCommandLine)(line);
+    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=displayArgumentHint.js.map

package/out/displayCommandTree.js

@@ -0,0 +1,115 @@
+"use strict";
+// src/displayCommandTree.ts
+//
+// Formats the command tree built by CommandTreeCrawler for human inspection.
+// Used by the .tree builtin.
+//
+// Output is one "usage line" per unique path through the tree — the same
+// style Minecraft's /help produces. A deep CHOICE_LIST (choices that have
+// their own sub-parameters, produced by buildParameterStructureFromVariants
+// for multi-variant commands) forks into one line per choice. A simple
+// CHOICE_LIST (inline `(a|b|c)` literals parsed from a single `(...)` token)
+// is collapsed onto the same line with bracket/pipe notation. Optional parameters are
+// shown in brackets rather than expanded, so the line count stays bounded.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatCommandTree = formatCommandTree;
+exports.formatCommandLog = formatCommandLog;
+const commandTree_1 = require("./commandTree");
+const ansi_1 = require("./ansi");
+/** A parameter's nested parameters, or `[]` for the leaf types that have none. */
+function childMembers(p) {
+    return p.type === commandTree_1.ParameterType.SUBCOMMAND ? p.members : [];
+}
+const MAX_LINES = 300;
+function formatCommandTree(rootCommands, commandName) {
+    if (commandName) {
+        const name = commandName.startsWith('/') ? commandName.slice(1) : commandName;
+        const node = rootCommands.get(name);
+        if (!node) {
+            return `Unknown command: /${name}\n`;
+        }
+        const lines = [];
+        walkSequential(`/${name}`, node.members, lines);
+        if (lines.length === 0) {
+            lines.push(`/${name}`);
+        }
+        if (lines.length >= MAX_LINES) {
+            lines.push('(truncated)');
+        }
+        return lines.join('\n') + '\n';
+    }
+    const names = [...rootCommands.keys()].sort((a, b) => {
+        const aNs = a.includes(':'), bNs = b.includes(':');
+        if (aNs !== bNs) {
+            return aNs ? 1 : -1;
+        }
+        return a < b ? -1 : a > b ? 1 : 0;
+    });
+    const lines = [`${names.length} commands:`];
+    const COL_WIDTH = 22, COLS = 4;
+    for (let i = 0; i < names.length; i += COLS) {
+        lines.push('  ' + names.slice(i, i + COLS).map(n => ('/' + n).padEnd(COL_WIDTH)).join('').trimEnd());
+    }
+    return lines.join('\n') + '\n';
+}
+/**
+ * Walks `members` sequentially, appending tokens to `prefix` and collecting
+ * complete usage lines into `out`. A deep CHOICE_LIST (any choice has
+ * sub-members) forks — one recursion per choice, each picking up the
+ * remaining siblings afterward. Simple CHOICE_LIST and all other parameter
+ * types are rendered as a single token and appended in-line.
+ */
+function walkSequential(prefix, members, out) {
+    if (out.length >= MAX_LINES) {
+        return;
+    }
+    if (members.length === 0) {
+        out.push(prefix);
+        return;
+    }
+    const [first, ...rest] = members;
+    if (first.type === commandTree_1.ParameterType.CHOICE_LIST && first.choices.some(c => childMembers(c).length)) {
+        // Deep alternation: fork one line per choice.
+        for (const choice of first.choices) {
+            if (out.length >= MAX_LINES) {
+                return;
+            }
+            walkSequential(`${prefix} ${paramToken(choice)}`, [...childMembers(choice), ...rest], out);
+        }
+        // If the whole CHOICE_LIST is optional, also emit the path that skips it.
+        if (first.optional) {
+            walkSequential(prefix, rest, out);
+        }
+    }
+    else {
+        // Sequential: append this token and recurse into sub-members then siblings.
+        const token = paramToken(first);
+        walkSequential(`${prefix} ${token}`, [...childMembers(first), ...rest], out);
+    }
+}
+function formatCommandLog(pairs) {
+    if (pairs.length === 0) {
+        return '';
+    }
+    const lines = ['', (0, ansi_1.dim)('── send/recv log ─────────────────────────')];
+    for (const { send, recv } of pairs) {
+        lines.push((0, ansi_1.cyan)(`> ${send}`));
+        const recvText = (0, ansi_1.stripColors)(recv).trimEnd();
+        for (const line of recvText.split('\n')) {
+            lines.push((0, ansi_1.gray)(`  ${line}`));
+        }
+    }
+    return lines.join('\n') + '\n';
+}
+function paramToken(p) {
+    switch (p.type) {
+        case commandTree_1.ParameterType.ARGUMENT: return p.optional ? `[<${p.name}>]` : `<${p.name}>`;
+        case commandTree_1.ParameterType.LITERAL: return p.optional ? `[${p.literal}]` : p.literal;
+        case commandTree_1.ParameterType.SUBCOMMAND: return p.optional ? `[${p.name}]` : p.name;
+        case commandTree_1.ParameterType.CHOICE_LIST: {
+            const inner = (0, commandTree_1.parameterLabel)(p);
+            return p.optional ? `[(${inner})]` : `(${inner})`;
+        }
+    }
+}
+//# sourceMappingURL=displayCommandTree.js.map

package/out/displaySuggestion.js

@@ -0,0 +1,282 @@
+"use strict";
+// src/displaySuggestion.ts
+//
+// Owns the suggestion-list / argument-hint display: the items, the selected
+// index, paging state, and the ANSI rendering/clearing of whatever's drawn
+// below the prompt. Pulled out of RconTerminal as part of the mega-module
+// split — see lineEditor.ts for the sibling extraction and its rationale.
+//
+// This class has no notion of the completionEngine or of dispatching events —
+// RconSession remains the single place that talks to the engine (it's the
+// one piece deliberately kept pure/central). Callers that need to know
+// *whether* an action makes sense (page forward/back) ask the read-only
+// `...Index()` queries, which return `number | null` — `null` meaning
+// "nothing to do" — and decide for themselves whether to dispatch.
+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.SuggestionDisplay = void 0;
+const displayArgumentHint_1 = require("./displayArgumentHint");
+const ansi = __importStar(require("./ansi"));
+class SuggestionDisplay {
+    host;
+    currentSuggestions = [];
+    suggestionIndex = -1;
+    showing = false;
+    displayLines = 0;
+    // Paging
+    visibleStart = 0;
+    maxVisible = 10;
+    needsClearOnNextRender = false;
+    constructor(host) {
+        this.host = host;
+    }
+    get isShowing() {
+        return this.showing;
+    }
+    get itemCount() {
+        return this.currentSuggestions.length;
+    }
+    get totalPages() {
+        return Math.ceil(this.currentSuggestions.length / this.maxVisible);
+    }
+    /** The 1-based page the selected item sits on (only meaningful while a list is showing). */
+    get currentPage() {
+        return Math.floor(this.suggestionIndex / this.maxVisible) + 1;
+    }
+    /** Replaces the direct `needsClearBeforeSuggestions = true` assignment from `executeCommand` — the next render should wipe the screen below the cursor first (e.g. after a multi-line command response may have pushed the display area around). */
+    markNeedsClearOnNextRender() {
+        this.needsClearOnNextRender = true;
+    }
+    nextPageIndex() {
+        if (!this.showing || this.currentSuggestions.length === 0 || this.totalPages <= 1) {
+            return null;
+        }
+        const nextPageStart = this.currentPage * this.maxVisible;
+        return nextPageStart < this.currentSuggestions.length ? nextPageStart : 0;
+    }
+    previousPageIndex() {
+        if (!this.showing || this.currentSuggestions.length === 0 || this.totalPages <= 1) {
+            return null;
+        }
+        return this.currentPage > 1
+            ? (this.currentPage - 2) * this.maxVisible
+            : (this.totalPages - 1) * this.maxVisible;
+    }
+    /**
+     * Sets the displayed items/selection from the engine's `render` effect and
+     * draws the appropriate combination of suggestion list and argument hint —
+     * `usage` is only ever a single, resolved usage line (the engine collapses
+     * "(too broad...)" failures and ambiguous-prefix multi-candidate responses
+     * down to empty), so a non-null `display` here means the command portion is
+     * fully resolved — independent of how many argument-level completions
+     * remain, so it's shown alongside the list whenever available.
+     */
+    render(items, selectedIndex, usage, currentLine) {
+        this.currentSuggestions = items;
+        this.suggestionIndex = selectedIndex;
+        this.clear();
+        const display = usage ? (0, displayArgumentHint_1.formatArgumentHint)(usage, currentLine) : null;
+        let lines = [];
+        if (items.length > 0) {
+            this.showing = true;
+            lines = this.buildSuggestionListLines(currentLine);
+            if (display) {
+                lines = lines.concat(this.buildArgumentHintLines(display));
+            }
+        }
+        else {
+            this.showing = false;
+            if (display) {
+                lines = this.buildArgumentHintLines(display);
+            }
+        }
+        this.renderSuggestionArea(lines);
+    }
+    hide() {
+        this.clear();
+        this.showing = false;
+        this.suggestionIndex = -1;
+        this.currentSuggestions = [];
+        this.visibleStart = 0;
+    }
+    /** Erases whatever's currently drawn in the display area — the single source of truth for "clear the old frame before drawing (or removing) the new one." */
+    clear() {
+        if (this.displayLines === 0) {
+            return;
+        }
+        this.host.write('\r\n'); // Move to the display area
+        for (let i = 0; i < this.displayLines; i++) {
+            this.host.write('\x1b[2K'); // Clear entire line
+            if (i < this.displayLines - 1) {
+                this.host.write('\r\n');
+            }
+        }
+        this.returnCursorToPrompt(this.displayLines);
+        this.displayLines = 0;
+    }
+    /**
+     * Returns the cursor to the prompt after drawing or erasing `lineCount` lines
+     * in the area below it: up `lineCount` rows, back to column 0, then out to the
+     * prompt's column. Uses a *relative* cursor-up (`\x1b[NA`) rather than an
+     * absolute save/restore (`\x1b7`/`\x1b8`), because the `\r\n`s used to enter
+     * the area may have scrolled the terminal and invalidated any saved row.
+     */
+    returnCursorToPrompt(lineCount) {
+        this.host.write(`\x1b[${lineCount}A`);
+        this.host.write('\r');
+        const col = this.host.cursorColumn();
+        if (col > 0) {
+            this.host.write(`\x1b[${col}C`);
+        }
+    }
+    /**
+     * Builds the suggestion list's content lines — fully ANSI-styled, but with
+     * no `\x1b[2K`/`\r\n` baked in. `renderSuggestionArea` is the single place
+     * that turns a list of content strings into clear-and-draw ANSI, whether
+     * it's drawing the list alone, the hint alone, or (when there's exactly one
+     * suggestion left) both stacked together in one frame.
+     */
+    buildSuggestionListLines(currentLine) {
+        // Calculate the visible window based on the selected index
+        this.updateVisibleWindow();
+        const lines = [];
+        // Get only the completed parts of the command (everything before the last space or the whole line if no space)
+        let completedText = '';
+        if (currentLine.includes(' ')) {
+            // If there's a space, get everything up to and including the last space
+            const lastSpaceIndex = currentLine.lastIndexOf(' ');
+            completedText = currentLine.substring(0, lastSpaceIndex + 1);
+        }
+        const prefix = completedText ? ansi.hidden(completedText) : '';
+        // Show indicator if there are items above the visible window
+        if (this.visibleStart > 0) {
+            lines.push(prefix + ansi.gray('  ▲ (' + this.visibleStart + ' more above)'));
+        }
+        // Show visible suggestions in vertical list
+        const visibleEnd = Math.min(this.visibleStart + this.maxVisible, this.currentSuggestions.length);
+        for (let i = this.visibleStart; i < visibleEnd; i++) {
+            // Show selection indicator and item
+            if (i === this.suggestionIndex) {
+                // Yellow for selected item with arrow indicator
+                lines.push(prefix + ansi.brightYellow('→ ' + this.currentSuggestions[i]));
+            }
+            else {
+                // Gray for other items with space for alignment
+                lines.push(prefix + ansi.gray('  ' + this.currentSuggestions[i]));
+            }
+        }
+        // Show indicator if there are items below the visible window
+        if (visibleEnd < this.currentSuggestions.length) {
+            const remaining = this.currentSuggestions.length - visibleEnd;
+            lines.push(prefix + ansi.gray('  ▼ (' + remaining + ' more below)'));
+        }
+        // Show current position and page indicator at bottom
+        lines.push(prefix + ansi.gray('  [' + (this.suggestionIndex + 1) + '/' + this.currentSuggestions.length + '] ' +
+            'Page ' + this.currentPage + '/' + this.totalPages));
+        return lines;
+    }
+    /**
+     * Builds the argument-hint's content lines: the usage line, shown in full
+     * and literally — with the argument the user is currently editing bolded
+     * and everything else (command prefix and other tokens alike) gray. Same
+     * "fully-styled content strings, no \x1b[2K/\r\n" convention as
+     * `buildSuggestionListLines`, so `renderSuggestionArea` can draw either or
+     * both in one frame.
+     *
+     * Shown alongside or in place of the suggestion list when a command has
+     * argument structure worth showing — e.g. "/gamemode creative " (nothing
+     * left to complete for the target selector, but worth showing what comes
+     * next), or "/gamemode cr" (one match left — "creative" — where seeing the
+     * full usage helps confirm that's the right command to commit to). The
+     * actual parsing of `usage`/`line` into positions and hint text is pure —
+     * see displayArgumentHint.ts — this is just the ANSI rendering of that
+     * already-computed structure.
+     */
+    buildArgumentHintLines(display) {
+        let usageLine = '  ' + ansi.gray(display.commandPrefixText);
+        for (let i = 0; i < display.tokens.length; i++) {
+            usageLine += ' ';
+            usageLine += (i === display.currentArgIndex)
+                ? ansi.boldBrightWhite(display.tokens[i])
+                : ansi.gray(display.tokens[i]);
+        }
+        return [usageLine];
+    }
+    /**
+     * Draws a single frame of suggestion-area content — one save/clear/restore
+     * cycle, regardless of whether `lines` came from the list, the hint, or
+     * both stacked together. `clear` (called centrally before this, by `render`)
+     * has already erased whatever was there before, so this only ever draws
+     * onto a blank area — each line gets its own `\x1b[2K` defensively, but
+     * there's no "clear the old N lines" dance to duplicate here.
+     */
+    renderSuggestionArea(lines) {
+        if (lines.length === 0) {
+            return;
+        }
+        if (this.needsClearOnNextRender) {
+            this.host.write('\x1b[J'); // Clear from cursor to end of screen
+            this.needsClearOnNextRender = false;
+        }
+        this.host.write('\r\n'); // Move to the display area
+        for (let i = 0; i < lines.length; i++) {
+            this.host.write('\x1b[2K'); // Clear line first
+            this.host.write(lines[i]);
+            if (i < lines.length - 1) {
+                this.host.write('\r\n');
+            }
+        }
+        this.displayLines = lines.length;
+        this.returnCursorToPrompt(lines.length);
+    }
+    updateVisibleWindow() {
+        // Keep a buffer of 2 items above and below the selected item when possible
+        const buffer = 2;
+        // Update the visible window
+        if (this.suggestionIndex < this.visibleStart + buffer) {
+            // Scrolling up
+            this.visibleStart = Math.max(0, this.suggestionIndex - buffer);
+        }
+        else if (this.suggestionIndex >= this.visibleStart + this.maxVisible - buffer) {
+            // Scrolling down
+            this.visibleStart = Math.min(this.suggestionIndex - this.maxVisible + buffer + 1, Math.max(0, this.currentSuggestions.length - this.maxVisible));
+        }
+        // Final boundary check
+        this.visibleStart = Math.max(0, this.visibleStart);
+        this.visibleStart = Math.min(this.visibleStart, Math.max(0, this.currentSuggestions.length - this.maxVisible));
+    }
+}
+exports.SuggestionDisplay = SuggestionDisplay;
+//# sourceMappingURL=displaySuggestion.js.map