looking good

src/app/workspace/cmdinput/suggestionview.tsx

@@ -7,6 +7,7 @@ import { observer } from "mobx-react";
 import { If } from "tsx-control-statements/components";
 
 import "./suggestionview.less";
+import { getAll, getFirst } from "@/autocomplete/runtime/utils";
 
 export const SuggestionView: React.FC = observer(() => {
     const [selectedSuggestion, setSelectedSuggestion] = React.useState<number>(0);
@@ -60,14 +61,15 @@ export const SuggestionView: React.FC = observer(() => {
             </If>
             {suggestions?.suggestions.map((suggestion, idx) => (
                 <div
-                    key={suggestion.name}
+                    key={getFirst(suggestion.name)}
                     title={suggestion.description}
                     className={cn("suggestion-item", { "is-selected": selectedSuggestion === idx })}
                     onClick={() => {
                         setSuggestion(idx);
                     }}
                 >
-                    {suggestion.icon} {suggestion.name} {suggestion.description ? `- ${suggestion.description}` : ""}
+                    {suggestion.icon} {getAll(suggestion.name).join(",")}{" "}
+                    {suggestion.description ? `- ${suggestion.description}` : ""}
                 </div>
             ))}
         </AuxiliaryCmdView>

src/app/workspace/cmdinput/textareainput.tsx

@@ -102,19 +102,6 @@ class HistoryKeybindings extends React.Component<{}, {}> {
     }
 }
 
-const SuggestionsInfoMsg = (props: { suggestions: SuggestionBlob }) => {
-    const suggestions = props.suggestions.suggestions;
-    return (
-        <div className="cmd-input-info">
-            {suggestions.map((s) => (
-                <div key={s.name} className="cmd-input-info-item">
-                    {s.icon} {s.name}
-                </div>
-            ))}
-        </div>
-    );
-};
-
 class CmdInputKeybindings extends React.Component<{ inputObject: TextAreaInput }, {}> {
     curPress: string;
     lastTab: boolean;

src/autocomplete/runtime/model.ts

@@ -15,7 +15,7 @@ export type Suggestion = {
 };
 
 export type SuggestionBlob = {
-    suggestions: Suggestion[];
+    suggestions: Fig.Suggestion[];
     argumentDescription?: string;
     charactersToDrop?: number;
 };

src/autocomplete/runtime/runtime.ts

@@ -11,6 +11,7 @@ import speclist, {
     // @ts-ignore
 } from "@withfig/autocomplete/build/index";
 import { parseCommand, CommandToken } from "./parser";
+import { Newton } from "./newton";
 import { getArgDrivenRecommendation, getSubcommandDrivenRecommendation } from "./suggestion";
 import { SuggestionBlob } from "./model";
 import { buildExecuteShellCommand, resolveCwd } from "./utils";
@@ -95,6 +96,13 @@ const lazyLoadSpecLocation = async (location: Fig.SpecLocation): Promise<Fig.Spe
 
 export const getSuggestions = async (cmd: string, cwd: string, shell: Shell): Promise<SuggestionBlob | undefined> => {
     const activeCmd = parseCommand(cmd);
+    const parserCmd = activeCmd.map((c) => c.token);
+    if (cmd.endsWith(" ")) {
+        parserCmd.push(" ");
+    }
+    const parser = new Newton(undefined, parserCmd, cwd);
+    const sugg = await parser.generateSuggestions();
+    log.debug("newton done");
     log.debug("activeCmd", activeCmd);
     if (activeCmd.length === 0) {
         return;
@@ -133,7 +141,8 @@ export const getSuggestions = async (cmd: string, cwd: string, shell: Shell): Pr
     }
 
     if (result == null) return;
-    log.debug("result", result);
+    log.debug("result og", result);
+    log.debug("result newton", sugg);
     return { ...result, charactersToDrop };
 };
 
@@ -156,7 +165,7 @@ const getSubcommand = (spec?: Fig.Spec): Fig.Subcommand | undefined => {
     if (spec == null) return;
     if (typeof spec === "function") {
         const potentialSubcommand = spec();
-        if (Object.prototype.hasOwnProperty.call(potentialSubcommand, "name")) {
+        if (Object.hasOwn(potentialSubcommand, "name")) {
             return potentialSubcommand as Fig.Subcommand;
         }
         return;

src/autocomplete/runtime/suggestion.ts

@@ -11,6 +11,7 @@ import { runTemplates } from "./template";
 import { Suggestion, SuggestionBlob } from "./model";
 import { getApi } from "@/models";
 import log from "../utils/log";
+import { getAll, matchAny } from "./utils";
 
 enum SuggestionIcons {
     File = "📄",
@@ -24,7 +25,7 @@ enum SuggestionIcons {
     Default = "📀",
 }
 
-const getIcon = (icon: string | undefined, suggestionType: Fig.SuggestionType | undefined): string => {
+export const getIcon = (icon: string | undefined, suggestionType: Fig.SuggestionType | undefined): string => {
     // TODO: enable fig icons once spacing is better
     // if (icon && /[^\u0000-\u00ff]/.test(icon)) {
     //   return icon;
@@ -73,7 +74,7 @@ function filter<
     filterStrategy: FilterStrategy | undefined,
     partialCmd: string | undefined,
     suggestionType: Fig.SuggestionType | undefined
-): Suggestion[] {
+): Fig.Suggestion[] {
     log.debug("filter", suggestions, filterStrategy, partialCmd, suggestionType);
     if (!partialCmd)
         return suggestions
@@ -143,18 +144,16 @@ function filter<
     }
 }
 
-type FilterStrategy = "fuzzy" | "prefix" | "default";
+export type FilterStrategy = "fuzzy" | "prefix" | "default";
 
-const generatorSuggestions = async (
+export const generatorSuggestionsTokens = async (
     generator: Fig.SingleOrArray<Fig.Generator> | undefined,
-    acceptedTokens: CommandToken[],
+    tokens: string[],
     filterStrategy: FilterStrategy | undefined,
     partialCmd: string | undefined,
     cwd: string
-): Promise<Suggestion[]> => {
+) => {
     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<Fig.Suggestion>(
         suggestions.map((suggestion) => ({ ...suggestion, priority: suggestion.priority ?? 60 })),
@@ -164,30 +163,43 @@ const generatorSuggestions = async (
     );
 };
 
-const templateSuggestions = async (
+export const generatorSuggestions = async (
+    generator: Fig.SingleOrArray<Fig.Generator> | undefined,
+    acceptedTokens: CommandToken[],
+    filterStrategy: FilterStrategy | undefined,
+    partialCmd: string | undefined,
+    cwd: string
+): Promise<Fig.Suggestion[]> => {
+    const generators = generator instanceof Array ? generator : generator ? [generator] : [];
+    const tokens = acceptedTokens.map((t) => t.token);
+    if (partialCmd) tokens.push(partialCmd);
+    return generatorSuggestionsTokens(generators, tokens, filterStrategy, partialCmd, cwd);
+};
+
+export const templateSuggestions = async (
     templates: Fig.Template | undefined,
     filterStrategy: FilterStrategy | undefined,
     partialCmd: string | undefined,
     cwd: string
-): Promise<Suggestion[]> => {
+): Promise<Fig.Suggestion[]> => {
     log.debug("templateSuggestions", templates, filterStrategy, partialCmd);
     return filter<Fig.Suggestion>(await runTemplates(templates ?? [], cwd), filterStrategy, partialCmd, undefined);
 };
 
-const suggestionSuggestions = (
+export const suggestionSuggestions = (
     suggestions: (string | Fig.Suggestion)[] | undefined,
     filterStrategy: FilterStrategy | undefined,
     partialCmd: string | undefined
-): Suggestion[] => {
+): Fig.Suggestion[] => {
     const cleanedSuggestions = suggestions?.map((s) => (typeof s === "string" ? { name: s } : s)) ?? [];
     return filter<Fig.Suggestion>(cleanedSuggestions ?? [], filterStrategy, partialCmd, undefined);
 };
 
-const subcommandSuggestions = (
+export const subcommandSuggestions = (
     subcommands: Fig.Subcommand[] | undefined,
     filterStrategy: FilterStrategy | undefined,
     partialCmd: string | undefined
-): Suggestion[] => {
+): Fig.Suggestion[] => {
     return filter<Fig.Subcommand>(subcommands ?? [], filterStrategy, partialCmd, "subcommand");
 };
 
@@ -196,7 +208,7 @@ const optionSuggestions = (
     acceptedTokens: CommandToken[],
     filterStrategy: FilterStrategy | undefined,
     partialCmd: string | undefined
-): Suggestion[] => {
+): Fig.Suggestion[] => {
     log.debug("optionSuggestions", options, acceptedTokens, filterStrategy, partialCmd);
     const usedOptions = new Set(acceptedTokens.filter((t) => t.isOption).map((t) => t.token));
     const validOptions = options?.filter(
@@ -205,23 +217,23 @@ const optionSuggestions = (
     return filter<Fig.Option>(validOptions ?? [], filterStrategy, partialCmd, "option");
 };
 
-const removeAcceptedSuggestions = (suggestions: Suggestion[], acceptedTokens: CommandToken[]): Suggestion[] => {
+const removeAcceptedSuggestions = (suggestions: Fig.Suggestion[], acceptedTokens: CommandToken[]): Fig.Suggestion[] => {
     const seen = new Set<string>(acceptedTokens.map((t) => t.token));
-    return suggestions.filter((s) => s.allNames.every((n) => !seen.has(n)));
+    return suggestions.filter((s) => matchAny(s.name, (n) => !seen.has(n)));
 };
 
-const removeDuplicateSuggestion = (suggestions: Suggestion[]): Suggestion[] => {
+const removeDuplicateSuggestion = (suggestions: Fig.Suggestion[]): Fig.Suggestion[] => {
     const seen = new Set<string>();
     return suggestions
         .map((s) => {
-            if (seen.has(s.name)) return null;
-            seen.add(s.name);
+            if (matchAny(s.name, (n) => seen.has(n))) return null;
+            for (const name of s.name) seen.add(name);
             return s;
         })
-        .filter((s): s is Suggestion => s != null);
+        .filter((s): s is Fig.Suggestion => s != null);
 };
 
-const removeEmptySuggestion = (suggestions: Suggestion[]): Suggestion[] => {
+const removeEmptySuggestion = (suggestions: Fig.Suggestion[]): Fig.Suggestion[] => {
     return suggestions.filter((s) => s.name.length > 0);
 };
 
@@ -245,7 +257,7 @@ export const getSubcommandDrivenRecommendation = async (
         partialCmd = partialToken.isPathComplete ? "" : getApi().pathBaseName(partialCmd ?? "");
     }
 
-    const suggestions: Suggestion[] = [];
+    const suggestions: Fig.Suggestion[] = [];
     const argLength = subcommand.args instanceof Array ? subcommand.args.length : subcommand.args ? 1 : 0;
     const allOptions = persistentOptions.concat(subcommand.options ?? []);
     log.debug("allOptions", allOptions, persistentOptions, subcommand.options, subcommand.args, argLength);

src/autocomplete/runtime/template.ts

@@ -41,6 +41,7 @@ const historyTemplate = (): Fig.TemplateSuggestion[] => {
                             templateType: "history",
                         },
                         insertValue,
+                        type: "special",
                     });
                 }
             }

src/autocomplete/runtime/utils.ts

@@ -52,6 +52,17 @@ export const buildExecuteShellCommand =
         return output;
     };
 
+export const resolveCwdToken = async (
+    token: string,
+    cwd: string,
+    shell: Shell
+): Promise<{ cwd: string; pathy: boolean; complete: boolean }> => {
+    if (token == null) return { cwd, pathy: false, complete: false };
+    const sep = shell == Shell.Bash ? "/" : getApi().pathSep();
+    if (!token.includes(sep)) return { cwd, pathy: false, complete: false };
+    return { cwd: cwd, pathy: true, complete: token.endsWith(sep) };
+};
+
 export const resolveCwd = async (
     cmdToken: CommandToken | undefined,
     cwd: string,
@@ -59,11 +70,15 @@ export const resolveCwd = async (
 ): Promise<{ cwd: string; pathy: boolean; complete: boolean }> => {
     if (cmdToken == null) return { cwd, pathy: false, complete: false };
     const { token } = cmdToken;
-    const sep = shell == Shell.Bash ? "/" : getApi().pathSep();
-    if (!token.includes(sep)) return { cwd, pathy: false, complete: false };
-    return { cwd: cwd, pathy: true, complete: token.endsWith(sep) };
+    return resolveCwdToken(token, cwd, shell);
 };
 
+/**
+ * Retrieves the contents of the specified directory on the active remote machine.
+ * @param cwd The directory whose contents should be returned.
+ * @param tempType The template to use when returning the contents. If "folders" is passed, only the directories within the specified directory will be returned. Otherwise, all the contents will be returned.
+ * @returns The contents of the directory formatted to the specified template.
+ */
 export const getCompletionSuggestions = async (
     cwd: string,
     tempType: "filepaths" | "folders"
@@ -86,3 +101,204 @@ export const getCompletionSuggestions = async (
         }
     }
 };
+
+/**
+ * Runs the comparator function on each value and returns true if any of them match
+ * @param values The value(s) to check
+ * @param comparator The function to use to compare the values
+ * @returns True if any of the values match the comparator
+ */
+export function matchAny<T>(values: Fig.SingleOrArray<T>, comparator: (a: T) => boolean) {
+    if (Array.isArray(values)) {
+        for (const value of values) {
+            if (comparator(value)) {
+                return true;
+            }
+        }
+        return false;
+    } else {
+        return comparator(values);
+    }
+}
+
+/**
+ * Checks if any of the values start with the input string
+ * @param values The value(s) to check
+ * @param input The input to check against
+ * @returns True if any of the values start with the input
+ */
+export function startsWithAny(values: Fig.SingleOrArray<string>, input: string) {
+    return matchAny(values, (a) => a.startsWith(input));
+}
+
+/**
+ * Checks if any of the values are not equal to the input
+ * @param values The value(s) to check
+ * @param input The input to check against
+ * @returns True if any of the values are not equal to the input
+ */
+export function equalsAny<T>(values: Fig.SingleOrArray<T>, input: T) {
+    return matchAny(values, (a) => a == input);
+}
+
+/**
+ * Checks if any of the values of the SingleOrArray are not in the array
+ * @param values The value(s) to check
+ * @param arr The array to check against
+ * @returns True if any of the values are not in the array
+ */
+export function notInAny<T>(values: Fig.SingleOrArray<T>, arr: T[]) {
+    return matchAny(values, (a) => !arr.includes(a));
+}
+
+/**
+ * Get the first element of a Fig.SingleOrArray<T>.
+ * @param values Either a single value or an array of values of the specified type.
+ * @returns The first element of the array, or the value.
+ */
+export function getFirst<T>(values: Fig.SingleOrArray<T>): T {
+    if (Array.isArray(values)) {
+        return values[0];
+    }
+    return values;
+}
+
+/**
+ * Get all elements of a Fig.SingleOrArray<T>
+ * @param values Either a single value or an array of values of the specified type.
+ * @returns The array of values, or an empty array
+ */
+export function getAll<T>(values: Fig.SingleOrArray<T> | undefined): T[] {
+    if (Array.isArray(values)) {
+        return values;
+    }
+    return [values as T];
+}
+
+/**
+ * Checks if a string is an option, i.e. starts with "--".
+ * @param value The string to check.
+ * @returns True if the string is an option.
+ */
+export function isOption(value: string): boolean {
+    return value.startsWith("--");
+}
+
+/**
+ * Checks if a string is a flag, i.e. starts with "-" but not "--".
+ * @param value The string to check.
+ * @returns True if the string is a flag.
+ */
+export function isFlag(value: string): boolean {
+    return value.startsWith("-") && !isOption(value);
+}
+
+/**
+ * Checks if a string is either a flag or an option, i.e. starts with "-".
+ * @param value The string to check.
+ * @returns True if the string is a flag or an option.
+ */
+export function isFlagOrOption(value: string): boolean {
+    return value.startsWith("-");
+}
+
+/**
+ * Get the flag of a Fig.SingleOrArray<string>.
+ * @param values Either a string or an array of strings.
+ * @returns The flag, or undefined if none is found.
+ */
+export function getFlag(values: Fig.SingleOrArray<string>): string | undefined {
+    if (Array.isArray(values)) {
+        for (const value of values) {
+            if (isFlag(value)) {
+                return value;
+            }
+        }
+    } else if (isFlag(values)) {
+        return values;
+    }
+    return undefined;
+}
+
+/**
+ * Checks if a string is a command, i.e. not a flag or option.
+ * @param value The string to check.
+ * @returns True if the string is a command.
+ */
+export function isCommand(value: string): boolean {
+    return !isFlag(value) && !isOption(value);
+}
+
+/**
+ * Checks if an option suggestion contains a flag. If so, modifies the name to include the preceding flags.
+ * @param option The option to modify.
+ * @param precedingFlags The preceding flags to prepend to the suggestion name.
+ * @returns The modified option suggestion.
+ */
+export function modifyPosixFlags(option: Fig.Option, precedingFlags: string): Fig.Option {
+    // We only want to modify the name if the option is a flag
+    if (option.name) {
+        // Get the name of the flag without the preceding "-"
+        const name = getFlag(option.name)?.slice(1);
+
+        if (name) {
+            // Shallow copy the option so we can modify the name without modifying the original spec.
+            option = { ...option };
+
+            // We want to prepend the existing flags to the name, except for the suggestion of the last flag (i.e. the `c` of an input `-abc`), which we want to replace with the existing flags.
+            // The end result is that we will suggest -abc instead of -a -b -c. We do not want -abb. The case of -aba should already be covered by filterFlags.
+            if (name === precedingFlags.at(-1)) {
+                option.name = "-" + precedingFlags;
+            } else {
+                option.name = "-" + precedingFlags + name;
+            }
+        }
+    }
+    return option;
+}
+
+/**
+ * Sort suggestions in-place by priority, then by name.
+ * @param suggestions The suggestions to sort.
+ */
+export function sortSuggestions(suggestions: Fig.Suggestion[]) {
+    suggestions.sort((a, b) => {
+        if (a.priority == b.priority) {
+            if (a.name) {
+                if (b.name) {
+                    return getFirst(a.name).trim().localeCompare(getFirst(b.name));
+                } else {
+                    return -1;
+                }
+            } else if (b.name) {
+                return 1;
+            }
+        }
+        return (b.priority ?? 0) - (a.priority ?? 0);
+    });
+}
+
+/**
+ * Merge two subcommand objects, with the second subcommand taking precedence in case of conflicts.
+ * @param subcommand1 The first subcommand.
+ * @param subcommand2 The second subcommand.
+ * @returns The merged subcommand.
+ */
+export function mergeSubcomands(subcommand1: Fig.Subcommand, subcommand2: Fig.Subcommand): Fig.Subcommand {
+    log.debug("merging two subcommands", subcommand1, subcommand2);
+    const newCommand: Fig.Subcommand = { ...subcommand1 };
+
+    // Merge the generated spec with the existing spec
+    for (const key in subcommand2) {
+        if (Array.isArray(subcommand2[key])) {
+            newCommand[key] = [...subcommand2[key], ...(newCommand[key] ?? [])];
+            continue;
+        } else if (typeof subcommand2[key] === "object") {
+            newCommand[key] = { ...subcommand2[key], ...(newCommand[key] ?? {}) };
+        } else {
+            newCommand[key] = subcommand2[key];
+        }
+    }
+    log.debug("merged subcommand:", newCommand);
+    return newCommand;
+}

src/models/autocomplete.ts

@@ -125,7 +125,11 @@ export class AutocompleteModel {
         let retVal = "";
         if (autocompleteSuggestions != null && autocompleteSuggestions.suggestions.length > index) {
             const suggestion = autocompleteSuggestions.suggestions[index];
-            retVal = suggestion.name;
+            if (typeof suggestion.name === "string") {
+                retVal = suggestion.name;
+            } else if (suggestion.name.length > 0) {
+                retVal = suggestion.name[0];
+            }
             if (suggestion.insertValue) {
                 retVal = suggestion.insertValue;
             }

tsconfig.json

@@ -1,9 +1,10 @@
 {
     "include": ["src/**/*", "types/**/*"],
     "compilerOptions": {
-        "target": "es5",
+        "target": "es6",
         "module": "commonjs",
         "jsx": "preserve",
+        "lib": ["ES2022"],
         "esModuleInterop": true,
         "skipLibCheck": true,
         "forceConsistentCasingInFileNames": true,