minercon 3.0.0

package/out/extension.js

@@ -0,0 +1,190 @@
+"use strict";
+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.activate = activate;
+exports.deactivate = deactivate;
+// src/extension.ts
+const vscode = __importStar(require("vscode"));
+const consola_1 = require("consola");
+const logger_1 = require("./logger");
+const path = __importStar(require("path"));
+function activate(context) {
+    const logger = (0, consola_1.createConsola)({});
+    let currentConnection = null;
+    migratePasswordToSecureStorage(context).catch(err => {
+        logger.warn(`Password migration warning: ${err}`);
+    });
+    // Register the terminal profile provider
+    context.subscriptions.push(vscode.window.registerTerminalProfileProvider('minercon.terminal', {
+        provideTerminalProfile: async (token) => {
+            const { profile, connectionInfo } = await createRconTerminalProfile(context);
+            currentConnection = connectionInfo;
+            profile.options.iconPath = {
+                light: vscode.Uri.file(path.join(context.extensionPath, 'images', 'light.png')),
+                dark: vscode.Uri.file(path.join(context.extensionPath, 'images', 'dark.png'))
+            };
+            return profile;
+        }
+    }));
+    const connectCommand = vscode.commands.registerCommand('minercon.connect', async () => {
+        const connectionInfo = await connectToRcon(logger, context);
+        if (connectionInfo) {
+            currentConnection = connectionInfo;
+        }
+    });
+    const connectNewCommand = vscode.commands.registerCommand('minercon.connectNew', async () => {
+        const connectionInfo = await connectToRcon(logger, context, false);
+        if (connectionInfo) {
+            currentConnection = connectionInfo;
+        }
+    });
+    const saveDefaultsCommand = vscode.commands.registerCommand('minercon.saveDefaults', async () => {
+        if (!currentConnection) {
+            vscode.window.showWarningMessage('No active connection to save');
+            return;
+        }
+        const config = vscode.workspace.getConfiguration('minercon');
+        try {
+            await config.update('defaultHost', currentConnection.host, vscode.ConfigurationTarget.Global);
+            await config.update('defaultPort', currentConnection.port, vscode.ConfigurationTarget.Global);
+            await context.secrets.store('minercon.defaultPassword', currentConnection.password);
+            vscode.window.showInformationMessage(`Saved connection settings for ${currentConnection.host}:${currentConnection.port} as defaults`);
+        }
+        catch (err) {
+            vscode.window.showErrorMessage(`Failed to save defaults: ${err}`);
+        }
+    });
+    context.subscriptions.push(connectCommand, connectNewCommand, saveDefaultsCommand);
+}
+async function migratePasswordToSecureStorage(context) {
+    const config = vscode.workspace.getConfiguration('minercon');
+    const oldPassword = config.get('defaultPassword');
+    if (oldPassword && oldPassword !== '') {
+        await context.secrets.store('minercon.defaultPassword', oldPassword);
+        await config.update('defaultPassword', undefined, vscode.ConfigurationTarget.Global);
+        vscode.window.showWarningMessage('🔒 Your RCON password has been migrated to secure storage', 'OK');
+    }
+}
+async function createRconTerminalProfile(context, useDefaults = true) {
+    const config = vscode.workspace.getConfiguration('minercon');
+    const defaultHost = config.get('defaultHost');
+    const defaultPort = config.get('defaultPort');
+    const defaultPassword = await context.secrets.get('minercon.defaultPassword');
+    const historySize = config.get('historySize', 100);
+    const unpaginateOutput = config.get('unpaginateOutput', true);
+    const terminalPager = config.get('terminalPager', true);
+    let host;
+    let port;
+    let password;
+    if (useDefaults && defaultHost && defaultPort && defaultPassword) {
+        host = defaultHost;
+        port = defaultPort;
+        password = defaultPassword;
+    }
+    else {
+        host = await vscode.window.showInputBox({
+            prompt: 'RCON Host', value: defaultHost ?? '127.0.0.1', placeHolder: 'e.g., 127.0.0.1 or mc.example.com'
+        });
+        if (!host) {
+            throw new Error('Host is required');
+        }
+        const portInput = await vscode.window.showInputBox({
+            prompt: 'RCON Port', value: String(defaultPort ?? 25575), placeHolder: 'e.g., 25575'
+        });
+        if (!portInput) {
+            throw new Error('Port is required');
+        }
+        port = parseInt(portInput, 10);
+        // Cancelling the box (undefined) aborts like host/port do; an explicitly
+        // empty password (plain Enter) is allowed — some servers use one.
+        const passwordInput = await vscode.window.showInputBox({
+            prompt: 'RCON Password', password: true, value: defaultPassword ?? '', placeHolder: 'Enter your server RCON password'
+        });
+        if (passwordInput === undefined) {
+            throw new Error('Password is required');
+        }
+        password = passwordInput;
+    }
+    const minerconPath = context.asAbsolutePath(path.join('dist', 'minercon.js'));
+    const profile = new vscode.TerminalProfile({
+        name: `RCON: ${host}:${port}`,
+        // Run the built minercon CLI as the terminal's process. process.execPath
+        // is the Node runtime bundled with VS Code itself — ELECTRON_RUN_AS_NODE
+        // makes it execute minerconPath as a plain node script rather than
+        // launching another VS Code window, so this works without requiring the
+        // user to have node on their PATH.
+        shellPath: process.execPath,
+        shellArgs: [minerconPath, host, String(port)],
+        env: {
+            ELECTRON_RUN_AS_NODE: '1',
+            MCRCON_PASSWORD: password,
+            MCRCON_HISTORY_SIZE: String(historySize),
+            // Booleans are passed as '0'/'1'; the CLI treats absent as the default-on.
+            MCRCON_UNPAGINATE: unpaginateOutput ? '1' : '0',
+            MCRCON_PAGER: terminalPager ? '1' : '0',
+        },
+    });
+    return {
+        profile,
+        connectionInfo: { host, port, password }
+    };
+}
+async function connectToRcon(logger, context, useDefaults = true) {
+    try {
+        const { profile, connectionInfo } = await createRconTerminalProfile(context, useDefaults);
+        const terminal = vscode.window.createTerminal({
+            ...profile.options,
+            iconPath: {
+                light: vscode.Uri.file(path.join(context.extensionPath, 'images', 'light.png')),
+                dark: vscode.Uri.file(path.join(context.extensionPath, 'images', 'dark.png'))
+            }
+        });
+        terminal.show();
+        vscode.window.showInformationMessage(`Connecting to Minecraft server...`);
+        return connectionInfo;
+    }
+    catch (err) {
+        const message = (0, logger_1.errorMessage)(err);
+        if (!message.includes('required')) {
+            logger.error('Connection failed: ' + message);
+            vscode.window.showErrorMessage('RCON connection failed: ' + message);
+        }
+        return undefined;
+    }
+}
+function deactivate() {
+    // Cleanup will happen automatically
+}
+//# sourceMappingURL=extension.js.map

package/out/helpTextParsing.js

@@ -0,0 +1,445 @@
+"use strict";
+// src/helpTextParsing.ts
+//
+// Pure parsing of Minecraft's Brigadier-shaped `/help` output (flat
+// `/cmd <args>` blobs, as returned by `minecraft:help` and vanilla's plain
+// `help`) into a `Parameter` tree, plus the root-listing parser
+// (`parseHelpResponse`) and the one-time namespace-support probe
+// (`isUnsupportedNamespaceError`). No state, no IO — every export here is a
+// deterministic function of its arguments, which is what makes them directly
+// unit-testable without constructing a `LocalCommandTree`.
+//
+// Bukkit's hand-written `Description:`/`Usage:`/`Aliases:` `/help <command>`
+// pages are a different grammar entirely - their extraction lives in
+// `bukkitHelpParsing.ts`.
+//
+// `stripColors` (used throughout to normalize input before parsing) and the
+// `formatMinecraftColors`/ANSI rendering side live in ansi.ts.
+//
+// The `Parameter`/`ParameterType` tree this file builds is defined in
+// `commandTree.ts`.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tokenizeParameterString = tokenizeParameterString;
+exports.parseParameter = parseParameter;
+exports.parseCommandHelp = parseCommandHelp;
+exports.classifyParameterTokens = classifyParameterTokens;
+exports.splitConcatenatedHelpLines = splitConcatenatedHelpLines;
+exports.parseAliasRedirect = parseAliasRedirect;
+exports.parseHelpLines = parseHelpLines;
+exports.isGenericArgsPlaceholder = isGenericArgsPlaceholder;
+exports.hasUsableArguments = hasUsableArguments;
+exports.hasRealUsage = hasRealUsage;
+exports.parseHelpResponse = parseHelpResponse;
+exports.isUnsupportedNamespaceError = isUnsupportedNamespaceError;
+exports.buildParameterStructureFromVariants = buildParameterStructureFromVariants;
+const ansi_1 = require("./ansi");
+const commandTree_1 = require("./commandTree");
+/**
+ * Tokenize parameter string handling nested structures
+ */
+function tokenizeParameterString(str) {
+    const tokens = [];
+    let current = '';
+    let depth = 0;
+    let inBrackets = false;
+    for (let i = 0; i < str.length; i++) {
+        const char = str[i];
+        if ((char === '<' || char === '[' || char === '(')) {
+            if (depth === 0) {
+                if (current.trim()) {
+                    // This is a literal
+                    tokens.push(current.trim());
+                    current = '';
+                }
+                inBrackets = true;
+            }
+            depth++;
+            current += char;
+        }
+        else if ((char === '>' || char === ']' || char === ')')) {
+            depth--;
+            current += char;
+            if (depth === 0) {
+                tokens.push(current.trim());
+                current = '';
+                inBrackets = false;
+            }
+        }
+        else if (char === ' ' && depth === 0 && !inBrackets) {
+            if (current.trim()) {
+                tokens.push(current.trim());
+                current = '';
+            }
+        }
+        else {
+            current += char;
+        }
+    }
+    if (current.trim()) {
+        tokens.push(current.trim());
+    }
+    return tokens;
+}
+/**
+ * Parse a single parameter token
+ */
+function parseParameter(token, position) {
+    // Check for choice list (option1|option2|...)
+    if (token.startsWith('(') && token.endsWith(')')) {
+        const choicesStr = token.slice(1, -1);
+        const choices = choicesStr.split('|').map((choice, idx) => ({
+            type: commandTree_1.ParameterType.LITERAL,
+            literal: choice.trim(),
+            optional: false,
+            position: idx
+        }));
+        return {
+            type: commandTree_1.ParameterType.CHOICE_LIST,
+            choices,
+            optional: false,
+            position
+        };
+    }
+    // Check for optional argument [name] or [<name>]
+    if (token.startsWith('[') && token.endsWith(']')) {
+        let name = token.slice(1, -1); // Remove [ and ]
+        // Also remove inner angle brackets if present
+        if (name.startsWith('<') && name.endsWith('>')) {
+            name = name.slice(1, -1); // Remove < and >
+            return {
+                type: commandTree_1.ParameterType.ARGUMENT,
+                name,
+                optional: true,
+                position
+            };
+        }
+        // For [literal] without angle brackets, this could be an optional subcommand
+        // Return as LITERAL but we'll handle it specially in loadCommandDetails
+        return {
+            type: commandTree_1.ParameterType.LITERAL,
+            literal: name, // Store WITHOUT the brackets
+            optional: true,
+            position
+        };
+    }
+    // Check for required argument <name>
+    if (token.startsWith('<') && token.endsWith('>')) {
+        const name = token.slice(1, -1);
+        return {
+            type: commandTree_1.ParameterType.ARGUMENT,
+            name,
+            optional: false,
+            position
+        };
+    }
+    // Otherwise it's a literal (could be a subcommand name)
+    // We'll determine if it's actually a subcommand later when we see it has members
+    return {
+        type: commandTree_1.ParameterType.LITERAL,
+        literal: token,
+        optional: false,
+        position
+    };
+}
+/**
+ * Parse command help output to extract parameters
+ */
+function parseCommandHelp(helpText) {
+    const parameters = [];
+    const stripped = (0, ansi_1.stripColors)(helpText).trim();
+    // Remove the command name from the beginning if present
+    const syntaxMatch = stripped.match(/^\/?\w+\s+(.*)/);
+    const paramString = syntaxMatch ? syntaxMatch[1] : stripped;
+    // Split into tokens - handle nested brackets/parens
+    const tokens = tokenizeParameterString(paramString);
+    tokens.forEach((token, index) => {
+        const param = parseParameter(token, index);
+        if (param) {
+            parameters.push(param);
+        }
+    });
+    return parameters;
+}
+/**
+ * Classify a tokenized parameter string as either a named subcommand variant
+ * or a direct parameter list, parsing the relevant tokens along the way.
+ */
+function classifyParameterTokens(tokens) {
+    if (tokens.length === 0) {
+        return null;
+    }
+    const firstToken = tokens[0];
+    // Determine if first token is a literal/subcommand or an argument
+    // FIXED: Better detection for optional subcommands vs optional arguments
+    let isArgument = false;
+    if (firstToken.startsWith('<')) {
+        // <arg> - required argument
+        isArgument = true;
+    }
+    else if (firstToken.startsWith('[') && firstToken.endsWith(']')) {
+        // Could be [<arg>] or [subcommand]
+        const inner = firstToken.slice(1, -1);
+        if (inner.startsWith('<') && inner.endsWith('>')) {
+            // [<arg>] - optional argument
+            isArgument = true;
+        }
+        else {
+            // [subcommand] - optional subcommand, treat as subcommand
+            isArgument = false;
+        }
+    }
+    else if (firstToken.startsWith('(') && firstToken.endsWith(')')) {
+        // (choice1|choice2) - choice list, treat as argument
+        isArgument = true;
+    }
+    if (isArgument) {
+        // Every token is a direct parameter of the command/subcommand itself
+        const parameters = [];
+        for (let i = 0; i < tokens.length; i++) {
+            const param = parseParameter(tokens[i], i);
+            if (param) {
+                parameters.push(param);
+            }
+        }
+        return { kind: 'direct', parameters };
+    }
+    // First token is a literal/subcommand name introducing a variant
+    let name = firstToken;
+    let optional = false;
+    // Strip optional brackets if present
+    if (name.startsWith('[') && name.endsWith(']')) {
+        name = name.slice(1, -1); // Remove [ and ]
+        optional = true;
+    }
+    const parameters = [];
+    for (let i = 1; i < tokens.length; i++) {
+        const param = parseParameter(tokens[i], i - 1);
+        if (param) {
+            parameters.push(param);
+        }
+    }
+    return { kind: 'variant', name, optional, parameters };
+}
+/**
+ * Re-split a help response that packs multiple `/cmd ...` entries onto one
+ * line with no separators (e.g. a `minecraft:help` blob, or vanilla's `help
+ * <path>` for a multi-variant command like `gamerule`/`team`/`debug`) into
+ * one entry per line, ready for `parseHelpResponse`/`parseHelpLines`.
+ *
+ * Header/separator (`---...`) and blank lines are dropped first, so a
+ * `§e--------- §fHelp: /<cmd> §e----...` banner line - which itself contains
+ * a `/` - doesn't get re-split into a bogus `/<cmd> ----...` entry.
+ */
+function splitConcatenatedHelpLines(text) {
+    return text.split('\n')
+        .filter(line => {
+        const stripped = (0, ansi_1.stripColors)(line).trim();
+        return stripped && !stripped.startsWith('---');
+    })
+        .join('\n')
+        .replace(/\//g, '\n/');
+}
+/**
+ * Parse a single (already `stripColors`'d and trimmed) help line as a
+ * vanilla `minecraft:help` alias redirect of the form `/<alias> -> <target>`
+ * (e.g. `/tp -> teleport`, `/minecraft:xp -> experience`). Either side may
+ * carry a namespace prefix (e.g. `minecraft:`); namespace prefixes are
+ * preserved verbatim on both sides - per "ingest everything", a namespaced
+ * alias like `minecraft:tp` is its own root command, not folded into `tp`.
+ * Returns `null` if `line` doesn't match this shape.
+ */
+function parseAliasRedirect(line) {
+    const match = line.match(/^\/([a-zA-Z0-9_:-]+)\s*->\s*([a-zA-Z0-9_:-]+)$/);
+    if (!match) {
+        return null;
+    }
+    return { alias: match[1], target: match[2] };
+}
+/**
+ * Parse every line of `text` that describes `commandPath`'s syntax (an
+ * optional leading `/`, then `commandPath` with internal spaces matching
+ * runs of whitespace, then the argument tokens), collecting subcommand
+ * variants and/or a direct parameter list. Lines for other commands, alias
+ * redirects (`-> target`), and lines with no arguments at all are ignored.
+ *
+ * `text` is matched line-by-line (split on `\n`) — callers whose source may
+ * pack multiple commands' syntax onto one line without separators (e.g. a
+ * `minecraft:help` blob, where consecutive commands are simply concatenated)
+ * must first replace `/` with `\n/` to re-split it into one command per line.
+ */
+function parseHelpLines(text, commandPath) {
+    const escaped = commandPath
+        .replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+        .replace(/ /g, '\\s+');
+    const pattern = new RegExp(`^/?${escaped}(?::)?\\s*(.*)$`, 'i');
+    const variants = new Map();
+    let direct = null;
+    for (const rawLine of text.split('\n')) {
+        const stripped = (0, ansi_1.stripColors)(rawLine).trim();
+        if (!stripped || stripped.startsWith('---')) {
+            continue;
+        }
+        const match = stripped.match(pattern);
+        if (!match) {
+            continue;
+        }
+        const afterCommand = match[1] || '';
+        if (!afterCommand || afterCommand.startsWith('->')) {
+            continue;
+        }
+        const tokens = tokenizeParameterString(afterCommand);
+        const classified = classifyParameterTokens(tokens);
+        if (classified?.kind === 'variant') {
+            variants.set(classified.name, { optional: classified.optional, members: classified.parameters });
+        }
+        else if (classified?.kind === 'direct') {
+            direct = classified.parameters;
+        }
+    }
+    return { variants, direct };
+}
+/**
+ * True iff `parameters` is exactly a bare `<args>`/`[<args>]` placeholder -
+ * the generic stand-in Bukkit emits (e.g. for `minecraft:help <cmd>` on
+ * commands that aren't Brigadier-backed, like `version`/`reload`/`plugins`)
+ * when it has no real argument info, regardless of whether it's optional.
+ */
+function isArgsPlaceholder(parameters) {
+    return parameters.length === 1
+        && parameters[0].type === commandTree_1.ParameterType.ARGUMENT
+        && parameters[0].name === 'args';
+}
+/**
+ * True iff `parameters` is exactly the generic `[<args>]` placeholder Bukkit
+ * emits for `minecraft:help <cmd>` on commands that aren't Brigadier-backed
+ * (e.g. `version`, `reload`, `plugins`) — i.e. no real argument info.
+ */
+function isGenericArgsPlaceholder(parameters) {
+    return isArgsPlaceholder(parameters) && parameters[0].optional === true;
+}
+/**
+ * True iff `members` carries real, usable argument info for a subcommand
+ * variant - i.e. it's non-empty and not just an `<args>`/`[<args>]`
+ * placeholder (which means "no info available", whether or not it's
+ * optional). Used to decide whether the usage already parsed from a parent
+ * command's help output is trustworthy enough to skip a further per-subcommand
+ * help round trip.
+ */
+function hasUsableArguments(members) {
+    return members.length > 0 && !isArgsPlaceholder(members);
+}
+/**
+ * True iff `result` carries real, usable syntax info - either a non-placeholder
+ * `direct` parameter list or at least one subcommand variant. Used to decide
+ * whether a help source already answers a command's usage, or whether the
+ * caller needs to try another source.
+ */
+function hasRealUsage(result) {
+    return (result.direct !== null && !isGenericArgsPlaceholder(result.direct)) || result.variants.size > 0;
+}
+/**
+ * Parse a `/help` or `minecraft:help` response into the root commands and
+ * alias redirects it describes.
+ *
+ * `response` is first run through `splitConcatenatedHelpLines` so that a
+ * `minecraft:help` blob (multiple `/cmd ...` entries packed onto one line)
+ * is split one-per-line. Each resulting line is then matched against one of:
+ *
+ * - an alias redirect (`/<alias> -> <target>`, via `parseAliasRedirect`)
+ * - `/command ...` or `/namespace:command ...`
+ * - `command: ...` or `command-with-hyphens: ...`
+ * - `- command ...` or `* command ...`
+ * - `command <args>` (command name followed by `-`/`<`/`[`/`(`)
+ *
+ * Namespace prefixes (`minecraft:`, `bukkit:`, ...) are part of the command
+ * name - per "ingest everything", `minecraft:advancement` is its own root
+ * command, not just `minecraft`, so `:` is included in every pattern's
+ * character class. Common non-command words that appear in descriptions
+ * (`usage`, `example`, `description`, `syntax`) are skipped.
+ *
+ * For each command found, `isPlaceholder` reflects whether its summary line
+ * already carries real syntax info (`hasRealUsage`), so callers can decide
+ * which help source to try first for that command's full details.
+ */
+function parseHelpResponse(response) {
+    const lines = splitConcatenatedHelpLines(response).split('\n');
+    const commands = [];
+    const aliases = [];
+    for (const line of lines) {
+        const stripped = (0, ansi_1.stripColors)(line).trim();
+        // Skip empty lines and headers
+        if (!stripped || stripped.startsWith('---') || stripped.startsWith('===')) {
+            continue;
+        }
+        // Alias redirect lines (`/tp -> teleport`) describe an alias, not a
+        // root command in their own right.
+        const redirect = parseAliasRedirect(stripped);
+        if (redirect) {
+            aliases.push(redirect);
+            continue;
+        }
+        const patterns = [
+            /^\/([a-zA-Z0-9_:-]+)/, // /command or /namespace:command
+            /^([a-zA-Z0-9_:-]+):\s/, // command: or command-with-hyphens:
+            /^[-*]\s*([a-zA-Z0-9_:-]+)/, // - command or * command
+            /^([a-zA-Z0-9_:-]+)\s+[-<[(]/ // command followed by args
+        ];
+        for (const pattern of patterns) {
+            const match = stripped.match(pattern);
+            if (!match) {
+                continue;
+            }
+            const commandName = match[1];
+            // Skip common non-command words that appear in descriptions
+            if (['usage', 'example', 'description', 'syntax'].includes(commandName.toLowerCase())) {
+                continue;
+            }
+            const summary = parseHelpLines(stripped, commandName);
+            commands.push({ name: commandName, isPlaceholder: !hasRealUsage(summary) });
+            break;
+        }
+    }
+    return { commands, aliases };
+}
+/**
+ * True iff `response` is the Brigadier "unknown namespace" syntax error
+ * returned for `minecraft:help` on servers where the `minecraft:` command
+ * namespace prefix isn't registered (vanilla/fabric) — distinct from the
+ * normal "Unknown command or insufficient permissions" not-found message.
+ */
+function isUnsupportedNamespaceError(response) {
+    return /^Unknown or incomplete command/i.test((0, ansi_1.stripColors)(response).trim());
+}
+/**
+ * Build the parameter structure representing a set of collected variants:
+ * a single SUBCOMMAND if there's only one, or a CHOICE_LIST wrapping a
+ * SUBCOMMAND for each variant (in encounter order) otherwise.
+ */
+function buildParameterStructureFromVariants(variants) {
+    if (variants.size === 0) {
+        return [];
+    }
+    const subcommandChoices = [];
+    for (const [name, { optional, members }] of variants) {
+        subcommandChoices.push({
+            type: commandTree_1.ParameterType.SUBCOMMAND,
+            name,
+            literal: name,
+            optional,
+            position: subcommandChoices.length,
+            members,
+            isComplete: false
+        });
+    }
+    // If there's only one variant, use it directly; otherwise wrap in a choice list
+    if (subcommandChoices.length === 1) {
+        return [subcommandChoices[0]];
+    }
+    return [{
+            type: commandTree_1.ParameterType.CHOICE_LIST,
+            optional: false,
+            position: 0,
+            choices: subcommandChoices
+        }];
+}
+//# sourceMappingURL=helpTextParsing.js.map

package/out/historySearch.js

@@ -0,0 +1,46 @@
+"use strict";
+// src/historySearch.ts
+//
+// Pure state and matching logic for Ctrl+R reverse history search. Unlike
+// completionEngine.ts, there's no network round trip involved — searching is
+// just filtering an in-memory array — so this is plain synchronous state
+// transitions, no reducer/effect machinery needed.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchHistory = searchHistory;
+exports.startHistorySearch = startHistorySearch;
+exports.setHistorySearchQuery = setHistorySearchQuery;
+exports.cycleHistorySearch = cycleHistorySearch;
+/** Entries from `history` (oldest-first) containing `query` (case-insensitive), most-recently-used first, deduplicated. An empty query matches everything, so the list starts as "recent history, newest first". */
+function searchHistory(history, query) {
+    const lowerQuery = query.toLowerCase();
+    const seen = new Set();
+    const results = [];
+    for (let i = history.length - 1; i >= 0; i--) {
+        const entry = history[i];
+        if (seen.has(entry)) {
+            continue;
+        }
+        seen.add(entry);
+        if (entry.toLowerCase().includes(lowerQuery)) {
+            results.push(entry);
+        }
+    }
+    return results;
+}
+/** Enters search mode: empty query, recent history shown newest-first. */
+function startHistorySearch(history, originalLine) {
+    return { query: '', items: searchHistory(history, ''), selectedIndex: 0, originalLine };
+}
+/** Re-filters as the query changes (typing or backspacing), resetting to the best (first) match. */
+function setHistorySearchQuery(history, state, query) {
+    return { ...state, query, items: searchHistory(history, query), selectedIndex: 0 };
+}
+/** Moves the selection by `delta`, wrapping; a no-op when there's nothing to select. */
+function cycleHistorySearch(state, delta) {
+    if (state.items.length === 0) {
+        return state;
+    }
+    const selectedIndex = ((state.selectedIndex + delta) % state.items.length + state.items.length) % state.items.length;
+    return { ...state, selectedIndex };
+}
+//# sourceMappingURL=historySearch.js.map