minercon 3.0.3 → 3.0.4

package/out/helpTextParsing.js

@@ -1,445 +0,0 @@
-"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

@@ -1,46 +0,0 @@
-"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