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

package/build/runtime/runtime.js

@@ -4,25 +4,35 @@ 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 } from "./utils.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 = {};
-speclist.forEach((s) => {
-    let activeSet = specSet;
-    const specRoutes = s.split("/");
-    specRoutes.forEach((route, idx) => {
-        if (idx === specRoutes.length - 1) {
-            const prefix = versionedSpeclist.includes(s) ? "/index.js" : `.js`;
-            activeSet[route] = `@withfig/autocomplete/build/${s}${prefix}`;
-        }
-        else {
-            activeSet[route] = activeSet[route] || {};
-            activeSet = activeSet[route];
-        }
+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);
@@ -46,25 +56,53 @@ const lazyLoadSpec = async (key) => {
 const lazyLoadSpecLocation = async (location) => {
     return; //TODO: implement spec location loading
 };
-export const getSuggestions = async (cmd) => {
-    const activeCmd = parseCommand(cmd);
+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 result = await runSubcommand(activeCmd.slice(1), subcommand);
+    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 lastCommand = activeCmd.at(-1);
-    const charactersToDrop = lastCommand?.complete ? 0 : lastCommand?.token.length ?? 0;
+    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));
@@ -82,14 +120,14 @@ const getSubcommand = (spec) => {
     }
     return spec;
 };
-const executeShellCommand = buildExecuteShellCommand(5000);
+const executeShellCommand = await buildExecuteShellCommand(5000);
 const genSubcommand = async (command, parentCommand) => {
-    const subcommandIdx = parentCommand.subcommands?.findIndex((s) => s.name === command);
-    if (subcommandIdx == null)
+    if (!parentCommand.subcommands || parentCommand.subcommands.length === 0)
         return;
-    const subcommand = parentCommand.subcommands?.at(subcommandIdx);
-    if (subcommand == null)
+    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) {
@@ -115,17 +153,29 @@ const genSubcommand = async (command, parentCommand) => {
                 return parentCommand.subcommands[subcommandIdx];
             }
             else {
-                parentCommand.subcommands[subcommandIdx] = { ...subcommand, ...partSpec, loadSpec: undefined };
+                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 };
+            parentCommand.subcommands[subcommandIdx] = {
+                ...subcommand,
+                ...(getSubcommand(spec) ?? []),
+                loadSpec: undefined,
+            };
             return parentCommand.subcommands[subcommandIdx];
         }
         case "object": {
-            parentCommand.subcommands[subcommandIdx] = { ...subcommand, ...(subcommand.loadSpec ?? {}), loadSpec: undefined };
+            parentCommand.subcommands[subcommandIdx] = {
+                ...subcommand,
+                ...(subcommand.loadSpec ?? {}),
+                loadSpec: undefined,
+            };
             return parentCommand.subcommands[subcommandIdx];
         }
         case "undefined": {
@@ -142,7 +192,7 @@ const getPersistentTokens = (tokens) => {
 const getArgs = (args) => {
     return args instanceof Array ? args : args != null ? [args] : [];
 };
-const runOption = async (tokens, option, subcommand, persistentOptions, acceptedTokens) => {
+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");
     }
@@ -150,37 +200,40 @@ const runOption = async (tokens, option, subcommand, persistentOptions, accepted
     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, persistentOptions, acceptedTokens.concat(activeToken), true, false);
+        return runArg(tokens.slice(1), args, subcommand, cwd, shell, persistentOptions, acceptedTokens.concat(activeToken), true, false);
     }
-    return runSubcommand(tokens.slice(1), subcommand, persistentOptions, acceptedTokens.concat({ ...activeToken, isPersistent }));
+    return runSubcommand(tokens.slice(1), subcommand, cwd, shell, persistentOptions, acceptedTokens.concat({
+        ...activeToken,
+        isPersistent,
+    }));
 };
-const runArg = async (tokens, args, subcommand, persistentOptions, acceptedTokens, fromOption, fromVariadic) => {
+const runArg = async (tokens, args, subcommand, cwd, shell, persistentOptions, acceptedTokens, fromOption, fromVariadic) => {
     if (args.length === 0) {
-        return runSubcommand(tokens, subcommand, persistentOptions, acceptedTokens, true, !fromOption);
+        return runSubcommand(tokens, subcommand, cwd, shell, persistentOptions, acceptedTokens, true, !fromOption);
     }
     else if (tokens.length === 0) {
-        return await getArgDrivenRecommendation(args, subcommand, persistentOptions, undefined, acceptedTokens, fromVariadic);
+        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].token, acceptedTokens, fromVariadic);
+        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, persistentOptions, acceptedTokens);
+                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, persistentOptions, getPersistentTokens(acceptedTokens.concat(activeToken)));
+            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, persistentOptions, acceptedTokens.concat(activeToken), fromOption, true);
+        return runArg(tokens.slice(1), args, subcommand, cwd, shell, persistentOptions, acceptedTokens.concat(activeToken), fromOption, true);
     }
     else if (activeArg.isCommand) {
         if (tokens.length <= 0) {
@@ -192,16 +245,16 @@ const runArg = async (tokens, args, subcommand, persistentOptions, acceptedToken
         const subcommand = getSubcommand(spec);
         if (subcommand == null)
             return;
-        return runSubcommand(tokens.slice(1), subcommand);
+        return runSubcommand(tokens.slice(1), subcommand, cwd, shell);
     }
-    return runArg(tokens.slice(1), args.slice(1), subcommand, persistentOptions, acceptedTokens.concat(activeToken), fromOption, false);
+    return runArg(tokens.slice(1), args.slice(1), subcommand, cwd, shell, persistentOptions, acceptedTokens.concat(activeToken), fromOption, false);
 };
-const runSubcommand = async (tokens, subcommand, persistentOptions = [], acceptedTokens = [], argsDepleted = false, argsUsed = 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);
+        return getSubcommandDrivenRecommendation(subcommand, persistentOptions, undefined, argsDepleted, argsUsed, acceptedTokens, cwd, shell);
     }
     else if (!tokens.at(0)?.complete) {
-        return getSubcommandDrivenRecommendation(subcommand, persistentOptions, tokens[0].token, argsDepleted, argsUsed, acceptedTokens);
+        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;
@@ -209,16 +262,21 @@ const runSubcommand = async (tokens, subcommand, persistentOptions = [], accepte
     if (activeToken.isOption) {
         const option = getOption(activeToken, allOptions);
         if (option != null) {
-            return runOption(tokens, option, subcommand, persistentOptions, acceptedTokens);
+            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, getPersistentOptions(persistentOptions, subcommand.options), getPersistentTokens(acceptedTokens.concat(activeToken)));
+        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
     }
-    return runArg(tokens, getArgs(subcommand.args), subcommand, allOptions, acceptedTokens, false, false);
+    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

@@ -0,0 +1,36 @@
+"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,8 +1,12 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
+import path from "node:path";
 import { runGenerator } from "./generator.js";
 import { runTemplates } from "./template.js";
-var SuggestionIcons;
+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";
@@ -14,7 +18,11 @@ var SuggestionIcons;
     SuggestionIcons["Special"] = "\u2B50";
     SuggestionIcons["Default"] = "\uD83D\uDCC0";
 })(SuggestionIcons || (SuggestionIcons = {}));
-const getIcon = (suggestionType) => {
+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;
@@ -38,16 +46,20 @@ const getIcon = (suggestionType) => {
 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(type ?? suggestion.type),
+        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) {
@@ -65,10 +77,11 @@ function filter(suggestions, filterStrategy, partialCmd, suggestionType) {
                         ? {
                             name: matchedName,
                             description: s.description,
-                            icon: getIcon(s.type ?? suggestionType),
+                            icon: getIcon(s.icon, s.type ?? suggestionType),
                             allNames: s.name,
                             priority: s.priority ?? 50,
                             insertValue: s.insertValue,
+                            type: s.type,
                         }
                         : undefined;
                 }
@@ -76,10 +89,11 @@ function filter(suggestions, filterStrategy, partialCmd, suggestionType) {
                     ? {
                         name: s.name,
                         description: s.description,
-                        icon: getIcon(s.type ?? suggestionType),
+                        icon: getIcon(s.icon, s.type ?? suggestionType),
                         allNames: [s.name],
                         priority: s.priority ?? 50,
                         insertValue: s.insertValue,
+                        type: s.type,
                     }
                     : undefined;
             })
@@ -95,10 +109,11 @@ function filter(suggestions, filterStrategy, partialCmd, suggestionType) {
                         ? {
                             name: matchedName,
                             description: s.description,
-                            icon: getIcon(s.type ?? suggestionType),
+                            icon: getIcon(s.icon, s.type ?? suggestionType),
                             allNames: s.name,
                             insertValue: s.insertValue,
                             priority: s.priority ?? 50,
+                            type: s.type,
                         }
                         : undefined;
                 }
@@ -106,24 +121,27 @@ function filter(suggestions, filterStrategy, partialCmd, suggestionType) {
                     ? {
                         name: s.name,
                         description: s.description,
-                        icon: getIcon(s.type ?? suggestionType),
+                        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) => {
+const generatorSuggestions = async (generator, acceptedTokens, filterStrategy, partialCmd, cwd) => {
     const generators = generator instanceof Array ? generator : generator ? [generator] : [];
     const tokens = acceptedTokens.map((t) => t.token);
-    const suggestions = (await Promise.all(generators.map((gen) => runGenerator(gen, tokens)))).flat();
-    return filter(suggestions, filterStrategy, partialCmd, undefined);
+    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) => {
-    return filter(await runTemplates(templates ?? []), 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)) ?? [];
@@ -137,17 +155,43 @@ const optionSuggestions = (options, acceptedTokens, filterStrategy, partialCmd)
     const validOptions = options?.filter((o) => o.exclusiveOn?.every((exclusiveOption) => !usedOptions.has(exclusiveOption)) ?? true);
     return filter(validOptions ?? [], filterStrategy, partialCmd, "option");
 };
-const removeDuplicateSuggestions = (suggestions, acceptedTokens) => {
+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, partialCmd, argsDepleted, argsFromSubcommand, acceptedTokens) => {
+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 ?? []);
@@ -157,28 +201,32 @@ export const getSubcommandDrivenRecommendation = async (subcommand, persistentOp
     }
     if (argLength != 0) {
         const activeArg = subcommand.args instanceof Array ? subcommand.args[0] : subcommand.args;
-        suggestions.push(...(await generatorSuggestions(activeArg?.generators, acceptedTokens, activeArg?.filterStrategy, partialCmd)));
+        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)));
+        suggestions.push(...(await templateSuggestions(activeArg?.template, activeArg?.filterStrategy, partialCmd, cwd)));
     }
     return {
-        suggestions: removeEmptySuggestion(removeDuplicateSuggestions(suggestions.sort((a, b) => b.priority - a.priority), acceptedTokens)),
+        suggestions: removeDuplicateSuggestion(removeEmptySuggestion(removeAcceptedSuggestions(adjustPathSuggestions(suggestions.sort((a, b) => b.priority - a.priority), partialToken, shell), acceptedTokens))),
     };
 };
-export const getArgDrivenRecommendation = async (args, subcommand, persistentOptions, partialCmd, acceptedTokens, variadicArgBound) => {
+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)),
+        ...(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)),
+        ...(await templateSuggestions(args[0].template, activeArg?.filterStrategy, partialCmd, cwd)),
     ];
-    if ((activeArg.isOptional && !activeArg.isVariadic) || (activeArg.isVariadic && activeArg.isOptional && !variadicArgBound)) {
+    if (activeArg.isOptional || (activeArg.isVariadic && variadicArgBound)) {
         suggestions.push(...subcommandSuggestions(subcommand.subcommands, activeArg?.filterStrategy, partialCmd));
         suggestions.push(...optionSuggestions(allOptions, acceptedTokens, activeArg?.filterStrategy, partialCmd));
     }
     return {
-        suggestions: removeEmptySuggestion(removeDuplicateSuggestions(suggestions.sort((a, b) => b.priority - a.priority), acceptedTokens)),
+        suggestions: removeDuplicateSuggestion(removeEmptySuggestion(removeAcceptedSuggestions(adjustPathSuggestions(suggestions.sort((a, b) => b.priority - a.priority), partialToken, shell), acceptedTokens))),
         argumentDescription: activeArg.description ?? activeArg.name,
     };
 };

package/build/runtime/template.js

@@ -1,14 +1,23 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
-import fsAsync from "fs/promises";
-import process from "node:process";
-const filepathsTemplate = async () => {
-    const files = await fsAsync.readdir(process.cwd(), { withFileTypes: true });
-    return files.filter((f) => f.isFile() || f.isDirectory()).map((f) => ({ name: f.name, priority: 90 }));
+import fsAsync from "node:fs/promises";
+import log from "../utils/log.js";
+const filepathsTemplate = async (cwd) => {
+    const files = await fsAsync.readdir(cwd, { withFileTypes: true });
+    return files
+        .filter((f) => f.isFile() || f.isDirectory())
+        .map((f) => ({ name: f.name, priority: 55, context: { templateType: "filepaths" }, type: f.isDirectory() ? "folder" : "file" }));
 };
-const foldersTemplate = async () => {
-    const files = await fsAsync.readdir(process.cwd(), { withFileTypes: true });
-    return files.filter((f) => f.isDirectory()).map((f) => ({ name: f.name, priority: 90 }));
+const foldersTemplate = async (cwd) => {
+    const files = await fsAsync.readdir(cwd, { withFileTypes: true });
+    return files
+        .filter((f) => f.isDirectory())
+        .map((f) => ({
+        name: f.name,
+        priority: 55,
+        context: { templateType: "folders" },
+        type: "folder",
+    }));
 };
 // TODO: implement history template
 const historyTemplate = () => {
@@ -18,18 +27,24 @@ const historyTemplate = () => {
 const helpTemplate = () => {
     return [];
 };
-export const runTemplates = async (template) => {
+export const runTemplates = async (template, cwd) => {
     const templates = template instanceof Array ? template : [template];
     return (await Promise.all(templates.map(async (t) => {
-        switch (t) {
-            case "filepaths":
-                return await filepathsTemplate();
-            case "folders":
-                return await foldersTemplate();
-            case "history":
-                return historyTemplate();
-            case "help":
-                return helpTemplate();
+        try {
+            switch (t) {
+                case "filepaths":
+                    return await filepathsTemplate(cwd);
+                case "folders":
+                    return await foldersTemplate(cwd);
+                case "history":
+                    return historyTemplate();
+                case "help":
+                    return helpTemplate();
+            }
+        }
+        catch (e) {
+            log.debug({ msg: "template failed", e, template: t, cwd });
+            return [];
         }
     }))).flat();
 };