@microsoft/inshellisense 0.0.1-rc.21 → 0.0.1-rc.23

package/build/runtime/parser.js

@@ -1,133 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-import wcwidth from "wcwidth";
-import { getShellWhitespaceEscapeChar } from "./utils.js";
-const cmdDelim = /(\|\|)|(&&)|(;)|(\|)/;
-const spaceRegex = /\s/;
-export const parseCommand = (command, shell) => {
-    const lastCommand = command.split(cmdDelim).at(-1)?.trimStart();
-    const tokens = lastCommand ? lex(lastCommand, shell) : [];
-    return sanitizeTokens(tokens, shell);
-};
-const sanitizeTokens = (cmdTokens, shell) => unwrapQuotedTokens(unescapeSpaceTokens(cmdTokens, shell), shell);
-// remove escapes around spaces
-const unescapeSpaceTokens = (cmdTokens, shell) => {
-    const escapeChar = getShellWhitespaceEscapeChar(shell);
-    return cmdTokens.map((cmdToken) => {
-        const { token, isQuoted } = cmdToken;
-        if (!isQuoted && token.includes(`${escapeChar} `)) {
-            return { ...cmdToken, token: token.replaceAll(`${escapeChar} `, " ") };
-        }
-        return cmdToken;
-    });
-};
-// need to unwrap tokens that are quoted with content after the quotes like `"hello"world`
-const unwrapQuotedTokens = (cmdTokens, shell) => {
-    const escapeChar = getShellWhitespaceEscapeChar(shell);
-    return cmdTokens.map((cmdToken) => {
-        const { token, isQuoteContinued } = cmdToken;
-        if (isQuoteContinued) {
-            const quoteChar = token[0];
-            const unquotedToken = token.replaceAll(`${escapeChar}${quoteChar}`, "\u001B").replaceAll(quoteChar, "").replaceAll("\u001B", quoteChar);
-            return { ...cmdToken, token: unquotedToken };
-        }
-        return cmdToken;
-    });
-};
-const lex = (command, shell) => {
-    const tokens = [];
-    const escapeChar = getShellWhitespaceEscapeChar(shell);
-    let [readingQuotedString, readingQuoteContinuedString, readingFlag, readingCmd] = [false, false, false, false];
-    let readingIdx = 0;
-    let readingQuoteChar = "";
-    [...command].forEach((char, idx) => {
-        const reading = readingQuotedString || readingQuoteContinuedString || readingFlag || readingCmd;
-        if (!reading && (char === `'` || char === `"` || char == "`")) {
-            [readingQuotedString, readingIdx, readingQuoteChar] = [true, idx, char];
-            return;
-        }
-        else if (!reading && char === `-`) {
-            [readingFlag, readingIdx] = [true, idx];
-            return;
-        }
-        else if (!reading && !spaceRegex.test(char)) {
-            [readingCmd, readingIdx] = [true, idx];
-            return;
-        }
-        if (readingQuotedString && char === readingQuoteChar && command.at(idx - 1) !== escapeChar && !spaceRegex.test(command.at(idx + 1) ?? " ")) {
-            readingQuotedString = false;
-            readingQuoteContinuedString = true;
-        }
-        else if (readingQuotedString && char === readingQuoteChar && command.at(idx - 1) !== escapeChar) {
-            readingQuotedString = false;
-            const complete = idx + 1 < command.length && spaceRegex.test(command[idx + 1]);
-            tokens.push({
-                token: command.slice(readingIdx + 1, idx),
-                tokenLength: wcwidth(command.slice(readingIdx + 1, idx)) + 2,
-                complete,
-                isOption: false,
-                isQuoted: true,
-            });
-        }
-        else if (readingQuoteContinuedString && spaceRegex.test(char) && command.at(idx - 1) !== escapeChar) {
-            readingQuoteContinuedString = false;
-            tokens.push({
-                token: command.slice(readingIdx, idx),
-                tokenLength: wcwidth(command.slice(readingIdx, idx)),
-                complete: true,
-                isOption: false,
-                isQuoted: true,
-                isQuoteContinued: true,
-            });
-        }
-        else if ((readingFlag && spaceRegex.test(char)) || char === "=") {
-            readingFlag = false;
-            tokens.push({
-                token: command.slice(readingIdx, idx),
-                tokenLength: wcwidth(command.slice(readingIdx, idx)),
-                complete: true,
-                isOption: true,
-            });
-        }
-        else if (readingCmd && spaceRegex.test(char) && command.at(idx - 1) !== escapeChar) {
-            readingCmd = false;
-            tokens.push({
-                token: command.slice(readingIdx, idx),
-                tokenLength: wcwidth(command.slice(readingIdx, idx)),
-                complete: true,
-                isOption: false,
-            });
-        }
-    });
-    const reading = readingQuotedString || readingQuoteContinuedString || readingFlag || readingCmd;
-    if (reading) {
-        if (readingQuotedString) {
-            tokens.push({
-                token: command.slice(readingIdx + 1),
-                tokenLength: wcwidth(command.slice(readingIdx + 1)) + 1,
-                complete: false,
-                isOption: false,
-                isQuoted: true,
-            });
-        }
-        else if (readingQuoteContinuedString) {
-            tokens.push({
-                token: command.slice(readingIdx),
-                tokenLength: wcwidth(command.slice(readingIdx)),
-                complete: false,
-                isOption: false,
-                isQuoted: true,
-                isQuoteContinued: true,
-            });
-        }
-        else {
-            tokens.push({
-                token: command.slice(readingIdx),
-                tokenLength: wcwidth(command.slice(readingIdx)),
-                complete: false,
-                isOption: readingFlag,
-            });
-        }
-    }
-    return tokens;
-};

package/build/runtime/runtime.js

@@ -1,282 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-import speclist, { diffVersionedCompletions as versionedSpeclist,
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-ignore
- } from "@withfig/autocomplete/build/index.js";
-import path from "node:path";
-import { parseCommand } from "./parser.js";
-import { getArgDrivenRecommendation, getSubcommandDrivenRecommendation } from "./suggestion.js";
-import { buildExecuteShellCommand, resolveCwd } from "./utils.js";
-import { aliasExpand } from "./alias.js";
-import { getConfig } from "../utils/config.js";
-import log from "../utils/log.js";
-// eslint-disable-next-line @typescript-eslint/no-explicit-any -- recursive type, setting as any
-const specSet = {};
-function loadSpecsSet(speclist, versionedSpeclist, specsPath) {
-    speclist.forEach((s) => {
-        let activeSet = specSet;
-        const specRoutes = s.split("/");
-        specRoutes.forEach((route, idx) => {
-            if (typeof activeSet !== "object") {
-                return;
-            }
-            if (idx === specRoutes.length - 1) {
-                const prefix = versionedSpeclist.includes(s) ? "/index.js" : `.js`;
-                activeSet[route] = `${specsPath}/${s}${prefix}`;
-            }
-            else {
-                activeSet[route] = activeSet[route] || {};
-                activeSet = activeSet[route];
-            }
-        });
-    });
-}
-loadSpecsSet(speclist, versionedSpeclist, `@withfig/autocomplete/build`);
-const loadedSpecs = {};
-const loadSpec = async (cmd) => {
-    const rootToken = cmd.at(0);
-    if (!rootToken?.complete) {
-        return;
-    }
-    if (loadedSpecs[rootToken.token]) {
-        return loadedSpecs[rootToken.token];
-    }
-    if (specSet[rootToken.token]) {
-        const spec = (await import(specSet[rootToken.token])).default;
-        loadedSpecs[rootToken.token] = spec;
-        return spec;
-    }
-};
-// this load spec function should only be used for `loadSpec` on the fly as it is cacheless
-const lazyLoadSpec = async (key) => {
-    return (await import(`@withfig/autocomplete/build/${key}.js`)).default;
-};
-// eslint-disable-next-line @typescript-eslint/no-unused-vars -- will be implemented in below TODO
-const lazyLoadSpecLocation = async (location) => {
-    return; //TODO: implement spec location loading
-};
-export const loadLocalSpecsSet = async () => {
-    const specsPath = getConfig()?.specs?.path;
-    if (!specsPath) {
-        return;
-    }
-    try {
-        await Promise.allSettled(specsPath.map((specPath) => import(path.join(specPath, "index.js"))
-            .then((res) => {
-            const { default: speclist, diffVersionedCompletions: versionedSpeclist } = res;
-            loadSpecsSet(speclist, versionedSpeclist, specPath);
-        })
-            .catch((e) => {
-            log.debug({ msg: "load local spec failed", e: e.message, specPath });
-        })));
-    }
-    catch (e) {
-        log.debug({ msg: "load local specs failed", e: e.message, specsPath });
-    }
-};
-export const getSuggestions = async (cmd, cwd, shell) => {
-    let activeCmd = parseCommand(cmd, shell);
-    const rootToken = activeCmd.at(0);
-    if (activeCmd.length === 0 || !rootToken?.complete) {
-        return;
-    }
-    activeCmd = aliasExpand(activeCmd);
-    const spec = await loadSpec(activeCmd);
-    if (spec == null)
-        return;
-    const subcommand = getSubcommand(spec);
-    if (subcommand == null)
-        return;
-    const lastCommand = activeCmd.at(-1);
-    const { cwd: resolvedCwd, pathy, complete: pathyComplete } = await resolveCwd(lastCommand, cwd, shell);
-    if (pathy && lastCommand) {
-        lastCommand.isPath = true;
-        lastCommand.isPathComplete = pathyComplete;
-    }
-    const result = await runSubcommand(activeCmd.slice(1), subcommand, resolvedCwd, shell);
-    if (result == null)
-        return;
-    const charactersToDrop = lastCommand?.complete ? 0 : lastCommand?.tokenLength;
-    return { ...result, charactersToDrop };
-};
-export const getSpecNames = () => {
-    return Object.keys(specSet).filter((spec) => !spec.startsWith("@") && spec != "-");
-};
-const getPersistentOptions = (persistentOptions, options) => {
-    const persistentOptionNames = new Set(persistentOptions.map((o) => (typeof o.name === "string" ? [o.name] : o.name)).flat());
-    return persistentOptions.concat((options ?? []).filter((o) => (typeof o.name == "string" ? !persistentOptionNames.has(o.name) : o.name.some((n) => !persistentOptionNames.has(n))) && o.isPersistent === true));
-};
-// TODO: handle subcommands that are versioned
-const getSubcommand = (spec) => {
-    if (spec == null)
-        return;
-    if (typeof spec === "function") {
-        const potentialSubcommand = spec();
-        if (Object.prototype.hasOwnProperty.call(potentialSubcommand, "name")) {
-            return potentialSubcommand;
-        }
-        return;
-    }
-    return spec;
-};
-const executeShellCommand = await buildExecuteShellCommand(5000);
-const genSubcommand = async (command, parentCommand) => {
-    if (!parentCommand.subcommands || parentCommand.subcommands.length === 0)
-        return;
-    const subcommandIdx = parentCommand.subcommands.findIndex((s) => (Array.isArray(s.name) ? s.name.includes(command) : s.name === command));
-    if (subcommandIdx === -1)
-        return;
-    const subcommand = parentCommand.subcommands[subcommandIdx];
-    // this pulls in the spec from the load spec and overwrites the subcommand in the parent with the loaded spec.
-    // then it returns the subcommand and clears the loadSpec field so that it doesn't get called again
-    switch (typeof subcommand.loadSpec) {
-        case "function": {
-            const partSpec = await subcommand.loadSpec(command, executeShellCommand);
-            if (partSpec instanceof Array) {
-                const locationSpecs = (await Promise.all(partSpec.map((s) => lazyLoadSpecLocation(s)))).filter((s) => s != null);
-                const subcommands = locationSpecs.map((s) => getSubcommand(s)).filter((s) => s != null);
-                parentCommand.subcommands[subcommandIdx] = {
-                    ...subcommand,
-                    ...(subcommands.find((s) => s?.name == command) ?? []),
-                    loadSpec: undefined,
-                };
-                return parentCommand.subcommands[subcommandIdx];
-            }
-            else if (Object.prototype.hasOwnProperty.call(partSpec, "type")) {
-                const locationSingleSpec = await lazyLoadSpecLocation(partSpec);
-                parentCommand.subcommands[subcommandIdx] = {
-                    ...subcommand,
-                    ...(getSubcommand(locationSingleSpec) ?? []),
-                    loadSpec: undefined,
-                };
-                return parentCommand.subcommands[subcommandIdx];
-            }
-            else {
-                parentCommand.subcommands[subcommandIdx] = {
-                    ...subcommand,
-                    ...partSpec,
-                    loadSpec: undefined,
-                };
-                return parentCommand.subcommands[subcommandIdx];
-            }
-        }
-        case "string": {
-            const spec = await lazyLoadSpec(subcommand.loadSpec);
-            parentCommand.subcommands[subcommandIdx] = {
-                ...subcommand,
-                ...(getSubcommand(spec) ?? []),
-                loadSpec: undefined,
-            };
-            return parentCommand.subcommands[subcommandIdx];
-        }
-        case "object": {
-            parentCommand.subcommands[subcommandIdx] = {
-                ...subcommand,
-                ...(subcommand.loadSpec ?? {}),
-                loadSpec: undefined,
-            };
-            return parentCommand.subcommands[subcommandIdx];
-        }
-        case "undefined": {
-            return subcommand;
-        }
-    }
-};
-const getOption = (activeToken, options) => {
-    return options.find((o) => (typeof o.name === "string" ? o.name === activeToken.token : o.name.includes(activeToken.token)));
-};
-const getPersistentTokens = (tokens) => {
-    return tokens.filter((t) => t.isPersistent === true);
-};
-const getArgs = (args) => {
-    return args instanceof Array ? args : args != null ? [args] : [];
-};
-const runOption = async (tokens, option, subcommand, cwd, shell, persistentOptions, acceptedTokens) => {
-    if (tokens.length === 0) {
-        throw new Error("invalid state reached, option expected but no tokens found");
-    }
-    const activeToken = tokens[0];
-    const isPersistent = persistentOptions.some((o) => (typeof o.name === "string" ? o.name === activeToken.token : o.name.includes(activeToken.token)));
-    if ((option.args instanceof Array && option.args.length > 0) || option.args != null) {
-        const args = option.args instanceof Array ? option.args : [option.args];
-        return runArg(tokens.slice(1), args, subcommand, cwd, shell, persistentOptions, acceptedTokens.concat(activeToken), true, false);
-    }
-    return runSubcommand(tokens.slice(1), subcommand, cwd, shell, persistentOptions, acceptedTokens.concat({
-        ...activeToken,
-        isPersistent,
-    }));
-};
-const runArg = async (tokens, args, subcommand, cwd, shell, persistentOptions, acceptedTokens, fromOption, fromVariadic) => {
-    if (args.length === 0) {
-        return runSubcommand(tokens, subcommand, cwd, shell, persistentOptions, acceptedTokens, true, !fromOption);
-    }
-    else if (tokens.length === 0) {
-        return await getArgDrivenRecommendation(args, subcommand, persistentOptions, undefined, acceptedTokens, fromVariadic, cwd, shell);
-    }
-    else if (!tokens.at(0)?.complete) {
-        return await getArgDrivenRecommendation(args, subcommand, persistentOptions, tokens[0], acceptedTokens, fromVariadic, cwd, shell);
-    }
-    const activeToken = tokens[0];
-    if (args.every((a) => a.isOptional)) {
-        if (activeToken.isOption) {
-            const option = getOption(activeToken, persistentOptions.concat(subcommand.options ?? []));
-            if (option != null) {
-                return runOption(tokens, option, subcommand, cwd, shell, persistentOptions, acceptedTokens);
-            }
-            return;
-        }
-        const nextSubcommand = await genSubcommand(activeToken.token, subcommand);
-        if (nextSubcommand != null) {
-            return runSubcommand(tokens.slice(1), nextSubcommand, cwd, shell, persistentOptions, getPersistentTokens(acceptedTokens.concat(activeToken)));
-        }
-    }
-    const activeArg = args[0];
-    if (activeArg.isVariadic) {
-        return runArg(tokens.slice(1), args, subcommand, cwd, shell, persistentOptions, acceptedTokens.concat(activeToken), fromOption, true);
-    }
-    else if (activeArg.isCommand) {
-        if (tokens.length <= 0) {
-            return;
-        }
-        const spec = await loadSpec(tokens);
-        if (spec == null)
-            return;
-        const subcommand = getSubcommand(spec);
-        if (subcommand == null)
-            return;
-        return runSubcommand(tokens.slice(1), subcommand, cwd, shell);
-    }
-    return runArg(tokens.slice(1), args.slice(1), subcommand, cwd, shell, persistentOptions, acceptedTokens.concat(activeToken), fromOption, false);
-};
-const runSubcommand = async (tokens, subcommand, cwd, shell, persistentOptions = [], acceptedTokens = [], argsDepleted = false, argsUsed = false) => {
-    if (tokens.length === 0) {
-        return getSubcommandDrivenRecommendation(subcommand, persistentOptions, undefined, argsDepleted, argsUsed, acceptedTokens, cwd, shell);
-    }
-    else if (!tokens.at(0)?.complete) {
-        return getSubcommandDrivenRecommendation(subcommand, persistentOptions, tokens[0], argsDepleted, argsUsed, acceptedTokens, cwd, shell);
-    }
-    const activeToken = tokens[0];
-    const activeArgsLength = subcommand.args instanceof Array ? subcommand.args.length : 1;
-    const allOptions = [...persistentOptions, ...(subcommand.options ?? [])];
-    if (activeToken.isOption) {
-        const option = getOption(activeToken, allOptions);
-        if (option != null) {
-            return runOption(tokens, option, subcommand, cwd, shell, persistentOptions, acceptedTokens);
-        }
-        return;
-    }
-    const nextSubcommand = await genSubcommand(activeToken.token, subcommand);
-    if (nextSubcommand != null) {
-        return runSubcommand(tokens.slice(1), nextSubcommand, cwd, shell, getPersistentOptions(persistentOptions, subcommand.options), getPersistentTokens(acceptedTokens.concat(activeToken)));
-    }
-    if (activeArgsLength <= 0) {
-        return; // not subcommand or option & no args exist
-    }
-    const args = getArgs(subcommand.args);
-    if (args.length != 0) {
-        return runArg(tokens, args, subcommand, cwd, shell, allOptions, acceptedTokens, false, false);
-    }
-    // if the subcommand has no args specified, fallback to the subcommand and ignore this item
-    return runSubcommand(tokens.slice(1), subcommand, cwd, shell, persistentOptions, acceptedTokens.concat(activeToken));
-};

package/build/runtime/spec.js

@@ -1,36 +0,0 @@
-"use strict";
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDiffVersionedSpeclist = exports.getSpeclist = void 0;
-let speclist = undefined;
-let versionedSpeclist = undefined;
-const getSpeclist = () => __awaiter(void 0, void 0, void 0, function* () {
-    if (!speclist) {
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-ignore
-        const autocomplete = yield import("@withfig/autocomplete/build/index.js");
-        speclist = autocomplete.default;
-    }
-    return speclist;
-});
-exports.getSpeclist = getSpeclist;
-const getDiffVersionedSpeclist = () => __awaiter(void 0, void 0, void 0, function* () {
-    if (!versionedSpeclist) {
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-ignore
-        const autocomplete = yield import("@withfig/autocomplete/build/index.js");
-        versionedSpeclist = autocomplete.diffVersionedCompletions;
-    }
-    return versionedSpeclist;
-});
-exports.getDiffVersionedSpeclist = getDiffVersionedSpeclist;

package/build/runtime/suggestion.js

@@ -1,232 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-import path from "node:path";
-import { runGenerator } from "./generator.js";
-import { runTemplates } from "./template.js";
-import log from "../utils/log.js";
-import { escapePath } from "./utils.js";
-import { addPathSeparator, getPathDirname, removePathSeparator } from "../utils/shell.js";
-export var SuggestionIcons;
-(function (SuggestionIcons) {
-    SuggestionIcons["File"] = "\uD83D\uDCC4";
-    SuggestionIcons["Folder"] = "\uD83D\uDCC1";
-    SuggestionIcons["Subcommand"] = "\uD83D\uDCE6";
-    SuggestionIcons["Option"] = "\uD83D\uDD17";
-    SuggestionIcons["Argument"] = "\uD83D\uDCB2";
-    SuggestionIcons["Mixin"] = "\uD83C\uDFDD\uFE0F";
-    SuggestionIcons["Shortcut"] = "\uD83D\uDD25";
-    SuggestionIcons["Special"] = "\u2B50";
-    SuggestionIcons["Default"] = "\uD83D\uDCC0";
-})(SuggestionIcons || (SuggestionIcons = {}));
-const getIcon = (icon, suggestionType) => {
-    // eslint-disable-next-line no-control-regex
-    if (icon && /[^\u0000-\u00ff]/.test(icon)) {
-        return icon;
-    }
-    switch (suggestionType) {
-        case "arg":
-            return SuggestionIcons.Argument;
-        case "file":
-            return SuggestionIcons.File;
-        case "folder":
-            return SuggestionIcons.Folder;
-        case "option":
-            return SuggestionIcons.Option;
-        case "subcommand":
-            return SuggestionIcons.Subcommand;
-        case "mixin":
-            return SuggestionIcons.Mixin;
-        case "shortcut":
-            return SuggestionIcons.Shortcut;
-        case "special":
-            return SuggestionIcons.Special;
-    }
-    return SuggestionIcons.Default;
-};
-const getLong = (suggestion) => {
-    return suggestion instanceof Array ? suggestion.reduce((p, c) => (p.length > c.length ? p : c)) : suggestion;
-};
-const getPathy = (type) => {
-    return type === "file" || type === "folder";
-};
-const toSuggestion = (suggestion, name, type) => {
-    if (suggestion.name == null)
-        return;
-    return {
-        name: name ?? getLong(suggestion.name),
-        description: suggestion.description,
-        icon: getIcon(suggestion.icon, type ?? suggestion.type),
-        allNames: suggestion.name instanceof Array ? suggestion.name : [suggestion.name],
-        priority: suggestion.priority ?? 50,
-        insertValue: suggestion.insertValue,
-        type: suggestion.type,
-    };
-};
-function filter(suggestions, filterStrategy, partialCmd, suggestionType) {
-    if (!partialCmd)
-        return suggestions.map((s) => toSuggestion(s, undefined, suggestionType)).filter((s) => s != null);
-    switch (filterStrategy) {
-        case "fuzzy":
-            return suggestions
-                .map((s) => {
-                if (s.name == null)
-                    return;
-                if (s.name instanceof Array) {
-                    const matchedName = s.name.find((n) => n.toLowerCase().includes(partialCmd.toLowerCase()));
-                    return matchedName != null
-                        ? {
-                            name: matchedName,
-                            description: s.description,
-                            icon: getIcon(s.icon, s.type ?? suggestionType),
-                            allNames: s.name,
-                            priority: s.priority ?? 50,
-                            insertValue: s.insertValue,
-                            type: s.type,
-                        }
-                        : undefined;
-                }
-                return s.name.toLowerCase().includes(partialCmd.toLowerCase())
-                    ? {
-                        name: s.name,
-                        description: s.description,
-                        icon: getIcon(s.icon, s.type ?? suggestionType),
-                        allNames: [s.name],
-                        priority: s.priority ?? 50,
-                        insertValue: s.insertValue,
-                        type: s.type,
-                    }
-                    : undefined;
-            })
-                .filter((s) => s != null);
-        default:
-            return suggestions
-                .map((s) => {
-                if (s.name == null)
-                    return;
-                if (s.name instanceof Array) {
-                    const matchedName = s.name.find((n) => n.toLowerCase().startsWith(partialCmd.toLowerCase()));
-                    return matchedName != null
-                        ? {
-                            name: matchedName,
-                            description: s.description,
-                            icon: getIcon(s.icon, s.type ?? suggestionType),
-                            allNames: s.name,
-                            insertValue: s.insertValue,
-                            priority: s.priority ?? 50,
-                            type: s.type,
-                        }
-                        : undefined;
-                }
-                return s.name.toLowerCase().startsWith(partialCmd.toLowerCase())
-                    ? {
-                        name: s.name,
-                        description: s.description,
-                        icon: getIcon(s.icon, s.type ?? suggestionType),
-                        allNames: [s.name],
-                        insertValue: s.insertValue,
-                        priority: s.priority ?? 50,
-                        type: s.type,
-                    }
-                    : undefined;
-            })
-                .filter((s) => s != null);
-    }
-}
-const generatorSuggestions = async (generator, acceptedTokens, filterStrategy, partialCmd, cwd) => {
-    const generators = generator instanceof Array ? generator : generator ? [generator] : [];
-    const tokens = acceptedTokens.map((t) => t.token);
-    if (partialCmd)
-        tokens.push(partialCmd);
-    const suggestions = (await Promise.all(generators.map((gen) => runGenerator(gen, tokens, cwd)))).flat();
-    return filter(suggestions.map((suggestion) => ({ ...suggestion, priority: suggestion.priority ?? 60 })), filterStrategy, partialCmd, undefined);
-};
-const templateSuggestions = async (templates, filterStrategy, partialCmd, cwd) => {
-    return filter(await runTemplates(templates ?? [], cwd), filterStrategy, partialCmd, undefined);
-};
-const suggestionSuggestions = (suggestions, filterStrategy, partialCmd) => {
-    const cleanedSuggestions = suggestions?.map((s) => (typeof s === "string" ? { name: s } : s)) ?? [];
-    return filter(cleanedSuggestions ?? [], filterStrategy, partialCmd, undefined);
-};
-const subcommandSuggestions = (subcommands, filterStrategy, partialCmd) => {
-    return filter(subcommands ?? [], filterStrategy, partialCmd, "subcommand");
-};
-const optionSuggestions = (options, acceptedTokens, filterStrategy, partialCmd) => {
-    const usedOptions = new Set(acceptedTokens.filter((t) => t.isOption).map((t) => t.token));
-    const validOptions = options?.filter((o) => o.exclusiveOn?.every((exclusiveOption) => !usedOptions.has(exclusiveOption)) ?? true);
-    return filter(validOptions ?? [], filterStrategy, partialCmd, "option");
-};
-function adjustPathSuggestions(suggestions, partialToken, shell) {
-    return suggestions.map((s) => {
-        const pathy = getPathy(s.type);
-        const rawInsertValue = removePathSeparator(s.insertValue ?? s.name ?? "");
-        const insertValue = s.type == "folder" ? addPathSeparator(rawInsertValue, shell) : rawInsertValue;
-        const partialDir = getPathDirname(partialToken?.token ?? "", shell);
-        const fullPath = partialToken?.isPath ? `${partialDir}${insertValue}` : insertValue;
-        return pathy ? { ...s, insertValue: escapePath(fullPath, shell), name: removePathSeparator(s.name) } : s;
-    });
-}
-const removeAcceptedSuggestions = (suggestions, acceptedTokens) => {
-    const seen = new Set(acceptedTokens.map((t) => t.token));
-    return suggestions.filter((s) => s.allNames.every((n) => !seen.has(n)));
-};
-const removeDuplicateSuggestion = (suggestions) => {
-    const seen = new Set();
-    return suggestions
-        .map((s) => {
-        if (seen.has(s.name))
-            return null;
-        seen.add(s.name);
-        return s;
-    })
-        .filter((s) => s != null);
-};
-const removeEmptySuggestion = (suggestions) => {
-    return suggestions.filter((s) => s.name.length > 0);
-};
-export const getSubcommandDrivenRecommendation = async (subcommand, persistentOptions, partialToken, argsDepleted, argsFromSubcommand, acceptedTokens, cwd, shell) => {
-    log.debug({ msg: "suggestion point", subcommand, persistentOptions, partialToken, argsDepleted, argsFromSubcommand, acceptedTokens, cwd });
-    if (argsDepleted && argsFromSubcommand) {
-        return;
-    }
-    let partialCmd = partialToken?.token;
-    if (partialToken?.isPath) {
-        partialCmd = partialToken.isPathComplete ? "" : path.basename(partialCmd ?? "");
-    }
-    const suggestions = [];
-    const argLength = subcommand.args instanceof Array ? subcommand.args.length : subcommand.args ? 1 : 0;
-    const allOptions = persistentOptions.concat(subcommand.options ?? []);
-    if (!argsFromSubcommand) {
-        suggestions.push(...subcommandSuggestions(subcommand.subcommands, subcommand.filterStrategy, partialCmd));
-        suggestions.push(...optionSuggestions(allOptions, acceptedTokens, subcommand.filterStrategy, partialCmd));
-    }
-    if (argLength != 0) {
-        const activeArg = subcommand.args instanceof Array ? subcommand.args[0] : subcommand.args;
-        suggestions.push(...(await generatorSuggestions(activeArg?.generators, acceptedTokens, activeArg?.filterStrategy, partialCmd, cwd)));
-        suggestions.push(...suggestionSuggestions(activeArg?.suggestions, activeArg?.filterStrategy, partialCmd));
-        suggestions.push(...(await templateSuggestions(activeArg?.template, activeArg?.filterStrategy, partialCmd, cwd)));
-    }
-    return {
-        suggestions: removeDuplicateSuggestion(removeEmptySuggestion(removeAcceptedSuggestions(adjustPathSuggestions(suggestions.sort((a, b) => b.priority - a.priority), partialToken, shell), acceptedTokens))),
-    };
-};
-export const getArgDrivenRecommendation = async (args, subcommand, persistentOptions, partialToken, acceptedTokens, variadicArgBound, cwd, shell) => {
-    let partialCmd = partialToken?.token;
-    if (partialToken?.isPath) {
-        partialCmd = partialToken.isPathComplete ? "" : path.basename(partialCmd ?? "");
-    }
-    const activeArg = args[0];
-    const allOptions = persistentOptions.concat(subcommand.options ?? []);
-    const suggestions = [
-        ...(await generatorSuggestions(args[0].generators, acceptedTokens, activeArg?.filterStrategy, partialCmd, cwd)),
-        ...suggestionSuggestions(args[0].suggestions, activeArg?.filterStrategy, partialCmd),
-        ...(await templateSuggestions(args[0].template, activeArg?.filterStrategy, partialCmd, cwd)),
-    ];
-    if (activeArg.isOptional || (activeArg.isVariadic && variadicArgBound)) {
-        suggestions.push(...subcommandSuggestions(subcommand.subcommands, activeArg?.filterStrategy, partialCmd));
-        suggestions.push(...optionSuggestions(allOptions, acceptedTokens, activeArg?.filterStrategy, partialCmd));
-    }
-    return {
-        suggestions: removeDuplicateSuggestion(removeEmptySuggestion(removeAcceptedSuggestions(adjustPathSuggestions(suggestions.sort((a, b) => b.priority - a.priority), partialToken, shell), acceptedTokens))),
-        argumentDescription: activeArg.description ?? activeArg.name,
-    };
-};